import React$1, { ReactPortal } from 'react';
import ReactReconciler from 'react-reconciler';

type Gtk40 = typeof Gtk

declare global {
  interface NodeGtkGi {
    require(ns: "Gtk", ver?: "4.0"): Gtk40
  }
}

type Gsk40 = typeof Gsk

declare global {
  interface NodeGtkGi {
    require(ns: "Gsk", ver?: "4.0"): Gsk40
  }
}

type Graphene10 = typeof Graphene

declare global {
  interface NodeGtkGi {
    require(ns: "Graphene", ver?: "1.0"): Graphene10
  }
}

type GObject20 = typeof GObject

declare global {
  interface NodeGtkGi {
    require(ns: "GObject", ver?: "2.0"): GObject20
  }
}

type GLib20 = typeof GLib

declare global {
  interface NodeGtkGi {
    require(ns: "GLib", ver?: "2.0"): GLib20
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace GLib {
  /**
   * Error codes returned by bookmark file parsing.
   */
  enum BookmarkFileError {
    /**
     * URI was ill-formed
     */
    INVALID_URI,
    /**
     * a requested field was not found
     */
    INVALID_VALUE,
    /**
     * a requested application did
     *     not register a bookmark
     */
    APP_NOT_REGISTERED,
    /**
     * a requested URI was not found
     */
    URI_NOT_FOUND,
    /**
     * document was ill formed
     */
    READ,
    /**
     * the text being parsed was
     *     in an unknown encoding
     */
    UNKNOWN_ENCODING,
    /**
     * an error occurred while writing
     */
    WRITE,
    /**
     * requested file was not found
     */
    FILE_NOT_FOUND,
  }
  /**
   * The hashing algorithm to be used by #GChecksum when performing the
   * digest of some data.
   *
   * Note that the #GChecksumType enumeration may be extended at a later
   * date to include new hashing algorithm types.
   */
  enum ChecksumType {
    /**
     * Use the MD5 hashing algorithm
     */
    MD5,
    /**
     * Use the SHA-1 hashing algorithm
     */
    SHA1,
    /**
     * Use the SHA-256 hashing algorithm
     */
    SHA256,
    /**
     * Use the SHA-512 hashing algorithm (Since: 2.36)
     */
    SHA512,
    /**
     * Use the SHA-384 hashing algorithm (Since: 2.51)
     */
    SHA384,
  }
  /**
   * Error codes returned by character set conversion routines.
   */
  enum ConvertError {
    /**
     * Conversion between the requested character
     *     sets is not supported.
     */
    NO_CONVERSION,
    /**
     * Invalid byte sequence in conversion input;
     *    or the character sequence could not be represented in the target
     *    character set.
     */
    ILLEGAL_SEQUENCE,
    /**
     * Conversion failed for some reason.
     */
    FAILED,
    /**
     * Partial character sequence at end of input.
     */
    PARTIAL_INPUT,
    /**
     * URI is invalid.
     */
    BAD_URI,
    /**
     * Pathname is not an absolute path.
     */
    NOT_ABSOLUTE_PATH,
    /**
     * No memory available. Since: 2.40
     */
    NO_MEMORY,
    /**
     * An embedded NUL character is present in
     *     conversion output where a NUL-terminated string is expected.
     *     Since: 2.56
     */
    EMBEDDED_NUL,
  }
  /**
   * This enumeration isn't used in the API, but may be useful if you need
   * to mark a number as a day, month, or year.
   */
  enum DateDMY {
    /**
     * a day
     */
    DAY,
    /**
     * a month
     */
    MONTH,
    /**
     * a year
     */
    YEAR,
  }
  /**
   * Enumeration representing a month; values are %G_DATE_JANUARY,
   * %G_DATE_FEBRUARY, etc. %G_DATE_BAD_MONTH is the invalid value.
   */
  enum DateMonth {
    /**
     * invalid value
     */
    BAD_MONTH,
    /**
     * January
     */
    JANUARY,
    /**
     * February
     */
    FEBRUARY,
    /**
     * March
     */
    MARCH,
    /**
     * April
     */
    APRIL,
    /**
     * May
     */
    MAY,
    /**
     * June
     */
    JUNE,
    /**
     * July
     */
    JULY,
    /**
     * August
     */
    AUGUST,
    /**
     * September
     */
    SEPTEMBER,
    /**
     * October
     */
    OCTOBER,
    /**
     * November
     */
    NOVEMBER,
    /**
     * December
     */
    DECEMBER,
  }
  /**
   * Enumeration representing a day of the week; %G_DATE_MONDAY,
   * %G_DATE_TUESDAY, etc. %G_DATE_BAD_WEEKDAY is an invalid weekday.
   */
  enum DateWeekday {
    /**
     * invalid value
     */
    BAD_WEEKDAY,
    /**
     * Monday
     */
    MONDAY,
    /**
     * Tuesday
     */
    TUESDAY,
    /**
     * Wednesday
     */
    WEDNESDAY,
    /**
     * Thursday
     */
    THURSDAY,
    /**
     * Friday
     */
    FRIDAY,
    /**
     * Saturday
     */
    SATURDAY,
    /**
     * Sunday
     */
    SUNDAY,
  }
  /**
   * The possible errors, used in the `v_error` field
   * of #GTokenValue, when the token is a %G_TOKEN_ERROR.
   */
  enum ErrorType {
    /**
     * unknown error
     */
    UNKNOWN,
    /**
     * unexpected end of file
     */
    UNEXP_EOF,
    /**
     * unterminated string constant
     */
    UNEXP_EOF_IN_STRING,
    /**
     * unterminated comment
     */
    UNEXP_EOF_IN_COMMENT,
    /**
     * non-digit character in a number
     */
    NON_DIGIT_IN_CONST,
    /**
     * digit beyond radix in a number
     */
    DIGIT_RADIX,
    /**
     * non-decimal floating point number
     */
    FLOAT_RADIX,
    /**
     * malformed floating point number
     */
    FLOAT_MALFORMED,
  }
  /**
   * Values corresponding to `errno` codes returned from file operations
   * on UNIX. Unlike `errno` codes, GFileError values are available on
   * all systems, even Windows. The exact meaning of each code depends
   * on what sort of file operation you were performing; the UNIX
   * documentation gives more details. The following error code descriptions
   * come from the GNU C Library manual, and are under the copyright
   * of that manual.
   *
   * It's not very portable to make detailed assumptions about exactly
   * which errors will be returned from a given operation. Some errors
   * don't occur on some systems, etc., sometimes there are subtle
   * differences in when a system will report a given error, etc.
   */
  enum FileError {
    /**
     * Operation not permitted; only the owner of
     *     the file (or other resource) or processes with special privileges
     *     can perform the operation.
     */
    EXIST,
    /**
     * File is a directory; you cannot open a directory
     *     for writing, or create or remove hard links to it.
     */
    ISDIR,
    /**
     * Permission denied; the file permissions do not
     *     allow the attempted operation.
     */
    ACCES,
    /**
     * Filename too long.
     */
    NAMETOOLONG,
    /**
     * No such file or directory. This is a "file
     *     doesn't exist" error for ordinary files that are referenced in
     *     contexts where they are expected to already exist.
     */
    NOENT,
    /**
     * A file that isn't a directory was specified when
     *     a directory is required.
     */
    NOTDIR,
    /**
     * No such device or address. The system tried to
     *     use the device represented by a file you specified, and it
     *     couldn't find the device. This can mean that the device file was
     *     installed incorrectly, or that the physical device is missing or
     *     not correctly attached to the computer.
     */
    NXIO,
    /**
     * The underlying file system of the specified file
     *     does not support memory mapping.
     */
    NODEV,
    /**
     * The directory containing the new link can't be
     *     modified because it's on a read-only file system.
     */
    ROFS,
    /**
     * Text file busy.
     */
    TXTBSY,
    /**
     * You passed in a pointer to bad memory.
     *     (GLib won't reliably return this, don't pass in pointers to bad
     *     memory.)
     */
    FAULT,
    /**
     * Too many levels of symbolic links were encountered
     *     in looking up a file name. This often indicates a cycle of symbolic
     *     links.
     */
    LOOP,
    /**
     * No space left on device; write operation on a
     *     file failed because the disk is full.
     */
    NOSPC,
    /**
     * No memory available. The system cannot allocate
     *     more virtual memory because its capacity is full.
     */
    NOMEM,
    /**
     * The current process has too many files open and
     *     can't open any more. Duplicate descriptors do count toward this
     *     limit.
     */
    MFILE,
    /**
     * There are too many distinct file openings in the
     *     entire system.
     */
    NFILE,
    /**
     * Bad file descriptor; for example, I/O on a
     *     descriptor that has been closed or reading from a descriptor open
     *     only for writing (or vice versa).
     */
    BADF,
    /**
     * Invalid argument. This is used to indicate
     *     various kinds of problems with passing the wrong argument to a
     *     library function.
     */
    INVAL,
    /**
     * Broken pipe; there is no process reading from the
     *     other end of a pipe. Every library function that returns this
     *     error code also generates a 'SIGPIPE' signal; this signal
     *     terminates the program if not handled or blocked. Thus, your
     *     program will never actually see this code unless it has handled
     *     or blocked 'SIGPIPE'.
     */
    PIPE,
    /**
     * Resource temporarily unavailable; the call might
     *     work if you try again later.
     */
    AGAIN,
    /**
     * Interrupted function call; an asynchronous signal
     *     occurred and prevented completion of the call. When this
     *     happens, you should try the call again.
     */
    INTR,
    /**
     * Input/output error; usually used for physical read
     *    or write errors. i.e. the disk or other physical device hardware
     *    is returning errors.
     */
    IO,
    /**
     * Operation not permitted; only the owner of the
     *    file (or other resource) or processes with special privileges can
     *    perform the operation.
     */
    PERM,
    /**
     * Function not implemented; this indicates that
     *    the system is missing some functionality.
     */
    NOSYS,
    /**
     * Does not correspond to a UNIX error code; this
     *    is the standard "failed for unspecified reason" error code present
     *    in all #GError error code enumerations. Returned if no specific
     *    code applies.
     */
    FAILED,
  }
  /**
   * Error codes returned by #GIOChannel operations.
   */
  enum IOChannelError {
    /**
     * File too large.
     */
    FBIG,
    /**
     * Invalid argument.
     */
    INVAL,
    /**
     * IO error.
     */
    IO,
    /**
     * File is a directory.
     */
    ISDIR,
    /**
     * No space left on device.
     */
    NOSPC,
    /**
     * No such device or address.
     */
    NXIO,
    /**
     * Value too large for defined datatype.
     */
    OVERFLOW,
    /**
     * Broken pipe.
     */
    PIPE,
    /**
     * Some other error.
     */
    FAILED,
  }
  /**
   * #GIOError is only used by the deprecated functions
   * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
   */
  enum IOError {
    /**
     * no error
     */
    NONE,
    /**
     * an EAGAIN error occurred
     */
    AGAIN,
    /**
     * an EINVAL error occurred
     */
    INVAL,
    /**
     * another error occurred
     */
    UNKNOWN,
  }
  /**
   * Statuses returned by most of the #GIOFuncs functions.
   */
  enum IOStatus {
    /**
     * An error occurred.
     */
    ERROR,
    /**
     * Success.
     */
    NORMAL,
    /**
     * End of file.
     */
    EOF,
    /**
     * Resource temporarily unavailable.
     */
    AGAIN,
  }
  /**
   * Error codes returned by key file parsing.
   */
  enum KeyFileError {
    /**
     * the text being parsed was in
     *   an unknown encoding
     */
    UNKNOWN_ENCODING,
    /**
     * document was ill-formed
     */
    PARSE,
    /**
     * the file was not found
     */
    NOT_FOUND,
    /**
     * a requested key was not found
     */
    KEY_NOT_FOUND,
    /**
     * a requested group was not found
     */
    GROUP_NOT_FOUND,
    /**
     * a value could not be parsed
     */
    INVALID_VALUE,
  }
  /**
   * Return values from #GLogWriterFuncs to indicate whether the given log entry
   * was successfully handled by the writer, or whether there was an error in
   * handling it (and hence a fallback writer should be used).
   *
   * If a #GLogWriterFunc ignores a log entry, it should return
   * %G_LOG_WRITER_HANDLED.
   */
  enum LogWriterOutput {
    /**
     * Log writer has handled the log entry.
     */
    HANDLED,
    /**
     * Log writer could not handle the log entry.
     */
    UNHANDLED,
  }
  /**
   * Error codes returned by markup parsing.
   */
  enum MarkupError {
    /**
     * text being parsed was not valid UTF-8
     */
    BAD_UTF8,
    /**
     * document contained nothing, or only whitespace
     */
    EMPTY,
    /**
     * document was ill-formed
     */
    PARSE,
    /**
     * error should be set by #GMarkupParser
     *     functions; element wasn't known
     */
    UNKNOWN_ELEMENT,
    /**
     * error should be set by #GMarkupParser
     *     functions; attribute wasn't known
     */
    UNKNOWN_ATTRIBUTE,
    /**
     * error should be set by #GMarkupParser
     *     functions; content was invalid
     */
    INVALID_CONTENT,
    /**
     * error should be set by #GMarkupParser
     *     functions; a required attribute was missing
     */
    MISSING_ATTRIBUTE,
  }
  /**
   * Defines how a Unicode string is transformed in a canonical
   * form, standardizing such issues as whether a character with
   * an accent is represented as a base character and combining
   * accent or as a single precomposed character. Unicode strings
   * should generally be normalized before comparing them.
   */
  enum NormalizeMode {
    /**
     * standardize differences that do not affect the
     *     text content, such as the above-mentioned accent representation
     */
    DEFAULT,
    /**
     * another name for %G_NORMALIZE_DEFAULT
     */
    NFD,
    /**
     * like %G_NORMALIZE_DEFAULT, but with
     *     composed forms rather than a maximally decomposed form
     */
    DEFAULT_COMPOSE,
    /**
     * another name for %G_NORMALIZE_DEFAULT_COMPOSE
     */
    NFC,
    /**
     * beyond %G_NORMALIZE_DEFAULT also standardize the
     *     "compatibility" characters in Unicode, such as SUPERSCRIPT THREE
     *     to the standard forms (in this case DIGIT THREE). Formatting
     *     information may be lost but for most text operations such
     *     characters should be considered the same
     */
    ALL,
    /**
     * another name for %G_NORMALIZE_ALL
     */
    NFKD,
    /**
     * like %G_NORMALIZE_ALL, but with composed
     *     forms rather than a maximally decomposed form
     */
    ALL_COMPOSE,
    /**
     * another name for %G_NORMALIZE_ALL_COMPOSE
     */
    NFKC,
  }
  /**
   * Error codes returned by functions converting a string to a number.
   */
  enum NumberParserError {
    /**
     * string was not a valid number
     */
    INVALID,
    /**
     * string was a number, but out of bounds
     */
    OUT_OF_BOUNDS,
  }
  /**
   * The possible statuses of a one-time initialization function
   * controlled by a #GOnce struct.
   */
  enum OnceStatus {
    /**
     * the function has not been called yet.
     */
    NOTCALLED,
    /**
     * the function call is currently in progress.
     */
    PROGRESS,
    /**
     * the function has been called.
     */
    READY,
  }
  /**
   * The #GOptionArg enum values determine which type of extra argument the
   * options expect to find. If an option expects an extra argument, it can
   * be specified in several ways; with a short option: `-x arg`, with a long
   * option: `--name arg` or combined in a single argument: `--name=arg`.
   */
  enum OptionArg {
    /**
     * No extra argument. This is useful for simple flags or booleans.
     */
    NONE,
    /**
     * The option takes a UTF-8 string argument.
     */
    STRING,
    /**
     * The option takes an integer argument.
     */
    INT,
    /**
     * The option provides a callback (of type
     *     #GOptionArgFunc) to parse the extra argument.
     */
    CALLBACK,
    /**
     * The option takes a filename as argument, which will
     *        be in the GLib filename encoding rather than UTF-8.
     */
    FILENAME,
    /**
     * The option takes a string argument, multiple
     *     uses of the option are collected into an array of strings.
     */
    STRING_ARRAY,
    /**
     * The option takes a filename as argument,
     *     multiple uses of the option are collected into an array of strings.
     */
    FILENAME_ARRAY,
    /**
     * The option takes a double argument. The argument
     *     can be formatted either for the user's locale or for the "C" locale.
     *     Since 2.12
     */
    DOUBLE,
    /**
     * The option takes a 64-bit integer. Like
     *     %G_OPTION_ARG_INT but for larger numbers. The number can be in
     *     decimal base, or in hexadecimal (when prefixed with `0x`, for
     *     example, `0xffffffff`). Since 2.12
     */
    INT64,
  }
  /**
   * Error codes returned by option parsing.
   */
  enum OptionError {
    /**
     * An option was not known to the parser.
     *  This error will only be reported, if the parser hasn't been instructed
     *  to ignore unknown options, see g_option_context_set_ignore_unknown_options().
     */
    UNKNOWN_OPTION,
    /**
     * A value couldn't be parsed.
     */
    BAD_VALUE,
    /**
     * A #GOptionArgFunc callback failed.
     */
    FAILED,
  }
  /**
   * Error codes returned by regular expressions functions.
   */
  enum RegexError {
    /**
     * Compilation of the regular expression failed.
     */
    COMPILE,
    /**
     * Optimization of the regular expression failed.
     */
    OPTIMIZE,
    /**
     * Replacement failed due to an ill-formed replacement
     *     string.
     */
    REPLACE,
    /**
     * The match process failed.
     */
    MATCH,
    /**
     * Internal error of the regular expression engine.
     *     Since 2.16
     */
    INTERNAL,
    /**
     * "\\" at end of pattern. Since 2.16
     */
    STRAY_BACKSLASH,
    /**
     * "\\c" at end of pattern. Since 2.16
     */
    MISSING_CONTROL_CHAR,
    /**
     * Unrecognized character follows "\\".
     *     Since 2.16
     */
    UNRECOGNIZED_ESCAPE,
    /**
     * Numbers out of order in "{}"
     *     quantifier. Since 2.16
     */
    QUANTIFIERS_OUT_OF_ORDER,
    /**
     * Number too big in "{}" quantifier.
     *     Since 2.16
     */
    QUANTIFIER_TOO_BIG,
    /**
     * Missing terminating "]" for
     *     character class. Since 2.16
     */
    UNTERMINATED_CHARACTER_CLASS,
    /**
     * Invalid escape sequence
     *     in character class. Since 2.16
     */
    INVALID_ESCAPE_IN_CHARACTER_CLASS,
    /**
     * Range out of order in character class.
     *     Since 2.16
     */
    RANGE_OUT_OF_ORDER,
    /**
     * Nothing to repeat. Since 2.16
     */
    NOTHING_TO_REPEAT,
    /**
     * Unrecognized character after "(?",
     *     "(?<" or "(?P". Since 2.16
     */
    UNRECOGNIZED_CHARACTER,
    /**
     * POSIX named classes are
     *     supported only within a class. Since 2.16
     */
    POSIX_NAMED_CLASS_OUTSIDE_CLASS,
    /**
     * Missing terminating ")" or ")"
     *     without opening "(". Since 2.16
     */
    UNMATCHED_PARENTHESIS,
    /**
     * Reference to non-existent
     *     subpattern. Since 2.16
     */
    INEXISTENT_SUBPATTERN_REFERENCE,
    /**
     * Missing terminating ")" after comment.
     *     Since 2.16
     */
    UNTERMINATED_COMMENT,
    /**
     * Regular expression too large.
     *     Since 2.16
     */
    EXPRESSION_TOO_LARGE,
    /**
     * Failed to get memory. Since 2.16
     */
    MEMORY_ERROR,
    /**
     * Lookbehind assertion is not
     *     fixed length. Since 2.16
     */
    VARIABLE_LENGTH_LOOKBEHIND,
    /**
     * Malformed number or name after "(?(".
     *     Since 2.16
     */
    MALFORMED_CONDITION,
    /**
     * Conditional group contains
     *     more than two branches. Since 2.16
     */
    TOO_MANY_CONDITIONAL_BRANCHES,
    /**
     * Assertion expected after "(?(".
     *     Since 2.16
     */
    ASSERTION_EXPECTED,
    /**
     * Unknown POSIX class name.
     *     Since 2.16
     */
    UNKNOWN_POSIX_CLASS_NAME,
    /**
     * POSIX collating
     *     elements are not supported. Since 2.16
     */
    POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED,
    /**
     * Character value in "\\x{...}" sequence
     *     is too large. Since 2.16
     */
    HEX_CODE_TOO_LARGE,
    /**
     * Invalid condition "(?(0)". Since 2.16
     */
    INVALID_CONDITION,
    /**
     * \\C not allowed in
     *     lookbehind assertion. Since 2.16
     */
    SINGLE_BYTE_MATCH_IN_LOOKBEHIND,
    /**
     * Recursive call could loop indefinitely.
     *     Since 2.16
     */
    INFINITE_LOOP,
    /**
     * Missing terminator
     *     in subpattern name. Since 2.16
     */
    MISSING_SUBPATTERN_NAME_TERMINATOR,
    /**
     * Two named subpatterns have
     *     the same name. Since 2.16
     */
    DUPLICATE_SUBPATTERN_NAME,
    /**
     * Malformed "\\P" or "\\p" sequence.
     *     Since 2.16
     */
    MALFORMED_PROPERTY,
    /**
     * Unknown property name after "\\P" or
     *     "\\p". Since 2.16
     */
    UNKNOWN_PROPERTY,
    /**
     * Subpattern name is too long
     *     (maximum 32 characters). Since 2.16
     */
    SUBPATTERN_NAME_TOO_LONG,
    /**
     * Too many named subpatterns (maximum
     *     10,000). Since 2.16
     */
    TOO_MANY_SUBPATTERNS,
    /**
     * Octal value is greater than "\\377".
     *     Since 2.16
     */
    INVALID_OCTAL_VALUE,
    /**
     * "DEFINE" group contains more
     *     than one branch. Since 2.16
     */
    TOO_MANY_BRANCHES_IN_DEFINE,
    /**
     * Repeating a "DEFINE" group is not allowed.
     *     This error is never raised. Since: 2.16 Deprecated: 2.34
     */
    DEFINE_REPETION,
    /**
     * Inconsistent newline options.
     *     Since 2.16
     */
    INCONSISTENT_NEWLINE_OPTIONS,
    /**
     * "\\g" is not followed by a braced,
     *      angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16
     */
    MISSING_BACK_REFERENCE,
    /**
     * relative reference must not be zero. Since: 2.34
     */
    INVALID_RELATIVE_REFERENCE,
    /**
     * the backtracing
     *     control verb used does not allow an argument. Since: 2.34
     */
    BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN,
    /**
     * unknown backtracing
     *     control verb. Since: 2.34
     */
    UNKNOWN_BACKTRACKING_CONTROL_VERB,
    /**
     * number is too big in escape sequence. Since: 2.34
     */
    NUMBER_TOO_BIG,
    /**
     * Missing subpattern name. Since: 2.34
     */
    MISSING_SUBPATTERN_NAME,
    /**
     * Missing digit. Since 2.34
     */
    MISSING_DIGIT,
    /**
     * In JavaScript compatibility mode,
     *     "[" is an invalid data character. Since: 2.34
     */
    INVALID_DATA_CHARACTER,
    /**
     * different names for subpatterns of the
     *     same number are not allowed. Since: 2.34
     */
    EXTRA_SUBPATTERN_NAME,
    /**
     * the backtracing control
     *     verb requires an argument. Since: 2.34
     */
    BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED,
    /**
     * "\\c" must be followed by an ASCII
     *     character. Since: 2.34
     */
    INVALID_CONTROL_CHAR,
    /**
     * "\\k" is not followed by a braced, angle-bracketed, or
     *     quoted name. Since: 2.34
     */
    MISSING_NAME,
    /**
     * "\\N" is not supported in a class. Since: 2.34
     */
    NOT_SUPPORTED_IN_CLASS,
    /**
     * too many forward references. Since: 2.34
     */
    TOO_MANY_FORWARD_REFERENCES,
    /**
     * the name is too long in "(*MARK)", "(*PRUNE)",
     *     "(*SKIP)", or "(*THEN)". Since: 2.34
     */
    NAME_TOO_LONG,
    /**
     * the character value in the \\u sequence is
     *     too large. Since: 2.34
     */
    CHARACTER_VALUE_TOO_LARGE,
  }
  /**
   * An enumeration specifying the base position for a
   * g_io_channel_seek_position() operation.
   */
  enum SeekType {
    /**
     * the current position in the file.
     */
    CUR,
    /**
     * the start of the file.
     */
    SET,
    /**
     * the end of the file.
     */
    END,
  }
  /**
   * Error codes returned by shell functions.
   */
  enum ShellError {
    /**
     * Mismatched or otherwise mangled quoting.
     */
    BAD_QUOTING,
    /**
     * String to be parsed was empty.
     */
    EMPTY_STRING,
    /**
     * Some other error.
     */
    FAILED,
  }
  enum SliceConfig {
    ALWAYS_MALLOC,
    BYPASS_MAGAZINES,
    WORKING_SET_MSECS,
    COLOR_INCREMENT,
    CHUNK_SIZES,
    CONTENTION_COUNTER,
  }
  /**
   * Error codes returned by spawning processes.
   */
  enum SpawnError {
    /**
     * Fork failed due to lack of memory.
     */
    FORK,
    /**
     * Read or select on pipes failed.
     */
    READ,
    /**
     * Changing to working directory failed.
     */
    CHDIR,
    /**
     * execv() returned `EACCES`
     */
    ACCES,
    /**
     * execv() returned `EPERM`
     */
    PERM,
    /**
     * execv() returned `E2BIG`
     */
    TOO_BIG,
    /**
     * deprecated alias for %G_SPAWN_ERROR_TOO_BIG (deprecated since GLib 2.32)
     */
    TODO_2BIG,
    /**
     * execv() returned `ENOEXEC`
     */
    NOEXEC,
    /**
     * execv() returned `ENAMETOOLONG`
     */
    NAMETOOLONG,
    /**
     * execv() returned `ENOENT`
     */
    NOENT,
    /**
     * execv() returned `ENOMEM`
     */
    NOMEM,
    /**
     * execv() returned `ENOTDIR`
     */
    NOTDIR,
    /**
     * execv() returned `ELOOP`
     */
    LOOP,
    /**
     * execv() returned `ETXTBUSY`
     */
    TXTBUSY,
    /**
     * execv() returned `EIO`
     */
    IO,
    /**
     * execv() returned `ENFILE`
     */
    NFILE,
    /**
     * execv() returned `EMFILE`
     */
    MFILE,
    /**
     * execv() returned `EINVAL`
     */
    INVAL,
    /**
     * execv() returned `EISDIR`
     */
    ISDIR,
    /**
     * execv() returned `ELIBBAD`
     */
    LIBBAD,
    /**
     * Some other fatal failure,
     *   `error->message` should explain.
     */
    FAILED,
  }
  /**
   * The type of file to return the filename for, when used with
   * g_test_build_filename().
   *
   * These two options correspond rather directly to the 'dist' and
   * 'built' terminology that automake uses and are explicitly used to
   * distinguish between the 'srcdir' and 'builddir' being separate.  All
   * files in your project should either be dist (in the
   * `EXTRA_DIST` or `dist_schema_DATA`
   * sense, in which case they will always be in the srcdir) or built (in
   * the `BUILT_SOURCES` sense, in which case they will
   * always be in the builddir).
   *
   * Note: as a general rule of automake, files that are generated only as
   * part of the build-from-git process (but then are distributed with the
   * tarball) always go in srcdir (even if doing a srcdir != builddir
   * build from git) and are considered as distributed files.
   */
  enum TestFileType {
    /**
     * a file that was included in the distribution tarball
     */
    DIST,
    /**
     * a file that was built on the compiling machine
     */
    BUILT,
  }
  enum TestLogType {
    NONE,
    ERROR,
    START_BINARY,
    LIST_CASE,
    SKIP_CASE,
    START_CASE,
    STOP_CASE,
    MIN_RESULT,
    MAX_RESULT,
    MESSAGE,
    START_SUITE,
    STOP_SUITE,
  }
  enum TestResult {
    SUCCESS,
    SKIPPED,
    FAILURE,
    INCOMPLETE,
  }
  /**
   * Possible errors of thread related functions.
   */
  enum ThreadError {
    /**
     * a thread couldn't be created due to resource
     *                        shortage. Try again later.
     */
    THREAD_ERROR_AGAIN,
  }
  /**
   * Disambiguates a given time in two ways.
   *
   * First, specifies if the given time is in universal or local time.
   *
   * Second, if the time is in local time, specifies if it is local
   * standard time or local daylight time.  This is important for the case
   * where the same local time occurs twice (during daylight savings time
   * transitions, for example).
   */
  enum TimeType {
    /**
     * the time is in local standard time
     */
    STANDARD,
    /**
     * the time is in local daylight time
     */
    DAYLIGHT,
    /**
     * the time is in UTC
     */
    UNIVERSAL,
  }
  /**
   * The possible types of token returned from each
   * g_scanner_get_next_token() call.
   */
  enum TokenType {
    /**
     * the end of the file
     */
    EOF,
    /**
     * a '(' character
     */
    LEFT_PAREN,
    /**
     * a ')' character
     */
    RIGHT_PAREN,
    /**
     * a '{' character
     */
    LEFT_CURLY,
    /**
     * a '}' character
     */
    RIGHT_CURLY,
    /**
     * a '[' character
     */
    LEFT_BRACE,
    /**
     * a ']' character
     */
    RIGHT_BRACE,
    /**
     * a '=' character
     */
    EQUAL_SIGN,
    /**
     * a ',' character
     */
    COMMA,
    /**
     * not a token
     */
    NONE,
    /**
     * an error occurred
     */
    ERROR,
    /**
     * a character
     */
    CHAR,
    /**
     * a binary integer
     */
    BINARY,
    /**
     * an octal integer
     */
    OCTAL,
    /**
     * an integer
     */
    INT,
    /**
     * a hex integer
     */
    HEX,
    /**
     * a floating point number
     */
    FLOAT,
    /**
     * a string
     */
    STRING,
    /**
     * a symbol
     */
    SYMBOL,
    /**
     * an identifier
     */
    IDENTIFIER,
    /**
     * a null identifier
     */
    IDENTIFIER_NULL,
    /**
     * one line comment
     */
    COMMENT_SINGLE,
    /**
     * multi line comment
     */
    COMMENT_MULTI,
  }
  /**
   * Specifies the type of traversal performed by g_tree_traverse(),
   * g_node_traverse() and g_node_find(). The different orders are
   * illustrated here:
   * - In order: A, B, C, D, E, F, G, H, I
   *   ![](Sorted_binary_tree_inorder.svg)
   * - Pre order: F, B, A, D, C, E, G, I, H
   *   ![](Sorted_binary_tree_preorder.svg)
   * - Post order: A, C, E, D, B, H, I, G, F
   *   ![](Sorted_binary_tree_postorder.svg)
   * - Level order: F, B, G, A, D, I, C, E, H
   *   ![](Sorted_binary_tree_breadth-first_traversal.svg)
   */
  enum TraverseType {
    /**
     * vists a node's left child first, then the node itself,
     *              then its right child. This is the one to use if you
     *              want the output sorted according to the compare
     *              function.
     */
    IN_ORDER,
    /**
     * visits a node, then its children.
     */
    PRE_ORDER,
    /**
     * visits the node's children, then the node itself.
     */
    POST_ORDER,
    /**
     * is not implemented for
     *              [balanced binary trees][glib-Balanced-Binary-Trees].
     *              For [n-ary trees][glib-N-ary-Trees], it
     *              vists the root node first, then its children, then
     *              its grandchildren, and so on. Note that this is less
     *              efficient than the other orders.
     */
    LEVEL_ORDER,
  }
  /**
   * These are the possible line break classifications.
   *
   * Since new Unicode versions may add new types here, applications should be ready
   * to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN.
   *
   * See [Unicode Line Breaking Algorithm](https://www.unicode.org/reports/tr14/).
   */
  enum UnicodeBreakType {
    /**
     * Mandatory Break (BK)
     */
    MANDATORY,
    /**
     * Carriage Return (CR)
     */
    CARRIAGE_RETURN,
    /**
     * Line Feed (LF)
     */
    LINE_FEED,
    /**
     * Attached Characters and Combining Marks (CM)
     */
    COMBINING_MARK,
    /**
     * Surrogates (SG)
     */
    SURROGATE,
    /**
     * Zero Width Space (ZW)
     */
    ZERO_WIDTH_SPACE,
    /**
     * Inseparable (IN)
     */
    INSEPARABLE,
    /**
     * Non-breaking ("Glue") (GL)
     */
    NON_BREAKING_GLUE,
    /**
     * Contingent Break Opportunity (CB)
     */
    CONTINGENT,
    /**
     * Space (SP)
     */
    SPACE,
    /**
     * Break Opportunity After (BA)
     */
    AFTER,
    /**
     * Break Opportunity Before (BB)
     */
    BEFORE,
    /**
     * Break Opportunity Before and After (B2)
     */
    BEFORE_AND_AFTER,
    /**
     * Hyphen (HY)
     */
    HYPHEN,
    /**
     * Nonstarter (NS)
     */
    NON_STARTER,
    /**
     * Opening Punctuation (OP)
     */
    OPEN_PUNCTUATION,
    /**
     * Closing Punctuation (CL)
     */
    CLOSE_PUNCTUATION,
    /**
     * Ambiguous Quotation (QU)
     */
    QUOTATION,
    /**
     * Exclamation/Interrogation (EX)
     */
    EXCLAMATION,
    /**
     * Ideographic (ID)
     */
    IDEOGRAPHIC,
    /**
     * Numeric (NU)
     */
    NUMERIC,
    /**
     * Infix Separator (Numeric) (IS)
     */
    INFIX_SEPARATOR,
    /**
     * Symbols Allowing Break After (SY)
     */
    SYMBOL,
    /**
     * Ordinary Alphabetic and Symbol Characters (AL)
     */
    ALPHABETIC,
    /**
     * Prefix (Numeric) (PR)
     */
    PREFIX,
    /**
     * Postfix (Numeric) (PO)
     */
    POSTFIX,
    /**
     * Complex Content Dependent (South East Asian) (SA)
     */
    COMPLEX_CONTEXT,
    /**
     * Ambiguous (Alphabetic or Ideographic) (AI)
     */
    AMBIGUOUS,
    /**
     * Unknown (XX)
     */
    UNKNOWN,
    /**
     * Next Line (NL)
     */
    NEXT_LINE,
    /**
     * Word Joiner (WJ)
     */
    WORD_JOINER,
    /**
     * Hangul L Jamo (JL)
     */
    HANGUL_L_JAMO,
    /**
     * Hangul V Jamo (JV)
     */
    HANGUL_V_JAMO,
    /**
     * Hangul T Jamo (JT)
     */
    HANGUL_T_JAMO,
    /**
     * Hangul LV Syllable (H2)
     */
    HANGUL_LV_SYLLABLE,
    /**
     * Hangul LVT Syllable (H3)
     */
    HANGUL_LVT_SYLLABLE,
    /**
     * Closing Parenthesis (CP). Since 2.28. Deprecated: 2.70: Use %G_UNICODE_BREAK_CLOSE_PARENTHESIS instead.
     */
    CLOSE_PARANTHESIS,
    /**
     * Closing Parenthesis (CP). Since 2.70
     */
    CLOSE_PARENTHESIS,
    /**
     * Conditional Japanese Starter (CJ). Since: 2.32
     */
    CONDITIONAL_JAPANESE_STARTER,
    /**
     * Hebrew Letter (HL). Since: 2.32
     */
    HEBREW_LETTER,
    /**
     * Regional Indicator (RI). Since: 2.36
     */
    REGIONAL_INDICATOR,
    /**
     * Emoji Base (EB). Since: 2.50
     */
    EMOJI_BASE,
    /**
     * Emoji Modifier (EM). Since: 2.50
     */
    EMOJI_MODIFIER,
    /**
     * Zero Width Joiner (ZWJ). Since: 2.50
     */
    ZERO_WIDTH_JOINER,
    /**
     * Aksara (AK). Since: 2.80
     * `G_UNICODE_BREAK_AKSARA_PRE_BASE` (AP). Since: 2.80
     * `G_UNICODE_BREAK_AKSARA_START` (AS). Since: 2.80
     * `G_UNICODE_BREAK_VIRAMA_FINAL` (VF). Since: 2.80
     * `G_UNICODE_BREAK_VIRAMA` (VI). Since: 2.80
     */
    AKSARA,
    AKSARA_PRE_BASE,
    AKSARA_START,
    VIRAMA_FINAL,
    VIRAMA,
  }
  /**
   * The #GUnicodeScript enumeration identifies different writing
   * systems. The values correspond to the names as defined in the
   * Unicode standard. The enumeration has been added in GLib 2.14,
   * and is interchangeable with #PangoScript.
   *
   * Note that new types may be added in the future. Applications
   * should be ready to handle unknown values.
   * See [Unicode Standard Annex #24: Script names](http://www.unicode.org/reports/tr24/).
   */
  enum UnicodeScript {
    /**
     * a value never returned from g_unichar_get_script()
     */
    INVALID_CODE,
    /**
     * a character used by multiple different scripts
     */
    COMMON,
    /**
     * a mark glyph that takes its script from the
     *                               base glyph to which it is attached
     */
    INHERITED,
    /**
     * Arabic
     */
    ARABIC,
    /**
     * Armenian
     */
    ARMENIAN,
    /**
     * Bengali
     */
    BENGALI,
    /**
     * Bopomofo
     */
    BOPOMOFO,
    /**
     * Cherokee
     */
    CHEROKEE,
    /**
     * Coptic
     */
    COPTIC,
    /**
     * Cyrillic
     */
    CYRILLIC,
    /**
     * Deseret
     */
    DESERET,
    /**
     * Devanagari
     */
    DEVANAGARI,
    /**
     * Ethiopic
     */
    ETHIOPIC,
    /**
     * Georgian
     */
    GEORGIAN,
    /**
     * Gothic
     */
    GOTHIC,
    /**
     * Greek
     */
    GREEK,
    /**
     * Gujarati
     */
    GUJARATI,
    /**
     * Gurmukhi
     */
    GURMUKHI,
    /**
     * Han
     */
    HAN,
    /**
     * Hangul
     */
    HANGUL,
    /**
     * Hebrew
     */
    HEBREW,
    /**
     * Hiragana
     */
    HIRAGANA,
    /**
     * Kannada
     */
    KANNADA,
    /**
     * Katakana
     */
    KATAKANA,
    /**
     * Khmer
     */
    KHMER,
    /**
     * Lao
     */
    LAO,
    /**
     * Latin
     */
    LATIN,
    /**
     * Malayalam
     */
    MALAYALAM,
    /**
     * Mongolian
     */
    MONGOLIAN,
    /**
     * Myanmar
     */
    MYANMAR,
    /**
     * Ogham
     */
    OGHAM,
    /**
     * Old Italic
     */
    OLD_ITALIC,
    /**
     * Oriya
     */
    ORIYA,
    /**
     * Runic
     */
    RUNIC,
    /**
     * Sinhala
     */
    SINHALA,
    /**
     * Syriac
     */
    SYRIAC,
    /**
     * Tamil
     */
    TAMIL,
    /**
     * Telugu
     */
    TELUGU,
    /**
     * Thaana
     */
    THAANA,
    /**
     * Thai
     */
    THAI,
    /**
     * Tibetan
     */
    TIBETAN,
    /**
     * Canadian Aboriginal
     */
    CANADIAN_ABORIGINAL,
    /**
     * Yi
     */
    YI,
    /**
     * Tagalog
     */
    TAGALOG,
    /**
     * Hanunoo
     */
    HANUNOO,
    /**
     * Buhid
     */
    BUHID,
    /**
     * Tagbanwa
     */
    TAGBANWA,
    /**
     * Braille
     */
    BRAILLE,
    /**
     * Cypriot
     */
    CYPRIOT,
    /**
     * Limbu
     */
    LIMBU,
    /**
     * Osmanya
     */
    OSMANYA,
    /**
     * Shavian
     */
    SHAVIAN,
    /**
     * Linear B
     */
    LINEAR_B,
    /**
     * Tai Le
     */
    TAI_LE,
    /**
     * Ugaritic
     */
    UGARITIC,
    /**
     * New Tai Lue
     */
    NEW_TAI_LUE,
    /**
     * Buginese
     */
    BUGINESE,
    /**
     * Glagolitic
     */
    GLAGOLITIC,
    /**
     * Tifinagh
     */
    TIFINAGH,
    /**
     * Syloti Nagri
     */
    SYLOTI_NAGRI,
    /**
     * Old Persian
     */
    OLD_PERSIAN,
    /**
     * Kharoshthi
     */
    KHAROSHTHI,
    /**
     * an unassigned code point
     */
    UNKNOWN,
    /**
     * Balinese
     */
    BALINESE,
    /**
     * Cuneiform
     */
    CUNEIFORM,
    /**
     * Phoenician
     */
    PHOENICIAN,
    /**
     * Phags-pa
     */
    PHAGS_PA,
    /**
     * N'Ko
     */
    NKO,
    /**
     * Kayah Li. Since 2.16.3
     */
    KAYAH_LI,
    /**
     * Lepcha. Since 2.16.3
     */
    LEPCHA,
    /**
     * Rejang. Since 2.16.3
     */
    REJANG,
    /**
     * Sundanese. Since 2.16.3
     */
    SUNDANESE,
    /**
     * Saurashtra. Since 2.16.3
     */
    SAURASHTRA,
    /**
     * Cham. Since 2.16.3
     */
    CHAM,
    /**
     * Ol Chiki. Since 2.16.3
     */
    OL_CHIKI,
    /**
     * Vai. Since 2.16.3
     */
    VAI,
    /**
     * Carian. Since 2.16.3
     */
    CARIAN,
    /**
     * Lycian. Since 2.16.3
     */
    LYCIAN,
    /**
     * Lydian. Since 2.16.3
     */
    LYDIAN,
    /**
     * Avestan. Since 2.26
     */
    AVESTAN,
    /**
     * Bamum. Since 2.26
     */
    BAMUM,
    /**
     * Egyptian Hieroglpyhs. Since 2.26
     */
    EGYPTIAN_HIEROGLYPHS,
    /**
     * Imperial Aramaic. Since 2.26
     */
    IMPERIAL_ARAMAIC,
    /**
     * Inscriptional Pahlavi. Since 2.26
     */
    INSCRIPTIONAL_PAHLAVI,
    /**
     * Inscriptional Parthian. Since 2.26
     */
    INSCRIPTIONAL_PARTHIAN,
    /**
     * Javanese. Since 2.26
     */
    JAVANESE,
    /**
     * Kaithi. Since 2.26
     */
    KAITHI,
    /**
     * Lisu. Since 2.26
     */
    LISU,
    /**
     * Meetei Mayek. Since 2.26
     */
    MEETEI_MAYEK,
    /**
     * Old South Arabian. Since 2.26
     */
    OLD_SOUTH_ARABIAN,
    /**
     * Old Turkic. Since 2.28
     */
    OLD_TURKIC,
    /**
     * Samaritan. Since 2.26
     */
    SAMARITAN,
    /**
     * Tai Tham. Since 2.26
     */
    TAI_THAM,
    /**
     * Tai Viet. Since 2.26
     */
    TAI_VIET,
    /**
     * Batak. Since 2.28
     */
    BATAK,
    /**
     * Brahmi. Since 2.28
     */
    BRAHMI,
    /**
     * Mandaic. Since 2.28
     */
    MANDAIC,
    /**
     * Chakma. Since: 2.32
     */
    CHAKMA,
    /**
     * Meroitic Cursive. Since: 2.32
     */
    MEROITIC_CURSIVE,
    /**
     * Meroitic Hieroglyphs. Since: 2.32
     */
    MEROITIC_HIEROGLYPHS,
    /**
     * Miao. Since: 2.32
     */
    MIAO,
    /**
     * Sharada. Since: 2.32
     */
    SHARADA,
    /**
     * Sora Sompeng. Since: 2.32
     */
    SORA_SOMPENG,
    /**
     * Takri. Since: 2.32
     */
    TAKRI,
    /**
     * Bassa. Since: 2.42
     */
    BASSA_VAH,
    /**
     * Caucasian Albanian. Since: 2.42
     */
    CAUCASIAN_ALBANIAN,
    /**
     * Duployan. Since: 2.42
     */
    DUPLOYAN,
    /**
     * Elbasan. Since: 2.42
     */
    ELBASAN,
    /**
     * Grantha. Since: 2.42
     */
    GRANTHA,
    /**
     * Kjohki. Since: 2.42
     */
    KHOJKI,
    /**
     * Khudawadi, Sindhi. Since: 2.42
     */
    KHUDAWADI,
    /**
     * Linear A. Since: 2.42
     */
    LINEAR_A,
    /**
     * Mahajani. Since: 2.42
     */
    MAHAJANI,
    /**
     * Manichaean. Since: 2.42
     */
    MANICHAEAN,
    /**
     * Mende Kikakui. Since: 2.42
     */
    MENDE_KIKAKUI,
    /**
     * Modi. Since: 2.42
     */
    MODI,
    /**
     * Mro. Since: 2.42
     */
    MRO,
    /**
     * Nabataean. Since: 2.42
     */
    NABATAEAN,
    /**
     * Old North Arabian. Since: 2.42
     */
    OLD_NORTH_ARABIAN,
    /**
     * Old Permic. Since: 2.42
     */
    OLD_PERMIC,
    /**
     * Pahawh Hmong. Since: 2.42
     */
    PAHAWH_HMONG,
    /**
     * Palmyrene. Since: 2.42
     */
    PALMYRENE,
    /**
     * Pau Cin Hau. Since: 2.42
     */
    PAU_CIN_HAU,
    /**
     * Psalter Pahlavi. Since: 2.42
     */
    PSALTER_PAHLAVI,
    /**
     * Siddham. Since: 2.42
     */
    SIDDHAM,
    /**
     * Tirhuta. Since: 2.42
     */
    TIRHUTA,
    /**
     * Warang Citi. Since: 2.42
     */
    WARANG_CITI,
    /**
     * Ahom. Since: 2.48
     */
    AHOM,
    /**
     * Anatolian Hieroglyphs. Since: 2.48
     */
    ANATOLIAN_HIEROGLYPHS,
    /**
     * Hatran. Since: 2.48
     */
    HATRAN,
    /**
     * Multani. Since: 2.48
     */
    MULTANI,
    /**
     * Old Hungarian. Since: 2.48
     */
    OLD_HUNGARIAN,
    /**
     * Signwriting. Since: 2.48
     */
    SIGNWRITING,
    /**
     * Adlam. Since: 2.50
     */
    ADLAM,
    /**
     * Bhaiksuki. Since: 2.50
     */
    BHAIKSUKI,
    /**
     * Marchen. Since: 2.50
     */
    MARCHEN,
    /**
     * Newa. Since: 2.50
     */
    NEWA,
    /**
     * Osage. Since: 2.50
     */
    OSAGE,
    /**
     * Tangut. Since: 2.50
     */
    TANGUT,
    /**
     * Masaram Gondi. Since: 2.54
     */
    MASARAM_GONDI,
    /**
     * Nushu. Since: 2.54
     */
    NUSHU,
    /**
     * Soyombo. Since: 2.54
     */
    SOYOMBO,
    /**
     * Zanabazar Square. Since: 2.54
     */
    ZANABAZAR_SQUARE,
    /**
     * Dogra. Since: 2.58
     */
    DOGRA,
    /**
     * Gunjala Gondi. Since: 2.58
     */
    GUNJALA_GONDI,
    /**
     * Hanifi Rohingya. Since: 2.58
     */
    HANIFI_ROHINGYA,
    /**
     * Makasar. Since: 2.58
     */
    MAKASAR,
    /**
     * Medefaidrin. Since: 2.58
     */
    MEDEFAIDRIN,
    /**
     * Old Sogdian. Since: 2.58
     */
    OLD_SOGDIAN,
    /**
     * Sogdian. Since: 2.58
     */
    SOGDIAN,
    /**
     * Elym. Since: 2.62
     */
    ELYMAIC,
    /**
     * Nand. Since: 2.62
     */
    NANDINAGARI,
    /**
     * Rohg. Since: 2.62
     */
    NYIAKENG_PUACHUE_HMONG,
    /**
     * Wcho. Since: 2.62
     */
    WANCHO,
    /**
     * Chorasmian. Since: 2.66
     */
    CHORASMIAN,
    /**
     * Dives Akuru. Since: 2.66
     */
    DIVES_AKURU,
    /**
     * Khitan small script. Since: 2.66
     */
    KHITAN_SMALL_SCRIPT,
    /**
     * Yezidi. Since: 2.66
     */
    YEZIDI,
    /**
     * Cypro-Minoan. Since: 2.72
     */
    CYPRO_MINOAN,
    /**
     * Old Uyghur. Since: 2.72
     */
    OLD_UYGHUR,
    /**
     * Tangsa. Since: 2.72
     */
    TANGSA,
    /**
     * Toto. Since: 2.72
     */
    TOTO,
    /**
     * Vithkuqi. Since: 2.72
     */
    VITHKUQI,
    /**
     * Mathematical notation. Since: 2.72
     */
    MATH,
    /**
     * Kawi. Since 2.74
     */
    KAWI,
    /**
     * Nag Mundari. Since 2.74
     */
    NAG_MUNDARI,
  }
  /**
   * These are the possible character classifications from the
   * Unicode specification.
   * See [Unicode Character Database](http://www.unicode.org/reports/tr44/#General_Category_Values).
   */
  enum UnicodeType {
    /**
     * General category "Other, Control" (Cc)
     */
    CONTROL,
    /**
     * General category "Other, Format" (Cf)
     */
    FORMAT,
    /**
     * General category "Other, Not Assigned" (Cn)
     */
    UNASSIGNED,
    /**
     * General category "Other, Private Use" (Co)
     */
    PRIVATE_USE,
    /**
     * General category "Other, Surrogate" (Cs)
     */
    SURROGATE,
    /**
     * General category "Letter, Lowercase" (Ll)
     */
    LOWERCASE_LETTER,
    /**
     * General category "Letter, Modifier" (Lm)
     */
    MODIFIER_LETTER,
    /**
     * General category "Letter, Other" (Lo)
     */
    OTHER_LETTER,
    /**
     * General category "Letter, Titlecase" (Lt)
     */
    TITLECASE_LETTER,
    /**
     * General category "Letter, Uppercase" (Lu)
     */
    UPPERCASE_LETTER,
    /**
     * General category "Mark, Spacing" (Mc)
     */
    SPACING_MARK,
    /**
     * General category "Mark, Enclosing" (Me)
     */
    ENCLOSING_MARK,
    /**
     * General category "Mark, Nonspacing" (Mn)
     */
    NON_SPACING_MARK,
    /**
     * General category "Number, Decimal Digit" (Nd)
     */
    DECIMAL_NUMBER,
    /**
     * General category "Number, Letter" (Nl)
     */
    LETTER_NUMBER,
    /**
     * General category "Number, Other" (No)
     */
    OTHER_NUMBER,
    /**
     * General category "Punctuation, Connector" (Pc)
     */
    CONNECT_PUNCTUATION,
    /**
     * General category "Punctuation, Dash" (Pd)
     */
    DASH_PUNCTUATION,
    /**
     * General category "Punctuation, Close" (Pe)
     */
    CLOSE_PUNCTUATION,
    /**
     * General category "Punctuation, Final quote" (Pf)
     */
    FINAL_PUNCTUATION,
    /**
     * General category "Punctuation, Initial quote" (Pi)
     */
    INITIAL_PUNCTUATION,
    /**
     * General category "Punctuation, Other" (Po)
     */
    OTHER_PUNCTUATION,
    /**
     * General category "Punctuation, Open" (Ps)
     */
    OPEN_PUNCTUATION,
    /**
     * General category "Symbol, Currency" (Sc)
     */
    CURRENCY_SYMBOL,
    /**
     * General category "Symbol, Modifier" (Sk)
     */
    MODIFIER_SYMBOL,
    /**
     * General category "Symbol, Math" (Sm)
     */
    MATH_SYMBOL,
    /**
     * General category "Symbol, Other" (So)
     */
    OTHER_SYMBOL,
    /**
     * General category "Separator, Line" (Zl)
     */
    LINE_SEPARATOR,
    /**
     * General category "Separator, Paragraph" (Zp)
     */
    PARAGRAPH_SEPARATOR,
    /**
     * General category "Separator, Space" (Zs)
     */
    SPACE_SEPARATOR,
  }
  /**
   * Mnemonic constants for the ends of a Unix pipe.
   */
  enum UnixPipeEnd {
    /**
     * The readable file descriptor 0
     */
    READ,
    /**
     * The writable file descriptor 1
     */
    WRITE,
  }
  /**
   * Error codes returned by #GUri methods.
   */
  enum UriError {
    /**
     * Generic error if no more specific error is available.
     *     See the error message for details.
     */
    FAILED,
    /**
     * The scheme of a URI could not be parsed.
     */
    BAD_SCHEME,
    /**
     * The user/userinfo of a URI could not be parsed.
     */
    BAD_USER,
    /**
     * The password of a URI could not be parsed.
     */
    BAD_PASSWORD,
    /**
     * The authentication parameters of a URI could not be parsed.
     */
    BAD_AUTH_PARAMS,
    /**
     * The host of a URI could not be parsed.
     */
    BAD_HOST,
    /**
     * The port of a URI could not be parsed.
     */
    BAD_PORT,
    /**
     * The path of a URI could not be parsed.
     */
    BAD_PATH,
    /**
     * The query of a URI could not be parsed.
     */
    BAD_QUERY,
    /**
     * The fragment of a URI could not be parsed.
     */
    BAD_FRAGMENT,
  }
  /**
   * These are logical ids for special directories which are defined
   * depending on the platform used. You should use g_get_user_special_dir()
   * to retrieve the full path associated to the logical id.
   *
   * The #GUserDirectory enumeration can be extended at later date. Not
   * every platform has a directory for every logical id in this
   * enumeration.
   */
  enum UserDirectory {
    /**
     * the user's Desktop directory
     */
    DIRECTORY_DESKTOP,
    /**
     * the user's Documents directory
     */
    DIRECTORY_DOCUMENTS,
    /**
     * the user's Downloads directory
     */
    DIRECTORY_DOWNLOAD,
    /**
     * the user's Music directory
     */
    DIRECTORY_MUSIC,
    /**
     * the user's Pictures directory
     */
    DIRECTORY_PICTURES,
    /**
     * the user's shared directory
     */
    DIRECTORY_PUBLIC_SHARE,
    /**
     * the user's Templates directory
     */
    DIRECTORY_TEMPLATES,
    /**
     * the user's Movies directory
     */
    DIRECTORY_VIDEOS,
    /**
     * the number of enum values
     */
    N_DIRECTORIES,
  }
  /**
   * The range of possible top-level types of #GVariant instances.
   */
  enum VariantClass {
    /**
     * The #GVariant is a boolean.
     */
    BOOLEAN,
    /**
     * The #GVariant is a byte.
     */
    BYTE,
    /**
     * The #GVariant is a signed 16 bit integer.
     */
    INT16,
    /**
     * The #GVariant is an unsigned 16 bit integer.
     */
    UINT16,
    /**
     * The #GVariant is a signed 32 bit integer.
     */
    INT32,
    /**
     * The #GVariant is an unsigned 32 bit integer.
     */
    UINT32,
    /**
     * The #GVariant is a signed 64 bit integer.
     */
    INT64,
    /**
     * The #GVariant is an unsigned 64 bit integer.
     */
    UINT64,
    /**
     * The #GVariant is a file handle index.
     */
    HANDLE,
    /**
     * The #GVariant is a double precision floating
     *                          point value.
     */
    DOUBLE,
    /**
     * The #GVariant is a normal string.
     */
    STRING,
    /**
     * The #GVariant is a D-Bus object path
     *                               string.
     */
    OBJECT_PATH,
    /**
     * The #GVariant is a D-Bus signature string.
     */
    SIGNATURE,
    /**
     * The #GVariant is a variant.
     */
    VARIANT,
    /**
     * The #GVariant is a maybe-typed value.
     */
    MAYBE,
    /**
     * The #GVariant is an array.
     */
    ARRAY,
    /**
     * The #GVariant is a tuple.
     */
    TUPLE,
    /**
     * The #GVariant is a dictionary entry.
     */
    DICT_ENTRY,
  }
  /**
   * Error codes returned by parsing text-format GVariants.
   */
  enum VariantParseError {
    /**
     * generic error (unused)
     */
    FAILED,
    /**
     * a non-basic #GVariantType was given where a basic type was expected
     */
    BASIC_TYPE_EXPECTED,
    /**
     * cannot infer the #GVariantType
     */
    CANNOT_INFER_TYPE,
    /**
     * an indefinite #GVariantType was given where a definite type was expected
     */
    DEFINITE_TYPE_EXPECTED,
    /**
     * extra data after parsing finished
     */
    INPUT_NOT_AT_END,
    /**
     * invalid character in number or unicode escape
     */
    INVALID_CHARACTER,
    /**
     * not a valid #GVariant format string
     */
    INVALID_FORMAT_STRING,
    /**
     * not a valid object path
     */
    INVALID_OBJECT_PATH,
    /**
     * not a valid type signature
     */
    INVALID_SIGNATURE,
    /**
     * not a valid #GVariant type string
     */
    INVALID_TYPE_STRING,
    /**
     * could not find a common type for array entries
     */
    NO_COMMON_TYPE,
    /**
     * the numerical value is out of range of the given type
     */
    NUMBER_OUT_OF_RANGE,
    /**
     * the numerical value is out of range for any type
     */
    NUMBER_TOO_BIG,
    /**
     * cannot parse as variant of the specified type
     */
    TYPE_ERROR,
    /**
     * an unexpected token was encountered
     */
    UNEXPECTED_TOKEN,
    /**
     * an unknown keyword was encountered
     */
    UNKNOWN_KEYWORD,
    /**
     * unterminated string constant
     */
    UNTERMINATED_STRING_CONSTANT,
    /**
     * no value given
     */
    VALUE_EXPECTED,
    /**
     * variant was too deeply nested; #GVariant is only guaranteed to handle nesting up to 64 levels (Since: 2.64)
     */
    RECURSION,
  }
  enum AsciiType {
    ALNUM,
    ALPHA,
    CNTRL,
    DIGIT,
    GRAPH,
    LOWER,
    PRINT,
    PUNCT,
    SPACE,
    UPPER,
    XDIGIT,
  }
  /**
   * Flags to pass to g_file_set_contents_full() to affect its safety and
   * performance.
   * @bitfield
   */
  enum FileSetContentsFlags {
    /**
     * No guarantees about file consistency or durability.
     *   The most dangerous setting, which is slightly faster than other settings.
     */
    NONE,
    /**
     * Guarantee file consistency: after a crash,
     *   either the old version of the file or the new version of the file will be
     *   available, but not a mixture. On Unix systems this equates to an `fsync()`
     *   on the file and use of an atomic `rename()` of the new version of the file
     *   over the old.
     */
    CONSISTENT,
    /**
     * Guarantee file durability: after a crash, the
     *   new version of the file will be available. On Unix systems this equates to
     *   an `fsync()` on the file (if %G_FILE_SET_CONTENTS_CONSISTENT is unset), or
     *   the effects of %G_FILE_SET_CONTENTS_CONSISTENT plus an `fsync()` on the
     *   directory containing the file after calling `rename()`.
     */
    DURABLE,
    /**
     * Only apply consistency and durability
     *   guarantees if the file already exists. This may speed up file operations
     *   if the file doesn’t currently exist, but may result in a corrupted version
     *   of the new file if the system crashes while writing it.
     */
    ONLY_EXISTING,
  }
  /**
   * A test to perform on a file using g_file_test().
   * @bitfield
   */
  enum FileTest {
    /**
     * %TRUE if the file is a regular file
     *     (not a directory). Note that this test will also return %TRUE
     *     if the tested file is a symlink to a regular file.
     */
    IS_REGULAR,
    /**
     * %TRUE if the file is a symlink.
     */
    IS_SYMLINK,
    /**
     * %TRUE if the file is a directory.
     */
    IS_DIR,
    /**
     * %TRUE if the file is executable.
     */
    IS_EXECUTABLE,
    /**
     * %TRUE if the file exists. It may or may not
     *     be a regular file.
     */
    EXISTS,
  }
  /**
   * Flags to modify the format of the string returned by g_format_size_full().
   * @bitfield
   */
  enum FormatSizeFlags {
    /**
     * behave the same as g_format_size()
     */
    DEFAULT,
    /**
     * include the exact number of bytes as part
     *     of the returned string.  For example, "45.6 kB (45,612 bytes)".
     */
    LONG_FORMAT,
    /**
     * use IEC (base 1024) units with "KiB"-style
     *     suffixes. IEC units should only be used for reporting things with
     *     a strong "power of 2" basis, like RAM sizes or RAID stripe sizes.
     *     Network and storage sizes should be reported in the normal SI units.
     */
    IEC_UNITS,
    /**
     * set the size as a quantity in bits, rather than
     *     bytes, and return units in bits. For example, ‘Mbit’ rather than ‘MB’.
     */
    BITS,
    /**
     * return only value, without unit; this should
     *     not be used together with `G_FORMAT_SIZE_LONG_FORMAT`
     *     nor `G_FORMAT_SIZE_ONLY_UNIT`. Since: 2.74
     */
    ONLY_VALUE,
    /**
     * return only unit, without value; this should
     *     not be used together with `G_FORMAT_SIZE_LONG_FORMAT`
     *     nor `G_FORMAT_SIZE_ONLY_VALUE`. Since: 2.74
     */
    ONLY_UNIT,
  }
  /**
   * Flags used internally in the #GHook implementation.
   * @bitfield
   */
  enum HookFlagMask {
    /**
     * set if the hook has not been destroyed
     */
    ACTIVE,
    /**
     * set if the hook is currently being run
     */
    IN_CALL,
    /**
     * A mask covering all bits reserved for
     *   hook flags; see %G_HOOK_FLAG_USER_SHIFT
     */
    MASK,
  }
  /**
   * A bitwise combination representing a condition to watch for on an
   * event source.
   * @bitfield
   */
  enum IOCondition {
    /**
     * There is data to read.
     */
    IN,
    /**
     * Data can be written (without blocking).
     */
    OUT,
    /**
     * There is urgent data to read.
     */
    PRI,
    /**
     * Error condition.
     */
    ERR,
    /**
     * Hung up (the connection has been broken, usually for
     *            pipes and sockets).
     */
    HUP,
    /**
     * Invalid request. The file descriptor is not open.
     */
    NVAL,
  }
  /**
   * Specifies properties of a #GIOChannel. Some of the flags can only be
   * read with g_io_channel_get_flags(), but not changed with
   * g_io_channel_set_flags().
   * @bitfield
   */
  enum IOFlags {
    /**
     * no special flags set. Since: 2.74
     */
    NONE,
    /**
     * turns on append mode, corresponds to %O_APPEND
     *     (see the documentation of the UNIX open() syscall)
     */
    APPEND,
    /**
     * turns on nonblocking mode, corresponds to
     *     %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open()
     *     syscall)
     */
    NONBLOCK,
    /**
     * indicates that the io channel is readable.
     *     This flag cannot be changed.
     */
    IS_READABLE,
    /**
     * indicates that the io channel is writable.
     *     This flag cannot be changed.
     */
    IS_WRITABLE,
    /**
     * a misspelled version of `G_IO_FLAG_IS_WRITABLE`
     *     that existed before the spelling was fixed in GLib 2.30. It is kept
     *     here for compatibility reasons. Deprecated since 2.30
     */
    IS_WRITEABLE,
    /**
     * indicates that the io channel is seekable,
     *     i.e. that g_io_channel_seek_position() can be used on it.
     *     This flag cannot be changed.
     */
    IS_SEEKABLE,
    /**
     * the mask that specifies all the valid flags.
     */
    MASK,
    /**
     * the mask of the flags that are returned from
     *     g_io_channel_get_flags()
     */
    GET_MASK,
    /**
     * the mask of the flags that the user can modify
     *     with g_io_channel_set_flags()
     */
    SET_MASK,
  }
  /**
   * Flags which influence the parsing.
   * @bitfield
   */
  enum KeyFileFlags {
    /**
     * No flags, default behaviour
     */
    NONE,
    /**
     * Use this flag if you plan to write the
     *   (possibly modified) contents of the key file back to a file;
     *   otherwise all comments will be lost when the key file is
     *   written back.
     */
    KEEP_COMMENTS,
    /**
     * Use this flag if you plan to write the
     *   (possibly modified) contents of the key file back to a file;
     *   otherwise only the translations for the current language will be
     *   written back.
     */
    KEEP_TRANSLATIONS,
  }
  /**
   * Flags specifying the level of log messages.
   *
   * It is possible to change how GLib treats messages of the various
   * levels using [func`GLib`.log_set_handler] and [func`GLib`.log_set_fatal_mask].
   * @bitfield
   */
  enum LogLevelFlags {
    /**
     * internal flag
     */
    FLAG_RECURSION,
    /**
     * internal flag
     */
    FLAG_FATAL,
    /**
     * log level for errors, see [func`GLib`.error].
     *   This level is also used for messages produced by [func`GLib`.assert].
     */
    LEVEL_ERROR,
    /**
     * log level for critical warning messages, see
     *   [func`GLib`.critical]. This level is also used for messages produced by
     *   [func`GLib`.return_if_fail] and [func`GLib`.return_val_if_fail].
     */
    LEVEL_CRITICAL,
    /**
     * log level for warnings, see [func`GLib`.warning]
     */
    LEVEL_WARNING,
    /**
     * log level for messages, see [func`GLib`.message]
     */
    LEVEL_MESSAGE,
    /**
     * log level for informational messages, see [func`GLib`.info]
     */
    LEVEL_INFO,
    /**
     * log level for debug messages, see [func`GLib`.debug]
     */
    LEVEL_DEBUG,
    /**
     * a mask including all log levels
     */
    LEVEL_MASK,
  }
  /**
   * Flags to pass to g_main_context_new_with_flags() which affect the behaviour
   * of a #GMainContext.
   * @bitfield
   */
  enum MainContextFlags {
    /**
     * Default behaviour.
     */
    NONE,
    /**
     * Assume that polling for events will
     * free the thread to process other jobs. That's useful if you're using
     * `g_main_context_{prepare,query,check,dispatch}` to integrate GMainContext in
     * other event loops.
     */
    OWNERLESS_POLLING,
  }
  /**
   * A mixed enumerated type and flags field. You must specify one type
   * (string, strdup, boolean, tristate).  Additionally, you may  optionally
   * bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL.
   *
   * It is likely that this enum will be extended in the future to
   * support other types.
   * @bitfield
   */
  enum MarkupCollectType {
    /**
     * used to terminate the list of attributes
     *     to collect
     */
    INVALID,
    /**
     * collect the string pointer directly from
     *     the attribute_values[] array. Expects a parameter of type (const
     *     char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the
     *     attribute isn't present then the pointer will be set to %NULL
     */
    STRING,
    /**
     * as with %G_MARKUP_COLLECT_STRING, but
     *     expects a parameter of type (char **) and g_strdup()s the
     *     returned pointer. The pointer must be freed with g_free()
     */
    STRDUP,
    /**
     * expects a parameter of type (gboolean *)
     *     and parses the attribute value as a boolean. Sets %FALSE if the
     *     attribute isn't present. Valid boolean values consist of
     *     (case-insensitive) "false", "f", "no", "n", "0" and "true", "t",
     *     "yes", "y", "1"
     */
    BOOLEAN,
    /**
     * as with %G_MARKUP_COLLECT_BOOLEAN, but
     *     in the case of a missing attribute a value is set that compares
     *     equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is
     *     implied
     */
    TRISTATE,
    /**
     * can be bitwise ORed with the other fields.
     *     If present, allows the attribute not to appear. A default value
     *     is set depending on what value type is used
     */
    OPTIONAL,
  }
  /**
   * Flags that affect the behaviour of the parser.
   * @bitfield
   */
  enum MarkupParseFlags {
    /**
     * No special behaviour. Since: 2.74
     */
    DEFAULT_FLAGS,
    /**
     * flag you should not use
     */
    DO_NOT_USE_THIS_UNSUPPORTED_FLAG,
    /**
     * When this flag is set, CDATA marked
     *     sections are not passed literally to the `passthrough` function of
     *     the parser. Instead, the content of the section (without the
     *     `<![CDATA[` and `]]>`) is
     *     passed to the `text` function. This flag was added in GLib 2.12
     */
    TREAT_CDATA_AS_TEXT,
    /**
     * Normally errors caught by GMarkup
     *     itself have line/column information prefixed to them to let the
     *     caller know the location of the error. When this flag is set the
     *     location information is also prefixed to errors generated by the
     *     #GMarkupParser implementation functions
     */
    PREFIX_ERROR_POSITION,
    /**
     * Ignore (don't report) qualified
     *     attributes and tags, along with their contents.  A qualified
     *     attribute or tag is one that contains ':' in its name (ie: is in
     *     another namespace).  Since: 2.40.
     */
    IGNORE_QUALIFIED,
  }
  /**
   * Flags which modify individual options.
   * @bitfield
   */
  enum OptionFlags {
    /**
     * No flags. Since: 2.42.
     */
    NONE,
    /**
     * The option doesn't appear in `--help` output.
     */
    HIDDEN,
    /**
     * The option appears in the main section of the
     *     `--help` output, even if it is defined in a group.
     */
    IN_MAIN,
    /**
     * For options of the %G_OPTION_ARG_NONE kind, this
     *     flag indicates that the sense of the option is reversed. i.e. %FALSE will
     *     be stored into the argument rather than %TRUE.
     */
    REVERSE,
    /**
     * For options of the %G_OPTION_ARG_CALLBACK kind,
     *     this flag indicates that the callback does not take any argument
     *     (like a %G_OPTION_ARG_NONE option). Since 2.8
     */
    NO_ARG,
    /**
     * For options of the %G_OPTION_ARG_CALLBACK
     *     kind, this flag indicates that the argument should be passed to the
     *     callback in the GLib filename encoding rather than UTF-8. Since 2.8
     */
    FILENAME,
    /**
     * For options of the %G_OPTION_ARG_CALLBACK
     *     kind, this flag indicates that the argument supply is optional.
     *     If no argument is given then data of %GOptionParseFunc will be
     *     set to NULL. Since 2.8
     */
    OPTIONAL_ARG,
    /**
     * This flag turns off the automatic conflict
     *     resolution which prefixes long option names with `groupname-` if
     *     there is a conflict. This option should only be used in situations
     *     where aliasing is necessary to model some legacy commandline interface.
     *     It is not safe to use this option, unless all option groups are under
     *     your direct control. Since 2.8.
     */
    NOALIAS,
  }
  /**
   * Flags specifying compile-time options.
   * @bitfield
   */
  enum RegexCompileFlags {
    /**
     * No special options set. Since: 2.74
     */
    DEFAULT,
    /**
     * Letters in the pattern match both upper- and
     *     lowercase letters. This option can be changed within a pattern
     *     by a "(?i)" option setting.
     */
    CASELESS,
    /**
     * By default, GRegex treats the strings as consisting
     *     of a single line of characters (even if it actually contains
     *     newlines). The "start of line" metacharacter ("^") matches only
     *     at the start of the string, while the "end of line" metacharacter
     *     ("$") matches only at the end of the string, or before a terminating
     *     newline (unless %G_REGEX_DOLLAR_ENDONLY is set). When
     *     %G_REGEX_MULTILINE is set, the "start of line" and "end of line"
     *     constructs match immediately following or immediately before any
     *     newline in the string, respectively, as well as at the very start
     *     and end. This can be changed within a pattern by a "(?m)" option
     *     setting.
     */
    MULTILINE,
    /**
     * A dot metacharacter (".") in the pattern matches all
     *     characters, including newlines. Without it, newlines are excluded.
     *     This option can be changed within a pattern by a ("?s") option setting.
     */
    DOTALL,
    /**
     * Whitespace data characters in the pattern are
     *     totally ignored except when escaped or inside a character class.
     *     Whitespace does not include the VT character (code 11). In addition,
     *     characters between an unescaped "#" outside a character class and
     *     the next newline character, inclusive, are also ignored. This can
     *     be changed within a pattern by a "(?x)" option setting.
     */
    EXTENDED,
    /**
     * The pattern is forced to be "anchored", that is,
     *     it is constrained to match only at the first matching point in the
     *     string that is being searched. This effect can also be achieved by
     *     appropriate constructs in the pattern itself such as the "^"
     *     metacharacter.
     */
    ANCHORED,
    /**
     * A dollar metacharacter ("$") in the pattern
     *     matches only at the end of the string. Without this option, a
     *     dollar also matches immediately before the final character if
     *     it is a newline (but not before any other newlines). This option
     *     is ignored if %G_REGEX_MULTILINE is set.
     */
    DOLLAR_ENDONLY,
    /**
     * Inverts the "greediness" of the quantifiers so that
     *     they are not greedy by default, but become greedy if followed by "?".
     *     It can also be set by a "(?U)" option setting within the pattern.
     */
    UNGREEDY,
    /**
     * Usually strings must be valid UTF-8 strings, using this
     *     flag they are considered as a raw sequence of bytes.
     */
    RAW,
    /**
     * Disables the use of numbered capturing
     *     parentheses in the pattern. Any opening parenthesis that is not
     *     followed by "?" behaves as if it were followed by "?:" but named
     *     parentheses can still be used for capturing (and they acquire numbers
     *     in the usual way).
     */
    NO_AUTO_CAPTURE,
    /**
     * Since 2.74 and the port to pcre2, requests JIT
     *     compilation, which, if the just-in-time compiler is available, further
     *     processes a compiled pattern into machine code that executes much
     *     faster. However, it comes at the cost of extra processing before the
     *     match is performed, so it is most beneficial to use this when the same
     *     compiled pattern is used for matching many times. Before 2.74 this
     *     option used the built-in non-JIT optimizations in pcre1.
     */
    OPTIMIZE,
    /**
     * Limits an unanchored pattern to match before (or at) the
     *     first newline. Since: 2.34
     */
    FIRSTLINE,
    /**
     * Names used to identify capturing subpatterns need not
     *     be unique. This can be helpful for certain types of pattern when it
     *     is known that only one instance of the named subpattern can ever be
     *     matched.
     */
    DUPNAMES,
    /**
     * Usually any newline character or character sequence is
     *     recognized. If this option is set, the only recognized newline character
     *     is '\r'.
     */
    NEWLINE_CR,
    /**
     * Usually any newline character or character sequence is
     *     recognized. If this option is set, the only recognized newline character
     *     is '\n'.
     */
    NEWLINE_LF,
    /**
     * Usually any newline character or character sequence is
     *     recognized. If this option is set, the only recognized newline character
     *     sequence is '\r\n'.
     */
    NEWLINE_CRLF,
    /**
     * Usually any newline character or character sequence
     *     is recognized. If this option is set, the only recognized newline character
     *     sequences are '\r', '\n', and '\r\n'. Since: 2.34
     */
    NEWLINE_ANYCRLF,
    /**
     * Usually any newline character or character sequence
     *     is recognised. If this option is set, then "\R" only recognizes the newline
     *    characters '\r', '\n' and '\r\n'. Since: 2.34
     */
    BSR_ANYCRLF,
    /**
     * Changes behaviour so that it is compatible with
     *     JavaScript rather than PCRE. Since GLib 2.74 this is no longer supported,
     *     as libpcre2 does not support it. Since: 2.34 Deprecated: 2.74
     */
    JAVASCRIPT_COMPAT,
  }
  /**
   * Flags specifying match-time options.
   * @bitfield
   */
  enum RegexMatchFlags {
    /**
     * No special options set. Since: 2.74
     */
    DEFAULT,
    /**
     * The pattern is forced to be "anchored", that is,
     *     it is constrained to match only at the first matching point in the
     *     string that is being searched. This effect can also be achieved by
     *     appropriate constructs in the pattern itself such as the "^"
     *     metacharacter.
     */
    ANCHORED,
    /**
     * Specifies that first character of the string is
     *     not the beginning of a line, so the circumflex metacharacter should
     *     not match before it. Setting this without %G_REGEX_MULTILINE (at
     *     compile time) causes circumflex never to match. This option affects
     *     only the behaviour of the circumflex metacharacter, it does not
     *     affect "\A".
     */
    NOTBOL,
    /**
     * Specifies that the end of the subject string is
     *     not the end of a line, so the dollar metacharacter should not match
     *     it nor (except in multiline mode) a newline immediately before it.
     *     Setting this without %G_REGEX_MULTILINE (at compile time) causes
     *     dollar never to match. This option affects only the behaviour of
     *     the dollar metacharacter, it does not affect "\Z" or "\z".
     */
    NOTEOL,
    /**
     * An empty string is not considered to be a valid
     *     match if this option is set. If there are alternatives in the pattern,
     *     they are tried. If all the alternatives match the empty string, the
     *     entire match fails. For example, if the pattern "a?b?" is applied to
     *     a string not beginning with "a" or "b", it matches the empty string
     *     at the start of the string. With this flag set, this match is not
     *     valid, so GRegex searches further into the string for occurrences
     *     of "a" or "b".
     */
    NOTEMPTY,
    /**
     * Turns on the partial matching feature, for more
     *     documentation on partial matching see g_match_info_is_partial_match().
     */
    PARTIAL,
    /**
     * Overrides the newline definition set when
     *     creating a new #GRegex, setting the '\r' character as line terminator.
     */
    NEWLINE_CR,
    /**
     * Overrides the newline definition set when
     *     creating a new #GRegex, setting the '\n' character as line terminator.
     */
    NEWLINE_LF,
    /**
     * Overrides the newline definition set when
     *     creating a new #GRegex, setting the '\r\n' characters sequence as line terminator.
     */
    NEWLINE_CRLF,
    /**
     * Overrides the newline definition set when
     *     creating a new #GRegex, any Unicode newline sequence
     *     is recognised as a newline. These are '\r', '\n' and '\rn', and the
     *     single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
     *     U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and
     *     U+2029 PARAGRAPH SEPARATOR.
     */
    NEWLINE_ANY,
    /**
     * Overrides the newline definition set when
     *     creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence
     *     is recognized as a newline. Since: 2.34
     */
    NEWLINE_ANYCRLF,
    /**
     * Overrides the newline definition for "\R" set when
     *     creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences
     *     are recognized as a newline by "\R". Since: 2.34
     */
    BSR_ANYCRLF,
    /**
     * Overrides the newline definition for "\R" set when
     *     creating a new #GRegex; any Unicode newline character or character sequence
     *     are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the
     *     single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
     *     U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and
     *     U+2029 PARAGRAPH SEPARATOR. Since: 2.34
     */
    BSR_ANY,
    /**
     * An alias for %G_REGEX_MATCH_PARTIAL. Since: 2.34
     */
    PARTIAL_SOFT,
    /**
     * Turns on the partial matching feature. In contrast to
     *     to %G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match
     *     is found, without continuing to search for a possible complete match. See
     *     g_match_info_is_partial_match() for more information. Since: 2.34
     */
    PARTIAL_HARD,
    /**
     * Like %G_REGEX_MATCH_NOTEMPTY, but only applied to
     *     the start of the matched string. For anchored
     *     patterns this can only happen for pattern containing "\K". Since: 2.34
     */
    NOTEMPTY_ATSTART,
  }
  /**
   * Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().
   * @bitfield
   */
  enum SpawnFlags {
    /**
     * no flags, default behaviour
     */
    DEFAULT,
    /**
     * the parent's open file descriptors will
     *     be inherited by the child; otherwise all descriptors except stdin,
     *     stdout and stderr will be closed before calling exec() in the child.
     */
    LEAVE_DESCRIPTORS_OPEN,
    /**
     * the child will not be automatically reaped;
     *     you must use g_child_watch_add() yourself (or call waitpid() or handle
     *     `SIGCHLD` yourself), or the child will become a zombie.
     */
    DO_NOT_REAP_CHILD,
    /**
     * `argv[0]` need not be an absolute path, it will be
     *     looked for in the user's `PATH`.
     */
    SEARCH_PATH,
    /**
     * the child's standard output will be discarded,
     *     instead of going to the same location as the parent's standard output.
     */
    STDOUT_TO_DEV_NULL,
    /**
     * the child's standard error will be discarded.
     */
    STDERR_TO_DEV_NULL,
    /**
     * the child will inherit the parent's standard
     *     input (by default, the child's standard input is attached to `/dev/null`).
     */
    CHILD_INHERITS_STDIN,
    /**
     * the first element of `argv` is the file to
     *     execute, while the remaining elements are the actual argument vector
     *     to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]`
     *     as the file to execute, and passes all of `argv` to the child.
     */
    FILE_AND_ARGV_ZERO,
    /**
     * if `argv[0]` is not an absolute path,
     *     it will be looked for in the `PATH` from the passed child environment.
     *     Since: 2.34
     */
    SEARCH_PATH_FROM_ENVP,
    /**
     * create all pipes with the `O_CLOEXEC` flag set.
     *     Since: 2.40
     */
    CLOEXEC_PIPES,
    /**
     * The child will inherit the parent's standard output.
     */
    CHILD_INHERITS_STDOUT,
    /**
     * The child will inherit the parent's standard error.
     */
    CHILD_INHERITS_STDERR,
    /**
     * The child's standard input is attached to `/dev/null`.
     */
    STDIN_FROM_DEV_NULL,
  }
  /**
   * Flags to pass to g_test_trap_subprocess() to control input and output.
   *
   * Note that in contrast with g_test_trap_fork(), the default is to
   * not show stdout and stderr.
   * @bitfield
   */
  enum TestSubprocessFlags {
    /**
     * Default behaviour. Since: 2.74
     */
    DEFAULT,
    /**
     * If this flag is given, the child
     *     process will inherit the parent's stdin. Otherwise, the child's
     *     stdin is redirected to `/dev/null`.
     */
    INHERIT_STDIN,
    /**
     * If this flag is given, the child
     *     process will inherit the parent's stdout. Otherwise, the child's
     *     stdout will not be visible, but it will be captured to allow
     *     later tests with g_test_trap_assert_stdout().
     */
    INHERIT_STDOUT,
    /**
     * If this flag is given, the child
     *     process will inherit the parent's stderr. Otherwise, the child's
     *     stderr will not be visible, but it will be captured to allow
     *     later tests with g_test_trap_assert_stderr().
     */
    INHERIT_STDERR,
  }
  /**
   * Test traps are guards around forked tests.
   * These flags determine what traps to set.
   * @bitfield
   */
  enum TestTrapFlags {
    /**
     * Default behaviour. Since: 2.74
     */
    DEFAULT,
    /**
     * Redirect stdout of the test child to
     *     `/dev/null` so it cannot be observed on the console during test
     *     runs. The actual output is still captured though to allow later
     *     tests with g_test_trap_assert_stdout().
     */
    SILENCE_STDOUT,
    /**
     * Redirect stderr of the test child to
     *     `/dev/null` so it cannot be observed on the console during test
     *     runs. The actual output is still captured though to allow later
     *     tests with g_test_trap_assert_stderr().
     */
    SILENCE_STDERR,
    /**
     * If this flag is given, stdin of the
     *     child process is shared with stdin of its parent process.
     *     It is redirected to `/dev/null` otherwise.
     */
    INHERIT_STDIN,
  }
  /**
   * Specifies which nodes are visited during several of the tree
   * functions, including g_node_traverse() and g_node_find().
   * @bitfield
   */
  enum TraverseFlags {
    /**
     * only leaf nodes should be visited. This name has
     *                     been introduced in 2.6, for older version use
     *                     %G_TRAVERSE_LEAFS.
     */
    LEAVES,
    /**
     * only non-leaf nodes should be visited. This
     *                         name has been introduced in 2.6, for older
     *                         version use %G_TRAVERSE_NON_LEAFS.
     */
    NON_LEAVES,
    /**
     * all nodes should be visited.
     */
    ALL,
    /**
     * a mask of all traverse flags.
     */
    MASK,
    /**
     * identical to %G_TRAVERSE_LEAVES.
     */
    LEAFS,
    /**
     * identical to %G_TRAVERSE_NON_LEAVES.
     */
    NON_LEAFS,
  }
  /**
   * Flags that describe a URI.
   *
   * When parsing a URI, if you need to choose different flags based on
   * the type of URI, you can use g_uri_peek_scheme() on the URI string
   * to check the scheme first, and use that to decide what flags to
   * parse it with.
   * @bitfield
   */
  enum UriFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Parse the URI more relaxedly than the
     *     [RFC 3986](https://tools.ietf.org/html/rfc3986) grammar specifies,
     *     fixing up or ignoring common mistakes in URIs coming from external
     *     sources. This is also needed for some obscure URI schemes where `;`
     *     separates the host from the path. Don’t use this flag unless you need to.
     */
    PARSE_RELAXED,
    /**
     * The userinfo field may contain a password,
     *     which will be separated from the username by `:`.
     */
    HAS_PASSWORD,
    /**
     * The userinfo may contain additional
     *     authentication-related parameters, which will be separated from
     *     the username and/or password by `;`.
     */
    HAS_AUTH_PARAMS,
    /**
     * When parsing a URI, this indicates that `%`-encoded
     *     characters in the userinfo, path, query, and fragment fields
     *     should not be decoded. (And likewise the host field if
     *     %G_URI_FLAGS_NON_DNS is also set.) When building a URI, it indicates
     *     that you have already `%`-encoded the components, and so #GUri
     *     should not do any encoding itself.
     */
    ENCODED,
    /**
     * The host component should not be assumed to be a
     *     DNS hostname or IP address (for example, for `smb` URIs with NetBIOS
     *     hostnames).
     */
    NON_DNS,
    /**
     * Same as %G_URI_FLAGS_ENCODED, for the query
     *     field only.
     */
    ENCODED_QUERY,
    /**
     * Same as %G_URI_FLAGS_ENCODED, for the path only.
     */
    ENCODED_PATH,
    /**
     * Same as %G_URI_FLAGS_ENCODED, for the
     *     fragment only.
     */
    ENCODED_FRAGMENT,
    /**
     * A scheme-based normalization will be applied.
     *     For example, when parsing an HTTP URI changing omitted path to `/` and
     *     omitted port to `80`; and when building a URI, changing empty path to `/`
     *     and default port `80`). This only supports a subset of known schemes. (Since: 2.68)
     */
    SCHEME_NORMALIZE,
  }
  /**
   * Flags describing what parts of the URI to hide in
   * g_uri_to_string_partial(). Note that %G_URI_HIDE_PASSWORD and
   * %G_URI_HIDE_AUTH_PARAMS will only work if the #GUri was parsed with
   * the corresponding flags.
   * @bitfield
   */
  enum UriHideFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Hide the userinfo.
     */
    USERINFO,
    /**
     * Hide the password.
     */
    PASSWORD,
    /**
     * Hide the auth_params.
     */
    AUTH_PARAMS,
    /**
     * Hide the query.
     */
    QUERY,
    /**
     * Hide the fragment.
     */
    FRAGMENT,
  }
  /**
   * Flags modifying the way parameters are handled by g_uri_parse_params() and
   * #GUriParamsIter.
   * @bitfield
   */
  enum UriParamsFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Parameter names are case insensitive.
     */
    CASE_INSENSITIVE,
    /**
     * Replace `+` with space character. Only useful for
     *     URLs on the web, using the `https` or `http` schemas.
     */
    WWW_FORM,
    /**
     * See %G_URI_FLAGS_PARSE_RELAXED.
     */
    PARSE_RELAXED,
  }
  const ALLOCATOR_LIST: number
  const ALLOCATOR_NODE: number
  const ALLOCATOR_SLIST: number
  const ALLOC_AND_FREE: number
  const ALLOC_ONLY: number
  const ANALYZER_ANALYZING: number
  /**
   * A good size for a buffer to be passed into [func`GLib`.ascii_dtostr].
   * It is guaranteed to be enough for all output of that function
   * on systems with 64bit IEEE-compatible doubles.
   *
   * The typical usage would be something like:
   * ```C
   * char buf[G_ASCII_DTOSTR_BUF_SIZE];
   *
   * fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));
   * ```
   */
  const ASCII_DTOSTR_BUF_SIZE: number
  /**
   * Evaluates to the initial reference count for `gatomicrefcount`.
   *
   * This macro is useful for initializing `gatomicrefcount` fields inside
   * structures, for instance:
   *
   *
   * ```c
   * typedef struct {
   *   gatomicrefcount ref_count;
   *   char *name;
   *   char *address;
   * } Person;
   *
   * static const Person default_person = {
   *   .ref_count = G_ATOMIC_REF_COUNT_INIT,
   *   .name = "Default name",
   *   .address = "Default address",
   * };
   * ```
   *
   */
  const ATOMIC_REF_COUNT_INIT: number
  const BIG_ENDIAN: number
  /**
   * The set of uppercase ASCII alphabet characters.
   * Used for specifying valid identifier characters
   * in #GScannerConfig.
   */
  const CSET_A_2_Z: string
  /**
   * The set of ASCII digits.
   * Used for specifying valid identifier characters
   * in #GScannerConfig.
   */
  const CSET_DIGITS: string
  /**
   * The set of lowercase ASCII alphabet characters.
   * Used for specifying valid identifier characters
   * in #GScannerConfig.
   */
  const CSET_a_2_z: string
  const C_STD_VERSION: number
  /**
   * A bitmask that restricts the possible flags passed to
   * g_datalist_set_flags(). Passing a flags value where
   * flags & ~G_DATALIST_FLAGS_MASK != 0 is an error.
   */
  const DATALIST_FLAGS_MASK: number
  /**
   * Represents an invalid #GDateDay.
   */
  const DATE_BAD_DAY: number
  /**
   * Represents an invalid Julian day number.
   */
  const DATE_BAD_JULIAN: number
  /**
   * Represents an invalid year.
   */
  const DATE_BAD_YEAR: number
  const DIR_SEPARATOR: number
  const DIR_SEPARATOR_S: string
  const E: number
  const GINT16_FORMAT: string
  const GINT16_MODIFIER: string
  const GINT32_FORMAT: string
  const GINT32_MODIFIER: string
  const GINT64_FORMAT: string
  const GINT64_MODIFIER: string
  const GINTPTR_FORMAT: string
  const GINTPTR_MODIFIER: string
  /**
   * Expands to "" on all modern compilers, and to  __FUNCTION__ on gcc
   * version 2.x. Don't use it.
   */
  const GNUC_FUNCTION: string
  /**
   * Expands to "" on all modern compilers, and to __PRETTY_FUNCTION__
   * on gcc version 2.x. Don't use it.
   */
  const GNUC_PRETTY_FUNCTION: string
  const GSIZE_FORMAT: string
  const GSIZE_MODIFIER: string
  const GSSIZE_FORMAT: string
  const GSSIZE_MODIFIER: string
  const GUINT16_FORMAT: string
  const GUINT32_FORMAT: string
  const GUINT64_FORMAT: string
  const GUINTPTR_FORMAT: string
  const HAVE_GINT64: number
  const HAVE_GNUC_VARARGS: number
  const HAVE_GNUC_VISIBILITY: number
  const HAVE_GROWING_STACK: number
  const HAVE_ISO_VARARGS: number
  /**
   * The position of the first bit which is not reserved for internal
   * use be the #GHook implementation, i.e.
   * `1 << G_HOOK_FLAG_USER_SHIFT` is the first
   * bit which can be used for application-defined flags.
   */
  const HOOK_FLAG_USER_SHIFT: number
  const IEEE754_DOUBLE_BIAS: number
  const IEEE754_FLOAT_BIAS: number
  /**
   * The name of the main group of a desktop entry file, as defined in the
   * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec).
   * Consult the specification for more
   * details about the meanings of the keys below.
   */
  const KEY_FILE_DESKTOP_GROUP: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string list
   * giving the available application actions.
   */
  const KEY_FILE_DESKTOP_KEY_ACTIONS: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list
   * of strings giving the categories in which the desktop entry
   * should be shown in a menu.
   */
  const KEY_FILE_DESKTOP_KEY_CATEGORIES: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
   * string giving the tooltip for the desktop entry.
   */
  const KEY_FILE_DESKTOP_KEY_COMMENT: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
   * set to true if the application is D-Bus activatable.
   */
  const KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
   * giving the command line to execute. It is only valid for desktop
   * entries with the `Application` type.
   */
  const KEY_FILE_DESKTOP_KEY_EXEC: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
   * string giving the generic name of the desktop entry.
   */
  const KEY_FILE_DESKTOP_KEY_GENERIC_NAME: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
   * stating whether the desktop entry has been deleted by the user.
   */
  const KEY_FILE_DESKTOP_KEY_HIDDEN: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
   * string giving the name of the icon to be displayed for the desktop
   * entry.
   */
  const KEY_FILE_DESKTOP_KEY_ICON: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list
   * of strings giving the MIME types supported by this desktop entry.
   */
  const KEY_FILE_DESKTOP_KEY_MIME_TYPE: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
   * string giving the specific name of the desktop entry.
   */
  const KEY_FILE_DESKTOP_KEY_NAME: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of
   * strings identifying the environments that should not display the
   * desktop entry.
   */
  const KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
   * stating whether the desktop entry should be shown in menus.
   */
  const KEY_FILE_DESKTOP_KEY_NO_DISPLAY: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of
   * strings identifying the environments that should display the
   * desktop entry.
   */
  const KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
   * containing the working directory to run the program in. It is only
   * valid for desktop entries with the `Application` type.
   */
  const KEY_FILE_DESKTOP_KEY_PATH: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
   * stating whether the application supports the
   * [Startup Notification Protocol Specification](http://www.freedesktop.org/Standards/startup-notification-spec).
   */
  const KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is string
   * identifying the WM class or name hint of a window that the application
   * will create, which can be used to emulate Startup Notification with
   * older applications.
   */
  const KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
   * stating whether the program should be run in a terminal window.
   *
   * It is only valid for desktop entries with the `Application` type.
   */
  const KEY_FILE_DESKTOP_KEY_TERMINAL: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
   * giving the file name of a binary on disk used to determine if the
   * program is actually installed. It is only valid for desktop entries
   * with the `Application` type.
   */
  const KEY_FILE_DESKTOP_KEY_TRY_EXEC: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
   * giving the type of the desktop entry.
   *
   * Usually %G_KEY_FILE_DESKTOP_TYPE_APPLICATION,
   * %G_KEY_FILE_DESKTOP_TYPE_LINK, or
   * %G_KEY_FILE_DESKTOP_TYPE_DIRECTORY.
   */
  const KEY_FILE_DESKTOP_KEY_TYPE: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
   * giving the URL to access. It is only valid for desktop entries
   * with the `Link` type.
   */
  const KEY_FILE_DESKTOP_KEY_URL: string
  /**
   * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
   * giving the version of the Desktop Entry Specification used for
   * the desktop entry file.
   */
  const KEY_FILE_DESKTOP_KEY_VERSION: string
  /**
   * The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
   * entries representing applications.
   */
  const KEY_FILE_DESKTOP_TYPE_APPLICATION: string
  /**
   * The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
   * entries representing directories.
   */
  const KEY_FILE_DESKTOP_TYPE_DIRECTORY: string
  /**
   * The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
   * entries representing links to documents.
   */
  const KEY_FILE_DESKTOP_TYPE_LINK: string
  const LITTLE_ENDIAN: number
  const LN10: number
  const LN2: number
  const LOG_2_BASE_10: number
  /**
   * Defines the log domain. See [Log Domains](#log-domains).
   *
   * Libraries should define this so that any messages
   * which they log can be differentiated from messages from other
   * libraries and application code. But be careful not to define
   * it in any public header files.
   *
   * Log domains must be unique, and it is recommended that they are the
   * application or library name, optionally followed by a hyphen and a sub-domain
   * name. For example, `bloatpad` or `bloatpad-io`.
   *
   * If undefined, it defaults to the default %NULL (or `""`) log domain; this is
   * not advisable, as it cannot be filtered against using the `G_MESSAGES_DEBUG`
   * environment variable.
   *
   * For example, GTK uses this in its `Makefile.am`:
   *
   * ```
   * AM_CPPFLAGS = -DG_LOG_DOMAIN=\"Gtk\"
   * ```
   *
   *
   * Applications can choose to leave it as the default %NULL (or `""`)
   * domain. However, defining the domain offers the same advantages as
   * above.
   */
  const LOG_DOMAIN: number
  /**
   * GLib log levels that are considered fatal by default.
   *
   * This is not used if structured logging is enabled; see
   * [Using Structured Logging](logging.html#using-structured-logging).
   */
  const LOG_FATAL_MASK: number
  /**
   * Log levels below `1<<G_LOG_LEVEL_USER_SHIFT` are used by GLib.
   * Higher bits can be used for user-defined log levels.
   */
  const LOG_LEVEL_USER_SHIFT: number
  /**
   * The major version number of the GLib library.
   *
   * Like #glib_major_version, but from the headers used at
   * application compile time, rather than from the library
   * linked against at application run time.
   */
  const MAJOR_VERSION: number
  const MAXINT16: number
  const MAXINT32: number
  const MAXINT64: number
  const MAXINT8: number
  const MAXUINT16: number
  const MAXUINT32: number
  const MAXUINT64: number
  const MAXUINT8: number
  /**
   * The micro version number of the GLib library.
   *
   * Like #gtk_micro_version, but from the headers used at
   * application compile time, rather than from the library
   * linked against at application run time.
   */
  const MICRO_VERSION: number
  /**
   * The minimum value which can be held in a #gint16.
   */
  const MININT16: number
  /**
   * The minimum value which can be held in a #gint32.
   */
  const MININT32: number
  /**
   * The minimum value which can be held in a #gint64.
   */
  const MININT64: number
  /**
   * The minimum value which can be held in a #gint8.
   */
  const MININT8: number
  /**
   * The minor version number of the GLib library.
   *
   * Like #gtk_minor_version, but from the headers used at
   * application compile time, rather than from the library
   * linked against at application run time.
   */
  const MINOR_VERSION: number
  const MODULE_SUFFIX: string
  /**
   * If a long option in the main group has this name, it is not treated as a
   * regular option. Instead it collects all non-option arguments which would
   * otherwise be left in `argv`. The option must be of type
   * %G_OPTION_ARG_CALLBACK, %G_OPTION_ARG_STRING_ARRAY
   * or %G_OPTION_ARG_FILENAME_ARRAY.
   *
   *
   * Using %G_OPTION_REMAINING instead of simply scanning `argv`
   * for leftover arguments has the advantage that GOption takes care of
   * necessary encoding conversions for strings or filenames.
   */
  const OPTION_REMAINING: string
  const PDP_ENDIAN: number
  const PI: number
  /**
   * A format specifier that can be used in printf()-style format strings
   * when printing a #GPid.
   */
  const PID_FORMAT: string
  const PI_2: number
  const PI_4: number
  /**
   * A format specifier that can be used in printf()-style format strings
   * when printing the `fd` member of a #GPollFD.
   */
  const POLLFD_FORMAT: string
  /**
   * Use this for default priority event sources.
   *
   * In GLib this priority is used when adding timeout functions
   * with g_timeout_add(). In GDK this priority is used for events
   * from the X server.
   */
  const PRIORITY_DEFAULT: number
  /**
   * Use this for default priority idle functions.
   *
   * In GLib this priority is used when adding idle functions with
   * g_idle_add().
   */
  const PRIORITY_DEFAULT_IDLE: number
  /**
   * Use this for high priority event sources.
   *
   * It is not used within GLib or GTK.
   */
  const PRIORITY_HIGH: number
  /**
   * Use this for high priority idle functions.
   *
   * GTK uses %G_PRIORITY_HIGH_IDLE + 10 for resizing operations,
   * and %G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is
   * done to ensure that any pending resizes are processed before any
   * pending redraws, so that widgets are not redrawn twice unnecessarily.)
   */
  const PRIORITY_HIGH_IDLE: number
  /**
   * Use this for very low priority background tasks.
   *
   * It is not used within GLib or GTK.
   */
  const PRIORITY_LOW: number
  /**
   * Evaluates to the initial reference count for `grefcount`.
   *
   * This macro is useful for initializing `grefcount` fields inside
   * structures, for instance:
   *
   *
   * ```c
   * typedef struct {
   *   grefcount ref_count;
   *   char *name;
   *   char *address;
   * } Person;
   *
   * static const Person default_person = {
   *   .ref_count = G_REF_COUNT_INIT,
   *   .name = "Default name",
   *   .address = "Default address",
   * };
   * ```
   *
   */
  const REF_COUNT_INIT: number
  const SEARCHPATH_SEPARATOR: number
  const SEARCHPATH_SEPARATOR_S: string
  const SIZEOF_LONG: number
  const SIZEOF_SIZE_T: number
  const SIZEOF_SSIZE_T: number
  const SIZEOF_VOID_P: number
  /**
   * Use this macro as the return value of a #GSourceFunc to leave
   * the #GSource in the main loop.
   */
  const SOURCE_CONTINUE: boolean
  /**
   * Use this macro as the return value of a #GSourceFunc to remove
   * the #GSource from the main loop.
   */
  const SOURCE_REMOVE: boolean
  const SQRT2: number
  /**
   * The standard delimiters, used in [func`GLib`.strdelimit].
   */
  const STR_DELIMITERS: string
  const SYSDEF_AF_INET: number
  const SYSDEF_AF_INET6: number
  const SYSDEF_AF_UNIX: number
  const SYSDEF_MSG_DONTROUTE: number
  const SYSDEF_MSG_OOB: number
  const SYSDEF_MSG_PEEK: number
  /**
   * Creates a unique temporary directory for each unit test and uses
   * g_set_user_dirs() to set XDG directories to point into subdirectories of it
   * for the duration of the unit test. The directory tree is cleaned up after the
   * test finishes successfully. Note that this doesn’t take effect until
   * g_test_run() is called, so calls to (for example) g_get_user_home_dir() will
   * return the system-wide value when made in a test program’s main() function.
   *
   * The following functions will return subdirectories of the temporary directory
   * when this option is used. The specific subdirectory paths in use are not
   * guaranteed to be stable API — always use a getter function to retrieve them.
   *
   *  - g_get_home_dir()
   *  - g_get_user_cache_dir()
   *  - g_get_system_config_dirs()
   *  - g_get_user_config_dir()
   *  - g_get_system_data_dirs()
   *  - g_get_user_data_dir()
   *  - g_get_user_state_dir()
   *  - g_get_user_runtime_dir()
   *
   * The subdirectories may not be created by the test harness; as with normal
   * calls to functions like g_get_user_cache_dir(), the caller must be prepared
   * to create the directory if it doesn’t exist.
   */
  const TEST_OPTION_ISOLATE_DIRS: string
  /**
   * Evaluates to a time span of one day.
   */
  const TIME_SPAN_DAY: number
  /**
   * Evaluates to a time span of one hour.
   */
  const TIME_SPAN_HOUR: number
  /**
   * Evaluates to a time span of one millisecond.
   */
  const TIME_SPAN_MILLISECOND: number
  /**
   * Evaluates to a time span of one minute.
   */
  const TIME_SPAN_MINUTE: number
  /**
   * Evaluates to a time span of one second.
   */
  const TIME_SPAN_SECOND: number
  /**
   * The maximum length (in codepoints) of a compatibility or canonical
   * decomposition of a single Unicode character.
   *
   * This is as defined by Unicode 6.1.
   */
  const UNICHAR_MAX_DECOMPOSITION_LENGTH: number
  /**
   * Generic delimiters characters as defined in
   * [RFC 3986](https://tools.ietf.org/html/rfc3986). Includes `:/?#[]```.
   */
  const URI_RESERVED_CHARS_GENERIC_DELIMITERS: string
  /**
   * Subcomponent delimiter characters as defined in
   * [RFC 3986](https://tools.ietf.org/html/rfc3986). Includes `!$&'()*+,;=`.
   */
  const URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS: string
  /**
   * Number of microseconds in one second (1 million).
   * This macro is provided for code readability.
   */
  const USEC_PER_SEC: number
  /**
   * A macro that should be defined by the user prior to including
   * the glib.h header.
   * The definition should be one of the predefined GLib version
   * macros: %GLIB_VERSION_2_26, %GLIB_VERSION_2_28,...
   *
   * This macro defines the earliest version of GLib that the package is
   * required to be able to compile against.
   *
   * If the compiler is configured to warn about the use of deprecated
   * functions, then using functions that were deprecated in version
   * %GLIB_VERSION_MIN_REQUIRED or earlier will cause warnings (but
   * using functions deprecated in later releases will not).
   */
  const VERSION_MIN_REQUIRED: number
  const WIN32_MSG_HANDLE: number
  const macro__has_attribute___noreturn__: number
  /**
   * A wrapper for the POSIX access() function. This function is used to
   * test a pathname for one or several of read, write or execute
   * permissions, or just existence.
   *
   * On Windows, the file protection mechanism is not at all POSIX-like,
   * and the underlying function in the C library only checks the
   * FAT-style READONLY attribute, and does not look at the ACL of a
   * file at all. This function is this in practise almost useless on
   * Windows. Software that needs to handle file permissions on Windows
   * more exactly should use the Win32 API.
   *
   * See your C library manual for more details about access().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param mode as in access()
   * @returns zero if the pathname refers to an existing file system     object that has all the tested permissions, or -1 otherwise     or on error.
   */
  function access(filename: string, mode: number): number
  /**
   * This function is similar to g_malloc(), allocating (`n_blocks` * `n_block_bytes)`
   * bytes, but care is taken to align the allocated memory to with the given
   * alignment value. Additionally, it will detect possible overflow during
   * multiplication.
   *
   * If the allocation fails (because the system is out of memory),
   * the program is terminated.
   *
   * Aligned memory allocations returned by this function can only be
   * freed using g_aligned_free_sized() or g_aligned_free().
   * @param nBlocks the number of blocks to allocate
   * @param nBlockBytes the size of each block in bytes
   * @param alignment the alignment to be enforced, which must be a positive power of 2   and a multiple of `sizeof(void*)`
   * @returns the allocated memory
   */
  function alignedAlloc(
    nBlocks: number,
    nBlockBytes: number,
    alignment: number
  ): any | null
  /**
   * This function is similar to g_aligned_alloc(), but it will
   * also clear the allocated memory before returning it.
   * @param nBlocks the number of blocks to allocate
   * @param nBlockBytes the size of each block in bytes
   * @param alignment the alignment to be enforced, which must be a positive power of 2   and a multiple of `sizeof(void*)`
   * @returns the allocated, cleared memory
   */
  function alignedAlloc0(
    nBlocks: number,
    nBlockBytes: number,
    alignment: number
  ): any | null
  /**
   * Frees the memory allocated by g_aligned_alloc().
   * @param mem the memory to deallocate
   */
  function alignedFree(mem: any | null): void
  /**
   * Frees the memory pointed to by `mem,` assuming it is has the given `size` and
   * `alignment`.
   *
   * If `mem` is %NULL this is a no-op (and `size` is ignored).
   *
   * It is an error if `size` doesn’t match the size, or `alignment` doesn’t match
   * the alignment, passed when `mem` was allocated. `size` and `alignment` are
   * passed to this function to allow optimizations in the allocator. If you
   * don’t know either of them, use g_aligned_free() instead.
   * @param mem the memory to free
   * @param alignment alignment of `mem`
   * @param size size of `mem,` in bytes
   */
  function alignedFreeSized(
    mem: any | null,
    alignment: number,
    size: number
  ): void
  /**
   * Determines the numeric value of a character as a decimal digit. If the
   * character is not a decimal digit according to [func`GLib`.ascii_isdigit],
   * `-1` is returned.
   *
   * Differs from [func`GLib`.unichar_digit_value] because it takes a char, so
   * there's no worry about sign extension if characters are signed.
   * @param c an ASCII character
   * @returns the numerical value of @c if it is a decimal digit, `-1` otherwise
   */
  function asciiDigitValue(c: number): number
  /**
   * Converts a `gdouble` to a string, using the '.' as
   * decimal point.
   *
   * This function generates enough precision that converting
   * the string back using [func`GLib`.ascii_strtod] gives the same machine-number
   * (on machines with IEEE compatible 64bit doubles). It is
   * guaranteed that the size of the resulting string will never
   * be larger than [const`GLib`.ASCII_DTOSTR_BUF_SIZE] bytes, including the terminating
   * nul character, which is always added.
   * @param buffer a buffer to place the resulting string in
   * @param bufLen the length of the buffer
   * @param d the value to convert
   * @returns the pointer to the buffer with the converted string
   */
  function asciiDtostr(
    buffer: string | null,
    bufLen: number,
    d: number
  ): string | null
  /**
   * Converts a `gdouble` to a string, using the '.' as
   * decimal point. To format the number you pass in
   * a `printf()`-style format string. Allowed conversion
   * specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
   *
   * The `format` must just be a single format specifier
   * starting with `%`, expecting a `gdouble` argument.
   *
   * The returned buffer is guaranteed to be nul-terminated.
   *
   * If you just want to want to serialize the value into a
   * string, use [func`GLib`.ascii_dtostr].
   * @param buffer a buffer to place the resulting string in
   * @param bufLen the length of the buffer
   * @param format the `printf()`-style format to use for the   code to use for converting
   * @param d the value to convert
   * @returns the pointer to the buffer with the converted string
   */
  function asciiFormatd(
    buffer: string | null,
    bufLen: number,
    format: string,
    d: number
  ): string | null
  /**
   * Compare two strings, ignoring the case of ASCII characters.
   *
   * Unlike the BSD `strcasecmp()` function, this only recognizes standard
   * ASCII letters and ignores the locale, treating all non-ASCII
   * bytes as if they are not letters.
   *
   * This function should be used only on strings that are known to be
   * in encodings where the bytes corresponding to ASCII letters always
   * represent themselves. This includes UTF-8 and the ISO-8859-*
   * charsets, but not for instance double-byte encodings like the
   * Windows Codepage 932, where the trailing bytes of double-byte
   * characters include all ASCII letters. If you compare two CP932
   * strings using this function, you will get false matches.
   *
   * Both `s1` and `s2` must be non-`NULL`.
   * @param s1 string to compare with `s2`
   * @param s2 string to compare with `s1`
   * @returns 0 if the strings match, a negative value if @s1 < @s2,   or a positive value if @s1 > @s2
   */
  function asciiStrcasecmp(s1: string, s2: string): number
  /**
   * Converts all upper case ASCII letters to lower case ASCII letters, with
   * semantics that exactly match [func`GLib`.ascii_tolower].
   * @param str a string
   * @param len length of `str` in bytes, or `-1` if `str` is nul-terminated
   * @returns a newly-allocated string, with all the upper case characters in   @str converted to lower case. (Note that this is unlike the old   [func@GLib.strdown], which modified the string in place.)
   */
  function asciiStrdown(str: string, len: number): string | null
  /**
   * A convenience function for converting a string to a signed number.
   *
   * This function assumes that `str` contains only a number of the given
   * `base` that is within inclusive bounds limited by `min` and `max`. If
   * this is true, then the converted number is stored in `out_num`. An
   * empty string is not a valid input. A string with leading or
   * trailing whitespace is also an invalid input.
   *
   * `base` can be between 2 and 36 inclusive. Hexadecimal numbers must
   * not be prefixed with "0x" or "0X". Such a problem does not exist
   * for octal numbers, since they were usually prefixed with a zero
   * which does not change the value of the parsed number.
   *
   * Parsing failures result in an error with the `G_NUMBER_PARSER_ERROR`
   * domain. If the input is invalid, the error code will be
   * [error`GLib`.NumberParserError.INVALID]. If the parsed number is out of
   * bounds - [error`GLib`.NumberParserError.OUT_OF_BOUNDS].
   *
   * See [func`GLib`.ascii_strtoll] if you have more complex needs such as
   * parsing a string which starts with a number, but then has other
   * characters.
   * @param str a string to convert
   * @param base base of a parsed number
   * @param min a lower bound (inclusive)
   * @param max an upper bound (inclusive)
   * @returns true if @str was a number, false otherwise
   */
  function asciiStringToSigned(
    str: string,
    base: number,
    min: number,
    max: number
  ): [/* returnType */ boolean, /* outNum */ number]
  /**
   * A convenience function for converting a string to an unsigned number.
   *
   * This function assumes that `str` contains only a number of the given
   * `base` that is within inclusive bounds limited by `min` and `max`. If
   * this is true, then the converted number is stored in `out_num`. An
   * empty string is not a valid input. A string with leading or
   * trailing whitespace is also an invalid input. A string with a leading sign
   * (`-` or `+`) is not a valid input for the unsigned parser.
   *
   * `base` can be between 2 and 36 inclusive. Hexadecimal numbers must
   * not be prefixed with "0x" or "0X". Such a problem does not exist
   * for octal numbers, since they were usually prefixed with a zero
   * which does not change the value of the parsed number.
   *
   * Parsing failures result in an error with the `G_NUMBER_PARSER_ERROR`
   * domain. If the input is invalid, the error code will be
   * [error`GLib`.NumberParserError.INVALID]. If the parsed number is out of
   * bounds - [error`GLib`.NumberParserError.OUT_OF_BOUNDS].
   *
   * See [func`GLib`.ascii_strtoull] if you have more complex needs such as
   * parsing a string which starts with a number, but then has other
   * characters.
   * @param str a string
   * @param base base of a parsed number
   * @param min a lower bound (inclusive)
   * @param max an upper bound (inclusive)
   * @returns true if @str was a number, false otherwise
   */
  function asciiStringToUnsigned(
    str: string,
    base: number,
    min: number,
    max: number
  ): [/* returnType */ boolean, /* outNum */ number]
  /**
   * Compare `s1` and `s2`, ignoring the case of ASCII characters and any
   * characters after the first `n` in each string. If either string is
   * less than `n` bytes long, comparison will stop at the first nul byte
   * encountered.
   *
   * Unlike the BSD `strncasecmp()` function, this only recognizes standard
   * ASCII letters and ignores the locale, treating all non-ASCII
   * characters as if they are not letters.
   *
   * The same warning as in [func`GLib`.ascii_strcasecmp] applies: Use this
   * function only on strings known to be in encodings where bytes
   * corresponding to ASCII letters always represent themselves.
   * @param s1 string to compare with `s2`
   * @param s2 string to compare with `s1`
   * @param n number of characters to compare
   * @returns 0 if the strings match, a negative value if @s1 < @s2,   or a positive value if @s1 > @s2
   */
  function asciiStrncasecmp(s1: string, s2: string, n: number): number
  /**
   * Converts a string to a floating point value.
   *
   * This function behaves like the standard `strtod()` function
   * does in the C locale. It does this without actually changing
   * the current locale, since that would not be thread-safe.
   * A limitation of the implementation is that this function
   * will still accept localized versions of infinities and NANs.
   *
   * This function is typically used when reading configuration
   * files or other non-user input that should be locale independent.
   * To handle input from the user you should normally use the
   * locale-sensitive system `strtod()` function.
   *
   * To convert from a gdouble to a string in a locale-insensitive
   * way, use [func`GLib`.ascii_dtostr].
   *
   * If the correct value would cause overflow, plus or minus `HUGE_VAL`
   * is returned (according to the sign of the value), and `ERANGE` is
   * stored in `errno`. If the correct value would cause underflow,
   * zero is returned and `ERANGE` is stored in `errno`.
   *
   * This function resets `errno` before calling `strtod()` so that
   * you can reliably detect overflow and underflow.
   * @param nptr the string to convert to a numeric value
   * @returns the converted value
   */
  function asciiStrtod(
    nptr: string
  ): [/* returnType */ number, /* endptr */ string]
  /**
   * Converts a string to a `gint64` value.
   *
   * This function behaves like the standard `strtoll()` function
   * does in the C locale. It does this without actually
   * changing the current locale, since that would not be
   * thread-safe.
   *
   * This function is typically used when reading configuration
   * files or other non-user input that should be locale independent.
   * To handle input from the user you should normally use the
   * locale-sensitive system `strtoll()` function.
   *
   * If the correct value would cause overflow, [const`GLib`.MAXINT64] or
   * [const`GLib`.MININT64] is returned, and `ERANGE` is stored in `errno`.
   * If the base is outside the valid range, zero is returned, and
   * `EINVAL` is stored in `errno`. If the
   * string conversion fails, zero is returned, and `endptr` returns `nptr`
   * (if `endptr` is non-`NULL`).
   * @param nptr the string to convert to a numeric value
   * @param base to be used for the conversion, 2..36 or 0
   * @returns the converted value, or zero on error
   */
  function asciiStrtoll(
    nptr: string,
    base: number
  ): [/* returnType */ number, /* endptr */ string]
  /**
   * Converts a string to a `guint64` value.
   *
   * This function behaves like the standard `strtoull()` function
   * does in the C locale. It does this without actually
   * changing the current locale, since that would not be
   * thread-safe.
   *
   * Note that input with a leading minus sign (`-`) is accepted, and will return
   * the negation of the parsed number, unless that would overflow a `guint64`.
   * Critically, this means you cannot assume that a short fixed length input will
   * result in a low return value, as the input could have a leading `-`.
   *
   * This function is typically used when reading configuration
   * files or other non-user input that should be locale independent.
   * To handle input from the user you should normally use the
   * locale-sensitive system `strtoull()` function.
   *
   * If the correct value would cause overflow, [const`GLib`.MAXUINT64]
   * is returned, and `ERANGE` is stored in `errno`.
   * If the base is outside the valid range, zero is returned, and
   * `EINVAL` is stored in `errno`.
   * If the string conversion fails, zero is returned, and `endptr` returns
   * `nptr` (if `endptr` is non-`NULL`).
   * @param nptr the string to convert to a numeric value
   * @param base to be used for the conversion, 2..36 or 0
   * @returns the converted value, or zero on error
   */
  function asciiStrtoull(
    nptr: string,
    base: number
  ): [/* returnType */ number, /* endptr */ string]
  /**
   * Converts all lower case ASCII letters to upper case ASCII letters, with
   * semantics that exactly match [func`GLib`.ascii_toupper].
   * @param str a string
   * @param len length of `str` in bytes, or `-1` if `str` is nul-terminated
   * @returns a newly-allocated string, with all the lower case characters   in @str converted to upper case. (Note that this is unlike the old   [func@GLib.strup], which modified the string in place.)
   */
  function asciiStrup(str: string, len: number): string | null
  /**
   * Convert a character to ASCII lower case. If the character is not an
   * ASCII upper case letter, it is returned unchanged.
   *
   * Unlike the standard C library `tolower()` function, this only
   * recognizes standard ASCII letters and ignores the locale, returning
   * all non-ASCII characters unchanged, even if they are lower case
   * letters in a particular character set. Also unlike the standard
   * library function, this takes and returns a char, not an int, so
   * don't call it on `EOF` but no need to worry about casting to `guchar`
   * before passing a possibly non-ASCII character in.
   * @param c any character
   * @returns the result of the conversion
   */
  function asciiTolower(c: number): number
  /**
   * Convert a character to ASCII upper case. If the character is not an
   * ASCII lower case letter, it is returned unchanged.
   *
   * Unlike the standard C library `toupper()` function, this only
   * recognizes standard ASCII letters and ignores the locale, returning
   * all non-ASCII characters unchanged, even if they are upper case
   * letters in a particular character set. Also unlike the standard
   * library function, this takes and returns a char, not an int, so
   * don't call it on `EOF` but no need to worry about casting to `guchar`
   * before passing a possibly non-ASCII character in.
   * @param c any character
   * @returns the result of the conversion
   */
  function asciiToupper(c: number): number
  /**
   * Determines the numeric value of a character as a hexadecimal digit. If the
   * character is not a hex digit according to [func`GLib`.ascii_isxdigit],
   * `-1` is returned.
   *
   * Differs from [func`GLib`.unichar_xdigit_value] because it takes a char, so
   * there's no worry about sign extension if characters are signed.
   *
   * Differs from [func`GLib`.unichar_xdigit_value] because it takes a char, so
   * there's no worry about sign extension if characters are signed.
   * @param c an ASCII character
   * @returns the numerical value of @c if it is a hex digit, `-1` otherwise
   */
  function asciiXdigitValue(c: number): number
  function assertWarning(
    logDomain: string,
    file: string,
    line: number,
    prettyFunction: string,
    expression: string
  ): void
  function assertionMessage(
    domain: string,
    file: string,
    line: number,
    func: string,
    message: string
  ): void
  function assertionMessageCmpint(
    domain: string,
    file: string,
    line: number,
    func: string,
    expr: string,
    arg1: number,
    cmp: string,
    arg2: number,
    numtype: number
  ): void
  function assertionMessageCmpstr(
    domain: string,
    file: string,
    line: number,
    func: string,
    expr: string,
    arg1: string,
    cmp: string,
    arg2: string
  ): void
  function assertionMessageCmpstrv(
    domain: string,
    file: string,
    line: number,
    func: string,
    expr: string,
    arg1: string,
    arg2: string,
    firstWrongIdx: number
  ): void
  function assertionMessageError(
    domain: string,
    file: string,
    line: number,
    func: string,
    expr: string,
    error: Error,
    errorDomain: Quark,
    errorCode: number
  ): void
  /**
   * Specifies a function to be called at normal program termination.
   *
   * Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor
   * macro that maps to a call to the atexit() function in the C
   * library. This means that in case the code that calls g_atexit(),
   * i.e. atexit(), is in a DLL, the function will be called when the
   * DLL is detached from the program. This typically makes more sense
   * than that the function is called when the GLib DLL is detached,
   * which happened earlier when g_atexit() was a function in the GLib
   * DLL.
   *
   * The behaviour of atexit() in the context of dynamically loaded
   * modules is not formally specified and varies wildly.
   *
   * On POSIX systems, calling g_atexit() (or atexit()) in a dynamically
   * loaded module which is unloaded before the program terminates might
   * well cause a crash at program exit.
   *
   * Some POSIX systems implement atexit() like Windows, and have each
   * dynamically loaded module maintain an own atexit chain that is
   * called when the module is unloaded.
   *
   * On other POSIX systems, before a dynamically loaded module is
   * unloaded, the registered atexit functions (if any) residing in that
   * module are called, regardless where the code that registered them
   * resided. This is presumably the most robust approach.
   *
   * As can be seen from the above, for portability it's best to avoid
   * calling g_atexit() (or atexit()) except in the main executable of a
   * program.
   * @param func the function to call on normal program termination.
   */
  function atexit(func: VoidFunc): void
  /**
   * Atomically adds `val` to the value of `atomic`.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic += val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * Before version 2.30, this function did not return a value
   * (but g_atomic_int_exchange_and_add() did, and had the same meaning).
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   * @param val the value to add
   * @returns the value of @atomic before the add, signed
   */
  function atomicIntAdd(atomic: number, val: number): number
  /**
   * Performs an atomic bitwise 'and' of the value of `atomic` and `val,`
   * storing the result back in `atomic`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic &= val; return tmp; }`.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   * @param val the value to 'and'
   * @returns the value of @atomic before the operation, unsigned
   */
  function atomicIntAnd(atomic: number, val: number): number
  /**
   * Compares `atomic` to `oldval` and, if equal, sets it to `newval`.
   * If `atomic` was not equal to `oldval` then no change occurs.
   *
   * This compare and exchange is done atomically.
   *
   * Think of this operation as an atomic version of
   * `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   * @param oldval the value to compare with
   * @param newval the value to conditionally replace with
   * @returns %TRUE if the exchange took place
   */
  function atomicIntCompareAndExchange(
    atomic: number,
    oldval: number,
    newval: number
  ): boolean
  /**
   * Compares `atomic` to `oldval` and, if equal, sets it to `newval`.
   * If `atomic` was not equal to `oldval` then no change occurs.
   * In any case the value of `atomic` before this operation is stored in `preval`.
   *
   * This compare and exchange is done atomically.
   *
   * Think of this operation as an atomic version of
   * `{ *preval = *atomic; if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * See also g_atomic_int_compare_and_exchange()
   * @param atomic a pointer to a #gint or #guint
   * @param oldval the value to compare with
   * @param newval the value to conditionally replace with
   * @returns %TRUE if the exchange took place
   */
  function atomicIntCompareAndExchangeFull(
    atomic: number,
    oldval: number,
    newval: number
  ): [/* returnType */ boolean, /* preval */ number]
  /**
   * Decrements the value of `atomic` by 1.
   *
   * Think of this operation as an atomic version of
   * `{ *atomic -= 1; return (*atomic == 0); }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   * @returns %TRUE if the resultant value is zero
   */
  function atomicIntDecAndTest(atomic: number): boolean
  /**
   * Sets the `atomic` to `newval` and returns the old value from `atomic`.
   *
   * This exchange is done atomically.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic = val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   * @param atomic a pointer to a #gint or #guint
   * @param newval the value to replace with
   * @returns the value of @atomic before the exchange, signed
   */
  function atomicIntExchange(atomic: number, newval: number): number
  /**
   * This function existed before g_atomic_int_add() returned the prior
   * value of the integer (which it now does).  It is retained only for
   * compatibility reasons.  Don't use this function in new code.
   * @param atomic a pointer to a #gint
   * @param val the value to add
   * @returns the value of @atomic before the add, signed
   */
  function atomicIntExchangeAndAdd(atomic: number, val: number): number
  /**
   * Gets the current value of `atomic`.
   *
   * This call acts as a full compiler and hardware
   * memory barrier (before the get).
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   * @returns the value of the integer
   */
  function atomicIntGet(atomic: number): number
  /**
   * Increments the value of `atomic` by 1.
   *
   * Think of this operation as an atomic version of `{ *atomic += 1; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   */
  function atomicIntInc(atomic: number): void
  /**
   * Performs an atomic bitwise 'or' of the value of `atomic` and `val,`
   * storing the result back in `atomic`.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic |= val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   * @param val the value to 'or'
   * @returns the value of @atomic before the operation, unsigned
   */
  function atomicIntOr(atomic: number, val: number): number
  /**
   * Sets the value of `atomic` to `newval`.
   *
   * This call acts as a full compiler and hardware
   * memory barrier (after the set).
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   * @param newval a new value to store
   */
  function atomicIntSet(atomic: number, newval: number): void
  /**
   * Performs an atomic bitwise 'xor' of the value of `atomic` and `val,`
   * storing the result back in `atomic`.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic ^= val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gint or #guint
   * @param val the value to 'xor'
   * @returns the value of @atomic before the operation, unsigned
   */
  function atomicIntXor(atomic: number, val: number): number
  /**
   * Atomically adds `val` to the value of `atomic`.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic += val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   *
   * In GLib 2.80, the return type was changed from #gssize to #gintptr to add
   * support for platforms with 128-bit pointers. This should not affect existing
   * code.
   * @param atomic a pointer to a #gpointer-sized value
   * @param val the value to add
   * @returns the value of @atomic before the add, signed
   */
  function atomicPointerAdd(atomic: any, val: number): any
  /**
   * Performs an atomic bitwise 'and' of the value of `atomic` and `val,`
   * storing the result back in `atomic`.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic &= val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   *
   * In GLib 2.80, the return type was changed from #gsize to #guintptr to add
   * support for platforms with 128-bit pointers. This should not affect existing
   * code.
   * @param atomic a pointer to a #gpointer-sized value
   * @param val the value to 'and'
   * @returns the value of @atomic before the operation, unsigned
   */
  function atomicPointerAnd(atomic: any, val: number): never
  /**
   * Compares `atomic` to `oldval` and, if equal, sets it to `newval`.
   * If `atomic` was not equal to `oldval` then no change occurs.
   *
   * This compare and exchange is done atomically.
   *
   * Think of this operation as an atomic version of
   * `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gpointer-sized value
   * @param oldval the value to compare with
   * @param newval the value to conditionally replace with
   * @returns %TRUE if the exchange took place
   */
  function atomicPointerCompareAndExchange(
    atomic: any,
    oldval: any | null,
    newval: any | null
  ): boolean
  /**
   * Compares `atomic` to `oldval` and, if equal, sets it to `newval`.
   * If `atomic` was not equal to `oldval` then no change occurs.
   * In any case the value of `atomic` before this operation is stored in `preval`.
   *
   * This compare and exchange is done atomically.
   *
   * Think of this operation as an atomic version of
   * `{ *preval = *atomic; if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * See also g_atomic_pointer_compare_and_exchange()
   * @param atomic a pointer to a #gpointer-sized value
   * @param oldval the value to compare with
   * @param newval the value to conditionally replace with
   * @returns %TRUE if the exchange took place
   */
  function atomicPointerCompareAndExchangeFull(
    atomic: any,
    oldval: any | null,
    newval: any | null
  ): [/* returnType */ boolean, /* preval */ any]
  /**
   * Sets the `atomic` to `newval` and returns the old value from `atomic`.
   *
   * This exchange is done atomically.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic = val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   * @param atomic a pointer to a #gpointer-sized value
   * @param newval the value to replace with
   * @returns the value of @atomic before the exchange
   */
  function atomicPointerExchange(
    atomic: any | null,
    newval: any | null
  ): any | null
  /**
   * Gets the current value of `atomic`.
   *
   * This call acts as a full compiler and hardware
   * memory barrier (before the get).
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gpointer-sized value
   * @returns the value of the pointer
   */
  function atomicPointerGet(atomic: any): any | null
  /**
   * Performs an atomic bitwise 'or' of the value of `atomic` and `val,`
   * storing the result back in `atomic`.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic |= val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   *
   * In GLib 2.80, the return type was changed from #gsize to #guintptr to add
   * support for platforms with 128-bit pointers. This should not affect existing
   * code.
   * @param atomic a pointer to a #gpointer-sized value
   * @param val the value to 'or'
   * @returns the value of @atomic before the operation, unsigned
   */
  function atomicPointerOr(atomic: any, val: number): never
  /**
   * Sets the value of `atomic` to `newval`.
   *
   * This call acts as a full compiler and hardware
   * memory barrier (after the set).
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param atomic a pointer to a #gpointer-sized value
   * @param newval a new value to store
   */
  function atomicPointerSet(atomic: any, newval: any | null): void
  /**
   * Performs an atomic bitwise 'xor' of the value of `atomic` and `val,`
   * storing the result back in `atomic`.
   *
   * Think of this operation as an atomic version of
   * `{ tmp = *atomic; *atomic ^= val; return tmp; }`.
   *
   * This call acts as a full compiler and hardware memory barrier.
   *
   * While `atomic` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   *
   * In GLib 2.80, the return type was changed from #gsize to #guintptr to add
   * support for platforms with 128-bit pointers. This should not affect existing
   * code.
   * @param atomic a pointer to a #gpointer-sized value
   * @param val the value to 'xor'
   * @returns the value of @atomic before the operation, unsigned
   */
  function atomicPointerXor(atomic: any, val: number): never
  /**
   * Atomically acquires a reference on the data pointed by `mem_block`.
   * @param memBlock a pointer to reference counted data
   * @returns a pointer to the data,   with its reference count increased
   */
  function atomicRcBoxAcquire(memBlock: any): any
  /**
   * Allocates `block_size` bytes of memory, and adds atomic
   * reference counting semantics to it.
   *
   * The data will be freed when its reference count drops to
   * zero.
   *
   * The allocated data is guaranteed to be suitably aligned for any
   * built-in type.
   * @param blockSize the size of the allocation, must be greater than 0
   * @returns a pointer to the allocated memory
   */
  function atomicRcBoxAlloc(blockSize: number): any
  /**
   * Allocates `block_size` bytes of memory, and adds atomic
   * reference counting semantics to it.
   *
   * The contents of the returned data is set to zero.
   *
   * The data will be freed when its reference count drops to
   * zero.
   *
   * The allocated data is guaranteed to be suitably aligned for any
   * built-in type.
   * @param blockSize the size of the allocation, must be greater than 0
   * @returns a pointer to the allocated memory
   */
  function atomicRcBoxAlloc0(blockSize: number): any
  /**
   * Allocates a new block of data with atomic reference counting
   * semantics, and copies `block_size` bytes of `mem_block`
   * into it.
   * @param blockSize the number of bytes to copy, must be greater than 0
   * @param memBlock the memory to copy
   * @returns a pointer to the allocated   memory
   */
  function atomicRcBoxDup(blockSize: number, memBlock: any): any
  /**
   * Retrieves the size of the reference counted data pointed by `mem_block`.
   * @param memBlock a pointer to reference counted data
   * @returns the size of the data, in bytes
   */
  function atomicRcBoxGetSize(memBlock: any): number
  /**
   * Atomically releases a reference on the data pointed by `mem_block`.
   *
   * If the reference was the last one, it will free the
   * resources allocated for `mem_block`.
   * @param memBlock a pointer to reference counted data
   */
  function atomicRcBoxRelease(memBlock: any): void
  /**
   * Atomically releases a reference on the data pointed by `mem_block`.
   *
   * If the reference was the last one, it will call `clear_func`
   * to clear the contents of `mem_block,` and then will free the
   * resources allocated for `mem_block`.
   * @param memBlock a pointer to reference counted data
   * @param clearFunc a function to call when clearing the data
   */
  function atomicRcBoxReleaseFull(memBlock: any, clearFunc: DestroyNotify): void
  /**
   * Atomically compares the current value of `arc` with `val`.
   * @param arc the address of an atomic reference count variable
   * @param val the value to compare
   * @returns %TRUE if the reference count is the same   as the given value
   */
  function atomicRefCountCompare(arc: number, val: number): boolean
  /**
   * Atomically decreases the reference count.
   *
   * If %TRUE is returned, the reference count reached 0. After this point, `arc`
   * is an undefined state and must be reinitialized with
   * g_atomic_ref_count_init() to be used again.
   * @param arc the address of an atomic reference count variable
   * @returns %TRUE if the reference count reached 0, and %FALSE otherwise
   */
  function atomicRefCountDec(arc: number): boolean
  /**
   * Atomically increases the reference count.
   * @param arc the address of an atomic reference count variable
   */
  function atomicRefCountInc(arc: number): void
  /**
   * Initializes a reference count variable to 1.
   * @param arc the address of an atomic reference count variable
   */
  function atomicRefCountInit(arc: number): void
  /**
   * Decode a sequence of Base-64 encoded text into binary data.  Note
   * that the returned binary data is not necessarily zero-terminated,
   * so it should not be used as a character string.
   * @param text zero-terminated string with base64 text to decode
   * @returns newly allocated buffer containing the binary data               that @text represents. The returned buffer must               be freed with g_free().
   */
  function base64Decode(text: string): number[]
  /**
   * Decode a sequence of Base-64 encoded text into binary data
   * by overwriting the input data.
   * @param text zero-terminated        string with base64 text to decode
   * @returns The binary data that @text responds. This pointer               is the same as the input @text.
   */
  function base64DecodeInplace(
    text: number[]
  ): [/* returnType */ number, /* text */ number[]]
  /**
   * Encode a sequence of binary data into its Base-64 stringified
   * representation.
   * @param data the binary data to encode
   * @returns a newly allocated, zero-terminated Base-64               encoded string representing @data. The returned string must               be freed with g_free().
   */
  function base64Encode(data: number[] | null): string | null
  /**
   * Flush the status from a sequence of calls to g_base64_encode_step().
   *
   * The output buffer must be large enough to fit all the data that will
   * be written to it. It will need up to 4 bytes, or up to 5 bytes if
   * line-breaking is enabled.
   *
   * The `out` array will not be automatically nul-terminated.
   * @param breakLines whether to break long lines
   * @param state Saved state from g_base64_encode_step()
   * @param save Saved state from g_base64_encode_step()
   * @returns The number of bytes of output that was written
   */
  function base64EncodeClose(
    breakLines: boolean,
    state: number,
    save: number
  ): [
    /* returnType */ number,
    /* out */ number[],
    /* state */ number,
    /* save */ number,
  ]
  /**
   * Incrementally encode a sequence of binary data into its Base-64 stringified
   * representation. By calling this function multiple times you can convert
   * data in chunks to avoid having to have the full encoded data in memory.
   *
   * When all of the data has been converted you must call
   * g_base64_encode_close() to flush the saved state.
   *
   * The output buffer must be large enough to fit all the data that will
   * be written to it. Due to the way base64 encodes you will need
   * at least: (`len` / 3 + 1) * 4 + 4 bytes (+ 4 may be needed in case of
   * non-zero state). If you enable line-breaking you will need at least:
   * ((`len` / 3 + 1) * 4 + 4) / 76 + 1 bytes of extra space.
   *
   * `break_lines` is typically used when putting base64-encoded data in emails.
   * It breaks the lines at 76 columns instead of putting all of the text on
   * the same line. This avoids problems with long lines in the email system.
   * Note however that it breaks the lines with `LF` characters, not
   * `CR LF` sequences, so the result cannot be passed directly to SMTP
   * or certain other protocols.
   * @param in_ the binary data to encode
   * @param breakLines whether to break long lines
   * @param state Saved state between steps, initialize to 0
   * @param save Saved state between steps, initialize to 0
   * @returns The number of bytes of output that was written
   */
  function base64EncodeStep(
    in_: number[],
    breakLines: boolean,
    state: number,
    save: number
  ): [
    /* returnType */ number,
    /* out */ number[],
    /* state */ number,
    /* save */ number,
  ]
  /**
   * Gets the name of the file without any leading directory
   * components. It returns a pointer into the given file name
   * string.
   * @param fileName the name of the file
   * @returns the name of the file without any leading   directory components
   */
  function basename(fileName: string): string
  /**
   * Sets the indicated `lock_bit` in `address`.  If the bit is already
   * set, this call will block until g_bit_unlock() unsets the
   * corresponding bit.
   *
   * Attempting to lock on two different bits within the same integer is
   * not supported and will very probably cause deadlocks.
   *
   * The value of the bit that is set is (1u << `bit)`.  If `bit` is not
   * between 0 and 31 then the result is undefined.
   *
   * This function accesses `address` atomically.  All other accesses to
   * `address` must be atomic in order for this function to work
   * reliably. While `address` has a `volatile` qualifier, this is a historical
   * artifact and the argument passed to it should not be `volatile`.
   * @param address a pointer to an integer
   * @param lockBit a bit value between 0 and 31
   */
  function bitLock(address: number, lockBit: number): void
  /**
   * Find the position of the first bit set in `mask,` searching
   * from (but not including) `nth_bit` upwards. Bits are numbered
   * from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
   * usually). To start searching from the 0th bit, set `nth_bit` to -1.
   * @param mask a #gulong containing flags
   * @param nthBit the index of the bit to start the search from
   * @returns the index of the first bit set which is higher than @nth_bit, or -1    if no higher bits are set
   */
  function bitNthLsf(mask: number, nthBit: number): number
  /**
   * Find the position of the first bit set in `mask,` searching
   * from (but not including) `nth_bit` downwards. Bits are numbered
   * from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
   * usually). To start searching from the last bit, set `nth_bit` to
   * -1 or GLIB_SIZEOF_LONG * 8.
   * @param mask a #gulong containing flags
   * @param nthBit the index of the bit to start the search from
   * @returns the index of the first bit set which is lower than @nth_bit, or -1    if no lower bits are set
   */
  function bitNthMsf(mask: number, nthBit: number): number
  /**
   * Gets the number of bits used to hold `number,`
   * e.g. if `number` is 4, 3 bits are needed.
   * @param number a #guint
   * @returns the number of bits used to hold @number
   */
  function bitStorage(number: number): number
  /**
   * Sets the indicated `lock_bit` in `address,` returning %TRUE if
   * successful.  If the bit is already set, returns %FALSE immediately.
   *
   * Attempting to lock on two different bits within the same integer is
   * not supported.
   *
   * The value of the bit that is set is (1u << `bit)`.  If `bit` is not
   * between 0 and 31 then the result is undefined.
   *
   * This function accesses `address` atomically.  All other accesses to
   * `address` must be atomic in order for this function to work
   * reliably. While `address` has a `volatile` qualifier, this is a historical
   * artifact and the argument passed to it should not be `volatile`.
   * @param address a pointer to an integer
   * @param lockBit a bit value between 0 and 31
   * @returns %TRUE if the lock was acquired
   */
  function bitTrylock(address: number, lockBit: number): boolean
  /**
   * Clears the indicated `lock_bit` in `address`.  If another thread is
   * currently blocked in g_bit_lock() on this same bit then it will be
   * woken up.
   *
   * This function accesses `address` atomically.  All other accesses to
   * `address` must be atomic in order for this function to work
   * reliably. While `address` has a `volatile` qualifier, this is a historical
   * artifact and the argument passed to it should not be `volatile`.
   * @param address a pointer to an integer
   * @param lockBit a bit value between 0 and 31
   */
  function bitUnlock(address: number, lockBit: number): void
  function blowChunks(): void
  function bookmarkFileErrorQuark(): Quark
  /**
   * Creates a filename from a vector of elements using the correct
   * separator for the current platform.
   *
   * This function behaves exactly like g_build_filename(), but takes the path
   * elements as a string array, instead of varargs. This function is mainly
   * meant for language bindings.
   *
   * If you are building a path programmatically you may want to use
   * #GPathBuf instead.
   * @param args %NULL-terminated   array of strings containing the path elements.
   * @returns the newly allocated path
   */
  function buildFilenamev(args: string[]): string
  /**
   * Behaves exactly like g_build_path(), but takes the path elements
   * as a string array, instead of variadic arguments.
   *
   * This function is mainly meant for language bindings.
   * @param separator a string used to separator the elements of the path.
   * @param args %NULL-terminated   array of strings containing the path elements.
   * @returns a newly-allocated string that     must be freed with g_free().
   */
  function buildPathv(separator: string, args: string[]): string
  /**
   * Adds the given bytes to the end of the #GByteArray.
   * The array will grow in size automatically if necessary.
   * @param array a #GByteArray
   * @param data the byte data to be added
   * @param len the number of bytes to add
   * @returns the #GByteArray
   */
  function byteArrayAppend(array: number[], data: number, len: number): number[]
  /**
   * Frees the memory allocated by the #GByteArray. If `free_segment` is
   * %TRUE it frees the actual byte data. If the reference count of
   * `array` is greater than one, the #GByteArray wrapper is preserved but
   * the size of `array` will be set to zero.
   * @param array a #GByteArray
   * @param freeSegment if %TRUE the actual byte data is freed as well
   * @returns the element data if @free_segment is %FALSE, otherwise          %NULL.  The element data should be freed using g_free().
   */
  function byteArrayFree(array: number[], freeSegment: boolean): number
  /**
   * Transfers the data from the #GByteArray into a new immutable #GBytes.
   *
   * The #GByteArray is freed unless the reference count of `array` is greater
   * than one, the #GByteArray wrapper is preserved but the size of `array`
   * will be set to zero.
   *
   * This is identical to using g_bytes_new_take() and g_byte_array_free()
   * together.
   * @param array a #GByteArray
   * @returns a new immutable #GBytes representing same     byte data that was in the array
   */
  function byteArrayFreeToBytes(array: number[]): any
  /**
   * Creates a new #GByteArray with a reference count of 1.
   * @returns the new #GByteArray
   */
  function byteArrayNew(): number[]
  /**
   * Creates a byte array containing the `data`.
   * After this call, `data` belongs to the #GByteArray and may no longer be
   * modified by the caller. The memory of `data` has to be dynamically
   * allocated and will eventually be freed with g_free().
   *
   * Do not use it if `len` is greater than %G_MAXUINT. #GByteArray
   * stores the length of its data in #guint, which may be shorter than
   * #gsize.
   * @param data byte data for the array
   * @returns a new #GByteArray
   */
  function byteArrayNewTake(data: number[]): number[]
  /**
   * Adds the given data to the start of the #GByteArray.
   * The array will grow in size automatically if necessary.
   * @param array a #GByteArray
   * @param data the byte data to be added
   * @param len the number of bytes to add
   * @returns the #GByteArray
   */
  function byteArrayPrepend(
    array: number[],
    data: number,
    len: number
  ): number[]
  /**
   * Atomically increments the reference count of `array` by one.
   * This function is thread-safe and may be called from any thread.
   * @param array A #GByteArray
   * @returns The passed in #GByteArray
   */
  function byteArrayRef(array: number[]): number[]
  /**
   * Removes the byte at the given index from a #GByteArray.
   * The following bytes are moved down one place.
   * @param array a #GByteArray
   * @param index the index of the byte to remove
   * @returns the #GByteArray
   */
  function byteArrayRemoveIndex(array: number[], index: number): number[]
  /**
   * Removes the byte at the given index from a #GByteArray. The last
   * element in the array is used to fill in the space, so this function
   * does not preserve the order of the #GByteArray. But it is faster
   * than g_byte_array_remove_index().
   * @param array a #GByteArray
   * @param index the index of the byte to remove
   * @returns the #GByteArray
   */
  function byteArrayRemoveIndexFast(array: number[], index: number): number[]
  /**
   * Removes the given number of bytes starting at the given index from a
   * #GByteArray.  The following elements are moved to close the gap.
   * @param array a `GByteArray`
   * @param index the index of the first byte to remove
   * @param length the number of bytes to remove
   * @returns the #GByteArray
   */
  function byteArrayRemoveRange(
    array: number[],
    index: number,
    length: number
  ): number[]
  /**
   * Sets the size of the #GByteArray, expanding it if necessary.
   * @param array a #GByteArray
   * @param length the new size of the #GByteArray
   * @returns the #GByteArray
   */
  function byteArraySetSize(array: number[], length: number): number[]
  /**
   * Creates a new #GByteArray with `reserved_size` bytes preallocated.
   * This avoids frequent reallocation, if you are going to add many
   * bytes to the array. Note however that the size of the array is still
   * 0.
   * @param reservedSize number of bytes preallocated
   * @returns the new #GByteArray
   */
  function byteArraySizedNew(reservedSize: number): number[]
  /**
   * Sorts a byte array, using `compare_func` which should be a
   * qsort()-style comparison function (returns less than zero for first
   * arg is less than second arg, zero for equal, greater than zero if
   * first arg is greater than second arg).
   *
   * If two array elements compare equal, their order in the sorted array
   * is undefined. If you want equal elements to keep their order (i.e.
   * you want a stable sort) you can write a comparison function that,
   * if two elements would otherwise compare equal, compares them by
   * their addresses.
   * @param array a #GByteArray
   * @param compareFunc comparison function
   */
  function byteArraySort(array: number[], compareFunc: CompareFunc): void
  /**
   * Like g_byte_array_sort(), but the comparison function takes an extra
   * user data argument.
   * @param array a #GByteArray
   * @param compareFunc comparison function
   */
  function byteArraySortWithData(
    array: number[],
    compareFunc: CompareDataFunc
  ): void
  /**
   * Frees the data in the array and resets the size to zero, while
   * the underlying array is preserved for use elsewhere and returned
   * to the caller.
   * @param array a #GByteArray.
   * @returns the element data, which should be     freed using g_free().
   */
  function byteArraySteal(
    array: number[]
  ): [/* returnType */ number, /* len */ number]
  /**
   * Atomically decrements the reference count of `array` by one. If the
   * reference count drops to 0, all memory allocated by the array is
   * released. This function is thread-safe and may be called from any
   * thread.
   * @param array A #GByteArray
   */
  function byteArrayUnref(array: number[]): void
  /**
   * Gets the canonical file name from `filename`. All triple slashes are turned into
   * single slashes, and all `..` and `.`s resolved against `relative_to`.
   *
   * Symlinks are not followed, and the returned path is guaranteed to be absolute.
   *
   * If `filename` is an absolute path, `relative_to` is ignored. Otherwise,
   * `relative_to` will be prepended to `filename` to make it absolute. `relative_to`
   * must be an absolute path, or %NULL. If `relative_to` is %NULL, it'll fallback
   * to g_get_current_dir().
   *
   * This function never fails, and will canonicalize file paths even if they don't
   * exist.
   *
   * No file system I/O is done.
   * @param filename the name of the file
   * @param relativeTo the relative directory, or %NULL to use the current working directory
   * @returns a newly allocated string with the   canonical file path
   */
  function canonicalizeFilename(
    filename: string,
    relativeTo: string | null
  ): string
  /**
   * A wrapper for the POSIX chdir() function. The function changes the
   * current directory of the process to `path`.
   *
   * See your C library manual for more details about chdir().
   * @param path a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @returns 0 on success, -1 if an error occurred.
   */
  function chdir(path: string): number
  /**
   * Checks that the GLib library in use is compatible with the
   * given version.
   *
   * Generally you would pass in the constants %GLIB_MAJOR_VERSION,
   * %GLIB_MINOR_VERSION, %GLIB_MICRO_VERSION as the three arguments
   * to this function; that produces a check that the library in use
   * is compatible with the version of GLib the application or module
   * was compiled against.
   *
   * Compatibility is defined by two things: first the version
   * of the running library is newer than the version
   * ``required_major`.required_minor.`required_micro``. Second
   * the running library must be binary compatible with the
   * version ``required_major`.`required_minor`.`required_micro``
   * (same major version.)
   * @param requiredMajor the required major version
   * @param requiredMinor the required minor version
   * @param requiredMicro the required micro version
   * @returns %NULL if the GLib library is   compatible with the given version, or a string describing the   version mismatch. The returned string is owned by GLib and must   not be modified or freed.
   */
  function checkVersion(
    requiredMajor: number,
    requiredMinor: number,
    requiredMicro: number
  ): string | null
  /**
   * Gets the length in bytes of digests of type `checksum_type`
   * @param checksumType a #GChecksumType
   * @returns the checksum length, or -1 if @checksum_type is not supported.
   */
  function checksumTypeGetLength(checksumType: ChecksumType): number
  /**
   * Sets a function to be called when the child indicated by `pid`
   * exits, at the priority `priority`.
   *
   * If you obtain `pid` from g_spawn_async() or g_spawn_async_with_pipes()
   * you will need to pass %G_SPAWN_DO_NOT_REAP_CHILD as flag to
   * the spawn function for the child watching to work.
   *
   * In many programs, you will want to call g_spawn_check_wait_status()
   * in the callback to determine whether or not the child exited
   * successfully.
   *
   * Also, note that on platforms where #GPid must be explicitly closed
   * (see g_spawn_close_pid()) `pid` must not be closed while the source
   * is still active.  Typically, you should invoke g_spawn_close_pid()
   * in the callback function for the source.
   *
   * GLib supports only a single callback per process id.
   * On POSIX platforms, the same restrictions mentioned for
   * g_child_watch_source_new() apply to this function.
   *
   * This internally creates a main loop source using
   * g_child_watch_source_new() and attaches it to the main loop context
   * using g_source_attach(). You can do these steps manually if you
   * need greater control.
   * @param priority the priority of the idle source. Typically this will be in the   range between %G_PRIORITY_DEFAULT_IDLE and %G_PRIORITY_HIGH_IDLE.
   * @param pid process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child).
   * @param function_ function to call
   * @returns the ID (greater than 0) of the event source.
   */
  function childWatchAdd(
    priority: number,
    pid: Pid,
    function_: ChildWatchFunc
  ): number
  /**
   * Creates a new child_watch source.
   *
   * The source will not initially be associated with any #GMainContext
   * and must be added to one with g_source_attach() before it will be
   * executed.
   *
   * Note that child watch sources can only be used in conjunction with
   * `g_spawn...` when the %G_SPAWN_DO_NOT_REAP_CHILD flag is used.
   *
   * Note that on platforms where #GPid must be explicitly closed
   * (see g_spawn_close_pid()) `pid` must not be closed while the
   * source is still active. Typically, you will want to call
   * g_spawn_close_pid() in the callback function for the source.
   *
   * On POSIX platforms, the following restrictions apply to this API
   * due to limitations in POSIX process interfaces:
   *
   * * `pid` must be a child of this process
   * * `pid` must be positive
   * * the application must not call `waitpid` with a non-positive
   *   first argument, for instance in another thread
   * * the application must not wait for `pid` to exit by any other
   *   mechanism, including `waitpid(pid, ...)` or a second child-watch
   *   source for the same `pid`
   * * the application must not ignore `SIGCHLD`
   * * Before 2.78, the application could not send a signal (`kill()`) to the
   *   watched `pid` in a race free manner. Since 2.78, you can do that while the
   *   associated #GMainContext is acquired.
   * * Before 2.78, even after destroying the #GSource, you could not
   *   be sure that `pid` wasn't already reaped. Hence, it was also not
   *   safe to `kill()` or `waitpid()` on the process ID after the child watch
   *   source was gone. Destroying the source before it fired made it
   *   impossible to reliably reap the process.
   *
   * If any of those conditions are not met, this and related APIs will
   * not work correctly. This can often be diagnosed via a GLib warning
   * stating that `ECHILD` was received by `waitpid`.
   *
   * Calling `waitpid` for specific processes other than `pid` remains a
   * valid thing to do.
   * @param pid process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child).
   * @returns the newly-created child watch source
   */
  function childWatchSourceNew(pid: Pid): Source
  /**
   * A wrapper for the POSIX chmod() function. The chmod() function is
   * used to set the permissions of a file system object.
   *
   * On Windows the file protection mechanism is not at all POSIX-like,
   * and the underlying chmod() function in the C library just sets or
   * clears the FAT-style READONLY attribute. It does not touch any
   * ACL. Software that needs to manage file permissions on Windows
   * exactly should use the Win32 API.
   *
   * See your C library manual for more details about chmod().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param mode as in chmod()
   * @returns 0 if the operation succeeded, -1 on error
   */
  function chmod(filename: string, mode: number): number
  /**
   * If `err` or *`err` is %NULL, does nothing. Otherwise,
   * calls g_error_free() on *`err` and sets *`err` to %NULL.
   */
  function clearError(): void
  /**
   * This wraps the close() call. In case of error, %errno will be
   * preserved, but the error will also be stored as a #GError in `error`.
   * In case of success, %errno is undefined.
   *
   * Besides using #GError, there is another major reason to prefer this
   * function over the call provided by the system; on Unix, it will
   * attempt to correctly handle %EINTR, which has platform-specific
   * semantics.
   *
   * It is a bug to call this function with an invalid file descriptor.
   *
   * On POSIX platforms since GLib 2.76, this function is async-signal safe
   * if (and only if) `error` is %NULL and `fd` is a valid open file descriptor.
   * This makes it safe to call from a signal handler or a #GSpawnChildSetupFunc
   * under those conditions.
   * See [`signal(7)`](man:signal(7)) and
   * [`signal-safety(7)`](man:signal-safety(7)) for more details.
   * @param fd A file descriptor
   * @returns %TRUE on success, %FALSE if there was an error.
   */
  function close(fd: number): boolean
  /**
   * Close every file descriptor equal to or greater than `lowfd`.
   *
   * Typically `lowfd` will be 3, to leave standard input, standard output
   * and standard error open.
   *
   * This is the same as Linux `close_range (lowfd, ~0U, 0)`,
   * but portable to other OSs and to older versions of Linux.
   * Equivalently, it is the same as BSD `closefrom (lowfd)`, but portable,
   * and async-signal-safe on all OSs.
   *
   * This function is async-signal safe, making it safe to call from a
   * signal handler or a [callback`GLib`.SpawnChildSetupFunc], as long as `lowfd` is
   * non-negative.
   * See [`signal(7)`](man:signal(7)) and
   * [`signal-safety(7)`](man:signal-safety(7)) for more details.
   * @param lowfd Minimum fd to close, which must be non-negative
   * @returns 0 on success, -1 with errno set on error
   */
  function closefrom(lowfd: number): number
  /**
   * Computes the checksum for a binary `data`. This is a
   * convenience wrapper for g_checksum_new(), g_checksum_get_string()
   * and g_checksum_free().
   *
   * The hexadecimal string returned will be in lower case.
   * @param checksumType a #GChecksumType
   * @param data binary blob to compute the digest of
   * @returns the digest of the binary data as a   string in hexadecimal, or %NULL if g_checksum_new() fails for   @checksum_type. The returned string should be freed with g_free() when   done using it.
   */
  function computeChecksumForBytes(
    checksumType: ChecksumType,
    data: any
  ): string | null
  /**
   * Computes the checksum for a binary `data` of `length`. This is a
   * convenience wrapper for g_checksum_new(), g_checksum_get_string()
   * and g_checksum_free().
   *
   * The hexadecimal string returned will be in lower case.
   * @param checksumType a #GChecksumType
   * @param data binary blob to compute the digest of
   * @returns the digest of the binary data as a   string in hexadecimal, or %NULL if g_checksum_new() fails for   @checksum_type. The returned string should be freed with g_free() when   done using it.
   */
  function computeChecksumForData(
    checksumType: ChecksumType,
    data: number[]
  ): string | null
  /**
   * Computes the checksum of a string.
   *
   * The hexadecimal string returned will be in lower case.
   * @param checksumType a #GChecksumType
   * @param str the string to compute the checksum of
   * @param length the length of the string, or -1 if the string is null-terminated.
   * @returns the checksum as a hexadecimal string,   or %NULL if g_checksum_new() fails for @checksum_type. The returned string   should be freed with g_free() when done using it.
   */
  function computeChecksumForString(
    checksumType: ChecksumType,
    str: string,
    length: number
  ): string | null
  /**
   * Computes the HMAC for a binary `data`. This is a
   * convenience wrapper for g_hmac_new(), g_hmac_get_string()
   * and g_hmac_unref().
   *
   * The hexadecimal string returned will be in lower case.
   * @param digestType a #GChecksumType to use for the HMAC
   * @param key the key to use in the HMAC
   * @param data binary blob to compute the HMAC of
   * @returns the HMAC of the binary data as a string in hexadecimal.   The returned string should be freed with g_free() when done using it.
   */
  function computeHmacForBytes(
    digestType: ChecksumType,
    key: any,
    data: any
  ): string | null
  /**
   * Computes the HMAC for a binary `data` of `length`. This is a
   * convenience wrapper for g_hmac_new(), g_hmac_get_string()
   * and g_hmac_unref().
   *
   * The hexadecimal string returned will be in lower case.
   * @param digestType a #GChecksumType to use for the HMAC
   * @param key the key to use in the HMAC
   * @param data binary blob to compute the HMAC of
   * @returns the HMAC of the binary data as a string in hexadecimal.   The returned string should be freed with g_free() when done using it.
   */
  function computeHmacForData(
    digestType: ChecksumType,
    key: number[],
    data: number[]
  ): string | null
  /**
   * Computes the HMAC for a string.
   *
   * The hexadecimal string returned will be in lower case.
   * @param digestType a #GChecksumType to use for the HMAC
   * @param key the key to use in the HMAC
   * @param str the string to compute the HMAC for
   * @param length the length of the string, or -1 if the string is nul-terminated
   * @returns the HMAC as a hexadecimal string.     The returned string should be freed with g_free()     when done using it.
   */
  function computeHmacForString(
    digestType: ChecksumType,
    key: number[],
    str: string,
    length: number
  ): string | null
  /**
   * Converts a string from one character set to another.
   *
   * Note that you should use g_iconv() for streaming conversions.
   * Despite the fact that `bytes_read` can return information about partial
   * characters, the g_convert_... functions are not generally suitable
   * for streaming. If the underlying converter maintains internal state,
   * then this won't be preserved across successive calls to g_convert(),
   * g_convert_with_iconv() or g_convert_with_fallback(). (An example of
   * this is the GNU C converter for CP1255 which does not emit a base
   * character until it knows that the next character is not a mark that
   * could combine with the base character.)
   *
   * Using extensions such as "//TRANSLIT" may not work (or may not work
   * well) on many platforms.  Consider using g_str_to_ascii() instead.
   * @param str the string to convert.
   * @param toCodeset name of character set into which to convert `str`
   * @param fromCodeset character set of `str`.
   * @returns If the conversion was successful, a newly allocated buffer          containing the converted string, which must be freed with g_free().          Otherwise %NULL and @error will be set.
   */
  function convert(
    str: number[],
    toCodeset: string,
    fromCodeset: string
  ): [/* returnType */ number[], /* bytesRead */ number]
  function convertErrorQuark(): Quark
  /**
   * Converts a string from one character set to another, possibly
   * including fallback sequences for characters not representable
   * in the output. Note that it is not guaranteed that the specification
   * for the fallback sequences in `fallback` will be honored. Some
   * systems may do an approximate conversion from `from_codeset`
   * to `to_codeset` in their iconv() functions,
   * in which case GLib will simply return that approximate conversion.
   *
   * Note that you should use g_iconv() for streaming conversions.
   * Despite the fact that `bytes_read` can return information about partial
   * characters, the g_convert_... functions are not generally suitable
   * for streaming. If the underlying converter maintains internal state,
   * then this won't be preserved across successive calls to g_convert(),
   * g_convert_with_iconv() or g_convert_with_fallback(). (An example of
   * this is the GNU C converter for CP1255 which does not emit a base
   * character until it knows that the next character is not a mark that
   * could combine with the base character.)
   * @param str the string to convert.
   * @param toCodeset name of character set into which to convert `str`
   * @param fromCodeset character set of `str`.
   * @param fallback UTF-8 string to use in place of characters not                present in the target encoding. (The string must be                representable in the target encoding).                If %NULL, characters not in the target encoding will                be represented as Unicode escapes \uxxxx or \Uxxxxyyyy.
   * @returns If the conversion was successful, a newly allocated buffer          containing the converted string, which must be freed with g_free().          Otherwise %NULL and @error will be set.
   */
  function convertWithFallback(
    str: number[],
    toCodeset: string,
    fromCodeset: string,
    fallback: string
  ): [/* returnType */ number[], /* bytesRead */ number]
  /**
   * A wrapper for the POSIX creat() function. The creat() function is
   * used to convert a pathname into a file descriptor, creating a file
   * if necessary.
   *
   * On POSIX systems file descriptors are implemented by the operating
   * system. On Windows, it's the C library that implements creat() and
   * file descriptors. The actual Windows API for opening files is
   * different, see MSDN documentation for CreateFile(). The Win32 API
   * uses file handles, which are more randomish integers, not small
   * integers like file descriptors.
   *
   * Because file descriptors are specific to the C library on Windows,
   * the file descriptor returned by this function makes sense only to
   * functions in the same C library. Thus if the GLib-using code uses a
   * different C library than GLib does, the file descriptor returned by
   * this function cannot be passed to C library functions like write()
   * or read().
   *
   * See your C library manual for more details about creat().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param mode as in creat()
   * @returns a new file descriptor, or -1 if an error occurred.     The return value can be used exactly like the return value     from creat().
   */
  function creat(filename: string, mode: number): number
  /**
   * Calls the given function for each data element of the datalist. The
   * function is called with each data element's #GQuark id and data,
   * together with the given `user_data` parameter. Note that this
   * function is NOT thread-safe. So unless `datalist` can be protected
   * from any modifications during invocation of this function, it should
   * not be called.
   *
   * `func` can make changes to `datalist,` but the iteration will not
   * reflect changes made during the g_datalist_foreach() call, other
   * than skipping over elements that are removed.
   * @param datalist a datalist.
   * @param func the function to call for each data element.
   */
  function datalistForeach(datalist: Data, func: DataForeachFunc): void
  /**
   * Gets a data element, using its string identifier. This is slower than
   * g_datalist_id_get_data() because it compares strings.
   * @param datalist a datalist.
   * @param key the string identifying a data element.
   * @returns the data element, or %NULL if it          is not found.
   */
  function datalistGetData(datalist: Data, key: string): any | null
  /**
   * Gets flags values packed in together with the datalist.
   * See g_datalist_set_flags().
   * @param datalist pointer to the location that holds a list
   * @returns the flags of the datalist
   */
  function datalistGetFlags(datalist: Data): number
  /**
   * Retrieves the data element corresponding to `key_id`.
   * @param datalist a datalist.
   * @param keyId the #GQuark identifying a data element.
   * @returns the data element, or %NULL if          it is not found.
   */
  function datalistIdGetData(datalist: Data, keyId: Quark): any | null
  /**
   * Removes multiple keys from a datalist.
   *
   * This is more efficient than calling g_datalist_id_remove_data()
   * multiple times in a row.
   *
   * Before 2.80, `n_keys` had to be not larger than 16. Now it can be larger, but
   * note that GData does a linear search, so an excessive number of keys will
   * perform badly.
   * @param datalist a datalist
   * @param keys keys to remove
   */
  function datalistIdRemoveMultiple(datalist: Data, keys: Quark[]): void
  /**
   * Turns on flag values for a data list. This function is used
   * to keep a small number of boolean flags in an object with
   * a data list without using any additional space. It is
   * not generally useful except in circumstances where space
   * is very tight. (It is used in the base #GObject type, for
   * example.)
   * @param datalist pointer to the location that holds a list
   * @param flags the flags to turn on. The values of the flags are   restricted by %G_DATALIST_FLAGS_MASK (currently   3; giving two possible boolean flags).   A value for `flags` that doesn't fit within the mask is   an error.
   */
  function datalistSetFlags(datalist: Data, flags: number): void
  /**
   * Turns off flag values for a data list. See g_datalist_unset_flags()
   * @param datalist pointer to the location that holds a list
   * @param flags the flags to turn off. The values of the flags are   restricted by %G_DATALIST_FLAGS_MASK (currently   3: giving two possible boolean flags).   A value for `flags` that doesn't fit within the mask is   an error.
   */
  function datalistUnsetFlags(datalist: Data, flags: number): void
  /**
   * Destroys the dataset, freeing all memory allocated, and calling any
   * destroy functions set for data elements.
   * @param datasetLocation the location identifying the dataset.
   */
  function datasetDestroy(datasetLocation: any): void
  /**
   * Calls the given function for each data element which is associated
   * with the given location. Note that this function is NOT thread-safe.
   * So unless `dataset_location` can be protected from any modifications
   * during invocation of this function, it should not be called.
   *
   * `func` can make changes to the dataset, but the iteration will not
   * reflect changes made during the g_dataset_foreach() call, other
   * than skipping over elements that are removed.
   * @param datasetLocation the location identifying the dataset.
   * @param func the function to call for each data element.
   */
  function datasetForeach(datasetLocation: any, func: DataForeachFunc): void
  /**
   * Gets the data element corresponding to a #GQuark.
   * @param datasetLocation the location identifying the dataset.
   * @param keyId the #GQuark id to identify the data element.
   * @returns the data element corresponding to          the #GQuark, or %NULL if it is not found.
   */
  function datasetIdGetData(datasetLocation: any, keyId: Quark): any | null
  /**
   * Returns the number of days in a month, taking leap
   * years into account.
   * @param month month
   * @param year year
   * @returns number of days in @month during the @year
   */
  function dateGetDaysInMonth(month: DateMonth, year: DateYear): number
  /**
   * Returns the number of weeks in the year, where weeks
   * are taken to start on Monday. Will be 52 or 53. The
   * date must be valid. (Years always have 52 7-day periods,
   * plus 1 or 2 extra days depending on whether it's a leap
   * year. This function is basically telling you how many
   * Mondays are in the year, i.e. there are 53 Mondays if
   * one of the extra days happens to be a Monday.)
   * @param year a year
   * @returns number of Mondays in the year
   */
  function dateGetMondayWeeksInYear(year: DateYear): number
  /**
   * Returns the number of weeks in the year, where weeks
   * are taken to start on Sunday. Will be 52 or 53. The
   * date must be valid. (Years always have 52 7-day periods,
   * plus 1 or 2 extra days depending on whether it's a leap
   * year. This function is basically telling you how many
   * Sundays are in the year, i.e. there are 53 Sundays if
   * one of the extra days happens to be a Sunday.)
   * @param year year to count weeks in
   * @returns the number of weeks in @year
   */
  function dateGetSundayWeeksInYear(year: DateYear): number
  /**
   * Returns %TRUE if the year is a leap year.
   *
   * For the purposes of this function, leap year is every year
   * divisible by 4 unless that year is divisible by 100. If it
   * is divisible by 100 it would be a leap year only if that year
   * is also divisible by 400.
   * @param year year to check
   * @returns %TRUE if the year is a leap year
   */
  function dateIsLeapYear(year: DateYear): boolean
  /**
   * Generates a printed representation of the date, in a
   * [locale][setlocale]-specific way.
   * Works just like the platform's C library strftime() function,
   * but only accepts date-related formats; time-related formats
   * give undefined results. Date must be valid. Unlike strftime()
   * (which uses the locale encoding), works on a UTF-8 format
   * string and stores a UTF-8 result.
   *
   * This function does not provide any conversion specifiers in
   * addition to those implemented by the platform's C library.
   * For example, don't expect that using g_date_strftime() would
   * make the \%F provided by the C99 strftime() work on Windows
   * where the C library only complies to C89.
   * @param s destination buffer
   * @param slen buffer size
   * @param format format string
   * @param date valid #GDate
   * @returns number of characters written to the buffer, or 0 the buffer was too small
   */
  function dateStrftime(
    s: string | null,
    slen: number,
    format: string,
    date: Date
  ): number
  /**
   * Returns %TRUE if the day of the month is valid (a day is valid if it's
   * between 1 and 31 inclusive).
   * @param day day to check
   * @returns %TRUE if the day is valid
   */
  function dateValidDay(day: DateDay): boolean
  /**
   * Returns %TRUE if the day-month-year triplet forms a valid, existing day
   * in the range of days #GDate understands (Year 1 or later, no more than
   * a few thousand years in the future).
   * @param day day
   * @param month month
   * @param year year
   * @returns %TRUE if the date is a valid one
   */
  function dateValidDmy(day: DateDay, month: DateMonth, year: DateYear): boolean
  /**
   * Returns %TRUE if the Julian day is valid. Anything greater than zero
   * is basically a valid Julian, though there is a 32-bit limit.
   * @param julianDate Julian day to check
   * @returns %TRUE if the Julian day is valid
   */
  function dateValidJulian(julianDate: number): boolean
  /**
   * Returns %TRUE if the month value is valid. The 12 #GDateMonth
   * enumeration values are the only valid months.
   * @param month month
   * @returns %TRUE if the month is valid
   */
  function dateValidMonth(month: DateMonth): boolean
  /**
   * Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration
   * values are the only valid weekdays.
   * @param weekday weekday
   * @returns %TRUE if the weekday is valid
   */
  function dateValidWeekday(weekday: DateWeekday): boolean
  /**
   * Returns %TRUE if the year is valid. Any year greater than 0 is valid,
   * though there is a 16-bit limit to what #GDate will understand.
   * @param year year
   * @returns %TRUE if the year is valid
   */
  function dateValidYear(year: DateYear): boolean
  /**
   * This is a variant of g_dgettext() that allows specifying a locale
   * category instead of always using `LC_MESSAGES`. See g_dgettext() for
   * more information about how this functions differs from calling
   * dcgettext() directly.
   * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
   * @param msgid message to translate
   * @param category a locale category
   * @returns the translated string for the given locale category
   */
  function dcgettext(
    domain: string | null,
    msgid: string,
    category: number
  ): string
  /**
   * This function is a wrapper of dgettext() which does not translate
   * the message if the default domain as set with textdomain() has no
   * translations for the current locale.
   *
   * The advantage of using this function over dgettext() proper is that
   * libraries using this function (like GTK) will not use translations
   * if the application using the library does not have translations for
   * the current locale.  This results in a consistent English-only
   * interface instead of one having partial translations.  For this
   * feature to work, the call to textdomain() and setlocale() should
   * precede any g_dgettext() invocations.  For GTK, it means calling
   * textdomain() before gtk_init or its variants.
   *
   * This function disables translations if and only if upon its first
   * call all the following conditions hold:
   *
   * - `domain` is not %NULL
   *
   * - textdomain() has been called to set a default text domain
   *
   * - there is no translations available for the default text domain
   *   and the current locale
   *
   * - current locale is not "C" or any English locales (those
   *   starting with "en_")
   *
   * Note that this behavior may not be desired for example if an application
   * has its untranslated messages in a language other than English. In those
   * cases the application should call textdomain() after initializing GTK.
   *
   * Applications should normally not use this function directly,
   * but use the _() macro for translations.
   * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
   * @param msgid message to translate
   * @returns The translated string
   */
  function dgettext(domain: string | null, msgid: string): string
  /**
   * Creates a subdirectory in the preferred directory for temporary
   * files (as returned by g_get_tmp_dir()).
   *
   * `tmpl` should be a string in the GLib file name encoding containing
   * a sequence of six 'X' characters, as the parameter to g_mkstemp().
   * However, unlike these functions, the template should only be a
   * basename, no directory components are allowed. If template is
   * %NULL, a default template is used.
   *
   * Note that in contrast to g_mkdtemp() (and mkdtemp()) `tmpl` is not
   * modified, and might thus be a read-only literal string.
   * @param tmpl Template for directory name,   as in g_mkdtemp(), basename only, or %NULL for a default template
   * @returns The actual name used. This string   should be freed with g_free() when not needed any longer and is   is in the GLib file name encoding. In case of errors, %NULL is   returned and @error will be set.
   */
  function dirMakeTmp(tmpl: string | null): string
  /**
   * Compares two #gpointer arguments and returns %TRUE if they are equal.
   * It can be passed to g_hash_table_new() as the `key_equal_func`
   * parameter, when using opaque pointers compared by pointer value as
   * keys in a #GHashTable.
   *
   * This equality function is also appropriate for keys that are integers
   * stored in pointers, such as `GINT_TO_POINTER (n)`.
   * @param v1 a key
   * @param v2 a key to compare with `v1`
   * @returns %TRUE if the two keys match.
   */
  function directEqual(v1: any | null, v2: any | null): boolean
  /**
   * Converts a gpointer to a hash value.
   * It can be passed to g_hash_table_new() as the `hash_func` parameter,
   * when using opaque pointers compared by pointer value as keys in a
   * #GHashTable.
   *
   * This hash function is also appropriate for keys that are integers
   * stored in pointers, such as `GINT_TO_POINTER (n)`.
   * @param v a #gpointer key
   * @returns a hash value corresponding to the key.
   */
  function directHash(v: any | null): number
  /**
   * This function is a wrapper of dngettext() which does not translate
   * the message if the default domain as set with textdomain() has no
   * translations for the current locale.
   *
   * See g_dgettext() for details of how this differs from dngettext()
   * proper.
   * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
   * @param msgid message to translate
   * @param msgidPlural plural form of the message
   * @param n the quantity for which translation is needed
   * @returns The translated string
   */
  function dngettext(
    domain: string | null,
    msgid: string,
    msgidPlural: string,
    n: number
  ): string
  /**
   * Compares the two #gdouble values being pointed to and returns
   * %TRUE if they are equal.
   * It can be passed to g_hash_table_new() as the `key_equal_func`
   * parameter, when using non-%NULL pointers to doubles as keys in a
   * #GHashTable.
   * @param v1 a pointer to a #gdouble key
   * @param v2 a pointer to a #gdouble key to compare with `v1`
   * @returns %TRUE if the two keys match.
   */
  function doubleEqual(v1: any, v2: any): boolean
  /**
   * Converts a pointer to a #gdouble to a hash value.
   * It can be passed to g_hash_table_new() as the `hash_func` parameter,
   * It can be passed to g_hash_table_new() as the `hash_func` parameter,
   * when using non-%NULL pointers to doubles as keys in a #GHashTable.
   * @param v a pointer to a #gdouble key
   * @returns a hash value corresponding to the key.
   */
  function doubleHash(v: any): number
  /**
   * This function is a variant of g_dgettext() which supports
   * a disambiguating message context. GNU gettext uses the
   * '\004' character to separate the message context and
   * message id in `msgctxtid`.
   * If 0 is passed as `msgidoffset,` this function will fall back to
   * trying to use the deprecated convention of using "|" as a separation
   * character.
   *
   * This uses g_dgettext() internally. See that functions for differences
   * with dgettext() proper.
   *
   * Applications should normally not use this function directly,
   * but use the C_() macro for translations with context.
   * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
   * @param msgctxtid a combined message context and message id, separated   by a \004 character
   * @param msgidoffset the offset of the message id in `msgctxid`
   * @returns The translated string
   */
  function dpgettext(
    domain: string | null,
    msgctxtid: string,
    msgidoffset: number
  ): string
  /**
   * This function is a variant of g_dgettext() which supports
   * a disambiguating message context. GNU gettext uses the
   * '\004' character to separate the message context and
   * message id in `msgctxtid`.
   *
   * This uses g_dgettext() internally. See that functions for differences
   * with dgettext() proper.
   *
   * This function differs from C_() in that it is not a macro and
   * thus you may use non-string-literals as context and msgid arguments.
   * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
   * @param context the message context
   * @param msgid the message
   * @returns The translated string
   */
  function dpgettext2(
    domain: string | null,
    context: string,
    msgid: string
  ): string
  /**
   * Returns the value of the environment variable `variable` in the
   * provided list `envp`.
   * @param envp an environment list (eg, as returned from g_get_environ()), or %NULL     for an empty environment list
   * @param variable the environment variable to get
   * @returns the value of the environment variable, or %NULL if     the environment variable is not set in @envp. The returned     string is owned by @envp, and will be freed if @variable is     set or unset again.
   */
  function environGetenv(envp: string[] | null, variable: string): string | null
  /**
   * Sets the environment variable `variable` in the provided list
   * `envp` to `value`.
   * @param envp an environment list that can be freed using g_strfreev() (e.g., as     returned from g_get_environ()), or %NULL for an empty     environment list
   * @param variable the environment variable to set, must not     contain '='
   * @param value the value for to set the variable to
   * @param overwrite whether to change the variable if it already exists
   * @returns the updated environment list. Free it using g_strfreev().
   */
  function environSetenv(
    envp: string[] | null,
    variable: string,
    value: string,
    overwrite: boolean
  ): string[]
  /**
   * Removes the environment variable `variable` from the provided
   * environment `envp`.
   * @param envp an environment list that can be freed using g_strfreev() (e.g., as     returned from g_get_environ()), or %NULL for an empty environment list
   * @param variable the environment variable to remove, must not     contain '='
   * @returns the updated environment list. Free it using g_strfreev().
   */
  function environUnsetenv(envp: string[] | null, variable: string): string[]
  /**
   * This function registers an extended #GError domain.
   * `error_type_name` will be duplicated. Otherwise does the same as
   * g_error_domain_register_static().
   * @param errorTypeName string to create a #GQuark from
   * @param errorTypePrivateSize size of the private error data in bytes
   * @param errorTypeInit function initializing fields of the private error data
   * @param errorTypeCopy function copying fields of the private error data
   * @param errorTypeClear function freeing fields of the private error data
   * @returns #GQuark representing the error domain
   */
  function errorDomainRegister(
    errorTypeName: string,
    errorTypePrivateSize: number,
    errorTypeInit: ErrorInitFunc,
    errorTypeCopy: ErrorCopyFunc,
    errorTypeClear: ErrorClearFunc
  ): Quark
  /**
   * This function registers an extended #GError domain.
   *
   * `error_type_name` should not be freed. `error_type_private_size` must
   * be greater than 0.
   *
   * `error_type_init` receives an initialized #GError and should then initialize
   * the private data.
   *
   * `error_type_copy` is a function that receives both original and a copy
   * #GError and should copy the fields of the private error data. The standard
   * #GError fields are already handled.
   *
   * `error_type_clear` receives the pointer to the error, and it should free the
   * fields of the private error data. It should not free the struct itself though.
   *
   * Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it
   * already takes care of passing valid information to this function.
   * @param errorTypeName static string to create a #GQuark from
   * @param errorTypePrivateSize size of the private error data in bytes
   * @param errorTypeInit function initializing fields of the private error data
   * @param errorTypeCopy function copying fields of the private error data
   * @param errorTypeClear function freeing fields of the private error data
   * @returns #GQuark representing the error domain
   */
  function errorDomainRegisterStatic(
    errorTypeName: string,
    errorTypePrivateSize: number,
    errorTypeInit: ErrorInitFunc,
    errorTypeCopy: ErrorCopyFunc,
    errorTypeClear: ErrorClearFunc
  ): Quark
  /**
   * Mark every file descriptor equal to or greater than `lowfd` to be closed
   * at the next `execve()` or similar, as if via the `FD_CLOEXEC` flag.
   *
   * Typically `lowfd` will be 3, to leave standard input, standard output
   * and standard error open after exec.
   *
   * This is the same as Linux `close_range (lowfd, ~0U, CLOSE_RANGE_CLOEXEC)`,
   * but portable to other OSs and to older versions of Linux.
   *
   * This function is async-signal safe, making it safe to call from a
   * signal handler or a [callback`GLib`.SpawnChildSetupFunc], as long as `lowfd` is
   * non-negative.
   * See [`signal(7)`](man:signal(7)) and
   * [`signal-safety(7)`](man:signal-safety(7)) for more details.
   * @param lowfd Minimum fd to act on, which must be non-negative
   * @returns 0 on success, -1 with errno set on error
   */
  function fdwalkSetCloexec(lowfd: number): number
  /**
   * Gets a #GFileError constant based on the passed-in `err_no`.
   *
   * For example, if you pass in `EEXIST` this function returns
   * %G_FILE_ERROR_EXIST. Unlike `errno` values, you can portably
   * assume that all #GFileError values will exist.
   *
   * Normally a #GFileError value goes into a #GError returned
   * from a function that manipulates files. So you would use
   * g_file_error_from_errno() when constructing a #GError.
   * @param errNo an "errno" value
   * @returns #GFileError corresponding to the given @err_no
   */
  function fileErrorFromErrno(errNo: number): FileError
  function fileErrorQuark(): Quark
  /**
   * Reads an entire file into allocated memory, with good error
   * checking.
   *
   * If the call was successful, it returns %TRUE and sets `contents` to the file
   * contents and `length` to the length of the file contents in bytes. The string
   * stored in `contents` will be nul-terminated, so for text files you can pass
   * %NULL for the `length` argument. If the call was not successful, it returns
   * %FALSE and sets `error`. The error domain is %G_FILE_ERROR. Possible error
   * codes are those in the #GFileError enumeration. In the error case,
   * `contents` is set to %NULL and `length` is set to zero.
   * @param filename name of a file to read contents from, in the GLib file name encoding
   * @returns %TRUE on success, %FALSE if an error occurred
   */
  function fileGetContents(
    filename: string
  ): [/* returnType */ boolean, /* contents */ number[]]
  /**
   * Opens a file for writing in the preferred directory for temporary
   * files (as returned by g_get_tmp_dir()).
   *
   * `tmpl` should be a string in the GLib file name encoding containing
   * a sequence of six 'X' characters, as the parameter to g_mkstemp().
   * However, unlike these functions, the template should only be a
   * basename, no directory components are allowed. If template is
   * %NULL, a default template is used.
   *
   * Note that in contrast to g_mkstemp() (and mkstemp()) `tmpl` is not
   * modified, and might thus be a read-only literal string.
   *
   * Upon success, and if `name_used` is non-%NULL, the actual name used
   * is returned in `name_used`. This string should be freed with g_free()
   * when not needed any longer. The returned name is in the GLib file
   * name encoding.
   * @param tmpl Template for file name, as in   g_mkstemp(), basename only, or %NULL for a default template
   * @returns A file handle (as from open()) to the file opened for   reading and writing. The file is opened in binary mode on platforms   where there is a difference. The file handle should be closed with   close(). In case of errors, -1 is returned and @error will be set.
   */
  function fileOpenTmp(
    tmpl: string | null
  ): [/* returnType */ number, /* nameUsed */ string]
  /**
   * Reads the contents of the symbolic link `filename` like the POSIX
   * `readlink()` function.
   *
   * The returned string is in the encoding used for filenames. Use
   * g_filename_to_utf8() to convert it to UTF-8.
   *
   * The returned string may also be a relative path. Use g_build_filename()
   * to convert it to an absolute path:
   *
   *
   * ```c
   * g_autoptr(GError) local_error = NULL;
   * g_autofree gchar *link_target = g_file_read_link ("/etc/localtime", &local_error);
   *
   * if (local_error != NULL)
   *   g_error ("Error reading link: %s", local_error->message);
   *
   * if (!g_path_is_absolute (link_target))
   *   {
   *     g_autofree gchar *absolute_link_target = g_build_filename ("/etc", link_target, NULL);
   *     g_free (link_target);
   *     link_target = g_steal_pointer (&absolute_link_target);
   *   }
   * ```
   *
   * @param filename the symbolic link
   * @returns A newly-allocated string with   the contents of the symbolic link, or %NULL if an error occurred.
   */
  function fileReadLink(filename: string): string
  /**
   * Writes all of `contents` to a file named `filename`. This is a convenience
   * wrapper around calling g_file_set_contents_full() with `flags` set to
   * `G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING` and
   * `mode` set to `0666`.
   * @param filename name of a file to write `contents` to, in the GLib file name   encoding
   * @param contents string to write to the file
   * @returns %TRUE on success, %FALSE if an error occurred
   */
  function fileSetContents(filename: string, contents: number[]): boolean
  /**
   * Writes all of `contents` to a file named `filename,` with good error checking.
   * If a file called `filename` already exists it will be overwritten.
   *
   * `flags` control the properties of the write operation: whether it’s atomic,
   * and what the tradeoff is between returning quickly or being resilient to
   * system crashes.
   *
   * As this function performs file I/O, it is recommended to not call it anywhere
   * where blocking would cause problems, such as in the main loop of a graphical
   * application. In particular, if `flags` has any value other than
   * %G_FILE_SET_CONTENTS_NONE then this function may call `fsync()`.
   *
   * If %G_FILE_SET_CONTENTS_CONSISTENT is set in `flags,` the operation is atomic
   * in the sense that it is first written to a temporary file which is then
   * renamed to the final name.
   *
   * Notes:
   *
   * - On UNIX, if `filename` already exists hard links to `filename` will break.
   *   Also since the file is recreated, existing permissions, access control
   *   lists, metadata etc. may be lost. If `filename` is a symbolic link,
   *   the link itself will be replaced, not the linked file.
   *
   * - On UNIX, if `filename` already exists and is non-empty, and if the system
   *   supports it (via a journalling filesystem or equivalent), and if
   *   %G_FILE_SET_CONTENTS_CONSISTENT is set in `flags,` the `fsync()` call (or
   *   equivalent) will be used to ensure atomic replacement: `filename`
   *   will contain either its old contents or `contents,` even in the face of
   *   system power loss, the disk being unsafely removed, etc.
   *
   * - On UNIX, if `filename` does not already exist or is empty, there is a
   *   possibility that system power loss etc. after calling this function will
   *   leave `filename` empty or full of NUL bytes, depending on the underlying
   *   filesystem, unless %G_FILE_SET_CONTENTS_DURABLE and
   *   %G_FILE_SET_CONTENTS_CONSISTENT are set in `flags`.
   *
   * - On Windows renaming a file will not remove an existing file with the
   *   new name, so on Windows there is a race condition between the existing
   *   file being removed and the temporary file being renamed.
   *
   * - On Windows there is no way to remove a file that is open to some
   *   process, or mapped into memory. Thus, this function will fail if
   *   `filename` already exists and is open.
   *
   * If the call was successful, it returns %TRUE. If the call was not successful,
   * it returns %FALSE and sets `error`. The error domain is %G_FILE_ERROR.
   * Possible error codes are those in the #GFileError enumeration.
   *
   * Note that the name for the temporary file is constructed by appending up
   * to 7 characters to `filename`.
   *
   * If the file didn’t exist before and is created, it will be given the
   * permissions from `mode`. Otherwise, the permissions of the existing file may
   * be changed to `mode` depending on `flags,` or they may remain unchanged.
   * @param filename name of a file to write `contents` to, in the GLib file name   encoding
   * @param contents string to write to the file
   * @param flags flags controlling the safety vs speed of the operation
   * @param mode file mode, as passed to `open()`; typically this will be `0666`
   * @returns %TRUE on success, %FALSE if an error occurred
   */
  function fileSetContentsFull(
    filename: string,
    contents: number[],
    flags: FileSetContentsFlags,
    mode: number
  ): boolean
  /**
   * Returns %TRUE if any of the tests in the bitfield `test` are
   * %TRUE. For example, `(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)`
   * will return %TRUE if the file exists; the check whether it's a
   * directory doesn't matter since the existence test is %TRUE. With
   * the current set of available tests, there's no point passing in
   * more than one test at a time.
   *
   * Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,
   * so for a symbolic link to a regular file g_file_test() will return
   * %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.
   *
   * Note, that for a dangling symbolic link g_file_test() will return
   * %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.
   *
   * You should never use g_file_test() to test whether it is safe
   * to perform an operation, because there is always the possibility
   * of the condition changing before you actually perform the operation,
   * see [TOCTOU](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use).
   *
   * For example, you might think you could use %G_FILE_TEST_IS_SYMLINK
   * to know whether it is safe to write to a file without being
   * tricked into writing into a different location. It doesn't work!
   *
   *
   * ```c
   *  // DON'T DO THIS
   *  if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK))
   *    {
   *      fd = g_open (filename, O_WRONLY);
   *      // write to fd
   *    }
   *
   *  // DO THIS INSTEAD
   *  fd = g_open (filename, O_WRONLY | O_NOFOLLOW | O_CLOEXEC);
   *  if (fd == -1)
   *    {
   *      // check error
   *      if (errno == ELOOP)
   *        // file is a symlink and can be ignored
   *      else
   *        // handle errors as before
   *    }
   *  else
   *    {
   *      // write to fd
   *    }
   * ```
   *
   *
   * Another thing to note is that %G_FILE_TEST_EXISTS and
   * %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()
   * system call. This usually doesn't matter, but if your program
   * is setuid or setgid it means that these tests will give you
   * the answer for the real user ID and group ID, rather than the
   * effective user ID and group ID.
   *
   * On Windows, there are no symlinks, so testing for
   * %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for
   * %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and
   * its name indicates that it is executable, checking for well-known
   * extensions and those listed in the `PATHEXT` environment variable.
   * @param filename a filename to test in the     GLib file name encoding
   * @param test bitfield of #GFileTest flags
   * @returns whether a test was %TRUE
   */
  function fileTest(filename: string, test: FileTest): boolean
  /**
   * Returns the display basename for the particular filename, guaranteed
   * to be valid UTF-8. The display name might not be identical to the filename,
   * for instance there might be problems converting it to UTF-8, and some files
   * can be translated in the display.
   *
   * If GLib cannot make sense of the encoding of `filename,` as a last resort it
   * replaces unknown characters with U+FFFD, the Unicode replacement character.
   * You can search the result for the UTF-8 encoding of this character (which is
   * "\357\277\275" in octal notation) to find out if `filename` was in an invalid
   * encoding.
   *
   * You must pass the whole absolute pathname to this functions so that
   * translation of well known locations can be done.
   *
   * This function is preferred over g_filename_display_name() if you know the
   * whole path, as it allows translation.
   * @param filename an absolute pathname in the     GLib file name encoding
   * @returns a newly allocated string containing   a rendition of the basename of the filename in valid UTF-8
   */
  function filenameDisplayBasename(filename: string): string | null
  /**
   * Converts a filename into a valid UTF-8 string. The conversion is
   * not necessarily reversible, so you should keep the original around
   * and use the return value of this function only for display purposes.
   * Unlike g_filename_to_utf8(), the result is guaranteed to be non-%NULL
   * even if the filename actually isn't in the GLib file name encoding.
   *
   * If GLib cannot make sense of the encoding of `filename,` as a last resort it
   * replaces unknown characters with U+FFFD, the Unicode replacement character.
   * You can search the result for the UTF-8 encoding of this character (which is
   * "\357\277\275" in octal notation) to find out if `filename` was in an invalid
   * encoding.
   *
   * If you know the whole pathname of the file you should use
   * g_filename_display_basename(), since that allows location-based
   * translation of filenames.
   * @param filename a pathname hopefully in the     GLib file name encoding
   * @returns a newly allocated string containing   a rendition of the filename in valid UTF-8
   */
  function filenameDisplayName(filename: string): string | null
  /**
   * Converts an escaped ASCII-encoded URI to a local filename in the
   * encoding used for filenames.
   *
   * Since GLib 2.78, the query string and fragment can be present in the URI,
   * but are not part of the resulting filename.
   * We take inspiration from https://url.spec.whatwg.org/#file-state,
   * but we don't support the entire standard.
   * @param uri a uri describing a filename (escaped, encoded in ASCII).
   * @returns a newly-allocated string holding               the resulting filename, or %NULL on an error.
   */
  function filenameFromUri(
    uri: string
  ): [/* returnType */ string, /* hostname */ string | null]
  /**
   * Converts a string from UTF-8 to the encoding GLib uses for
   * filenames. Note that on Windows GLib uses UTF-8 for filenames;
   * on other platforms, this function indirectly depends on the
   * [current locale][setlocale].
   *
   * The input string shall not contain nul characters even if the `len`
   * argument is positive. A nul character found inside the string will result
   * in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. If the filename encoding is
   * not UTF-8 and the conversion output contains a nul character, the error
   * %G_CONVERT_ERROR_EMBEDDED_NUL is set and the function returns %NULL.
   * @param utf8string a UTF-8 encoded string.
   * @param len the length of the string, or -1 if the string is                 nul-terminated.
   * @returns The converted string, or %NULL on an error.
   */
  function filenameFromUtf8(
    utf8string: string,
    len: number
  ): [
    /* returnType */ string,
    /* bytesRead */ number,
    /* bytesWritten */ number,
  ]
  /**
   * Converts an absolute filename to an escaped ASCII-encoded URI, with the path
   * component following Section 3.3. of RFC 2396.
   * @param filename an absolute filename specified in the GLib file     name encoding, which is the on-disk file name bytes on Unix, and UTF-8     on Windows
   * @param hostname A UTF-8 encoded hostname, or %NULL for none.
   * @returns a newly-allocated string holding the resulting               URI, or %NULL on an error.
   */
  function filenameToUri(
    filename: string,
    hostname: string | null
  ): string | null
  /**
   * Converts a string which is in the encoding used by GLib for
   * filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8
   * for filenames; on other platforms, this function indirectly depends on
   * the [current locale][setlocale].
   *
   * The input string shall not contain nul characters even if the `len`
   * argument is positive. A nul character found inside the string will result
   * in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE.
   * If the source encoding is not UTF-8 and the conversion output contains a
   * nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the
   * function returns %NULL. Use g_convert() to produce output that
   * may contain embedded nul characters.
   * @param opsysstring a string in the encoding for filenames
   * @param len the length of the string, or -1 if the string is                 nul-terminated (Note that some encodings may allow nul                 bytes to occur inside strings. In that case, using -1                 for the `len` parameter is unsafe)
   * @returns The converted string, or %NULL on an error.
   */
  function filenameToUtf8(
    opsysstring: string,
    len: number
  ): [
    /* returnType */ string | null,
    /* bytesRead */ number,
    /* bytesWritten */ number,
  ]
  /**
   * Locates the first executable named `program` in the user's path, in the
   * same way that execvp() would locate it. Returns an allocated string
   * with the absolute path name, or %NULL if the program is not found in
   * the path. If `program` is already an absolute path, returns a copy of
   * `program` if `program` exists and is executable, and %NULL otherwise.
   *
   * On Windows, if `program` does not have a file type suffix, tries
   * with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
   * the `PATHEXT` environment variable.
   *
   * On Windows, it looks for the file in the same way as CreateProcess()
   * would. This means first in the directory where the executing
   * program was loaded from, then in the current directory, then in the
   * Windows 32-bit system directory, then in the Windows directory, and
   * finally in the directories in the `PATH` environment variable. If
   * the program is found, the return value contains the full name
   * including the type suffix.
   * @param program a program name in the GLib file name encoding
   * @returns a newly-allocated   string with the absolute path, or %NULL
   */
  function findProgramInPath(program: string): string | null
  /**
   * A wrapper for the stdio `fopen()` function. The `fopen()` function
   * opens a file and associates a new stream with it.
   *
   * Because file descriptors are specific to the C library on Windows,
   * and a file descriptor is part of the `FILE` struct, the `FILE*` returned
   * by this function makes sense only to functions in the same C library.
   * Thus if the GLib-using code uses a different C library than GLib does,
   * the FILE* returned by this function cannot be passed to C library
   * functions like `fprintf()` or `fread()`.
   *
   * See your C library manual for more details about `fopen()`.
   *
   * As `close()` and `fclose()` are part of the C library, this implies that it is
   * currently impossible to close a file if the application C library and the C library
   * used by GLib are different. Convenience functions like g_file_set_contents_full()
   * avoid this problem.
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param mode a string describing the mode in which the file should be opened
   * @returns A `FILE*` if the file was successfully opened, or %NULL if     an error occurred
   */
  function fopen(filename: string, mode: string): any | null
  /**
   * Formats a size (for example the size of a file) into a human readable
   * string.  Sizes are rounded to the nearest size prefix (kB, MB, GB)
   * and are displayed rounded to the nearest tenth. E.g. the file size
   * 3292528 bytes will be converted into the string "3.2 MB". The returned string
   * is UTF-8, and may use a non-breaking space to separate the number and units,
   * to ensure they aren’t separated when line wrapped.
   *
   * The prefix units base is 1000 (i.e. 1 kB is 1000 bytes).
   *
   * This string should be freed with g_free() when not needed any longer.
   *
   * See g_format_size_full() for more options about how the size might be
   * formatted.
   * @param size a size in bytes
   * @returns a newly-allocated formatted string containing   a human readable file size
   */
  function formatSize(size: number): string | null
  /**
   * Formats a size (for example the size of a file) into a human
   * readable string. Sizes are rounded to the nearest size prefix
   * (KB, MB, GB) and are displayed rounded to the nearest tenth.
   * E.g. the file size 3292528 bytes will be converted into the
   * string "3.1 MB".
   *
   * The prefix units base is 1024 (i.e. 1 KB is 1024 bytes).
   *
   * This string should be freed with g_free() when not needed any longer.
   * @param size a size in bytes
   * @returns a newly-allocated formatted string   containing a human readable file size
   */
  function formatSizeForDisplay(size: number): string | null
  /**
   * Formats a size.
   *
   * This function is similar to g_format_size() but allows for flags
   * that modify the output. See #GFormatSizeFlags.
   * @param size a size in bytes
   * @param flags #GFormatSizeFlags to modify the output
   * @returns a newly-allocated formatted string   containing a human readable file size
   */
  function formatSizeFull(size: number, flags: FormatSizeFlags): string | null
  /**
   * Frees the memory pointed to by `mem`.
   *
   * If you know the allocated size of `mem,` calling g_free_sized() may be faster,
   * depending on the libc implementation in use.
   *
   * Starting from GLib 2.78, this may happen automatically in case a GCC
   * compatible compiler is used with some optimization level and the allocated
   * size is known at compile time (see [documentation of
   * `__builtin_object_size()`](https://gcc.gnu.org/onlinedocs/gcc/Object-Size-Checking.html)
   * to understand its caveats).
   *
   * If `mem` is %NULL it simply returns, so there is no need to check `mem`
   * against %NULL before calling this function.
   * @param mem the memory to free
   */
  function free(mem: any | null): void
  /**
   * Frees the memory pointed to by `mem,` assuming it is has the given `size`.
   *
   * If `mem` is %NULL this is a no-op (and `size` is ignored).
   *
   * It is an error if `size` doesn’t match the size passed when `mem` was
   * allocated. `size` is passed to this function to allow optimizations in the
   * allocator. If you don’t know the allocation size, use g_free() instead.
   *
   * In case a GCC compatible compiler is used, this function may be used
   * automatically via g_free() if the allocated size is known at compile time,
   * since GLib 2.78.
   * @param mem the memory to free
   * @param size size of `mem,` in bytes
   */
  function freeSized(mem: any | null, size: number): void
  /**
   * A wrapper for the POSIX freopen() function. The freopen() function
   * opens a file and associates it with an existing stream.
   *
   * See your C library manual for more details about freopen().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param mode a string describing the mode in which the file should be  opened
   * @param stream an existing stream which will be reused, or %NULL
   * @returns A FILE* if the file was successfully opened, or %NULL if     an error occurred.
   */
  function freopen(
    filename: string,
    mode: string,
    stream: any | null
  ): any | null
  /**
   * A wrapper for the POSIX `fsync()` function. On Windows, `_commit()` will be
   * used. On macOS, `fcntl(F_FULLFSYNC)` will be used.
   * The `fsync()` function is used to synchronize a file's in-core
   * state with that of the disk.
   *
   * This wrapper will handle retrying on `EINTR`.
   *
   * See the C library manual for more details about fsync().
   * @param fd a file descriptor
   * @returns 0 on success, or -1 if an error occurred. The return value can be used exactly like the return value from fsync().
   */
  function fsync(fd: number): number
  /**
   * Gets a human-readable name for the application, as set by
   * g_set_application_name(). This name should be localized if
   * possible, and is intended for display to the user.  Contrast with
   * g_get_prgname(), which gets a non-localized name. If
   * g_set_application_name() has not been called, returns the result of
   * g_get_prgname() (which may be %NULL if g_set_prgname() has also not
   * been called).
   * @returns human-readable application   name. May return %NULL
   */
  function getApplicationName(): string | null
  /**
   * Obtains the character set for the [current locale][setlocale]; you
   * might use this character set as an argument to g_convert(), to convert
   * from the current locale's encoding to some other encoding. (Frequently
   * g_locale_to_utf8() and g_locale_from_utf8() are nice shortcuts, though.)
   *
   * On Windows the character set returned by this function is the
   * so-called system default ANSI code-page. That is the character set
   * used by the "narrow" versions of C library and Win32 functions that
   * handle file names. It might be different from the character set
   * used by the C library's current locale.
   *
   * On Linux, the character set is found by consulting nl_langinfo() if
   * available. If not, the environment variables `LC_ALL`, `LC_CTYPE`, `LANG`
   * and `CHARSET` are queried in order. nl_langinfo() returns the C locale if
   * no locale has been loaded by setlocale().
   *
   * The return value is %TRUE if the locale's encoding is UTF-8, in that
   * case you can perhaps avoid calling g_convert().
   *
   * The string returned in `charset` is not allocated, and should not be
   * freed.
   * @returns %TRUE if the returned charset is UTF-8
   */
  function getCharset(): [/* returnType */ boolean, /* charset */ string]
  /**
   * Gets the character set for the current locale.
   * @returns a newly allocated string containing the name     of the character set. This string must be freed with g_free().
   */
  function getCodeset(): string | null
  /**
   * Obtains the character set used by the console attached to the process,
   * which is suitable for printing output to the terminal.
   *
   * Usually this matches the result returned by g_get_charset(), but in
   * environments where the locale's character set does not match the encoding
   * of the console this function tries to guess a more suitable value instead.
   *
   * On Windows the character set returned by this function is the
   * output code page used by the console associated with the calling process.
   * If the codepage can't be determined (for example because there is no
   * console attached) UTF-8 is assumed.
   *
   * The return value is %TRUE if the locale's encoding is UTF-8, in that
   * case you can perhaps avoid calling g_convert().
   *
   * The string returned in `charset` is not allocated, and should not be
   * freed.
   * @returns %TRUE if the returned charset is UTF-8
   */
  function getConsoleCharset(): [/* returnType */ boolean, /* charset */ string]
  /**
   * Gets the current directory.
   *
   * The returned string should be freed when no longer needed.
   * The encoding of the returned string is system defined.
   * On Windows, it is always UTF-8.
   *
   * Since GLib 2.40, this function will return the value of the "PWD"
   * environment variable if it is set and it happens to be the same as
   * the current directory.  This can make a difference in the case that
   * the current directory is the target of a symbolic link.
   * @returns the current directory
   */
  function getCurrentDir(): string
  /**
   * Equivalent to the UNIX gettimeofday() function, but portable.
   *
   * You may find g_get_real_time() to be more convenient.
   * @param result #GTimeVal structure in which to store current time.
   */
  function getCurrentTime(result: TimeVal): void
  /**
   * Gets the list of environment variables for the current process.
   *
   * The list is %NULL terminated and each item in the list is of the
   * form 'NAME=VALUE'.
   *
   * This is equivalent to direct access to the 'environ' global variable,
   * except portable.
   *
   * The return value is freshly allocated and it should be freed with
   * g_strfreev() when it is no longer needed.
   * @returns the list of environment variables
   */
  function getEnviron(): string[]
  /**
   * Determines the preferred character sets used for filenames.
   * The first character set from the `charsets` is the filename encoding, the
   * subsequent character sets are used when trying to generate a displayable
   * representation of a filename, see g_filename_display_name().
   *
   * On Unix, the character sets are determined by consulting the
   * environment variables `G_FILENAME_ENCODING` and `G_BROKEN_FILENAMES`.
   * On Windows, the character set used in the GLib API is always UTF-8
   * and said environment variables have no effect.
   *
   * `G_FILENAME_ENCODING` may be set to a comma-separated list of
   * character set names. The special token "\`locale"` is taken
   * to  mean the character set for the [current locale][setlocale].
   * If `G_FILENAME_ENCODING` is not set, but `G_BROKEN_FILENAMES` is,
   * the character set of the current locale is taken as the filename
   * encoding. If neither environment variable  is set, UTF-8 is taken
   * as the filename encoding, but the character set of the current locale
   * is also put in the list of encodings.
   *
   * The returned `charsets` belong to GLib and must not be freed.
   *
   * Note that on Unix, regardless of the locale character set or
   * `G_FILENAME_ENCODING` value, the actual file names present
   * on a system might be in any random encoding or just gibberish.
   * @returns %TRUE if the filename encoding is UTF-8.
   */
  function getFilenameCharsets(): [
    /* returnType */ boolean,
    /* filenameCharsets */ string[],
  ]
  /**
   * Gets the current user's home directory.
   *
   * As with most UNIX tools, this function will return the value of the
   * `HOME` environment variable if it is set to an existing absolute path
   * name, falling back to the `passwd` file in the case that it is unset.
   *
   * If the path given in `HOME` is non-absolute, does not exist, or is
   * not a directory, the result is undefined.
   *
   * Before version 2.36 this function would ignore the `HOME` environment
   * variable, taking the value from the `passwd` database instead. This was
   * changed to increase the compatibility of GLib with other programs (and
   * the XDG basedir specification) and to increase testability of programs
   * based on GLib (by making it easier to run them from test frameworks).
   *
   * If your program has a strong requirement for either the new or the
   * old behaviour (and if you don't wish to increase your GLib
   * dependency to ensure that the new behaviour is in effect) then you
   * should either directly check the `HOME` environment variable yourself
   * or unset it before calling any functions in GLib.
   * @returns the current user's home directory
   */
  function getHomeDir(): string
  /**
   * Return a name for the machine.
   *
   * The returned name is not necessarily a fully-qualified domain name,
   * or even present in DNS or some other name service at all. It need
   * not even be unique on your local network or site, but usually it
   * is. Callers should not rely on the return value having any specific
   * properties like uniqueness for security purposes. Even if the name
   * of the machine is changed while an application is running, the
   * return value from this function does not change. The returned
   * string is owned by GLib and should not be modified or freed. If no
   * name can be determined, a default fixed string "localhost" is
   * returned.
   *
   * The encoding of the returned string is UTF-8.
   * @returns the host name of the machine.
   */
  function getHostName(): string
  /**
   * Computes a list of applicable locale names, which can be used to
   * e.g. construct locale-dependent filenames or search paths. The returned
   * list is sorted from most desirable to least desirable and always contains
   * the default locale "C".
   *
   * For example, if LANGUAGE=de:en_US, then the returned list is
   * "de", "en_US", "en", "C".
   *
   * This function consults the environment variables `LANGUAGE`, `LC_ALL`,
   * `LC_MESSAGES` and `LANG` to find the list of locales specified by the
   * user.
   * @returns a %NULL-terminated array of strings owned by GLib    that must not be modified or freed.
   */
  function getLanguageNames(): string[]
  /**
   * Computes a list of applicable locale names with a locale category name,
   * which can be used to construct the fallback locale-dependent filenames
   * or search paths. The returned list is sorted from most desirable to
   * least desirable and always contains the default locale "C".
   *
   * This function consults the environment variables `LANGUAGE`, `LC_ALL`,
   * `category_name,` and `LANG` to find the list of locales specified by the
   * user.
   *
   * g_get_language_names() returns g_get_language_names_with_category("LC_MESSAGES").
   * @param categoryName a locale category name
   * @returns a %NULL-terminated array of strings owned by    the thread g_get_language_names_with_category was called from.    It must not be modified or freed. It must be copied if planned to be used in another thread.
   */
  function getLanguageNamesWithCategory(categoryName: string): string[]
  /**
   * Returns a list of derived variants of `locale,` which can be used to
   * e.g. construct locale-dependent filenames or search paths. The returned
   * list is sorted from most desirable to least desirable.
   * This function handles territory, charset and extra locale modifiers. See
   * [`setlocale(3)`](man:setlocale) for information about locales and their format.
   *
   * `locale` itself is guaranteed to be returned in the output.
   *
   * For example, if `locale` is `fr_BE`, then the returned list
   * is `fr_BE`, `fr`. If `locale` is `en_GB.UTF-8`euro``, then the returned list
   * is `en_GB.UTF-8`euro``, `en_GB.UTF-8`, `en_GB`euro``, `en_GB`, `en.UTF-8`euro``,
   * `en.UTF-8`, `en`euro``, `en`.
   *
   * If you need the list of variants for the current locale,
   * use g_get_language_names().
   * @param locale a locale identifier
   * @returns a newly   allocated array of newly allocated strings with the locale variants. Free with   g_strfreev().
   */
  function getLocaleVariants(locale: string): string[]
  /**
   * Queries the system monotonic time.
   *
   * The monotonic clock will always increase and doesn't suffer
   * discontinuities when the user (or NTP) changes the system time.  It
   * may or may not continue to tick during times where the machine is
   * suspended.
   *
   * We try to use the clock that corresponds as closely as possible to
   * the passage of time as measured by system calls such as poll() but it
   * may not always be possible to do this.
   * @returns the monotonic time, in microseconds
   */
  function getMonotonicTime(): number
  /**
   * Determine the approximate number of threads that the system will
   * schedule simultaneously for this process.  This is intended to be
   * used as a parameter to g_thread_pool_new() for CPU bound tasks and
   * similar cases.
   * @returns Number of schedulable threads, always greater than 0
   */
  function getNumProcessors(): number
  /**
   * Get information about the operating system.
   *
   * On Linux this comes from the `/etc/os-release` file. On other systems, it may
   * come from a variety of sources. You can either use the standard key names
   * like %G_OS_INFO_KEY_NAME or pass any UTF-8 string key name. For example,
   * `/etc/os-release` provides a number of other less commonly used values that may
   * be useful. No key is guaranteed to be provided, so the caller should always
   * check if the result is %NULL.
   * @param keyName a key for the OS info being requested, for example %G_OS_INFO_KEY_NAME.
   * @returns The associated value for the requested key or %NULL if   this information is not provided.
   */
  function getOsInfo(keyName: string): string | null
  /**
   * Gets the name of the program. This name should not be localized,
   * in contrast to g_get_application_name().
   *
   * If you are using #GApplication the program name is set in
   * g_application_run(). In case of GDK or GTK it is set in
   * gdk_init(), which is called by gtk_init() and the
   * #GtkApplication::startup handler. The program name is found by
   * taking the last component of `argv[`0].
   * @returns the name of the program,   or %NULL if it has not been set yet. The returned string belongs   to GLib and must not be modified or freed.
   */
  function getPrgname(): string | null
  /**
   * Gets the real name of the user. This usually comes from the user's
   * entry in the `passwd` file. The encoding of the returned string is
   * system-defined. (On Windows, it is, however, always UTF-8.) If the
   * real user name cannot be determined, the string "Unknown" is
   * returned.
   * @returns the user's real name.
   */
  function getRealName(): string
  /**
   * Queries the system wall-clock time.
   *
   * This call is functionally equivalent to g_get_current_time() except
   * that the return value is often more convenient than dealing with a
   * #GTimeVal.
   *
   * You should only use this call if you are actually interested in the real
   * wall-clock time.  g_get_monotonic_time() is probably more useful for
   * measuring intervals.
   * @returns the number of microseconds since January 1, 1970 UTC.
   */
  function getRealTime(): number
  /**
   * Returns an ordered list of base directories in which to access
   * system-wide configuration information.
   *
   * On UNIX platforms this is determined using the mechanisms described
   * in the
   * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
   * In this case the list of directories retrieved will be `XDG_CONFIG_DIRS`.
   *
   * On Windows it follows XDG Base Directory Specification if `XDG_CONFIG_DIRS` is defined.
   * If `XDG_CONFIG_DIRS` is undefined, the directory that contains application
   * data for all users is used instead. A typical path is
   * `C:\Documents and Settings\All Users\Application Data`.
   * This folder is used for application data
   * that is not user specific. For example, an application can store
   * a spell-check dictionary, a database of clip art, or a log file in the
   * FOLDERID_ProgramData folder. This information will not roam and is available
   * to anyone using the computer.
   *
   * The return value is cached and modifying it at runtime is not supported, as
   * it’s not thread-safe to modify environment variables at runtime.
   * @returns a %NULL-terminated array of strings owned by GLib that must not be     modified or freed.
   */
  function getSystemConfigDirs(): string[]
  /**
   * Returns an ordered list of base directories in which to access
   * system-wide application data.
   *
   * On UNIX platforms this is determined using the mechanisms described
   * in the
   * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec)
   * In this case the list of directories retrieved will be `XDG_DATA_DIRS`.
   *
   * On Windows it follows XDG Base Directory Specification if `XDG_DATA_DIRS` is defined.
   * If `XDG_DATA_DIRS` is undefined,
   * the first elements in the list are the Application Data
   * and Documents folders for All Users. (These can be determined only
   * on Windows 2000 or later and are not present in the list on other
   * Windows versions.) See documentation for FOLDERID_ProgramData and
   * FOLDERID_PublicDocuments.
   *
   * Then follows the "share" subfolder in the installation folder for
   * the package containing the DLL that calls this function, if it can
   * be determined.
   *
   * Finally the list contains the "share" subfolder in the installation
   * folder for GLib, and in the installation folder for the package the
   * application's .exe file belongs to.
   *
   * The installation folders above are determined by looking up the
   * folder where the module (DLL or EXE) in question is located. If the
   * folder's name is "bin", its parent is used, otherwise the folder
   * itself.
   *
   * Note that on Windows the returned list can vary depending on where
   * this function is called.
   *
   * The return value is cached and modifying it at runtime is not supported, as
   * it’s not thread-safe to modify environment variables at runtime.
   * @returns a %NULL-terminated array of strings owned by GLib that must not be     modified or freed.
   */
  function getSystemDataDirs(): string[]
  /**
   * Gets the directory to use for temporary files.
   *
   * On UNIX, this is taken from the `TMPDIR` environment variable.
   * If the variable is not set, `P_tmpdir` is
   * used, as defined by the system C library. Failing that, a
   * hard-coded default of "/tmp" is returned.
   *
   * On Windows, the `TEMP` environment variable is used, with the
   * root directory of the Windows installation (eg: "C:\") used
   * as a default.
   *
   * The encoding of the returned string is system-defined. On Windows,
   * it is always UTF-8. The return value is never %NULL or the empty
   * string.
   * @returns the directory to use for temporary files.
   */
  function getTmpDir(): string
  /**
   * Returns a base directory in which to store non-essential, cached
   * data specific to particular user.
   *
   * On UNIX platforms this is determined using the mechanisms described
   * in the
   * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
   * In this case the directory retrieved will be `XDG_CACHE_HOME`.
   *
   * On Windows it follows XDG Base Directory Specification if `XDG_CACHE_HOME` is defined.
   * If `XDG_CACHE_HOME` is undefined, the directory that serves as a common
   * repository for temporary Internet files is used instead. A typical path is
   * `C:\Documents and Settings\username\Local Settings\Temporary Internet Files`.
   * See the [documentation for `FOLDERID_InternetCache`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
   *
   * The return value is cached and modifying it at runtime is not supported, as
   * it’s not thread-safe to modify environment variables at runtime.
   * @returns a string owned by GLib that   must not be modified or freed.
   */
  function getUserCacheDir(): string
  /**
   * Returns a base directory in which to store user-specific application
   * configuration information such as user preferences and settings.
   *
   * On UNIX platforms this is determined using the mechanisms described
   * in the
   * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
   * In this case the directory retrieved will be `XDG_CONFIG_HOME`.
   *
   * On Windows it follows XDG Base Directory Specification if `XDG_CONFIG_HOME` is defined.
   * If `XDG_CONFIG_HOME` is undefined, the folder to use for local (as opposed
   * to roaming) application data is used instead. See the
   * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
   * Note that in this case on Windows it will be  the same
   * as what g_get_user_data_dir() returns.
   *
   * The return value is cached and modifying it at runtime is not supported, as
   * it’s not thread-safe to modify environment variables at runtime.
   * @returns a string owned by GLib that   must not be modified or freed.
   */
  function getUserConfigDir(): string
  /**
   * Returns a base directory in which to access application data such
   * as icons that is customized for a particular user.
   *
   * On UNIX platforms this is determined using the mechanisms described
   * in the
   * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
   * In this case the directory retrieved will be `XDG_DATA_HOME`.
   *
   * On Windows it follows XDG Base Directory Specification if `XDG_DATA_HOME`
   * is defined. If `XDG_DATA_HOME` is undefined, the folder to use for local (as
   * opposed to roaming) application data is used instead. See the
   * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
   * Note that in this case on Windows it will be the same
   * as what g_get_user_config_dir() returns.
   *
   * The return value is cached and modifying it at runtime is not supported, as
   * it’s not thread-safe to modify environment variables at runtime.
   * @returns a string owned by GLib that must   not be modified or freed.
   */
  function getUserDataDir(): string
  /**
   * Gets the user name of the current user. The encoding of the returned
   * string is system-defined. On UNIX, it might be the preferred file name
   * encoding, or something else, and there is no guarantee that it is even
   * consistent on a machine. On Windows, it is always UTF-8.
   * @returns the user name of the current user.
   */
  function getUserName(): string
  /**
   * Returns a directory that is unique to the current user on the local
   * system.
   *
   * This is determined using the mechanisms described
   * in the
   * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
   * This is the directory
   * specified in the `XDG_RUNTIME_DIR` environment variable.
   * In the case that this variable is not set, we return the value of
   * g_get_user_cache_dir(), after verifying that it exists.
   *
   * The return value is cached and modifying it at runtime is not supported, as
   * it’s not thread-safe to modify environment variables at runtime.
   * @returns a string owned by GLib that must not be     modified or freed.
   */
  function getUserRuntimeDir(): string
  /**
   * Returns the full path of a special directory using its logical id.
   *
   * On UNIX this is done using the XDG special user directories.
   * For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP
   * falls back to `$HOME/Desktop` when XDG special user directories have
   * not been set up.
   *
   * Depending on the platform, the user might be able to change the path
   * of the special directory without requiring the session to restart; GLib
   * will not reflect any change once the special directories are loaded.
   * @param directory the logical id of special directory
   * @returns the path to the specified special   directory, or %NULL if the logical id was not found. The returned string is   owned by GLib and should not be modified or freed.
   */
  function getUserSpecialDir(directory: UserDirectory): string | null
  /**
   * Returns a base directory in which to store state files specific to
   * particular user.
   *
   * On UNIX platforms this is determined using the mechanisms described
   * in the
   * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
   * In this case the directory retrieved will be `XDG_STATE_HOME`.
   *
   * On Windows it follows XDG Base Directory Specification if `XDG_STATE_HOME` is defined.
   * If `XDG_STATE_HOME` is undefined, the folder to use for local (as opposed
   * to roaming) application data is used instead. See the
   * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
   * Note that in this case on Windows it will be the same
   * as what g_get_user_data_dir() returns.
   *
   * The return value is cached and modifying it at runtime is not supported, as
   * it’s not thread-safe to modify environment variables at runtime.
   * @returns a string owned by GLib that   must not be modified or freed.
   */
  function getUserStateDir(): string
  /**
   * Returns the value of an environment variable.
   *
   * On UNIX, the name and value are byte strings which might or might not
   * be in some consistent character set and encoding. On Windows, they are
   * in UTF-8.
   * On Windows, in case the environment variable's value contains
   * references to other environment variables, they are expanded.
   * @param variable the environment variable to get
   * @returns the value of the environment variable, or %NULL if     the environment variable is not found. The returned string     may be overwritten by the next call to g_getenv(), g_setenv()     or g_unsetenv().
   */
  function getenv(variable: string): string | null
  /**
   * This is a convenience function for using a #GHashTable as a set.  It
   * is equivalent to calling g_hash_table_replace() with `key` as both the
   * key and the value.
   *
   * In particular, this means that if `key` already exists in the hash table, then
   * the old copy of `key` in the hash table is freed and `key` replaces it in the
   * table.
   *
   * When a hash table only ever contains keys that have themselves as the
   * corresponding value it is able to be stored more efficiently.  See
   * the discussion in the section description.
   *
   * Starting from GLib 2.40, this function returns a boolean value to
   * indicate whether the newly added value was already in the hash table
   * or not.
   * @param hashTable a #GHashTable
   * @param key a key to insert
   * @returns %TRUE if the key did not exist yet
   */
  function hashTableAdd(hashTable: HashTable, key: any | null): boolean
  /**
   * Checks if `key` is in `hash_table`.
   * @param hashTable a #GHashTable
   * @param key a key to check
   * @returns %TRUE if @key is in @hash_table, %FALSE otherwise.
   */
  function hashTableContains(hashTable: HashTable, key: any | null): boolean
  /**
   * Destroys all keys and values in the #GHashTable and decrements its
   * reference count by 1. If keys and/or values are dynamically allocated,
   * you should either free them first or create the #GHashTable with destroy
   * notifiers using g_hash_table_new_full(). In the latter case the destroy
   * functions you supplied will be called on all keys and values during the
   * destruction phase.
   * @param hashTable a #GHashTable
   */
  function hashTableDestroy(hashTable: HashTable): void
  /**
   * Calls the given function for key/value pairs in the #GHashTable
   * until `predicate` returns %TRUE. The function is passed the key
   * and value of each pair, and the given `user_data` parameter. The
   * hash table may not be modified while iterating over it (you can't
   * add/remove items).
   *
   * Note, that hash tables are really only optimized for forward
   * lookups, i.e. g_hash_table_lookup(). So code that frequently issues
   * g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of
   * once per every entry in a hash table) should probably be reworked
   * to use additional or different data structures for reverse lookups
   * (keep in mind that an O(n) find/foreach operation issued for all n
   * values in a hash table ends up needing O(n*n) operations).
   * @param hashTable a #GHashTable
   * @param predicate function to test the key/value pairs for a certain property
   * @returns The value of the first key/value pair is returned,     for which @predicate evaluates to %TRUE. If no pair with the     requested property is found, %NULL is returned.
   */
  function hashTableFind(hashTable: HashTable, predicate: HRFunc): any | null
  /**
   * Calls the given function for each of the key/value pairs in the
   * #GHashTable.  The function is passed the key and value of each
   * pair, and the given `user_data` parameter.  The hash table may not
   * be modified while iterating over it (you can't add/remove
   * items). To remove all items matching a predicate, use
   * g_hash_table_foreach_remove().
   *
   * The order in which g_hash_table_foreach() iterates over the keys/values in
   * the hash table is not defined.
   *
   * See g_hash_table_find() for performance caveats for linear
   * order searches in contrast to g_hash_table_lookup().
   * @param hashTable a #GHashTable
   * @param func the function to call for each key/value pair
   */
  function hashTableForeach(hashTable: HashTable, func: HFunc): void
  /**
   * Calls the given function for each key/value pair in the
   * #GHashTable. If the function returns %TRUE, then the key/value
   * pair is removed from the #GHashTable. If you supplied key or
   * value destroy functions when creating the #GHashTable, they are
   * used to free the memory allocated for the removed keys and values.
   *
   * See #GHashTableIter for an alternative way to loop over the
   * key/value pairs in the hash table.
   * @param hashTable a #GHashTable
   * @param func the function to call for each key/value pair
   * @returns the number of key/value pairs removed
   */
  function hashTableForeachRemove(hashTable: HashTable, func: HRFunc): number
  /**
   * Calls the given function for each key/value pair in the
   * #GHashTable. If the function returns %TRUE, then the key/value
   * pair is removed from the #GHashTable, but no key or value
   * destroy functions are called.
   *
   * See #GHashTableIter for an alternative way to loop over the
   * key/value pairs in the hash table.
   * @param hashTable a #GHashTable
   * @param func the function to call for each key/value pair
   * @returns the number of key/value pairs removed.
   */
  function hashTableForeachSteal(hashTable: HashTable, func: HRFunc): number
  /**
   * Inserts a new key and value into a #GHashTable.
   *
   * If the key already exists in the #GHashTable its current
   * value is replaced with the new value. If you supplied a
   * `value_destroy_func` when creating the #GHashTable, the old
   * value is freed using that function. If you supplied a
   * `key_destroy_func` when creating the #GHashTable, the passed
   * key is freed using that function.
   *
   * Starting from GLib 2.40, this function returns a boolean value to
   * indicate whether the newly added value was already in the hash table
   * or not.
   * @param hashTable a #GHashTable
   * @param key a key to insert
   * @param value the value to associate with the key
   * @returns %TRUE if the key did not exist yet
   */
  function hashTableInsert(
    hashTable: HashTable,
    key: any | null,
    value: any | null
  ): boolean
  /**
   * Looks up a key in a #GHashTable. Note that this function cannot
   * distinguish between a key that is not present and one which is present
   * and has the value %NULL. If you need this distinction, use
   * g_hash_table_lookup_extended().
   * @param hashTable a #GHashTable
   * @param key the key to look up
   * @returns the associated value, or %NULL if the key is not found
   */
  function hashTableLookup(hashTable: HashTable, key: any | null): any | null
  /**
   * Looks up a key in the #GHashTable, returning the original key and the
   * associated value and a #gboolean which is %TRUE if the key was found. This
   * is useful if you need to free the memory allocated for the original key,
   * for example before calling g_hash_table_remove().
   *
   * You can actually pass %NULL for `lookup_key` to test
   * whether the %NULL key exists, provided the hash and equal functions
   * of `hash_table` are %NULL-safe.
   * @param hashTable a #GHashTable
   * @param lookupKey the key to look up
   * @returns %TRUE if the key was found in the #GHashTable
   */
  function hashTableLookupExtended(
    hashTable: HashTable,
    lookupKey: any | null
  ): [
    /* returnType */ boolean,
    /* origKey */ any | null,
    /* value */ any | null,
  ]
  /**
   * Creates a new #GHashTable like g_hash_table_new_full() with a reference
   * count of 1.
   *
   * It inherits the hash function, the key equal function, the key destroy function,
   * as well as the value destroy function, from `other_hash_table`.
   *
   * The returned hash table will be empty; it will not contain the keys
   * or values from `other_hash_table`.
   * @param otherHashTable Another #GHashTable
   * @returns a new #GHashTable
   */
  function hashTableNewSimilar(otherHashTable: HashTable): HashTable
  /**
   * Atomically increments the reference count of `hash_table` by one.
   * This function is MT-safe and may be called from any thread.
   * @param hashTable a valid #GHashTable
   * @returns the passed in #GHashTable
   */
  function hashTableRef(hashTable: HashTable): HashTable
  /**
   * Removes a key and its associated value from a #GHashTable.
   *
   * If the #GHashTable was created using g_hash_table_new_full(), the
   * key and value are freed using the supplied destroy functions, otherwise
   * you have to make sure that any dynamically allocated values are freed
   * yourself.
   * @param hashTable a #GHashTable
   * @param key the key to remove
   * @returns %TRUE if the key was found and removed from the #GHashTable
   */
  function hashTableRemove(hashTable: HashTable, key: any | null): boolean
  /**
   * Removes all keys and their associated values from a #GHashTable.
   *
   * If the #GHashTable was created using g_hash_table_new_full(),
   * the keys and values are freed using the supplied destroy functions,
   * otherwise you have to make sure that any dynamically allocated
   * values are freed yourself.
   * @param hashTable a #GHashTable
   */
  function hashTableRemoveAll(hashTable: HashTable): void
  /**
   * Inserts a new key and value into a #GHashTable similar to
   * g_hash_table_insert(). The difference is that if the key
   * already exists in the #GHashTable, it gets replaced by the
   * new key. If you supplied a `value_destroy_func` when creating
   * the #GHashTable, the old value is freed using that function.
   * If you supplied a `key_destroy_func` when creating the
   * #GHashTable, the old key is freed using that function.
   *
   * Starting from GLib 2.40, this function returns a boolean value to
   * indicate whether the newly added value was already in the hash table
   * or not.
   * @param hashTable a #GHashTable
   * @param key a key to insert
   * @param value the value to associate with the key
   * @returns %TRUE if the key did not exist yet
   */
  function hashTableReplace(
    hashTable: HashTable,
    key: any | null,
    value: any | null
  ): boolean
  /**
   * Returns the number of elements contained in the #GHashTable.
   * @param hashTable a #GHashTable
   * @returns the number of key/value pairs in the #GHashTable.
   */
  function hashTableSize(hashTable: HashTable): number
  /**
   * Removes a key and its associated value from a #GHashTable without
   * calling the key and value destroy functions.
   * @param hashTable a #GHashTable
   * @param key the key to remove
   * @returns %TRUE if the key was found and removed from the #GHashTable
   */
  function hashTableSteal(hashTable: HashTable, key: any | null): boolean
  /**
   * Removes all keys and their associated values from a #GHashTable
   * without calling the key and value destroy functions.
   * @param hashTable a #GHashTable
   */
  function hashTableStealAll(hashTable: HashTable): void
  /**
   * Looks up a key in the #GHashTable, stealing the original key and the
   * associated value and returning %TRUE if the key was found. If the key was
   * not found, %FALSE is returned.
   *
   * If found, the stolen key and value are removed from the hash table without
   * calling the key and value destroy functions, and ownership is transferred to
   * the caller of this method, as with g_hash_table_steal(). That is the case
   * regardless whether `stolen_key` or `stolen_value` output parameters are
   * requested.
   *
   * You can pass %NULL for `lookup_key,` provided the hash and equal functions
   * of `hash_table` are %NULL-safe.
   *
   * The dictionary implementation optimizes for having all values identical to
   * their keys, for example by using g_hash_table_add(). When stealing both the
   * key and the value from such a dictionary, the value will be %NULL.
   * @param hashTable a #GHashTable
   * @param lookupKey the key to look up
   * @returns %TRUE if the key was found in the #GHashTable
   */
  function hashTableStealExtended(
    hashTable: HashTable,
    lookupKey: any | null
  ): [
    /* returnType */ boolean,
    /* stolenKey */ any | null,
    /* stolenValue */ any | null,
  ]
  /**
   * Atomically decrements the reference count of `hash_table` by one.
   * If the reference count drops to 0, all keys and values will be
   * destroyed, and all memory allocated by the hash table is released.
   * This function is MT-safe and may be called from any thread.
   * @param hashTable a valid #GHashTable
   */
  function hashTableUnref(hashTable: HashTable): void
  /**
   * Destroys a #GHook, given its ID.
   * @param hookList a #GHookList
   * @param hookId a hook ID
   * @returns %TRUE if the #GHook was found in the #GHookList and destroyed
   */
  function hookDestroy(hookList: HookList, hookId: number): boolean
  /**
   * Removes one #GHook from a #GHookList, marking it
   * inactive and calling g_hook_unref() on it.
   * @param hookList a #GHookList
   * @param hook the #GHook to remove
   */
  function hookDestroyLink(hookList: HookList, hook: Hook): void
  /**
   * Calls the #GHookList `finalize_hook` function if it exists,
   * and frees the memory allocated for the #GHook.
   * @param hookList a #GHookList
   * @param hook the #GHook to free
   */
  function hookFree(hookList: HookList, hook: Hook): void
  /**
   * Inserts a #GHook into a #GHookList, before a given #GHook.
   * @param hookList a #GHookList
   * @param sibling the #GHook to insert the new #GHook before
   * @param hook the #GHook to insert
   */
  function hookInsertBefore(
    hookList: HookList,
    sibling: Hook | null,
    hook: Hook
  ): void
  /**
   * Inserts a #GHook into a #GHookList, sorted by the given function.
   * @param hookList a #GHookList
   * @param hook the #GHook to insert
   * @param func the comparison function used to sort the #GHook elements
   */
  function hookInsertSorted(
    hookList: HookList,
    hook: Hook,
    func: HookCompareFunc
  ): void
  /**
   * Prepends a #GHook on the start of a #GHookList.
   * @param hookList a #GHookList
   * @param hook the #GHook to add to the start of `hook_list`
   */
  function hookPrepend(hookList: HookList, hook: Hook): void
  /**
   * Decrements the reference count of a #GHook.
   * If the reference count falls to 0, the #GHook is removed
   * from the #GHookList and g_hook_free() is called to free it.
   * @param hookList a #GHookList
   * @param hook the #GHook to unref
   */
  function hookUnref(hookList: HookList, hook: Hook): void
  /**
   * Tests if `hostname` contains segments with an ASCII-compatible
   * encoding of an Internationalized Domain Name. If this returns
   * %TRUE, you should decode the hostname with g_hostname_to_unicode()
   * before displaying it to the user.
   *
   * Note that a hostname might contain a mix of encoded and unencoded
   * segments, and so it is possible for g_hostname_is_non_ascii() and
   * g_hostname_is_ascii_encoded() to both return %TRUE for a name.
   * @param hostname a hostname
   * @returns %TRUE if @hostname contains any ASCII-encoded segments.
   */
  function hostnameIsAsciiEncoded(hostname: string): boolean
  /**
   * Tests if `hostname` is the string form of an IPv4 or IPv6 address.
   * (Eg, "192.168.0.1".)
   *
   * Since 2.66, IPv6 addresses with a zone-id are accepted (RFC6874).
   * @param hostname a hostname (or IP address in string form)
   * @returns %TRUE if @hostname is an IP address
   */
  function hostnameIsIpAddress(hostname: string): boolean
  /**
   * Tests if `hostname` contains Unicode characters. If this returns
   * %TRUE, you need to encode the hostname with g_hostname_to_ascii()
   * before using it in non-IDN-aware contexts.
   *
   * Note that a hostname might contain a mix of encoded and unencoded
   * segments, and so it is possible for g_hostname_is_non_ascii() and
   * g_hostname_is_ascii_encoded() to both return %TRUE for a name.
   * @param hostname a hostname
   * @returns %TRUE if @hostname contains any non-ASCII characters
   */
  function hostnameIsNonAscii(hostname: string): boolean
  /**
   * Converts `hostname` to its canonical ASCII form; an ASCII-only
   * string containing no uppercase letters and not ending with a
   * trailing dot.
   * @param hostname a valid UTF-8 or ASCII hostname
   * @returns an ASCII hostname, which must be freed,    or %NULL if @hostname is in some way invalid.
   */
  function hostnameToAscii(hostname: string): string | null
  /**
   * Converts `hostname` to its canonical presentation form; a UTF-8
   * string in Unicode normalization form C, containing no uppercase
   * letters, no forbidden characters, and no ASCII-encoded segments,
   * and not ending with a trailing dot.
   *
   * Of course if `hostname` is not an internationalized hostname, then
   * the canonical presentation form will be entirely ASCII.
   * @param hostname a valid UTF-8 or ASCII hostname
   * @returns a UTF-8 hostname, which must be freed,    or %NULL if @hostname is in some way invalid.
   */
  function hostnameToUnicode(hostname: string): string | null
  /**
   * Adds a function to be called whenever there are no higher priority
   * events pending.
   *
   * If the function returns %G_SOURCE_REMOVE or %FALSE it is automatically
   * removed from the list of event sources and will not be called again.
   *
   * See [memory management of sources][mainloop-memory-management] for details
   * on how to handle the return value and memory management of `data`.
   *
   * This internally creates a main loop source using g_idle_source_new()
   * and attaches it to the global #GMainContext using g_source_attach(), so
   * the callback will be invoked in whichever thread is running that main
   * context. You can do these steps manually if you need greater control or to
   * use a custom main context.
   * @param priority the priority of the idle source. Typically this will be in the   range between %G_PRIORITY_DEFAULT_IDLE and %G_PRIORITY_HIGH_IDLE.
   * @param function_ function to call
   * @returns the ID (greater than 0) of the event source.
   */
  function idleAdd(priority: number, function_: SourceFunc): number
  /**
   * Removes the idle function with the given data.
   * @param data the data for the idle source's callback.
   * @returns %TRUE if an idle source was found and removed.
   */
  function idleRemoveByData(data: any | null): boolean
  /**
   * Creates a new idle source.
   *
   * The source will not initially be associated with any #GMainContext
   * and must be added to one with g_source_attach() before it will be
   * executed. Note that the default priority for idle sources is
   * %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which
   * have a default priority of %G_PRIORITY_DEFAULT.
   * @returns the newly-created idle source
   */
  function idleSourceNew(): Source
  /**
   * Compares the two #gint64 values being pointed to and returns
   * %TRUE if they are equal.
   * It can be passed to g_hash_table_new() as the `key_equal_func`
   * parameter, when using non-%NULL pointers to 64-bit integers as keys in a
   * #GHashTable.
   * @param v1 a pointer to a #gint64 key
   * @param v2 a pointer to a #gint64 key to compare with `v1`
   * @returns %TRUE if the two keys match.
   */
  function int64Equal(v1: any, v2: any): boolean
  /**
   * Converts a pointer to a #gint64 to a hash value.
   *
   * It can be passed to g_hash_table_new() as the `hash_func` parameter,
   * when using non-%NULL pointers to 64-bit integer values as keys in a
   * #GHashTable.
   * @param v a pointer to a #gint64 key
   * @returns a hash value corresponding to the key.
   */
  function int64Hash(v: any): number
  /**
   * Compares the two #gint values being pointed to and returns
   * %TRUE if they are equal.
   * It can be passed to g_hash_table_new() as the `key_equal_func`
   * parameter, when using non-%NULL pointers to integers as keys in a
   * #GHashTable.
   *
   * Note that this function acts on pointers to #gint, not on #gint
   * directly: if your hash table's keys are of the form
   * `GINT_TO_POINTER (n)`, use g_direct_equal() instead.
   * @param v1 a pointer to a #gint key
   * @param v2 a pointer to a #gint key to compare with `v1`
   * @returns %TRUE if the two keys match.
   */
  function intEqual(v1: any, v2: any): boolean
  /**
   * Converts a pointer to a #gint to a hash value.
   * It can be passed to g_hash_table_new() as the `hash_func` parameter,
   * when using non-%NULL pointers to integer values as keys in a #GHashTable.
   *
   * Note that this function acts on pointers to #gint, not on #gint
   * directly: if your hash table's keys are of the form
   * `GINT_TO_POINTER (n)`, use g_direct_hash() instead.
   * @param v a pointer to a #gint key
   * @returns a hash value corresponding to the key.
   */
  function intHash(v: any): number
  /**
   * Returns a canonical representation for `string`. Interned strings
   * can be compared for equality by comparing the pointers, instead of
   * using strcmp(). g_intern_static_string() does not copy the string,
   * therefore `string` must not be freed or modified.
   *
   * This function must not be used before library constructors have finished
   * running. In particular, this means it cannot be used to initialize global
   * variables in C++.
   * @param string a static string
   * @returns a canonical representation for the string
   */
  function internStaticString(string: string | null): string
  /**
   * Returns a canonical representation for `string`. Interned strings
   * can be compared for equality by comparing the pointers, instead of
   * using strcmp().
   *
   * This function must not be used before library constructors have finished
   * running. In particular, this means it cannot be used to initialize global
   * variables in C++.
   * @param string a string
   * @returns a canonical representation for the string
   */
  function internString(string: string | null): string
  /**
   * Adds the #GIOChannel into the default main loop context
   * with the given priority.
   *
   * This internally creates a main loop source using g_io_create_watch()
   * and attaches it to the main loop context with g_source_attach().
   * You can do these steps manually if you need greater control.
   * @param channel a #GIOChannel
   * @param priority the priority of the #GIOChannel source
   * @param condition the condition to watch for
   * @param func the function to call when the condition is satisfied
   * @returns the event source id
   */
  function ioAddWatch(
    channel: IOChannel,
    priority: number,
    condition: IOCondition,
    func: IOFunc
  ): number
  /**
   * Converts an `errno` error number to a #GIOChannelError.
   * @param en an `errno` error number, e.g. `EINVAL`
   * @returns a #GIOChannelError error number, e.g.      %G_IO_CHANNEL_ERROR_INVAL.
   */
  function ioChannelErrorFromErrno(en: number): IOChannelError
  function ioChannelErrorQuark(): Quark
  /**
   * Creates a #GSource that's dispatched when `condition` is met for the
   * given `channel`. For example, if condition is %G_IO_IN, the source will
   * be dispatched when there's data available for reading.
   *
   * The callback function invoked by the #GSource should be added with
   * g_source_set_callback(), but it has type #GIOFunc (not #GSourceFunc).
   *
   * g_io_add_watch() is a simpler interface to this same functionality, for
   * the case where you want to add the source to the default main loop context
   * at the default priority.
   *
   * On Windows, polling a #GSource created to watch a channel for a socket
   * puts the socket in non-blocking mode. This is a side-effect of the
   * implementation and unavoidable.
   * @param channel a #GIOChannel to watch
   * @param condition conditions to watch for
   * @returns a new #GSource
   */
  function ioCreateWatch(channel: IOChannel, condition: IOCondition): Source
  function keyFileErrorQuark(): Quark
  function listPopAllocator(): void
  function listPushAllocator(allocator: Allocator): void
  /**
   * Gets the names of all variables set in the environment.
   *
   * Programs that want to be portable to Windows should typically use
   * this function and g_getenv() instead of using the environ array
   * from the C library directly. On Windows, the strings in the environ
   * array are in system codepage encoding, while in most of the typical
   * use cases for environment variables in GLib-using programs you want
   * the UTF-8 encoding that this function and g_getenv() provide.
   * @returns a %NULL-terminated list of strings which must be freed with     g_strfreev().
   */
  function listenv(): string[]
  /**
   * Converts a string from UTF-8 to the encoding used for strings by
   * the C runtime (usually the same as that used by the operating
   * system) in the [current locale][setlocale]. On Windows this means
   * the system codepage.
   *
   * The input string shall not contain nul characters even if the `len`
   * argument is positive. A nul character found inside the string will result
   * in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Use g_convert() to convert
   * input that may contain embedded nul characters.
   * @param utf8string a UTF-8 encoded string
   * @param len the length of the string, or -1 if the string is                 nul-terminated.
   * @returns A newly-allocated buffer containing the converted string,          or %NULL on an error, and error will be set.
   */
  function localeFromUtf8(
    utf8string: string,
    len: number
  ): [/* returnType */ number[], /* bytesRead */ number]
  /**
   * Converts a string which is in the encoding used for strings by
   * the C runtime (usually the same as that used by the operating
   * system) in the [current locale][setlocale] into a UTF-8 string.
   *
   * If the source encoding is not UTF-8 and the conversion output contains a
   * nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the
   * function returns %NULL.
   * If the source encoding is UTF-8, an embedded nul character is treated with
   * the %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error for backward compatibility with
   * earlier versions of this library. Use g_convert() to produce output that
   * may contain embedded nul characters.
   * @param opsysstring a string in the                 encoding of the current locale. On Windows                 this means the system codepage.
   * @returns The converted string, or %NULL on an error.
   */
  function localeToUtf8(
    opsysstring: number[]
  ): [
    /* returnType */ string | null,
    /* bytesRead */ number,
    /* bytesWritten */ number,
  ]
  /**
   * The default log handler set up by GLib; [func`GLib`.log_set_default_handler]
   * allows to install an alternate default log handler.
   *
   * This is used if no log handler has been set for the particular log
   * domain and log level combination. It outputs the message to `stderr`
   * or `stdout` and if the log level is fatal it calls [func`GLib`.BREAKPOINT]. It automatically
   * prints a new-line character after the message, so one does not need to be
   * manually included in `message`.
   *
   * The behavior of this log handler can be influenced by a number of
   * environment variables:
   *
   *   - `G_MESSAGES_PREFIXED`: A `:`-separated list of log levels for which
   *     messages should be prefixed by the program name and PID of the
   *     application.
   *   - `G_MESSAGES_DEBUG`: A space-separated list of log domains for
   *     which debug and informational messages are printed. By default
   *     these messages are not printed. If you need to set the allowed
   *     domains at runtime, use [func`GLib`.log_writer_default_set_debug_domains].
   *
   * `stderr` is used for levels [flags`GLib`.LogLevelFlags.LEVEL_ERROR],
   * [flags`GLib`.LogLevelFlags.LEVEL_CRITICAL], [flags`GLib`.LogLevelFlags.LEVEL_WARNING] and
   * [flags`GLib`.LogLevelFlags.LEVEL_MESSAGE]. `stdout` is used for
   * the rest, unless `stderr` was requested by
   * [func`GLib`.log_writer_default_set_use_stderr].
   *
   * This has no effect if structured logging is enabled; see
   * [Using Structured Logging](logging.html#using-structured-logging).
   * @param logDomain the log domain of the message, or `NULL` for the   default `""` application domain
   * @param logLevel the level of the message
   * @param message the message
   * @param unusedData data passed from [func`GLib`.log] which is unused
   */
  function logDefaultHandler(
    logDomain: string | null,
    logLevel: LogLevelFlags,
    message: string | null,
    unusedData: any | null
  ): void
  /**
   * Return whether debug output from the GLib logging system is enabled.
   *
   * Note that this should not be used to conditionalise calls to [func`GLib`.debug] or
   * other logging functions; it should only be used from [type`GLib`.LogWriterFunc]
   * implementations.
   *
   * Note also that the value of this does not depend on `G_MESSAGES_DEBUG`, nor
   * [func`GLib`.log_writer_default_set_debug_domains]; see the docs for [func`GLib`.log_set_debug_enabled].
   * @returns `TRUE` if debug output is enabled, `FALSE` otherwise
   */
  function logGetDebugEnabled(): boolean
  /**
   * Removes the log handler.
   *
   * This has no effect if structured logging is enabled; see
   * [Using Structured Logging](logging.html#using-structured-logging).
   * @param logDomain the log domain
   * @param handlerId the ID of the handler, which was returned   in [func`GLib`.log_set_handler]
   */
  function logRemoveHandler(logDomain: string, handlerId: number): void
  /**
   * Sets the message levels which are always fatal, in any log domain.
   *
   * When a message with any of these levels is logged the program terminates.
   * You can only set the levels defined by GLib to be fatal.
   * [flags`GLib`.LogLevelFlags.LEVEL_ERROR] is always fatal.
   *
   * You can also make some message levels fatal at runtime by setting
   * the `G_DEBUG` environment variable (see
   * [Running GLib Applications](glib-running.html)).
   *
   * Libraries should not call this function, as it affects all messages logged
   * by a process, including those from other libraries.
   *
   * Structured log messages (using [func`GLib`.log_structured] and
   * [func`GLib`.log_structured_array]) are fatal only if the default log writer is used;
   * otherwise it is up to the writer function to determine which log messages
   * are fatal. See [Using Structured Logging](logging.html#using-structured-logging).
   * @param fatalMask the mask containing bits set for each level of error which is   to be fatal
   * @returns the old fatal mask
   */
  function logSetAlwaysFatal(fatalMask: LogLevelFlags): LogLevelFlags
  /**
   * Enable or disable debug output from the GLib logging system for all domains.
   *
   * This value interacts disjunctively with `G_MESSAGES_DEBUG` and
   * [func`GLib`.log_writer_default_set_debug_domains] — if any of them would allow
   * a debug message to be outputted, it will be.
   *
   * Note that this should not be used from within library code to enable debug
   * output — it is intended for external use.
   * @param enabled `TRUE` to enable debug output, `FALSE` otherwise
   */
  function logSetDebugEnabled(enabled: boolean): void
  /**
   * Sets the log levels which are fatal in the given domain.
   *
   * [flags`GLib`.LogLevelFlags.LEVEL_ERROR] is always fatal.
   *
   * This has no effect on structured log messages (using [func`GLib`.log_structured] or
   * [func`GLib`.log_structured_array]). To change the fatal behaviour for specific log
   * messages, programs must install a custom log writer function using
   * [func`GLib`.log_set_writer_func]. See
   * [Using Structured Logging](logging.html#using-structured-logging).
   *
   * This function is mostly intended to be used with
   * [flags`GLib`.LogLevelFlags.LEVEL_CRITICAL].  You should typically not set
   * [flags`GLib`.LogLevelFlags.LEVEL_WARNING], [flags`GLib`.LogLevelFlags.LEVEL_MESSAGE], [flags`GLib`.LogLevelFlags.LEVEL_INFO] or
   * [flags`GLib`.LogLevelFlags.LEVEL_DEBUG] as fatal except inside of test programs.
   * @param logDomain the log domain
   * @param fatalMask the new fatal mask
   * @returns the old fatal mask for the log domain
   */
  function logSetFatalMask(
    logDomain: string,
    fatalMask: LogLevelFlags
  ): LogLevelFlags
  /**
   * Like [func`GLib`.log_set_handler], but takes a destroy notify for the `user_data`.
   *
   * This has no effect if structured logging is enabled; see
   * [Using Structured Logging](logging.html#using-structured-logging).
   * @param logDomain the log domain, or `NULL` for the default `""`   application domain
   * @param logLevels the log levels to apply the log handler for.   To handle fatal and recursive messages as well, combine   the log levels with the [flags`GLib`.LogLevelFlags.FLAG_FATAL] and   [flags`GLib`.LogLevelFlags.FLAG_RECURSION] bit flags.
   * @param logFunc the log handler function
   * @returns the ID of the new handler
   */
  function logSetHandler(
    logDomain: string | null,
    logLevels: LogLevelFlags,
    logFunc: LogFunc
  ): number
  /**
   * Set a writer function which will be called to format and write out each log
   * message.
   *
   * Each program should set a writer function, or the default writer
   * ([func`GLib`.log_writer_default]) will be used.
   *
   * Libraries **must not** call this function — only programs are allowed to
   * install a writer function, as there must be a single, central point where
   * log messages are formatted and outputted.
   *
   * There can only be one writer function. It is an error to set more than one.
   */
  function logSetWriterFunc(): void
  /**
   * Log a message with structured data.
   *
   * The message will be passed through to the log writer set by the application
   * using [func`GLib`.log_set_writer_func]. If the
   * message is fatal (i.e. its log level is [flags`GLib`.LogLevelFlags.LEVEL_ERROR]), the program will
   * be aborted at the end of this function.
   *
   * See [func`GLib`.log_structured] for more documentation.
   *
   * This assumes that `log_level` is already present in `fields` (typically as the
   * `PRIORITY` field).
   * @param logLevel log level, either from [type`GLib`.LogLevelFlags], or a user-defined    level
   * @param fields key–value pairs of structured data to add    to the log message
   */
  function logStructuredArray(logLevel: LogLevelFlags, fields: LogField[]): void
  /**
   * Log a message with structured data, accepting the data within a [type`GLib`.Variant].
   *
   * This version is especially useful for use in other languages, via introspection.
   *
   * The only mandatory item in the `fields` dictionary is the `"MESSAGE"` which must
   * contain the text shown to the user.
   *
   * The values in the `fields` dictionary are likely to be of type `G_VARIANT_TYPE_STRING`.
   * Array of bytes (`G_VARIANT_TYPE_BYTESTRING`) is also
   * supported. In this case the message is handled as binary and will be forwarded
   * to the log writer as such. The size of the array should not be higher than
   * `G_MAXSSIZE`. Otherwise it will be truncated to this size. For other types
   * [method`GLib`.Variant.print] will be used to convert the value into a string.
   *
   * For more details on its usage and about the parameters, see [func`GLib`.log_structured].
   * @param logDomain log domain, usually `G_LOG_DOMAIN`
   * @param logLevel log level, either from [type`GLib`.LogLevelFlags], or a user-defined    level
   * @param fields a dictionary ([type`GLib`.Variant] of the type `G_VARIANT_TYPE_VARDICT`) containing the key-value pairs of message data.
   */
  function logVariant(
    logDomain: string | null,
    logLevel: LogLevelFlags,
    fields: Variant
  ): void
  /**
   * Format a structured log message and output it to the default log destination
   * for the platform.
   *
   * On Linux, this is typically the systemd journal, falling
   * back to `stdout` or `stderr` if running from the terminal or if output is
   * being redirected to a file.
   *
   * Support for other platform-specific logging mechanisms may be added in
   * future. Distributors of GLib may modify this function to impose their own
   * (documented) platform-specific log writing policies.
   *
   * This is suitable for use as a [type`GLib`.LogWriterFunc], and is the default writer used
   * if no other is set using [func`GLib`.log_set_writer_func].
   *
   * As with [func`GLib`.log_default_handler], this function drops debug and informational
   * messages unless their log domain (or `all`) is listed in the space-separated
   * `G_MESSAGES_DEBUG` environment variable, or set at runtime by [func`GLib`.log_writer_default_set_debug_domains].
   *
   * [func`GLib`.log_writer_default] uses the mask set by [func`GLib`.log_set_always_fatal] to
   * determine which messages are fatal. When using a custom writer function instead it is
   * up to the writer function to determine which log messages are fatal.
   * @param logLevel log level, either from [type`GLib`.LogLevelFlags], or a user-defined    level
   * @param fields key–value pairs of structured data forming    the log message
   * @param userData user data passed to [func`GLib`.log_set_writer_func]
   * @returns [enum@GLib.LogWriterOutput.HANDLED] on success,   [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
   */
  function logWriterDefault(
    logLevel: LogLevelFlags,
    fields: LogField[],
    userData: any | null
  ): LogWriterOutput
  /**
   * Reset the list of domains to be logged, that might be initially set by the
   * `G_MESSAGES_DEBUG` environment variable.
   *
   * This function is thread-safe.
   * @param domains `NULL`-terminated array with domains to be printed.   `NULL` or an array with no values means none. Array with a single value `"all"` means all.
   */
  function logWriterDefaultSetDebugDomains(domains: string | null): void
  /**
   * Configure whether the built-in log functions will output all log messages to
   * `stderr`.
   *
   * The built-in log functions are [func`GLib`.log_default_handler] for the
   * old-style API, and both [func`GLib`.log_writer_default] and
   * [func`GLib`.log_writer_standard_streams] for the structured API.
   *
   * By default, log messages of levels [flags`GLib`.LogLevelFlags.LEVEL_INFO] and
   * [flags`GLib`.LogLevelFlags.LEVEL_DEBUG] are sent to `stdout`, and other log messages are
   * sent to `stderr`. This is problematic for applications that intend
   * to reserve `stdout` for structured output such as JSON or XML.
   *
   * This function sets global state. It is not thread-aware, and should be
   * called at the very start of a program, before creating any other threads
   * or creating objects that could create worker threads of their own.
   * @param useStderr If `TRUE`, use `stderr` for log messages that would  normally have appeared on `stdout`
   */
  function logWriterDefaultSetUseStderr(useStderr: boolean): void
  /**
   * Check whether [func`GLib`.log_writer_default] and [func`GLib`.log_default_handler] would
   * ignore a message with the given domain and level.
   *
   * As with [func`GLib`.log_default_handler], this function drops debug and informational
   * messages unless their log domain (or `all`) is listed in the space-separated
   * `G_MESSAGES_DEBUG` environment variable, or by [func`GLib`.log_writer_default_set_debug_domains].
   *
   * This can be used when implementing log writers with the same filtering
   * behaviour as the default, but a different destination or output format:
   *
   * ```c
   * if (g_log_writer_default_would_drop (log_level, log_domain))
   *   return G_LOG_WRITER_HANDLED;
   * ```
   *
   *
   * or to skip an expensive computation if it is only needed for a debugging
   * message, and `G_MESSAGES_DEBUG` is not set:
   *
   * ```c
   * if (!g_log_writer_default_would_drop (G_LOG_LEVEL_DEBUG, G_LOG_DOMAIN))
   *   {
   *     g_autofree gchar *result = expensive_computation (my_object);
   *
   *     g_debug ("my_object result: %s", result);
   *   }
   * ```
   * @param logLevel log level, either from [type`GLib`.LogLevelFlags], or a user-defined    level
   * @param logDomain log domain
   * @returns `TRUE` if the log message would be dropped by GLib’s   default log handlers
   */
  function logWriterDefaultWouldDrop(
    logLevel: LogLevelFlags,
    logDomain: string | null
  ): boolean
  /**
   * Format a structured log message as a string suitable for outputting to the
   * terminal (or elsewhere).
   *
   * This will include the values of all fields it knows
   * how to interpret, which includes `MESSAGE` and `GLIB_DOMAIN` (see the
   * documentation for [func`GLib`.log_structured]). It does not include values from
   * unknown fields.
   *
   * The returned string does **not** have a trailing new-line character. It is
   * encoded in the character set of the current locale, which is not necessarily
   * UTF-8.
   * @param logLevel log level, either from [type`GLib`.LogLevelFlags], or a user-defined    level
   * @param fields key–value pairs of structured data forming    the log message
   * @param useColor `TRUE` to use   [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code)   when formatting the message, `FALSE` to not
   * @returns string containing the formatted log message, in    the character set of the current locale
   */
  function logWriterFormatFields(
    logLevel: LogLevelFlags,
    fields: LogField[],
    useColor: boolean
  ): string | null
  /**
   * Check whether the given `output_fd` file descriptor is a connection to the
   * systemd journal, or something else (like a log file or `stdout` or
   * `stderr`).
   *
   * Invalid file descriptors are accepted and return `FALSE`, which allows for
   * the following construct without needing any additional error handling:
   * ```c
   * is_journald = g_log_writer_is_journald (fileno (stderr));
   * ```
   * @param outputFd output file descriptor to check
   * @returns `TRUE` if @output_fd points to the journal, `FALSE` otherwise
   */
  function logWriterIsJournald(outputFd: number): boolean
  /**
   * Format a structured log message and send it to the systemd journal as a set
   * of key–value pairs.
   *
   * All fields are sent to the journal, but if a field has
   * length zero (indicating program-specific data) then only its key will be
   * sent.
   *
   * This is suitable for use as a [type`GLib`.LogWriterFunc].
   *
   * If GLib has been compiled without systemd support, this function is still
   * defined, but will always return [enum`GLib`.LogWriterOutput.UNHANDLED].
   * @param logLevel log level, either from [type`GLib`.LogLevelFlags], or a user-defined    level
   * @param fields key–value pairs of structured data forming    the log message
   * @param userData user data passed to [func`GLib`.log_set_writer_func]
   * @returns [enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
   */
  function logWriterJournald(
    logLevel: LogLevelFlags,
    fields: LogField[],
    userData: any | null
  ): LogWriterOutput
  /**
   * Format a structured log message and print it to either `stdout` or `stderr`,
   * depending on its log level.
   *
   * [flags`GLib`.LogLevelFlags.LEVEL_INFO] and [flags`GLib`.LogLevelFlags.LEVEL_DEBUG] messages
   * are sent to `stdout`, or to `stderr` if requested by
   * [func`GLib`.log_writer_default_set_use_stderr];
   * all other log levels are sent to `stderr`. Only fields
   * which are understood by this function are included in the formatted string
   * which is printed.
   *
   * If the output stream supports
   * [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code),
   * they will be used in the output.
   *
   * A trailing new-line character is added to the log message when it is printed.
   *
   * This is suitable for use as a [type`GLib`.LogWriterFunc].
   * @param logLevel log level, either from [type`GLib`.LogLevelFlags], or a user-defined    level
   * @param fields key–value pairs of structured data forming    the log message
   * @param userData user data passed to [func`GLib`.log_set_writer_func]
   * @returns [enum@GLib.LogWriterOutput.HANDLED] on success,   [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
   */
  function logWriterStandardStreams(
    logLevel: LogLevelFlags,
    fields: LogField[],
    userData: any | null
  ): LogWriterOutput
  /**
   * Check whether the given `output_fd` file descriptor supports
   * [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code).
   *
   * If so, they can safely be used when formatting log messages.
   * @param outputFd output file descriptor to check
   * @returns `TRUE` if ANSI color escapes are supported, `FALSE` otherwise
   */
  function logWriterSupportsColor(outputFd: number): boolean
  /**
   * Format a structured log message and send it to the syslog daemon. Only fields
   * which are understood by this function are included in the formatted string
   * which is printed.
   *
   * Log facility will be defined via the SYSLOG_FACILITY field and accepts the following
   * values: "auth", "daemon", and "user". If SYSLOG_FACILITY is not specified, LOG_USER
   * facility will be used.
   *
   * This is suitable for use as a [type`GLib`.LogWriterFunc].
   *
   * If syslog is not supported, this function is still defined, but will always
   * return [enum`GLib`.LogWriterOutput.UNHANDLED].
   * @param logLevel log level, either from [type`GLib`.LogLevelFlags], or a user-defined    level
   * @param fields key–value pairs of structured data forming    the log message
   * @param userData user data passed to [func`GLib`.log_set_writer_func]
   * @returns [enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
   */
  function logWriterSyslog(
    logLevel: LogLevelFlags,
    fields: LogField[],
    userData: any | null
  ): LogWriterOutput
  /**
   * A wrapper for the POSIX lstat() function. The lstat() function is
   * like stat() except that in the case of symbolic links, it returns
   * information about the symbolic link itself and not the file that it
   * refers to. If the system does not support symbolic links g_lstat()
   * is identical to g_stat().
   *
   * See your C library manual for more details about lstat().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param buf a pointer to a stat struct, which will be filled with the file     information
   * @returns 0 if the information was successfully retrieved,     -1 if an error occurred
   */
  function lstat(filename: string, buf: StatBuf): number
  /**
   * Returns the global-default main context. This is the main context
   * used for main loop functions when a main loop is not explicitly
   * specified, and corresponds to the "main" main loop. See also
   * g_main_context_get_thread_default().
   * @returns the global-default main context.
   */
  function mainContextDefault(): MainContext
  /**
   * Gets the thread-default #GMainContext for this thread. Asynchronous
   * operations that want to be able to be run in contexts other than
   * the default one should call this method or
   * g_main_context_ref_thread_default() to get a #GMainContext to add
   * their #GSources to. (Note that even in single-threaded
   * programs applications may sometimes want to temporarily push a
   * non-default context, so it is not safe to assume that this will
   * always return %NULL if you are running in the default thread.)
   *
   * If you need to hold a reference on the context, use
   * g_main_context_ref_thread_default() instead.
   * @returns the thread-default #GMainContext, or %NULL if the thread-default context is the global-default main context.
   */
  function mainContextGetThreadDefault(): MainContext | null
  /**
   * Gets the thread-default #GMainContext for this thread, as with
   * g_main_context_get_thread_default(), but also adds a reference to
   * it with g_main_context_ref(). In addition, unlike
   * g_main_context_get_thread_default(), if the thread-default context
   * is the global-default context, this will return that #GMainContext
   * (with a ref added to it) rather than returning %NULL.
   * @returns the thread-default #GMainContext. Unref     with g_main_context_unref() when you are done with it.
   */
  function mainContextRefThreadDefault(): MainContext
  /**
   * Returns the currently firing source for this thread.
   * @returns The currently firing source or %NULL.
   */
  function mainCurrentSource(): Source | null
  /**
   * Returns the depth of the stack of calls to
   * g_main_context_dispatch() on any #GMainContext in the current thread.
   * That is, when called from the toplevel, it gives 0. When
   * called from within a callback from g_main_context_iteration()
   * (or g_main_loop_run(), etc.) it returns 1. When called from within
   * a callback to a recursive call to g_main_context_iteration(),
   * it returns 2. And so forth.
   *
   * This function is useful in a situation like the following:
   * Imagine an extremely simple "garbage collected" system.
   *
   *
   * ```c
   * static GList *free_list;
   *
   * gpointer
   * allocate_memory (gsize size)
   * {
   *   gpointer result = g_malloc (size);
   *   free_list = g_list_prepend (free_list, result);
   *   return result;
   * }
   *
   * void
   * free_allocated_memory (void)
   * {
   *   GList *l;
   *   for (l = free_list; l; l = l->next);
   *     g_free (l->data);
   *   g_list_free (free_list);
   *   free_list = NULL;
   *  }
   *
   * [...]
   *
   * while (TRUE);
   *  {
   *    g_main_context_iteration (NULL, TRUE);
   *    free_allocated_memory();
   *   }
   * ```
   *
   *
   * This works from an application, however, if you want to do the same
   * thing from a library, it gets more difficult, since you no longer
   * control the main loop. You might think you can simply use an idle
   * function to make the call to free_allocated_memory(), but that
   * doesn't work, since the idle function could be called from a
   * recursive callback. This can be fixed by using g_main_depth()
   *
   *
   * ```c
   * gpointer
   * allocate_memory (gsize size)
   * {
   *   FreeListBlock *block = g_new (FreeListBlock, 1);
   *   block->mem = g_malloc (size);
   *   block->depth = g_main_depth ();
   *   free_list = g_list_prepend (free_list, block);
   *   return block->mem;
   * }
   *
   * void
   * free_allocated_memory (void)
   * {
   *   GList *l;
   *
   *   int depth = g_main_depth ();
   *   for (l = free_list; l; );
   *     {
   *       GList *next = l->next;
   *       FreeListBlock *block = l->data;
   *       if (block->depth > depth)
   *         {
   *           g_free (block->mem);
   *           g_free (block);
   *           free_list = g_list_delete_link (free_list, l);
   *         }
   *
   *       l = next;
   *     }
   *   }
   * ```
   *
   *
   * There is a temptation to use g_main_depth() to solve
   * problems with reentrancy. For instance, while waiting for data
   * to be received from the network in response to a menu item,
   * the menu item might be selected again. It might seem that
   * one could make the menu item's callback return immediately
   * and do nothing if g_main_depth() returns a value greater than 1.
   * However, this should be avoided since the user then sees selecting
   * the menu item do nothing. Furthermore, you'll find yourself adding
   * these checks all over your code, since there are doubtless many,
   * many things that the user could do. Instead, you can use the
   * following techniques:
   *
   * 1. Use gtk_widget_set_sensitive() or modal dialogs to prevent
   *    the user from interacting with elements while the main
   *    loop is recursing.
   *
   * 2. Avoid main loop recursion in situations where you can't handle
   *    arbitrary  callbacks. Instead, structure your code so that you
   *    simply return to the main loop and then get called again when
   *    there is more work to do.
   * @returns The main loop recursion level in the current thread
   */
  function mainDepth(): number
  /**
   * Allocates `n_bytes` bytes of memory.
   * If `n_bytes` is 0 it returns %NULL.
   *
   * If the allocation fails (because the system is out of memory),
   * the program is terminated.
   * @param nBytes the number of bytes to allocate
   * @returns a pointer to the allocated memory
   */
  function malloc(nBytes: number): any | null
  /**
   * Allocates `n_bytes` bytes of memory, initialized to 0's.
   * If `n_bytes` is 0 it returns %NULL.
   *
   * If the allocation fails (because the system is out of memory),
   * the program is terminated.
   * @param nBytes the number of bytes to allocate
   * @returns a pointer to the allocated memory
   */
  function malloc0(nBytes: number): any | null
  /**
   * This function is similar to g_malloc0(), allocating (`n_blocks` * `n_block_bytes)` bytes,
   * but care is taken to detect possible overflow during multiplication.
   *
   * If the allocation fails (because the system is out of memory),
   * the program is terminated.
   * @param nBlocks the number of blocks to allocate
   * @param nBlockBytes the size of each block in bytes
   * @returns a pointer to the allocated memory
   */
  function malloc0N(nBlocks: number, nBlockBytes: number): any | null
  /**
   * This function is similar to g_malloc(), allocating (`n_blocks` * `n_block_bytes)` bytes,
   * but care is taken to detect possible overflow during multiplication.
   *
   * If the allocation fails (because the system is out of memory),
   * the program is terminated.
   * @param nBlocks the number of blocks to allocate
   * @param nBlockBytes the size of each block in bytes
   * @returns a pointer to the allocated memory
   */
  function mallocN(nBlocks: number, nBlockBytes: number): any | null
  function markupErrorQuark(): Quark
  /**
   * Escapes text so that the markup parser will parse it verbatim.
   * Less than, greater than, ampersand, etc. are replaced with the
   * corresponding entities. This function would typically be used
   * when writing out a file to be parsed with the markup parser.
   *
   * Note that this function doesn't protect whitespace and line endings
   * from being processed according to the XML rules for normalization
   * of line endings and attribute values.
   *
   * Note also that this function will produce character references in
   * the range of &#x1; ... &#x1f; for all control sequences
   * except for tabstop, newline and carriage return.  The character
   * references in this range are not valid XML 1.0, but they are
   * valid XML 1.1 and will be accepted by the GMarkup parser.
   * @param text some valid UTF-8 text
   * @param length length of `text` in bytes, or -1 if the text is nul-terminated
   * @returns a newly allocated string with the escaped text
   */
  function markupEscapeText(text: string, length: number): string | null
  function memChunkInfo(): void
  /**
   * Checks whether the allocator used by g_malloc() is the system's
   * malloc implementation. If it returns %TRUE memory allocated with
   * malloc() can be used interchangeably with memory allocated using g_malloc().
   * This function is useful for avoiding an extra copy of allocated memory returned
   * by a non-GLib-based API.
   * @returns if %TRUE, malloc() and g_malloc() can be mixed.
   */
  function memIsSystemMalloc(): boolean
  /**
   * GLib used to support some tools for memory profiling, but this
   * no longer works. There are many other useful tools for memory
   * profiling these days which can be used instead.
   */
  function memProfile(): void
  /**
   * This function used to let you override the memory allocation function.
   * However, its use was incompatible with the use of global constructors
   * in GLib and GIO, because those use the GLib allocators before main is
   * reached. Therefore this function is now deprecated and is just a stub.
   * @param vtable table of memory allocation routines.
   */
  function memSetVtable(vtable: MemVTable): void
  /**
   * Allocates `byte_size` bytes of memory, and copies `byte_size` bytes into it
   * from `mem`. If `mem` is `NULL` it returns `NULL`.
   * @param mem the memory to copy
   * @param byteSize the number of bytes to copy
   * @returns a pointer to the newly-allocated copy of the memory
   */
  function memdup(mem: any | null, byteSize: number): any | null
  /**
   * Allocates `byte_size` bytes of memory, and copies `byte_size` bytes into it
   * from `mem`. If `mem` is `NULL` it returns `NULL`.
   *
   * This replaces [func`GLib`.memdup], which was prone to integer overflows when
   * converting the argument from a `gsize` to a `guint`.
   * @param mem the memory to copy
   * @param byteSize the number of bytes to copy
   * @returns a pointer to the newly-allocated copy of the memory
   */
  function memdup2(mem: any | null, byteSize: number): any | null
  /**
   * A wrapper for the POSIX mkdir() function. The mkdir() function
   * attempts to create a directory with the given name and permissions.
   * The mode argument is ignored on Windows.
   *
   * See your C library manual for more details about mkdir().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param mode permissions to use for the newly created directory
   * @returns 0 if the directory was successfully created, -1 if an error    occurred
   */
  function mkdir(filename: string, mode: number): number
  /**
   * Create a directory if it doesn't already exist. Create intermediate
   * parent directories as needed, too.
   * @param pathname a pathname in the GLib file name encoding
   * @param mode permissions to use for newly created directories
   * @returns 0 if the directory already exists, or was successfully created. Returns -1 if an error occurred, with errno set.
   */
  function mkdirWithParents(pathname: string, mode: number): number
  function nodePopAllocator(): void
  function nodePushAllocator(allocator: Allocator): void
  /**
   * Set the pointer at the specified location to %NULL.
   * @param nullifyLocation the memory address of the pointer.
   */
  function nullifyPointer(nullifyLocation: any): void
  function numberParserErrorQuark(): Quark
  /**
   * Prompts the user with
   * `[E]xit, [H]alt, show [S]tack trace or [P]roceed`.
   * This function is intended to be used for debugging use only.
   * The following example shows how it can be used together with
   * the g_log() functions.
   *
   *
   * ```c
   * #include <glib.h>
   *
   * static void
   * log_handler (const gchar   *log_domain,
   *              GLogLevelFlags log_level,
   *              const gchar   *message,
   *              gpointer       user_data)
   * {
   *   g_log_default_handler (log_domain, log_level, message, user_data);
   *
   *   g_on_error_query (MY_PROGRAM_NAME);
   * }
   *
   * int
   * main (int argc, char *argv[])
   * {
   *   g_log_set_handler (MY_LOG_DOMAIN,
   *                      G_LOG_LEVEL_WARNING |
   *                      G_LOG_LEVEL_ERROR |
   *                      G_LOG_LEVEL_CRITICAL,
   *                      log_handler,
   *                      NULL);
   *   ...
   * ```
   *
   *
   * If "[E]xit" is selected, the application terminates with a call
   * to _exit(0).
   *
   * If "[S]tack" trace is selected, g_on_error_stack_trace() is called.
   * This invokes gdb, which attaches to the current process and shows
   * a stack trace. The prompt is then shown again.
   *
   * If "[P]roceed" is selected, the function returns.
   *
   * This function may cause different actions on non-UNIX platforms.
   *
   * On Windows consider using the `G_DEBUGGER` environment
   * variable (see [Running GLib Applications](glib-running.html)) and
   * calling g_on_error_stack_trace() instead.
   * @param prgName the program name, needed by gdb for the "[S]tack trace"     option. If `prg_name` is %NULL, g_get_prgname() is called to get     the program name (which will work correctly if gdk_init() or     gtk_init() has been called)
   */
  function onErrorQuery(prgName: string): void
  /**
   * Invokes gdb, which attaches to the current process and shows a
   * stack trace. Called by g_on_error_query() when the "[S]tack trace"
   * option is selected. You can get the current process's program name
   * with g_get_prgname(), assuming that you have called gtk_init() or
   * gdk_init().
   *
   * This function may cause different actions on non-UNIX platforms.
   *
   * When running on Windows, this function is *not* called by
   * g_on_error_query(). If called directly, it will raise an
   * exception, which will crash the program. If the `G_DEBUGGER` environment
   * variable is set, a debugger will be invoked to attach and
   * handle that exception (see [Running GLib Applications](glib-running.html)).
   * @param prgName the program name, needed by gdb for the "[S]tack trace"     option
   */
  function onErrorStackTrace(prgName: string): void
  /**
   * Function to be called when starting a critical initialization
   * section. The argument `location` must point to a static
   * 0-initialized variable that will be set to a value other than 0 at
   * the end of the initialization section. In combination with
   * g_once_init_leave() and the unique address `value_location,` it can
   * be ensured that an initialization section will be executed only once
   * during a program's life time, and that concurrent threads are
   * blocked until initialization completed. To be used in constructs
   * like this:
   *
   *
   * ```c
   *   static gsize initialization_value = 0;
   *
   *   if (g_once_init_enter (&initialization_value))
   *     {
   *       gsize setup_value = 42; // initialization code here
   *
   *       g_once_init_leave (&initialization_value, setup_value);
   *     }
   *
   *   // use initialization_value here
   * ```
   *
   *
   * While `location` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param location location of a static initializable variable    containing 0
   * @returns %TRUE if the initialization section should be entered,     %FALSE and blocks otherwise
   */
  function onceInitEnter(
    location: any
  ): [/* returnType */ boolean, /* location */ any]
  function onceInitEnterImpl(location: number): boolean
  /**
   * This functions behaves in the same way as g_once_init_enter(), but can
   * can be used to initialize pointers (or #guintptr) instead of #gsize.
   *
   *
   * ```c
   *   static MyStruct *interesting_struct = NULL;
   *
   *   if (g_once_init_enter_pointer (&interesting_struct))
   *     {
   *       MyStruct *setup_value = allocate_my_struct (); // initialization code here
   *
   *       g_once_init_leave_pointer (&interesting_struct, g_steal_pointer (&setup_value));
   *     }
   *
   *   // use interesting_struct here
   * ```
   *
   * @param location location of a static initializable variable    containing `NULL`
   * @returns %TRUE if the initialization section should be entered,     %FALSE and blocks otherwise
   */
  function onceInitEnterPointer(location: any): boolean
  /**
   * Counterpart to g_once_init_enter(). Expects a location of a static
   * 0-initialized initialization variable, and an initialization value
   * other than 0. Sets the variable to the initialization value, and
   * releases concurrent threads blocking in g_once_init_enter() on this
   * initialization variable.
   *
   * While `location` has a `volatile` qualifier, this is a historical artifact and
   * the pointer passed to it should not be `volatile`.
   * @param location location of a static initializable variable    containing 0
   * @param result new non-0 value for *`value_location`
   */
  function onceInitLeave(location: any, result: number): /* location */ any
  /**
   * Counterpart to g_once_init_enter_pointer(). Expects a location of a static
   * `NULL`-initialized initialization variable, and an initialization value
   * other than `NULL`. Sets the variable to the initialization value, and
   * releases concurrent threads blocking in g_once_init_enter_pointer() on this
   * initialization variable.
   *
   * This functions behaves in the same way as g_once_init_leave(), but
   * can be used to initialize pointers (or #guintptr) instead of #gsize.
   * @param location location of a static initializable variable    containing `NULL`
   * @param result new non-`NULL` value for `*location`
   */
  function onceInitLeavePointer(location: any, result: any | null): void
  /**
   * A wrapper for the POSIX open() function. The open() function is
   * used to convert a pathname into a file descriptor.
   *
   * On POSIX systems file descriptors are implemented by the operating
   * system. On Windows, it's the C library that implements open() and
   * file descriptors. The actual Win32 API for opening files is quite
   * different, see MSDN documentation for CreateFile(). The Win32 API
   * uses file handles, which are more randomish integers, not small
   * integers like file descriptors.
   *
   * Because file descriptors are specific to the C library on Windows,
   * the file descriptor returned by this function makes sense only to
   * functions in the same C library. Thus if the GLib-using code uses a
   * different C library than GLib does, the file descriptor returned by
   * this function cannot be passed to C library functions like write()
   * or read().
   *
   * See your C library manual for more details about open().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param flags as in open()
   * @param mode as in open()
   * @returns a new file descriptor, or -1 if an error occurred.     The return value can be used exactly like the return value     from open().
   */
  function open(filename: string, flags: number, mode: number): number
  function optionErrorQuark(): Quark
  /**
   * Parses a string containing debugging options
   * into a %guint containing bit flags. This is used
   * within GDK and GTK to parse the debug options passed on the
   * command line or through environment variables.
   *
   * If `string` is equal to "all", all flags are set. Any flags
   * specified along with "all" in `string` are inverted; thus,
   * "all,foo,bar" or "foo,bar,all" sets all flags except those
   * corresponding to "foo" and "bar".
   *
   * If `string` is equal to "help", all the available keys in `keys`
   * are printed out to standard error.
   * @param string a list of debug options separated by colons, spaces, or commas, or %NULL.
   * @param keys pointer to an array of #GDebugKey which associate     strings with bit flags.
   * @returns the combined set of bit flags.
   */
  function parseDebugString(string: string | null, keys: DebugKey[]): number
  /**
   * Compares two path buffers for equality and returns `TRUE`
   * if they are equal.
   *
   * The path inside the paths buffers are not going to be normalized,
   * so `X/Y/Z/A/..`, `X/./Y/Z` and `X/Y/Z` are not going to be considered
   * equal.
   *
   * This function can be passed to g_hash_table_new() as the
   * `key_equal_func` parameter.
   * @param v1 a path buffer to compare
   * @param v2 a path buffer to compare
   * @returns `TRUE` if the two path buffers are equal,   and `FALSE` otherwise
   */
  function pathBufEqual(v1: any, v2: any): boolean
  /**
   * Gets the last component of the filename.
   *
   * If `file_name` ends with a directory separator it gets the component
   * before the last slash. If `file_name` consists only of directory
   * separators (and on Windows, possibly a drive letter), a single
   * separator is returned. If `file_name` is empty, it gets ".".
   * @param fileName the name of the file
   * @returns a newly allocated string   containing the last component of the filename
   */
  function pathGetBasename(fileName: string): string
  /**
   * Gets the directory components of a file name. For example, the directory
   * component of `/usr/bin/test` is `/usr/bin`. The directory component of `/`
   * is `/`.
   *
   * If the file name has no directory components "." is returned.
   * The returned string should be freed when no longer needed.
   * @param fileName the name of the file
   * @returns the directory components of the file
   */
  function pathGetDirname(fileName: string): string
  /**
   * Returns %TRUE if the given `file_name` is an absolute file name.
   * Note that this is a somewhat vague concept on Windows.
   *
   * On POSIX systems, an absolute file name is well-defined. It always
   * starts from the single root directory. For example "/usr/local".
   *
   * On Windows, the concepts of current drive and drive-specific
   * current directory introduce vagueness. This function interprets as
   * an absolute file name one that either begins with a directory
   * separator such as "\Users\tml" or begins with the root on a drive,
   * for example "C:\Windows". The first case also includes UNC paths
   * such as "\\\\myserver\docs\foo". In all cases, either slashes or
   * backslashes are accepted.
   *
   * Note that a file name relative to the current drive root does not
   * truly specify a file uniquely over time and across processes, as
   * the current drive is a per-process value and can be changed.
   *
   * File names relative the current directory on some specific drive,
   * such as "D:foo/bar", are not interpreted as absolute by this
   * function, but they obviously are not relative to the normal current
   * directory as returned by getcwd() or g_get_current_dir()
   * either. Such paths should be avoided, or need to be handled using
   * Windows-specific code.
   * @param fileName a file name
   * @returns %TRUE if @file_name is absolute
   */
  function pathIsAbsolute(fileName: string): boolean
  /**
   * Returns a pointer into `file_name` after the root component,
   * i.e. after the "/" in UNIX or "C:\" under Windows. If `file_name`
   * is not an absolute path it returns %NULL.
   * @param fileName a file name
   * @returns a pointer into @file_name after the     root component
   */
  function pathSkipRoot(fileName: string): string | null
  /**
   * Matches a string against a pattern given as a string. If this
   * function is to be called in a loop, it's more efficient to compile
   * the pattern once with g_pattern_spec_new() and call
   * g_pattern_match_string() repeatedly.
   * @param pattern the UTF-8 encoded pattern
   * @param string the UTF-8 encoded string to match
   * @returns %TRUE if @string matches @pspec
   */
  function patternMatchSimple(pattern: string, string: string): boolean
  /**
   * This is equivalent to g_bit_lock, but working on pointers (or other
   * pointer-sized values).
   *
   * For portability reasons, you may only lock on the bottom 32 bits of
   * the pointer.
   *
   * While `address` has a `volatile` qualifier, this is a historical
   * artifact and the argument passed to it should not be `volatile`.
   * @param address a pointer to a #gpointer-sized value
   * @param lockBit a bit value between 0 and 31
   */
  function pointerBitLock(address: any, lockBit: number): void
  /**
   * This is equivalent to g_bit_lock, but working on pointers (or other
   * pointer-sized values).
   *
   * For portability reasons, you may only lock on the bottom 32 bits of
   * the pointer.
   * @param address a pointer to a #gpointer-sized value
   * @param lockBit a bit value between 0 and 31
   */
  function pointerBitLockAndGet(
    address: any,
    lockBit: number
  ): /* outPtr */ never
  /**
   * This mangles `ptr` as g_pointer_bit_lock() and g_pointer_bit_unlock()
   * do.
   * @param ptr the pointer to mask
   * @param lockBit the bit to set/clear. If set to `G_MAXUINT`, the   lockbit is taken from `preserve_ptr` or `ptr` (depending on `preserve_mask)`.
   * @param set whether to set (lock) the bit or unset (unlock). This   has no effect, if `lock_bit` is set to `G_MAXUINT`.
   * @param preserveMask if non-zero, a bit-mask for `preserve_ptr`. The   `preserve_mask` bits from `preserve_ptr` are set in the result.   Note that the `lock_bit` bit will be always set according to `set,`   regardless of `preserve_mask` and `preserve_ptr` (unless `lock_bit` is   `G_MAXUINT`).
   * @param preservePtr if `preserve_mask` is non-zero, the bits   from this pointer are set in the result.
   * @returns the mangled pointer.
   */
  function pointerBitLockMaskPtr(
    ptr: any | null,
    lockBit: number,
    set: boolean,
    preserveMask: never,
    preservePtr: any | null
  ): any | null
  /**
   * This is equivalent to g_bit_trylock(), but working on pointers (or
   * other pointer-sized values).
   *
   * For portability reasons, you may only lock on the bottom 32 bits of
   * the pointer.
   *
   * While `address` has a `volatile` qualifier, this is a historical
   * artifact and the argument passed to it should not be `volatile`.
   * @param address a pointer to a #gpointer-sized value
   * @param lockBit a bit value between 0 and 31
   * @returns %TRUE if the lock was acquired
   */
  function pointerBitTrylock(address: any, lockBit: number): boolean
  /**
   * This is equivalent to g_bit_unlock, but working on pointers (or other
   * pointer-sized values).
   *
   * For portability reasons, you may only lock on the bottom 32 bits of
   * the pointer.
   *
   * While `address` has a `volatile` qualifier, this is a historical
   * artifact and the argument passed to it should not be `volatile`.
   * @param address a pointer to a #gpointer-sized value
   * @param lockBit a bit value between 0 and 31
   */
  function pointerBitUnlock(address: any, lockBit: number): void
  /**
   * This is equivalent to g_pointer_bit_unlock() and atomically setting
   * the pointer value.
   *
   * Note that the lock bit will be cleared from the pointer. If the unlocked
   * pointer that was set is not identical to `ptr,` an assertion fails. In other
   * words, `ptr` must have `lock_bit` unset. This also means, you usually can
   * only use this on the lowest bits.
   * @param address a pointer to a #gpointer-sized value
   * @param lockBit a bit value between 0 and 31
   * @param ptr the new pointer value to set
   * @param preserveMask if non-zero, those bits of the current pointer in `address`   are preserved.   Note that the `lock_bit` bit will be always set according to `set,`   regardless of `preserve_mask` and the currently set value in `address`.
   */
  function pointerBitUnlockAndSet(
    address: any,
    lockBit: number,
    ptr: any | null,
    preserveMask: never
  ): void
  /**
   * Polls `fds,` as with the poll() system call, but portably. (On
   * systems that don't have poll(), it is emulated using select().)
   * This is used internally by #GMainContext, but it can be called
   * directly if you need to block until a file descriptor is ready, but
   * don't want to run the full main loop.
   *
   * Each element of `fds` is a #GPollFD describing a single file
   * descriptor to poll. The `fd` field indicates the file descriptor,
   * and the `events` field indicates the events to poll for. On return,
   * the `revents` fields will be filled with the events that actually
   * occurred.
   *
   * On POSIX systems, the file descriptors in `fds` can be any sort of
   * file descriptor, but the situation is much more complicated on
   * Windows. If you need to use g_poll() in code that has to run on
   * Windows, the easiest solution is to construct all of your
   * #GPollFDs with g_io_channel_win32_make_pollfd().
   * @param fds file descriptors to poll
   * @param nfds the number of file descriptors in `fds`
   * @param timeout amount of time to wait, in milliseconds, or -1 to wait forever
   * @returns the number of entries in @fds whose @revents fields were filled in, or 0 if the operation timed out, or -1 on error or if the call was interrupted.
   */
  function poll(fds: PollFD, nfds: number, timeout: number): number
  /**
   * Prefixes `prefix` to an existing error message. If `err` or *`err` is
   * %NULL (i.e.: no error variable) then do nothing.
   * @param err a return location for a #GError, or %NULL
   * @param prefix string to prefix `err` with
   */
  function prefixErrorLiteral(
    err: Error | null,
    prefix: string
  ): /* err */ Error | null
  /**
   * If `dest` is %NULL, free `src;` otherwise, moves `src` into *`dest`.
   * The error variable `dest` points to must be %NULL.
   *
   * `src` must be non-%NULL.
   *
   * Note that `src` is no longer valid after this call. If you want
   * to keep using the same GError*, you need to set it to %NULL
   * after calling this function on it.
   * @param src error to move into the return location
   */
  function propagateError(src: Error): /* dest */ Error | null
  /**
   * This is just like the standard C qsort() function, but
   * the comparison routine accepts a user data argument.
   *
   * This is guaranteed to be a stable sort since version 2.32.
   * @param pbase start of array to sort
   * @param totalElems elements in the array
   * @param size size of each element
   * @param compareFunc function to compare elements
   */
  function qsortWithData(
    pbase: any,
    totalElems: number,
    size: number,
    compareFunc: CompareDataFunc
  ): void
  /**
   * Gets the #GQuark identifying the given (static) string. If the
   * string does not currently have an associated #GQuark, a new #GQuark
   * is created, linked to the given string.
   *
   * Note that this function is identical to g_quark_from_string() except
   * that if a new #GQuark is created the string itself is used rather
   * than a copy. This saves memory, but can only be used if the string
   * will continue to exist until the program terminates. It can be used
   * with statically allocated strings in the main program, but not with
   * statically allocated memory in dynamically loaded modules, if you
   * expect to ever unload the module again (e.g. do not use this
   * function in GTK theme engines).
   *
   * This function must not be used before library constructors have finished
   * running. In particular, this means it cannot be used to initialize global
   * variables in C++.
   * @param string a string
   * @returns the #GQuark identifying the string, or 0 if @string is %NULL
   */
  function quarkFromStaticString(string: string | null): Quark
  /**
   * Gets the #GQuark identifying the given string. If the string does
   * not currently have an associated #GQuark, a new #GQuark is created,
   * using a copy of the string.
   *
   * This function must not be used before library constructors have finished
   * running. In particular, this means it cannot be used to initialize global
   * variables in C++.
   * @param string a string
   * @returns the #GQuark identifying the string, or 0 if @string is %NULL
   */
  function quarkFromString(string: string | null): Quark
  /**
   * Gets the string associated with the given #GQuark.
   * @param quark a #GQuark.
   * @returns the string associated with the #GQuark
   */
  function quarkToString(quark: Quark): string
  /**
   * Gets the #GQuark associated with the given string, or 0 if string is
   * %NULL or it has no associated #GQuark.
   *
   * If you want the GQuark to be created if it doesn't already exist,
   * use g_quark_from_string() or g_quark_from_static_string().
   *
   * This function must not be used before library constructors have finished
   * running.
   * @param string a string
   * @returns the #GQuark associated with the string, or 0 if @string is     %NULL or there is no #GQuark associated with it
   */
  function quarkTryString(string: string | null): Quark
  /**
   * Returns a random #gdouble equally distributed over the range [0..1).
   * @returns a random number
   */
  function randomDouble(): number
  /**
   * Returns a random #gdouble equally distributed over the range
   * [`begin`..`end)`.
   * @param begin lower closed bound of the interval
   * @param end upper open bound of the interval
   * @returns a random number
   */
  function randomDoubleRange(begin: number, end: number): number
  /**
   * Return a random #guint32 equally distributed over the range
   * [0..2^32-1].
   * @returns a random number
   */
  function randomInt(): number
  /**
   * Returns a random #gint32 equally distributed over the range
   * [`begin`..`end-1`].
   * @param begin lower closed bound of the interval
   * @param end upper open bound of the interval
   * @returns a random number
   */
  function randomIntRange(begin: number, end: number): number
  /**
   * Sets the seed for the global random number generator, which is used
   * by the g_random_* functions, to `seed`.
   * @param seed a value to reinitialize the global random number generator
   */
  function randomSetSeed(seed: number): void
  /**
   * Acquires a reference on the data pointed by `mem_block`.
   * @param memBlock a pointer to reference counted data
   * @returns a pointer to the data,   with its reference count increased
   */
  function rcBoxAcquire(memBlock: any): any
  /**
   * Allocates `block_size` bytes of memory, and adds reference
   * counting semantics to it.
   *
   * The data will be freed when its reference count drops to
   * zero.
   *
   * The allocated data is guaranteed to be suitably aligned for any
   * built-in type.
   * @param blockSize the size of the allocation, must be greater than 0
   * @returns a pointer to the allocated memory
   */
  function rcBoxAlloc(blockSize: number): any
  /**
   * Allocates `block_size` bytes of memory, and adds reference
   * counting semantics to it.
   *
   * The contents of the returned data is set to zero.
   *
   * The data will be freed when its reference count drops to
   * zero.
   *
   * The allocated data is guaranteed to be suitably aligned for any
   * built-in type.
   * @param blockSize the size of the allocation, must be greater than 0
   * @returns a pointer to the allocated memory
   */
  function rcBoxAlloc0(blockSize: number): any
  /**
   * Allocates a new block of data with reference counting
   * semantics, and copies `block_size` bytes of `mem_block`
   * into it.
   * @param blockSize the number of bytes to copy, must be greater than 0
   * @param memBlock the memory to copy
   * @returns a pointer to the allocated   memory
   */
  function rcBoxDup(blockSize: number, memBlock: any): any
  /**
   * Retrieves the size of the reference counted data pointed by `mem_block`.
   * @param memBlock a pointer to reference counted data
   * @returns the size of the data, in bytes
   */
  function rcBoxGetSize(memBlock: any): number
  /**
   * Releases a reference on the data pointed by `mem_block`.
   *
   * If the reference was the last one, it will free the
   * resources allocated for `mem_block`.
   * @param memBlock a pointer to reference counted data
   */
  function rcBoxRelease(memBlock: any): void
  /**
   * Releases a reference on the data pointed by `mem_block`.
   *
   * If the reference was the last one, it will call `clear_func`
   * to clear the contents of `mem_block,` and then will free the
   * resources allocated for `mem_block`.
   * @param memBlock a pointer to reference counted data
   * @param clearFunc a function to call when clearing the data
   */
  function rcBoxReleaseFull(memBlock: any, clearFunc: DestroyNotify): void
  /**
   * Reallocates the memory pointed to by `mem,` so that it now has space for
   * `n_bytes` bytes of memory. It returns the new address of the memory, which may
   * have been moved. `mem` may be %NULL, in which case it's considered to
   * have zero-length. `n_bytes` may be 0, in which case %NULL will be returned
   * and `mem` will be freed unless it is %NULL.
   *
   * If the allocation fails (because the system is out of memory),
   * the program is terminated.
   * @param mem the memory to reallocate
   * @param nBytes new size of the memory in bytes
   * @returns the new address of the allocated memory
   */
  function realloc(mem: any | null, nBytes: number): any | null
  /**
   * This function is similar to g_realloc(), allocating (`n_blocks` * `n_block_bytes)` bytes,
   * but care is taken to detect possible overflow during multiplication.
   *
   * If the allocation fails (because the system is out of memory),
   * the program is terminated.
   * @param mem the memory to reallocate
   * @param nBlocks the number of blocks to allocate
   * @param nBlockBytes the size of each block in bytes
   * @returns the new address of the allocated memory
   */
  function reallocN(
    mem: any | null,
    nBlocks: number,
    nBlockBytes: number
  ): any | null
  /**
   * Compares the current value of `rc` with `val`.
   * @param rc the address of a reference count variable
   * @param val the value to compare
   * @returns %TRUE if the reference count is the same   as the given value
   */
  function refCountCompare(rc: number, val: number): boolean
  /**
   * Decreases the reference count.
   *
   * If %TRUE is returned, the reference count reached 0. After this point, `rc`
   * is an undefined state and must be reinitialized with
   * g_ref_count_init() to be used again.
   * @param rc the address of a reference count variable
   * @returns %TRUE if the reference count reached 0, and %FALSE otherwise
   */
  function refCountDec(rc: number): boolean
  /**
   * Increases the reference count.
   * @param rc the address of a reference count variable
   */
  function refCountInc(rc: number): void
  /**
   * Initializes a reference count variable to 1.
   * @param rc the address of a reference count variable
   */
  function refCountInit(rc: number): void
  /**
   * Acquires a reference on a string.
   * @param str a reference counted string
   * @returns the given string, with its reference count increased
   */
  function refStringAcquire(str: string | null): string | null
  /**
   * Retrieves the length of `str`.
   * @param str a reference counted string
   * @returns the length of the given string, in bytes
   */
  function refStringLength(str: string | null): number
  /**
   * Creates a new reference counted string and copies the contents of `str`
   * into it.
   * @param str a NUL-terminated string
   * @returns the newly created reference counted string
   */
  function refStringNew(str: string): string | null
  /**
   * Creates a new reference counted string and copies the content of `str`
   * into it.
   *
   * If you call this function multiple times with the same `str,` or with
   * the same contents of `str,` it will return a new reference, instead of
   * creating a new string.
   * @param str a NUL-terminated string
   * @returns the newly created reference   counted string, or a new reference to an existing string
   */
  function refStringNewIntern(str: string): string | null
  /**
   * Creates a new reference counted string and copies the contents of `str`
   * into it, up to `len` bytes.
   *
   * Since this function does not stop at nul bytes, it is the caller's
   * responsibility to ensure that `str` has at least `len` addressable bytes.
   * @param str a string
   * @param len length of `str` to use, or -1 if `str` is nul-terminated
   * @returns the newly created reference counted string
   */
  function refStringNewLen(str: string, len: number): string | null
  /**
   * Releases a reference on a string; if it was the last reference, the
   * resources allocated by the string are freed as well.
   * @param str a reference counted string
   */
  function refStringRelease(str: string | null): void
  /**
   * Checks whether `replacement` is a valid replacement string
   * (see g_regex_replace()), i.e. that all escape sequences in
   * it are valid.
   *
   * If `has_references` is not %NULL then `replacement` is checked
   * for pattern references. For instance, replacement text 'foo\n'
   * does not contain references and may be evaluated without information
   * about actual match, but '\0\1' (whole match followed by first
   * subpattern) requires valid #GMatchInfo object.
   * @param replacement the replacement string
   * @returns whether @replacement is a valid replacement string
   */
  function regexCheckReplacement(
    replacement: string
  ): [/* returnType */ boolean, /* hasReferences */ boolean]
  function regexErrorQuark(): Quark
  /**
   * Escapes the nul characters in `string` to "\x00".  It can be used
   * to compile a regex with embedded nul characters.
   *
   * For completeness, `length` can be -1 for a nul-terminated string.
   * In this case the output string will be of course equal to `string`.
   * @param string the string to escape
   * @param length the length of `string`
   * @returns a newly-allocated escaped string
   */
  function regexEscapeNul(string: string, length: number): string | null
  /**
   * Escapes the special characters used for regular expressions
   * in `string,` for instance "a.b*c" becomes "a\.b\*c". This
   * function is useful to dynamically generate regular expressions.
   *
   * `string` can contain nul characters that are replaced with "\0",
   * in this case remember to specify the correct length of `string`
   * in `length`.
   * @param string the string to escape
   * @param length the length of `string,` in bytes, or -1 if `string` is nul-terminated
   * @returns a newly-allocated escaped string
   */
  function regexEscapeString(string: string, length: number): string | null
  /**
   * Scans for a match in `string` for `pattern`.
   *
   * This function is equivalent to g_regex_match() but it does not
   * require to compile the pattern with g_regex_new(), avoiding some
   * lines of code when you need just to do a match without extracting
   * substrings, capture counts, and so on.
   *
   * If this function is to be called on the same `pattern` more than
   * once, it's more efficient to compile the pattern once with
   * g_regex_new() and then use g_regex_match().
   * @param pattern the regular expression
   * @param string the string to scan for matches
   * @param compileOptions compile options for the regular expression, or 0
   * @param matchOptions match options, or 0
   * @returns %TRUE if the string matched, %FALSE otherwise
   */
  function regexMatchSimple(
    pattern: string,
    string: string,
    compileOptions: RegexCompileFlags,
    matchOptions: RegexMatchFlags
  ): boolean
  /**
   * Breaks the string on the pattern, and returns an array of
   * the tokens. If the pattern contains capturing parentheses,
   * then the text for each of the substrings will also be returned.
   * If the pattern does not match anywhere in the string, then the
   * whole string is returned as the first token.
   *
   * This function is equivalent to g_regex_split() but it does
   * not require to compile the pattern with g_regex_new(), avoiding
   * some lines of code when you need just to do a split without
   * extracting substrings, capture counts, and so on.
   *
   * If this function is to be called on the same `pattern` more than
   * once, it's more efficient to compile the pattern once with
   * g_regex_new() and then use g_regex_split().
   *
   * As a special case, the result of splitting the empty string ""
   * is an empty vector, not a vector containing a single string.
   * The reason for this special case is that being able to represent
   * an empty vector is typically more useful than consistent handling
   * of empty elements. If you do need to represent empty elements,
   * you'll need to check for the empty string before calling this
   * function.
   *
   * A pattern that can match empty strings splits `string` into
   * separate characters wherever it matches the empty string between
   * characters. For example splitting "ab c" using as a separator
   * "\s*", you will get "a", "b" and "c".
   * @param pattern the regular expression
   * @param string the string to scan for matches
   * @param compileOptions compile options for the regular expression, or 0
   * @param matchOptions match options, or 0
   * @returns a %NULL-terminated array of strings. Free it using g_strfreev()
   */
  function regexSplitSimple(
    pattern: string,
    string: string,
    compileOptions: RegexCompileFlags,
    matchOptions: RegexMatchFlags
  ): string[]
  /**
   * Resets the cache used for g_get_user_special_dir(), so
   * that the latest on-disk version is used. Call this only
   * if you just changed the data on disk yourself.
   *
   * Due to thread safety issues this may cause leaking of strings
   * that were previously returned from g_get_user_special_dir()
   * that can't be freed. We ensure to only leak the data for
   * the directories that actually changed value though.
   */
  function reloadUserSpecialDirsCache(): void
  /**
   * A wrapper for the POSIX remove() function. The remove() function
   * deletes a name from the filesystem.
   *
   * See your C library manual for more details about how remove() works
   * on your system. On Unix, remove() removes also directories, as it
   * calls unlink() for files and rmdir() for directories. On Windows,
   * although remove() in the C library only works for files, this
   * function tries first remove() and then if that fails rmdir(), and
   * thus works for both files and directories. Note however, that on
   * Windows, it is in general not possible to remove a file that is
   * open to some process, or mapped into memory.
   *
   * If this function fails on Windows you can't infer too much from the
   * errno value. rmdir() is tried regardless of what caused remove() to
   * fail. Any errno value set by remove() will be overwritten by that
   * set by rmdir().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @returns 0 if the file was successfully removed, -1 if an error    occurred
   */
  function remove(filename: string): number
  /**
   * A wrapper for the POSIX rename() function. The rename() function
   * renames a file, moving it between directories if required.
   *
   * See your C library manual for more details about how rename() works
   * on your system. It is not possible in general on Windows to rename
   * a file that is open to some process.
   * @param oldfilename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param newfilename a pathname in the GLib file name encoding
   * @returns 0 if the renaming succeeded, -1 if an error occurred
   */
  function rename(oldfilename: string, newfilename: string): number
  /**
   * A wrapper for the POSIX rmdir() function. The rmdir() function
   * deletes a directory from the filesystem.
   *
   * See your C library manual for more details about how rmdir() works
   * on your system.
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @returns 0 if the directory was successfully removed, -1 if an error    occurred
   */
  function rmdir(filename: string): number
  /**
   * Calls `func` for each item in the range (`begin,` `end)` passing
   * `user_data` to the function. `func` must not modify the sequence
   * itself.
   * @param begin a #GSequenceIter
   * @param end a #GSequenceIter
   * @param func a #GFunc
   */
  function sequenceForeachRange(
    begin: SequenceIter,
    end: SequenceIter,
    func: Func
  ): void
  /**
   * Returns the data that `iter` points to.
   * @param iter a #GSequenceIter
   * @returns the data that @iter points to
   */
  function sequenceGet(iter: SequenceIter): any | null
  /**
   * Inserts a new item just before the item pointed to by `iter`.
   * @param iter a #GSequenceIter
   * @param data the data for the new item
   * @returns an iterator pointing to the new item
   */
  function sequenceInsertBefore(
    iter: SequenceIter,
    data: any | null
  ): SequenceIter
  /**
   * Moves the item pointed to by `src` to the position indicated by `dest`.
   * After calling this function `dest` will point to the position immediately
   * after `src`. It is allowed for `src` and `dest` to point into different
   * sequences.
   * @param src a #GSequenceIter pointing to the item to move
   * @param dest a #GSequenceIter pointing to the position to which     the item is moved
   */
  function sequenceMove(src: SequenceIter, dest: SequenceIter): void
  /**
   * Inserts the (`begin,` `end)` range at the destination pointed to by `dest`.
   * The `begin` and `end` iters must point into the same sequence. It is
   * allowed for `dest` to point to a different sequence than the one pointed
   * into by `begin` and `end`.
   *
   * If `dest` is %NULL, the range indicated by `begin` and `end` is
   * removed from the sequence. If `dest` points to a place within
   * the (`begin,` `end)` range, the range does not move.
   * @param dest a #GSequenceIter
   * @param begin a #GSequenceIter
   * @param end a #GSequenceIter
   */
  function sequenceMoveRange(
    dest: SequenceIter,
    begin: SequenceIter,
    end: SequenceIter
  ): void
  /**
   * Finds an iterator somewhere in the range (`begin,` `end)`. This
   * iterator will be close to the middle of the range, but is not
   * guaranteed to be exactly in the middle.
   *
   * The `begin` and `end` iterators must both point to the same sequence
   * and `begin` must come before or be equal to `end` in the sequence.
   * @param begin a #GSequenceIter
   * @param end a #GSequenceIter
   * @returns a #GSequenceIter pointing somewhere in the    (@begin, @end) range
   */
  function sequenceRangeGetMidpoint(
    begin: SequenceIter,
    end: SequenceIter
  ): SequenceIter
  /**
   * Removes the item pointed to by `iter`. It is an error to pass the
   * end iterator to this function.
   *
   * If the sequence has a data destroy function associated with it, this
   * function is called on the data for the removed item.
   * @param iter a #GSequenceIter
   */
  function sequenceRemove(iter: SequenceIter): void
  /**
   * Removes all items in the (`begin,` `end)` range.
   *
   * If the sequence has a data destroy function associated with it, this
   * function is called on the data for the removed items.
   * @param begin a #GSequenceIter
   * @param end a #GSequenceIter
   */
  function sequenceRemoveRange(begin: SequenceIter, end: SequenceIter): void
  /**
   * Changes the data for the item pointed to by `iter` to be `data`. If
   * the sequence has a data destroy function associated with it, that
   * function is called on the existing data that `iter` pointed to.
   * @param iter a #GSequenceIter
   * @param data new data for the item
   */
  function sequenceSet(iter: SequenceIter, data: any | null): void
  /**
   * Moves the data pointed to by `iter` to a new position as indicated by
   * `cmp_func`. This
   * function should be called for items in a sequence already sorted according
   * to `cmp_func` whenever some aspect of an item changes so that `cmp_func`
   * may return different values for that item.
   *
   * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
   * It should return 0 if the items are equal, a negative value if
   * the first item comes before the second, and a positive value if
   * the second item comes before the first.
   * @param iter A #GSequenceIter
   * @param cmpFunc the function used to compare items in the sequence
   */
  function sequenceSortChanged(
    iter: SequenceIter,
    cmpFunc: CompareDataFunc
  ): void
  /**
   * Like g_sequence_sort_changed(), but uses
   * a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
   * the compare function.
   *
   * `iter_cmp` is called with two iterators pointing into the #GSequence that
   * `iter` points into. It should
   * return 0 if the iterators are equal, a negative value if the first
   * iterator comes before the second, and a positive value if the second
   * iterator comes before the first.
   * @param iter a #GSequenceIter
   * @param iterCmp the function used to compare iterators in the sequence
   */
  function sequenceSortChangedIter(
    iter: SequenceIter,
    iterCmp: SequenceIterCompareFunc
  ): void
  /**
   * Swaps the items pointed to by `a` and `b`. It is allowed for `a` and `b`
   * to point into difference sequences.
   * @param a a #GSequenceIter
   * @param b a #GSequenceIter
   */
  function sequenceSwap(a: SequenceIter, b: SequenceIter): void
  /**
   * Sets a human-readable name for the application. This name should be
   * localized if possible, and is intended for display to the user.
   * Contrast with g_set_prgname(), which sets a non-localized name.
   * g_set_prgname() will be called automatically by gtk_init(),
   * but g_set_application_name() will not.
   *
   * Note that for thread safety reasons, this function can only
   * be called once.
   *
   * The application name will be used in contexts such as error messages,
   * or when displaying an application's name in the task list.
   * @param applicationName localized name of the application
   */
  function setApplicationName(applicationName: string): void
  /**
   * Does nothing if `err` is %NULL; if `err` is non-%NULL, then *`err`
   * must be %NULL. A new #GError is created and assigned to *`err`.
   * Unlike g_set_error(), `message` is not a printf()-style format string.
   * Use this function if `message` contains text you don't have control over,
   * that could include printf() escape sequences.
   * @param domain error domain
   * @param code error code
   * @param message error message
   */
  function setErrorLiteral(
    domain: Quark,
    code: number,
    message: string
  ): /* err */ Error
  /**
   * Sets the name of the program. This name should not be localized,
   * in contrast to g_set_application_name().
   *
   * If you are using #GApplication the program name is set in
   * g_application_run(). In case of GDK or GTK it is set in
   * gdk_init(), which is called by gtk_init() and the
   * #GtkApplication::startup handler. The program name is found by
   * taking the last component of `argv[`0].
   *
   * Since GLib 2.72, this function can be called multiple times
   * and is fully thread safe. Prior to GLib 2.72, this function
   * could only be called once per process.
   * @param prgname the name of the program.
   */
  function setPrgname(prgname: string): void
  /**
   * Sets an environment variable. On UNIX, both the variable's name and
   * value can be arbitrary byte strings, except that the variable's name
   * cannot contain '='. On Windows, they should be in UTF-8.
   *
   * Note that on some systems, when variables are overwritten, the memory
   * used for the previous variables and its value isn't reclaimed.
   *
   * You should be mindful of the fact that environment variable handling
   * in UNIX is not thread-safe, and your program may crash if one thread
   * calls g_setenv() while another thread is calling getenv(). (And note
   * that many functions, such as gettext(), call getenv() internally.)
   * This function is only safe to use at the very start of your program,
   * before creating any other threads (or creating objects that create
   * worker threads of their own).
   *
   * If you need to set up the environment for a child process, you can
   * use g_get_environ() to get an environment array, modify that with
   * g_environ_setenv() and g_environ_unsetenv(), and then pass that
   * array directly to execvpe(), g_spawn_async(), or the like.
   * @param variable the environment variable to set, must not     contain '='.
   * @param value the value for to set the variable to.
   * @param overwrite whether to change the variable if it already exists.
   * @returns %FALSE if the environment variable couldn't be set.
   */
  function setenv(variable: string, value: string, overwrite: boolean): boolean
  function shellErrorQuark(): Quark
  /**
   * Parses a command line into an argument vector, in much the same way
   * the shell would, but without many of the expansions the shell would
   * perform (variable expansion, globs, operators, filename expansion,
   * etc. are not supported).
   *
   * The results are defined to be the same as those you would get from
   * a UNIX98 `/bin/sh`, as long as the input contains none of the
   * unsupported shell expansions. If the input does contain such expansions,
   * they are passed through literally.
   *
   * Possible errors are those from the %G_SHELL_ERROR domain.
   *
   * In particular, if `command_line` is an empty string (or a string containing
   * only whitespace), %G_SHELL_ERROR_EMPTY_STRING will be returned. It’s
   * guaranteed that `argvp` will be a non-empty array if this function returns
   * successfully.
   *
   * Free the returned vector with g_strfreev().
   * @param commandLine command line to parse
   * @returns %TRUE on success, %FALSE if error set
   */
  function shellParseArgv(
    commandLine: string
  ): [/* returnType */ boolean, /* argvp */ string[]]
  /**
   * Quotes a string so that the shell (/bin/sh) will interpret the
   * quoted string to mean `unquoted_string`.
   *
   * If you pass a filename to the shell, for example, you should first
   * quote it with this function.
   *
   * The return value must be freed with g_free().
   *
   * The quoting style used is undefined (single or double quotes may be
   * used).
   * @param unquotedString a literal string
   * @returns quoted string
   */
  function shellQuote(unquotedString: string): string
  /**
   * Unquotes a string as the shell (/bin/sh) would.
   *
   * This function only handles quotes; if a string contains file globs,
   * arithmetic operators, variables, backticks, redirections, or other
   * special-to-the-shell features, the result will be different from the
   * result a real shell would produce (the variables, backticks, etc.
   * will be passed through literally instead of being expanded).
   *
   * This function is guaranteed to succeed if applied to the result of
   * g_shell_quote(). If it fails, it returns %NULL and sets the
   * error.
   *
   * The `quoted_string` need not actually contain quoted or escaped text;
   * g_shell_unquote() simply goes through the string and unquotes/unescapes
   * anything that the shell would. Both single and double quotes are
   * handled, as are escapes including escaped newlines.
   *
   * The return value must be freed with g_free().
   *
   * Possible errors are in the %G_SHELL_ERROR domain.
   *
   * Shell quoting rules are a bit strange. Single quotes preserve the
   * literal string exactly. escape sequences are not allowed; not even
   * `\'` - if you want a `'` in the quoted text, you have to do something
   * like `'foo'\''bar'`. Double quotes allow `$`, ```, `"`, `\`, and
   * newline to be escaped with backslash. Otherwise double quotes
   * preserve things literally.
   * @param quotedString shell-quoted string
   * @returns an unquoted string
   */
  function shellUnquote(quotedString: string): string
  /**
   * Allocates a block of memory from the libc allocator.
   *
   * The block address handed out can be expected to be aligned
   * to at least `1 * sizeof (void*)`.
   *
   * Since GLib 2.76 this always uses the system malloc() implementation
   * internally.
   * @param blockSize the number of bytes to allocate
   * @returns a pointer to the allocated memory block, which will   be %NULL if and only if @mem_size is 0
   */
  function sliceAlloc(blockSize: number): any | null
  /**
   * Allocates a block of memory via g_slice_alloc() and initializes
   * the returned memory to 0.
   *
   * Since GLib 2.76 this always uses the system malloc() implementation
   * internally.
   * @param blockSize the number of bytes to allocate
   * @returns a pointer to the allocated block, which will be %NULL    if and only if @mem_size is 0
   */
  function sliceAlloc0(blockSize: number): any | null
  /**
   * Allocates a block of memory from the slice allocator
   * and copies `block_size` bytes into it from `mem_block`.
   *
   * `mem_block` must be non-%NULL if `block_size` is non-zero.
   *
   * Since GLib 2.76 this always uses the system malloc() implementation
   * internally.
   * @param blockSize the number of bytes to allocate
   * @param memBlock the memory to copy
   * @returns a pointer to the allocated memory block,    which will be %NULL if and only if @mem_size is 0
   */
  function sliceCopy(blockSize: number, memBlock: any | null): any | null
  /**
   * Frees a block of memory.
   *
   * The memory must have been allocated via g_slice_alloc() or
   * g_slice_alloc0() and the `block_size` has to match the size
   * specified upon allocation. Note that the exact release behaviour
   * can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment
   * variable.
   *
   * If `mem_block` is %NULL, this function does nothing.
   *
   * Since GLib 2.76 this always uses the system free_sized() implementation
   * internally.
   * @param blockSize the size of the block
   * @param memBlock a pointer to the block to free
   */
  function sliceFree1(blockSize: number, memBlock: any | null): void
  /**
   * Frees a linked list of memory blocks of structure type `type`.
   *
   * The memory blocks must be equal-sized, allocated via
   * g_slice_alloc() or g_slice_alloc0() and linked together by a
   * `next` pointer (similar to #GSList). The offset of the `next`
   * field in each block is passed as third argument.
   * Note that the exact release behaviour can be changed with the
   * [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable.
   *
   * If `mem_chain` is %NULL, this function does nothing.
   *
   * Since GLib 2.76 this always uses the system free_sized() implementation
   * internally.
   * @param blockSize the size of the blocks
   * @param memChain a pointer to the first block of the chain
   * @param nextOffset the offset of the `next` field in the blocks
   */
  function sliceFreeChainWithOffset(
    blockSize: number,
    memChain: any | null,
    nextOffset: number
  ): void
  function sliceGetConfig(ckey: SliceConfig): number
  function sliceGetConfigState(
    ckey: SliceConfig,
    address: number,
    nValues: number
  ): number
  function sliceSetConfig(ckey: SliceConfig, value: number): void
  function slistPopAllocator(): void
  function slistPushAllocator(allocator: Allocator): void
  /**
   * Removes the source with the given ID from the default main context. You must
   * use g_source_destroy() for sources added to a non-default main context.
   *
   * The ID of a #GSource is given by g_source_get_id(), or will be
   * returned by the functions g_source_attach(), g_idle_add(),
   * g_idle_add_full(), g_timeout_add(), g_timeout_add_full(),
   * g_child_watch_add(), g_child_watch_add_full(), g_io_add_watch(), and
   * g_io_add_watch_full().
   *
   * It is a programmer error to attempt to remove a non-existent source.
   *
   * More specifically: source IDs can be reissued after a source has been
   * destroyed and therefore it is never valid to use this function with a
   * source ID which may have already been removed.  An example is when
   * scheduling an idle to run in another thread with g_idle_add(): the
   * idle may already have run and been removed by the time this function
   * is called on its (now invalid) source ID.  This source ID may have
   * been reissued, leading to the operation being performed against the
   * wrong source.
   * @param tag the ID of the source to remove.
   * @returns %TRUE if the source was found and removed.
   */
  function sourceRemove(tag: number): boolean
  /**
   * Removes a source from the default main loop context given the
   * source functions and user data. If multiple sources exist with the
   * same source functions and user data, only one will be destroyed.
   * @param funcs The `source_funcs` passed to g_source_new()
   * @param userData the user data for the callback
   * @returns %TRUE if a source was found and removed.
   */
  function sourceRemoveByFuncsUserData(
    funcs: SourceFuncs,
    userData: any | null
  ): boolean
  /**
   * Removes a source from the default main loop context given the user
   * data for the callback. If multiple sources exist with the same user
   * data, only one will be destroyed.
   * @param userData the user_data for the callback.
   * @returns %TRUE if a source was found and removed.
   */
  function sourceRemoveByUserData(userData: any | null): boolean
  /**
   * Sets the name of a source using its ID.
   *
   * This is a convenience utility to set source names from the return
   * value of g_idle_add(), g_timeout_add(), etc.
   *
   * It is a programmer error to attempt to set the name of a non-existent
   * source.
   *
   * More specifically: source IDs can be reissued after a source has been
   * destroyed and therefore it is never valid to use this function with a
   * source ID which may have already been removed.  An example is when
   * scheduling an idle to run in another thread with g_idle_add(): the
   * idle may already have run and been removed by the time this function
   * is called on its (now invalid) source ID.  This source ID may have
   * been reissued, leading to the operation being performed against the
   * wrong source.
   * @param tag a #GSource ID
   * @param name debug name for the source
   */
  function sourceSetNameById(tag: number, name: string): void
  /**
   * Gets the smallest prime number from a built-in array of primes which
   * is larger than `num`. This is used within GLib to calculate the optimum
   * size of a #GHashTable.
   *
   * The built-in array of primes ranges from 11 to 13845163 such that
   * each prime is approximately 1.5-2 times the previous prime.
   * @param num a #guint
   * @returns the smallest prime number from a built-in array of primes     which is larger than @num
   */
  function spacedPrimesClosest(num: number): number
  /**
   * Executes a child program asynchronously.
   *
   * See g_spawn_async_with_pipes() for a full description; this function
   * simply calls the g_spawn_async_with_pipes() without any pipes.
   *
   * You should call g_spawn_close_pid() on the returned child process
   * reference when you don't need it any more.
   *
   * If you are writing a GTK application, and the program you are spawning is a
   * graphical application too, then to ensure that the spawned program opens its
   * windows on the right screen, you may want to use #GdkAppLaunchContext,
   * #GAppLaunchContext, or set the %DISPLAY environment variable.
   *
   * Note that the returned `child_pid` on Windows is a handle to the child
   * process and not its identifier. Process handles and process identifiers
   * are different concepts on Windows.
   * @param workingDirectory child's current working     directory, or %NULL to inherit parent's
   * @param argv child's argument vector
   * @param envp child's environment, or %NULL to inherit parent's
   * @param flags flags from #GSpawnFlags
   * @param childSetup function to run     in the child just before `exec()`
   * @returns %TRUE on success, %FALSE if error is set
   */
  function spawnAsync(
    workingDirectory: string | null,
    argv: string[],
    envp: string[] | null,
    flags: SpawnFlags,
    childSetup: SpawnChildSetupFunc | null
  ): [/* returnType */ boolean, /* childPid */ Pid]
  /**
   * Executes a child program asynchronously.
   *
   * Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
   * so no FD assignments are used.
   * @param workingDirectory child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding
   * @param argv child's argument vector, in the GLib file name encoding;   it must be non-empty and %NULL-terminated
   * @param envp child's environment, or %NULL to inherit parent's, in the GLib file name encoding
   * @param flags flags from #GSpawnFlags
   * @param childSetup function to run   in the child just before `exec()`
   * @param stdinFd file descriptor to use for child's stdin, or `-1`
   * @param stdoutFd file descriptor to use for child's stdout, or `-1`
   * @param stderrFd file descriptor to use for child's stderr, or `-1`
   * @returns %TRUE on success, %FALSE if an error was set
   */
  function spawnAsyncWithFds(
    workingDirectory: string | null,
    argv: string[],
    envp: string[] | null,
    flags: SpawnFlags,
    childSetup: SpawnChildSetupFunc | null,
    stdinFd: number,
    stdoutFd: number,
    stderrFd: number
  ): [/* returnType */ boolean, /* childPid */ Pid]
  /**
   * Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
   * so no FD assignments are used.
   * @param workingDirectory child's current working     directory, or %NULL to inherit parent's, in the GLib file name encoding
   * @param argv child's argument     vector, in the GLib file name encoding; it must be non-empty and %NULL-terminated
   * @param envp child's environment, or %NULL to inherit parent's, in the GLib file     name encoding
   * @param flags flags from #GSpawnFlags
   * @param childSetup function to run     in the child just before `exec()`
   * @returns %TRUE on success, %FALSE if an error was set
   */
  function spawnAsyncWithPipes(
    workingDirectory: string | null,
    argv: string[],
    envp: string[] | null,
    flags: SpawnFlags,
    childSetup: SpawnChildSetupFunc | null
  ): [
    /* returnType */ boolean,
    /* childPid */ Pid,
    /* standardInput */ number,
    /* standardOutput */ number,
    /* standardError */ number,
  ]
  /**
   * Executes a child program asynchronously (your program will not
   * block waiting for the child to exit).
   *
   * The child program is specified by the only argument that must be
   * provided, `argv`. `argv` should be a %NULL-terminated array of strings,
   * to be passed as the argument vector for the child. The first string
   * in `argv` is of course the name of the program to execute. By default,
   * the name of the program must be a full path. If `flags` contains the
   * %G_SPAWN_SEARCH_PATH flag, the `PATH` environment variable is used to
   * search for the executable. If `flags` contains the
   * %G_SPAWN_SEARCH_PATH_FROM_ENVP flag, the `PATH` variable from `envp`
   * is used to search for the executable. If both the
   * %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP flags are
   * set, the `PATH` variable from `envp` takes precedence over the
   * environment variable.
   *
   * If the program name is not a full path and %G_SPAWN_SEARCH_PATH flag
   * is not used, then the program will be run from the current directory
   * (or `working_directory,` if specified); this might be unexpected or even
   * dangerous in some cases when the current directory is world-writable.
   *
   * On Windows, note that all the string or string vector arguments to
   * this function and the other `g_spawn*()` functions are in UTF-8, the
   * GLib file name encoding. Unicode characters that are not part of
   * the system codepage passed in these arguments will be correctly
   * available in the spawned program only if it uses wide character API
   * to retrieve its command line. For C programs built with Microsoft's
   * tools it is enough to make the program have a `wmain()` instead of
   * `main()`. `wmain()` has a wide character argument vector as parameter.
   *
   * At least currently, mingw doesn't support `wmain()`, so if you use
   * mingw to develop the spawned program, it should call
   * g_win32_get_command_line() to get arguments in UTF-8.
   *
   * On Windows the low-level child process creation API `CreateProcess()`
   * doesn't use argument vectors, but a command line. The C runtime
   * library's `spawn*()` family of functions (which g_spawn_async_with_pipes()
   * eventually calls) paste the argument vector elements together into
   * a command line, and the C runtime startup code does a corresponding
   * reconstruction of an argument vector from the command line, to be
   * passed to `main()`. Complications arise when you have argument vector
   * elements that contain spaces or double quotes. The `spawn*()` functions
   * don't do any quoting or escaping, but on the other hand the startup
   * code does do unquoting and unescaping in order to enable receiving
   * arguments with embedded spaces or double quotes. To work around this
   * asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on
   * argument vector elements that need it before calling the C runtime
   * `spawn()` function.
   *
   * The returned `child_pid` on Windows is a handle to the child
   * process, not its identifier. Process handles and process
   * identifiers are different concepts on Windows.
   *
   * `envp` is a %NULL-terminated array of strings, where each string
   * has the form `KEY=VALUE`. This will become the child's environment.
   * If `envp` is %NULL, the child inherits its parent's environment.
   *
   * `flags` should be the bitwise OR of any flags you want to affect the
   * function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that the
   * child will not automatically be reaped; you must use a child watch
   * (g_child_watch_add()) to be notified about the death of the child process,
   * otherwise it will stay around as a zombie process until this process exits.
   * Eventually you must call g_spawn_close_pid() on the `child_pid,` in order to
   * free resources which may be associated with the child process. (On Unix,
   * using a child watch is equivalent to calling waitpid() or handling
   * the `SIGCHLD` signal manually. On Windows, calling g_spawn_close_pid()
   * is equivalent to calling `CloseHandle()` on the process handle returned
   * in `child_pid)`. See g_child_watch_add().
   *
   * Open UNIX file descriptors marked as `FD_CLOEXEC` will be automatically
   * closed in the child process. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that
   * other open file descriptors will be inherited by the child; otherwise all
   * descriptors except stdin/stdout/stderr will be closed before calling `exec()`
   * in the child. %G_SPAWN_SEARCH_PATH means that `argv[`0] need not be an
   * absolute path, it will be looked for in the `PATH` environment
   * variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an
   * absolute path, it will be looked for in the `PATH` variable from
   * `envp`. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP
   * are used, the value from `envp` takes precedence over the environment.
   *
   * %G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's
   * standard input (by default, the child's standard input is attached to
   * `/dev/null`). %G_SPAWN_STDIN_FROM_DEV_NULL explicitly imposes the default
   * behavior. Both flags cannot be enabled at the same time and, in both cases,
   * the `stdin_pipe_out` argument is ignored.
   *
   * %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output
   * will be discarded (by default, it goes to the same location as the parent's
   * standard output). %G_SPAWN_CHILD_INHERITS_STDOUT explicitly imposes the
   * default behavior. Both flags cannot be enabled at the same time and, in
   * both cases, the `stdout_pipe_out` argument is ignored.
   *
   * %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error
   * will be discarded (by default, it goes to the same location as the parent's
   * standard error). %G_SPAWN_CHILD_INHERITS_STDERR explicitly imposes the
   * default behavior. Both flags cannot be enabled at the same time and, in
   * both cases, the `stderr_pipe_out` argument is ignored.
   *
   * It is valid to pass the same FD in multiple parameters (e.g. you can pass
   * a single FD for both `stdout_fd` and `stderr_fd,` and include it in
   * `source_fds` too).
   *
   * `source_fds` and `target_fds` allow zero or more FDs from this process to be
   * remapped to different FDs in the spawned process. If `n_fds` is greater than
   * zero, `source_fds` and `target_fds` must both be non-%NULL and the same length.
   * Each FD in `source_fds` is remapped to the FD number at the same index in
   * `target_fds`. The source and target FD may be equal to simply propagate an FD
   * to the spawned process. FD remappings are processed after standard FDs, so
   * any target FDs which equal `stdin_fd,` `stdout_fd` or `stderr_fd` will overwrite
   * them in the spawned process.
   *
   * `source_fds` is supported on Windows since 2.72.
   *
   * %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of `argv` is
   * the file to execute, while the remaining elements are the actual
   * argument vector to pass to the file. Normally g_spawn_async_with_pipes()
   * uses `argv[`0] as the file to execute, and passes all of `argv` to the child.
   *
   * `child_setup` and `user_data` are a function and user data. On POSIX
   * platforms, the function is called in the child after GLib has
   * performed all the setup it plans to perform (including creating
   * pipes, closing file descriptors, etc.) but before calling `exec()`.
   * That is, `child_setup` is called just before calling `exec()` in the
   * child. Obviously actions taken in this function will only affect
   * the child, not the parent.
   *
   * On Windows, there is no separate `fork()` and `exec()` functionality.
   * Child processes are created and run with a single API call,
   * `CreateProcess()`. There is no sensible thing `child_setup`
   * could be used for on Windows so it is ignored and not called.
   *
   * If non-%NULL, `child_pid` will on Unix be filled with the child's
   * process ID. You can use the process ID to send signals to the child,
   * or to use g_child_watch_add() (or `waitpid()`) if you specified the
   * %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, `child_pid` will be
   * filled with a handle to the child process only if you specified the
   * %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child
   * process using the Win32 API, for example wait for its termination
   * with the `WaitFor*()` functions, or examine its exit code with
   * `GetExitCodeProcess()`. You should close the handle with `CloseHandle()`
   * or g_spawn_close_pid() when you no longer need it.
   *
   * If non-%NULL, the `stdin_pipe_out,` `stdout_pipe_out,` `stderr_pipe_out`
   * locations will be filled with file descriptors for writing to the child's
   * standard input or reading from its standard output or standard error.
   * The caller of g_spawn_async_with_pipes() must close these file descriptors
   * when they are no longer in use. If these parameters are %NULL, the
   * corresponding pipe won't be created.
   *
   * If `stdin_pipe_out` is %NULL, the child's standard input is attached to
   * `/dev/null` unless %G_SPAWN_CHILD_INHERITS_STDIN is set.
   *
   * If `stderr_pipe_out` is NULL, the child's standard error goes to the same
   * location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL
   * is set.
   *
   * If `stdout_pipe_out` is NULL, the child's standard output goes to the same
   * location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL
   * is set.
   *
   * `error` can be %NULL to ignore errors, or non-%NULL to report errors.
   * If an error is set, the function returns %FALSE. Errors are reported
   * even if they occur in the child (for example if the executable in
   * ``argv[`0]` is not found). Typically the `message` field of returned
   * errors should be displayed to users. Possible errors are those from
   * the %G_SPAWN_ERROR domain.
   *
   * If an error occurs, `child_pid,` `stdin_pipe_out,` `stdout_pipe_out,`
   * and `stderr_pipe_out` will not be filled with valid values.
   *
   * If `child_pid` is not %NULL and an error does not occur then the returned
   * process reference must be closed using g_spawn_close_pid().
   *
   * On modern UNIX platforms, GLib can use an efficient process launching
   * codepath driven internally by `posix_spawn()`. This has the advantage of
   * avoiding the fork-time performance costs of cloning the parent process
   * address space, and avoiding associated memory overcommit checks that are
   * not relevant in the context of immediately executing a distinct process.
   * This optimized codepath will be used provided that the following conditions
   * are met:
   *
   * 1. %G_SPAWN_DO_NOT_REAP_CHILD is set
   * 2. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN is set
   * 3. %G_SPAWN_SEARCH_PATH_FROM_ENVP is not set
   * 4. `working_directory` is %NULL
   * 5. `child_setup` is %NULL
   * 6. The program is of a recognised binary format, or has a shebang.
   *    Otherwise, GLib will have to execute the program through the
   *    shell, which is not done using the optimized codepath.
   *
   * If you are writing a GTK application, and the program you are spawning is a
   * graphical application too, then to ensure that the spawned program opens its
   * windows on the right screen, you may want to use #GdkAppLaunchContext,
   * #GAppLaunchContext, or set the `DISPLAY` environment variable.
   * @param workingDirectory child's current working     directory, or %NULL to inherit parent's, in the GLib file name encoding
   * @param argv child's argument     vector, in the GLib file name encoding; it must be non-empty and %NULL-terminated
   * @param envp child's environment, or %NULL to inherit parent's, in the GLib file     name encoding
   * @param flags flags from #GSpawnFlags
   * @param childSetup function to run     in the child just before `exec()`
   * @param stdinFd file descriptor to use for child's stdin, or `-1`
   * @param stdoutFd file descriptor to use for child's stdout, or `-1`
   * @param stderrFd file descriptor to use for child's stderr, or `-1`
   * @param sourceFds array of FDs from the parent    process to make available in the child process
   * @param targetFds array of FDs to remap    `source_fds` to in the child process
   * @returns %TRUE on success, %FALSE if an error was set
   */
  function spawnAsyncWithPipesAndFds(
    workingDirectory: string | null,
    argv: string[],
    envp: string[] | null,
    flags: SpawnFlags,
    childSetup: SpawnChildSetupFunc | null,
    stdinFd: number,
    stdoutFd: number,
    stderrFd: number,
    sourceFds: number[] | null,
    targetFds: number[] | null
  ): [
    /* returnType */ boolean,
    /* childPidOut */ Pid,
    /* stdinPipeOut */ number,
    /* stdoutPipeOut */ number,
    /* stderrPipeOut */ number,
  ]
  /**
   * An old name for g_spawn_check_wait_status(), deprecated because its
   * name is misleading.
   *
   * Despite the name of the function, `wait_status` must be the wait status
   * as returned by g_spawn_sync(), g_subprocess_get_status(), `waitpid()`,
   * etc. On Unix platforms, it is incorrect for it to be the exit status
   * as passed to `exit()` or returned by g_subprocess_get_exit_status() or
   * `WEXITSTATUS()`.
   * @param waitStatus A status as returned from g_spawn_sync()
   * @returns %TRUE if child exited successfully, %FALSE otherwise (and     @error will be set)
   */
  function spawnCheckExitStatus(waitStatus: number): boolean
  /**
   * Set `error` if `wait_status` indicates the child exited abnormally
   * (e.g. with a nonzero exit code, or via a fatal signal).
   *
   * The g_spawn_sync() and g_child_watch_add() family of APIs return the
   * status of subprocesses encoded in a platform-specific way.
   * On Unix, this is guaranteed to be in the same format waitpid() returns,
   * and on Windows it is guaranteed to be the result of GetExitCodeProcess().
   *
   * Prior to the introduction of this function in GLib 2.34, interpreting
   * `wait_status` required use of platform-specific APIs, which is problematic
   * for software using GLib as a cross-platform layer.
   *
   * Additionally, many programs simply want to determine whether or not
   * the child exited successfully, and either propagate a #GError or
   * print a message to standard error. In that common case, this function
   * can be used. Note that the error message in `error` will contain
   * human-readable information about the wait status.
   *
   * The `domain` and `code` of `error` have special semantics in the case
   * where the process has an "exit code", as opposed to being killed by
   * a signal. On Unix, this happens if WIFEXITED() would be true of
   * `wait_status`. On Windows, it is always the case.
   *
   * The special semantics are that the actual exit code will be the
   * code set in `error,` and the domain will be %G_SPAWN_EXIT_ERROR.
   * This allows you to differentiate between different exit codes.
   *
   * If the process was terminated by some means other than an exit
   * status (for example if it was killed by a signal), the domain will be
   * %G_SPAWN_ERROR and the code will be %G_SPAWN_ERROR_FAILED.
   *
   * This function just offers convenience; you can of course also check
   * the available platform via a macro such as %G_OS_UNIX, and use
   * WIFEXITED() and WEXITSTATUS() on `wait_status` directly. Do not attempt
   * to scan or parse the error message string; it may be translated and/or
   * change in future versions of GLib.
   *
   * Prior to version 2.70, g_spawn_check_exit_status() provides the same
   * functionality, although under a misleading name.
   * @param waitStatus A platform-specific wait status as returned from g_spawn_sync()
   * @returns %TRUE if child exited successfully, %FALSE otherwise (and   @error will be set)
   */
  function spawnCheckWaitStatus(waitStatus: number): boolean
  /**
   * On some platforms, notably Windows, the #GPid type represents a resource
   * which must be closed to prevent resource leaking. g_spawn_close_pid()
   * is provided for this purpose. It should be used on all platforms, even
   * though it doesn't do anything under UNIX.
   * @param pid The process reference to close
   */
  function spawnClosePid(pid: Pid): void
  /**
   * A simple version of g_spawn_async() that parses a command line with
   * g_shell_parse_argv() and passes it to g_spawn_async().
   *
   * Runs a command line in the background. Unlike g_spawn_async(), the
   * %G_SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note
   * that %G_SPAWN_SEARCH_PATH can have security implications, so
   * consider using g_spawn_async() directly if appropriate. Possible
   * errors are those from g_shell_parse_argv() and g_spawn_async().
   *
   * The same concerns on Windows apply as for g_spawn_command_line_sync().
   * @param commandLine a command line
   * @returns %TRUE on success, %FALSE if error is set
   */
  function spawnCommandLineAsync(commandLine: string): boolean
  /**
   * A simple version of g_spawn_sync() with little-used parameters
   * removed, taking a command line instead of an argument vector.
   *
   * See g_spawn_sync() for full details.
   *
   * The `command_line` argument will be parsed by g_shell_parse_argv().
   *
   * Unlike g_spawn_sync(), the %G_SPAWN_SEARCH_PATH flag is enabled.
   * Note that %G_SPAWN_SEARCH_PATH can have security implications, so
   * consider using g_spawn_sync() directly if appropriate.
   *
   * Possible errors are those from g_spawn_sync() and those
   * from g_shell_parse_argv().
   *
   * If `wait_status` is non-%NULL, the platform-specific status of
   * the child is stored there; see the documentation of
   * g_spawn_check_wait_status() for how to use and interpret this.
   * On Unix platforms, note that it is usually not equal
   * to the integer passed to `exit()` or returned from `main()`.
   *
   * On Windows, please note the implications of g_shell_parse_argv()
   * parsing `command_line`. Parsing is done according to Unix shell rules, not
   * Windows command interpreter rules.
   * Space is a separator, and backslashes are
   * special. Thus you cannot simply pass a `command_line` containing
   * canonical Windows paths, like "c:\\program files\\app\\app.exe", as
   * the backslashes will be eaten, and the space will act as a
   * separator. You need to enclose such paths with single quotes, like
   * "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".
   * @param commandLine a command line
   * @returns %TRUE on success, %FALSE if an error was set
   */
  function spawnCommandLineSync(
    commandLine: string
  ): [
    /* returnType */ boolean,
    /* standardOutput */ number[],
    /* standardError */ number[],
    /* waitStatus */ number,
  ]
  function spawnErrorQuark(): Quark
  function spawnExitErrorQuark(): Quark
  /**
   * Executes a child synchronously (waits for the child to exit before returning).
   *
   * All output from the child is stored in `standard_output` and `standard_error,`
   * if those parameters are non-%NULL. Note that you must set the
   * %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when
   * passing %NULL for `standard_output` and `standard_error`.
   *
   * If `wait_status` is non-%NULL, the platform-specific status of
   * the child is stored there; see the documentation of
   * g_spawn_check_wait_status() for how to use and interpret this.
   * On Unix platforms, note that it is usually not equal
   * to the integer passed to `exit()` or returned from `main()`.
   *
   * Note that it is invalid to pass %G_SPAWN_DO_NOT_REAP_CHILD in
   * `flags,` and on POSIX platforms, the same restrictions as for
   * g_child_watch_source_new() apply.
   *
   * If an error occurs, no data is returned in `standard_output,`
   * `standard_error,` or `wait_status`.
   *
   * This function calls g_spawn_async_with_pipes() internally; see that
   * function for full details on the other parameters and details on
   * how these functions work on Windows.
   * @param workingDirectory child's current working     directory, or %NULL to inherit parent's
   * @param argv child's argument vector, which must be non-empty and %NULL-terminated
   * @param envp child's environment, or %NULL to inherit parent's
   * @param flags flags from #GSpawnFlags
   * @param childSetup function to run     in the child just before `exec()`
   * @returns %TRUE on success, %FALSE if an error was set
   */
  function spawnSync(
    workingDirectory: string | null,
    argv: string[],
    envp: string[] | null,
    flags: SpawnFlags,
    childSetup: SpawnChildSetupFunc | null
  ): [
    /* returnType */ boolean,
    /* standardOutput */ number[],
    /* standardError */ number[],
    /* waitStatus */ number,
  ]
  /**
   * A wrapper for the POSIX stat() function. The stat() function
   * returns information about a file. On Windows the stat() function in
   * the C library checks only the FAT-style READONLY attribute and does
   * not look at the ACL at all. Thus on Windows the protection bits in
   * the `st_mode` field are a fabrication of little use.
   *
   * On Windows the Microsoft C libraries have several variants of the
   * stat struct and stat() function with names like _stat(), _stat32(),
   * _stat32i64() and _stat64i32(). The one used here is for 32-bit code
   * the one with 32-bit size and time fields, specifically called _stat32().
   *
   * In Microsoft's compiler, by default struct stat means one with
   * 64-bit time fields while in MinGW struct stat is the legacy one
   * with 32-bit fields. To hopefully clear up this messs, the gstdio.h
   * header defines a type #GStatBuf which is the appropriate struct type
   * depending on the platform and/or compiler being used. On POSIX it
   * is just struct stat, but note that even on POSIX platforms, stat()
   * might be a macro.
   *
   * See your C library manual for more details about stat().
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param buf a pointer to a stat struct, which will be filled with the file     information
   * @returns 0 if the information was successfully retrieved,     -1 if an error occurred
   */
  function stat(filename: string, buf: StatBuf): number
  /**
   * Copies a nul-terminated string into the destination buffer, including
   * the trailing nul byte, and returns a pointer to the trailing nul byte
   * in `dest`.  The return value is useful for concatenating multiple
   * strings without having to repeatedly scan for the end.
   * @param dest destination buffer
   * @param src source string
   * @returns a pointer to the trailing nul byte in `dest`
   */
  function stpcpy(dest: string | null, src: string): string | null
  /**
   * Compares two strings for byte-by-byte equality and returns %TRUE
   * if they are equal. It can be passed to g_hash_table_new() as the
   * `key_equal_func` parameter, when using non-%NULL strings as keys in a
   * #GHashTable.
   *
   * This function is typically used for hash table comparisons, but can be used
   * for general purpose comparisons of non-%NULL strings. For a %NULL-safe string
   * comparison function, see g_strcmp0().
   * @param v1 a key
   * @param v2 a key to compare with `v1`
   * @returns %TRUE if the two keys match
   */
  function strEqual(v1: any, v2: any): boolean
  /**
   * Looks whether the string `str` begins with `prefix`.
   * @param str a string to look in
   * @param prefix the prefix to look for
   * @returns true if @str begins with @prefix, false otherwise
   */
  function strHasPrefix(str: string, prefix: string): boolean
  /**
   * Looks whether a string ends with `suffix`.
   * @param str a string to look in
   * @param suffix the suffix to look for
   * @returns true if @str ends with @suffix, false otherwise
   */
  function strHasSuffix(str: string, suffix: string): boolean
  /**
   * Converts a string to a hash value.
   *
   * This function implements the widely used "djb" hash apparently
   * posted by Daniel Bernstein to comp.lang.c some time ago.  The 32
   * bit unsigned hash value starts at 5381 and for each byte 'c' in
   * the string, is updated: `hash = hash * 33 + c`. This function
   * uses the signed value of each byte.
   *
   * It can be passed to g_hash_table_new() as the `hash_func` parameter,
   * when using non-%NULL strings as keys in a #GHashTable.
   *
   * Note that this function may not be a perfect fit for all use cases.
   * For example, it produces some hash collisions with strings as short
   * as 2.
   * @param v a string key
   * @returns a hash value corresponding to the key
   */
  function strHash(v: any): number
  /**
   * Determines if a string is pure ASCII. A string is pure ASCII if it
   * contains no bytes with the high bit set.
   * @param str a string
   * @returns true if @str is ASCII
   */
  function strIsAscii(str: string): boolean
  /**
   * Checks if a search conducted for `search_term` should match
   * `potential_hit`.
   *
   * This function calls [func`GLib`.str_tokenize_and_fold] on both
   * `search_term` and `potential_hit`. ASCII alternates are never taken
   * for `search_term` but will be taken for `potential_hit` according to
   * the value of `accept_alternates`.
   *
   * A hit occurs when each folded token in `search_term` is a prefix of a
   * folded token from `potential_hit`.
   *
   * Depending on how you're performing the search, it will typically be
   * faster to call `g_str_tokenize_and_fold()` on each string in
   * your corpus and build an index on the returned folded tokens, then
   * call `g_str_tokenize_and_fold()` on the search term and
   * perform lookups into that index.
   *
   * As some examples, searching for ‘fred’ would match the potential hit
   * ‘Smith, Fred’ and also ‘Frédéric’.  Searching for ‘Fréd’ would match
   * ‘Frédéric’ but not ‘Frederic’ (due to the one-directional nature of
   * accent matching).  Searching ‘fo’ would match ‘Foo’ and ‘Bar Foo
   * Baz’, but not ‘SFO’ (because no word has ‘fo’ as a prefix).
   * @param searchTerm the search term from the user
   * @param potentialHit the text that may be a hit
   * @param acceptAlternates if true, ASCII alternates are accepted
   * @returns true if @potential_hit is a hit
   */
  function strMatchString(
    searchTerm: string,
    potentialHit: string,
    acceptAlternates: boolean
  ): boolean
  /**
   * Transliterate `str` to plain ASCII.
   *
   * For best results, `str` should be in composed normalised form.
   *
   * This function performs a reasonably good set of character
   * replacements.  The particular set of replacements that is done may
   * change by version or even by runtime environment.
   *
   * If the source language of `str` is known, it can used to improve the
   * accuracy of the translation by passing it as `from_locale`.  It should
   * be a valid POSIX locale string (of the form
   * `language[_territory][.codeset][`modifier]``).
   *
   * If `from_locale` is %NULL then the current locale is used.
   *
   * If you want to do translation for no specific locale, and you want it
   * to be done independently of the currently locale, specify `"C"` for
   * `from_locale`.
   * @param str a string, in UTF-8
   * @param fromLocale the source locale, if known
   * @returns a string in plain ASCII
   */
  function strToAscii(str: string, fromLocale: string | null): string | null
  /**
   * Tokenizes `string` and performs folding on each token.
   *
   * A token is a non-empty sequence of alphanumeric characters in the
   * source string, separated by non-alphanumeric characters.  An
   * "alphanumeric" character for this purpose is one that matches
   * [func`GLib`.unichar_isalnum] or [func`GLib`.unichar_ismark].
   *
   * Each token is then (Unicode) normalised and case-folded.  If
   * `ascii_alternates` is non-`NULL` and some of the returned tokens
   * contain non-ASCII characters, ASCII alternatives will be generated.
   *
   * The number of ASCII alternatives that are generated and the method
   * for doing so is unspecified, but `translit_locale` (if specified) may
   * improve the transliteration if the language of the source string is
   * known.
   * @param string a string to tokenize
   * @param translitLocale the language code (like 'de' or   'en_GB') from which `string` originates
   * @returns the folded tokens
   */
  function strTokenizeAndFold(
    string: string,
    translitLocale: string | null
  ): [/* returnType */ string[], /* asciiAlternates */ string[]]
  /**
   * For each character in `string,` if the character is not in `valid_chars,`
   * replaces the character with `substitutor`.
   *
   * Modifies `string` in place, and return `string` itself, not a copy. The
   * return value is to allow nesting such as:
   * ```C
   * g_ascii_strup (g_strcanon (str, "abc", '?'))
   * ```
   *
   * In order to modify a copy, you may use [func`GLib`.strdup]:
   * ```C
   * reformatted = g_strcanon (g_strdup (const_str), "abc", '?');
   * …
   * g_free (reformatted);
   * ```
   * @param string a nul-terminated array of bytes
   * @param validChars bytes permitted in `string`
   * @param substitutor replacement character for disallowed bytes
   * @returns the modified @string
   */
  function strcanon(
    string: string | null,
    validChars: string,
    substitutor: number
  ): string | null
  /**
   * A case-insensitive string comparison, corresponding to the standard
   * `strcasecmp()` function on platforms which support it.
   * @param s1 string to compare with `s2`
   * @param s2 string to compare with `s1`
   * @returns 0 if the strings match, a negative value if @s1 < @s2,   or a positive value if @s1 > @s2
   */
  function strcasecmp(s1: string, s2: string): number
  /**
   * Removes trailing whitespace from a string.
   *
   * This function doesn't allocate or reallocate any memory;
   * it modifies `string` in place. Therefore, it cannot be used
   * on statically allocated strings.
   *
   * The pointer to `string` is returned to allow the nesting of functions.
   *
   * Also see [func`GLib`.strchug] and [func`GLib`.strstrip].
   * @param string a string to remove the trailing whitespace from
   * @returns the modified @string
   */
  function strchomp(string: string | null): string | null
  /**
   * Removes leading whitespace from a string, by moving the rest
   * of the characters forward.
   *
   * This function doesn't allocate or reallocate any memory;
   * it modifies `string` in place. Therefore, it cannot be used on
   * statically allocated strings.
   *
   * The pointer to `string` is returned to allow the nesting of functions.
   *
   * Also see [func`GLib`.strchomp] and [func`GLib`.strstrip].
   * @param string a string to remove the leading whitespace from
   * @returns the modified @string
   */
  function strchug(string: string | null): string | null
  /**
   * Compares `str1` and `str2` like strcmp(). Handles %NULL
   * gracefully by sorting it before non-%NULL strings.
   * Comparing two %NULL pointers returns 0.
   * @param str1 a C string or %NULL
   * @param str2 another C string or %NULL
   * @returns an integer less than, equal to, or greater than zero, if @str1 is <, == or > than @str2.
   */
  function strcmp0(str1: string | null, str2: string | null): number
  /**
   * Replaces all escaped characters with their one byte equivalent.
   *
   * This function does the reverse conversion of [func`GLib`.strescape].
   * @param source a string to compress
   * @returns a newly-allocated copy of @source with all escaped   character compressed
   */
  function strcompress(source: string): string | null
  /**
   * Converts any delimiter characters in `string` to `new_delimiter`.
   *
   * Any characters in `string` which are found in `delimiters` are
   * changed to the `new_delimiter` character. Modifies `string` in place,
   * and returns `string` itself, not a copy.
   *
   * The return value is to allow nesting such as:
   * ```C
   * g_ascii_strup (g_strdelimit (str, "abc", '?'))
   * ```
   *
   * In order to modify a copy, you may use [func`GLib`.strdup]:
   * ```C
   * reformatted = g_strdelimit (g_strdup (const_str), "abc", '?');
   * …
   * g_free (reformatted);
   * ```
   * @param string the string to convert
   * @param delimiters a string containing the current delimiters, or   `NULL` to use the standard delimiters defined in [const`GLib`.STR_DELIMITERS]
   * @param newDelimiter the new delimiter character
   * @returns the modified @string
   */
  function strdelimit(
    string: string | null,
    delimiters: string | null,
    newDelimiter: number
  ): string | null
  /**
   * Converts a string to lower case.
   * @param string the string to convert
   * @returns the string
   */
  function strdown(string: string | null): string | null
  /**
   * Duplicates a string. If `str` is `NULL` it returns `NULL`.
   * @param str the string to duplicate
   * @returns a newly-allocated copy of @str
   */
  function strdup(str: string | null): string | null
  /**
   * Copies an array of strings. The copy is a deep copy; each string is also
   * copied.
   *
   * If called on a `NULL` value, `g_strdupv()` simply returns `NULL`.
   * @param strArray an array of strings to copy
   * @returns a   newly-allocated array of strings. Use [func@GLib.strfreev] to free it.
   */
  function strdupv(strArray: string[] | null): string[] | null
  /**
   * Returns a string corresponding to the given error code, e.g. "no
   * such process".
   *
   * Unlike `strerror()`, this always returns a string in
   * UTF-8 encoding, and the pointer is guaranteed to remain valid for
   * the lifetime of the process. If the error code is unknown, it returns a
   * string like “Unknown error <code\>”.
   *
   * Note that the string may be translated according to the current locale.
   *
   * The value of `errno` will not be changed by this function. However, it may
   * be changed by intermediate function calls, so you should save its value
   * as soon as the call returns:
   * ```C
   * int saved_errno;
   *
   * ret = read (blah);
   * saved_errno = errno;
   *
   * g_strerror (saved_errno);
   * ```
   * @param errnum the system error number. See the standard C `errno` documentation
   * @returns the string describing the error code
   */
  function strerror(errnum: number): string
  /**
   * Escapes the special characters '\b', '\f', '\n', '\r', '\t', '\v', '\'
   * and '"' in the string `source` by inserting a '\' before
   * them. Additionally all characters in the range 0x01-0x1F (everything
   * below SPACE) and in the range 0x7F-0xFF (all non-ASCII chars) are
   * replaced with a '\' followed by their octal representation.
   * Characters supplied in `exceptions` are not escaped.
   *
   * [func`GLib`.strcompress] does the reverse conversion.
   * @param source a string to escape
   * @param exceptions a string of characters not to escape in `source`
   * @returns a newly-allocated copy of @source with special characters escaped
   */
  function strescape(source: string, exceptions: string | null): string | null
  /**
   * Frees an array of strings, as well as each string it contains.
   *
   * If `str_array` is `NULL`, this function simply returns.
   * @param strArray an   array of strings to free
   */
  function strfreev(strArray: string[] | null): void
  /**
   * An auxiliary function for gettext() support (see Q_()).
   * @param msgid a string
   * @param msgval another string
   * @returns @msgval, unless @msgval is identical to @msgid     and contains a '|' character, in which case a pointer to     the substring of msgid after the first '|' character is returned.
   */
  function stripContext(msgid: string, msgval: string): string
  /**
   * Joins an array of strings together to form one long string, with the
   * optional `separator` inserted between each of them.
   *
   * If `str_array` has no items, the return value will be an
   * empty string. If `str_array` contains a single item, `separator` will not
   * appear in the resulting string.
   * @param separator a string to insert between each of the strings
   * @param strArray an array of strings to join
   * @returns a newly-allocated string containing all of the strings joined   together, with @separator between them
   */
  function strjoinv(separator: string | null, strArray: string[]): string | null
  /**
   * Portability wrapper that calls `strlcat()` on systems which have it,
   * and emulates it otherwise. Appends nul-terminated `src` string to `dest,`
   * guaranteeing nul-termination for `dest`. The total size of `dest` won't
   * exceed `dest_size`.
   *
   * At most `dest_size` - 1 characters will be copied. Unlike `strncat()`,
   * `dest_size` is the full size of dest, not the space left over. This
   * function does not allocate memory. It always nul-terminates (unless
   * `dest_size` == 0 or there were no nul characters in the `dest_size`
   * characters of dest to start with).
   *
   * Caveat: this is supposedly a more secure alternative to `strcat()` or
   * `strncat()`, but for real security [func`GLib`.strconcat] is harder to mess up.
   * @param dest destination buffer, already containing one nul-terminated string
   * @param src source buffer
   * @param destSize length of `dest` buffer in bytes (not length of existing string   inside `dest)`
   * @returns size of attempted result, which is `MIN (dest_size, strlen   (original dest)) + strlen (src)`, so if @retval >= @dest_size,   truncation occurred
   */
  function strlcat(dest: string | null, src: string, destSize: number): number
  /**
   * Portability wrapper that calls `strlcpy()` on systems which have it,
   * and emulates `strlcpy()` otherwise. Copies `src` to `dest;` `dest` is
   * guaranteed to be nul-terminated; `src` must be nul-terminated;
   * `dest_size` is the buffer size, not the number of bytes to copy.
   *
   * At most `dest_size` - 1 characters will be copied. Always nul-terminates
   * (unless `dest_size` is 0). This function does not allocate memory. Unlike
   * `strncpy()`, this function doesn't pad `dest` (so it's often faster). It
   * returns the size of the attempted result, `strlen (src)`, so if
   * `retval` >= `dest_size,` truncation occurred.
   *
   * Caveat: `strlcpy()` is supposedly more secure than `strcpy()` or `strncpy()`,
   * but if you really want to avoid screwups, [func`GLib`.strdup] is an even better
   * idea.
   * @param dest destination buffer
   * @param src source buffer
   * @param destSize length of `dest` in bytes
   * @returns length of @src
   */
  function strlcpy(dest: string | null, src: string, destSize: number): number
  /**
   * A case-insensitive string comparison, corresponding to the standard
   * `strncasecmp()` function on platforms which support it. It is similar
   * to [func`GLib`.strcasecmp] except it only compares the first `n` characters of
   * the strings.
   * @param s1 string to compare with `s2`
   * @param s2 string to compare with `s1`
   * @param n the maximum number of characters to compare
   * @returns 0 if the strings match, a negative value if @s1 < @s2,   or a positive value if @s1 > @s2
   */
  function strncasecmp(s1: string, s2: string, n: number): number
  /**
   * Duplicates the first `n` bytes of a string, returning a newly-allocated
   * buffer `n` + 1 bytes long which will always be nul-terminated. If `str`
   * is less than `n` bytes long the buffer is padded with nuls. If `str` is
   * `NULL` it returns `NULL`.
   *
   * To copy a number of characters from a UTF-8 encoded string,
   * use [func`GLib`.utf8_strncpy] instead.
   * @param str the string to duplicate
   * @param n the maximum number of bytes to copy from `str`
   * @returns a newly-allocated buffer containing the first    @n bytes of @str
   */
  function strndup(str: string | null, n: number): string | null
  /**
   * Creates a new string `length` bytes long filled with `fill_char`.
   * @param length the length of the new string
   * @param fillChar the byte to fill the string with
   * @returns a newly-allocated string filled with @fill_char
   */
  function strnfill(length: number, fillChar: number): string | null
  /**
   * Reverses all of the bytes in a string. For example,
   * `g_strreverse ("abcdef")` will result in "fedcba".
   *
   * Note that `g_strreverse()` doesn't work on UTF-8 strings
   * containing multibyte characters. For that purpose, use
   * [func`GLib`.utf8_strreverse].
   * @param string the string to reverse
   * @returns the @string, reversed in place
   */
  function strreverse(string: string | null): string | null
  /**
   * Searches the string `haystack` for the last occurrence
   * of the string `needle`.
   * @param haystack a string to search in
   * @param needle the string to search for
   * @returns a pointer to the found occurrence, or `NULL` if not found
   */
  function strrstr(haystack: string, needle: string): string | null
  /**
   * Searches the string `haystack` for the last occurrence
   * of the string `needle,` limiting the length of the search
   * to `haystack_len`.
   * @param haystack a string to search in
   * @param haystackLen the maximum length of `haystack` in bytes. A length of `-1`   can be used to mean "search the entire string", like [func`GLib`.strrstr]
   * @param needle the string to search for
   * @returns a pointer to the found occurrence, or `NULL` if not found
   */
  function strrstrLen(
    haystack: string,
    haystackLen: number,
    needle: string
  ): string | null
  /**
   * Returns a string describing the given signal, e.g. "Segmentation fault".
   * If the signal is unknown, it returns “unknown signal (<signum\>)”.
   *
   * You should use this function in preference to `strsignal()`, because it
   * returns a string in UTF-8 encoding, and since not all platforms support
   * the `strsignal()` function.
   * @param signum the signal number. See the `signal` documentation
   * @returns the string describing the signal
   */
  function strsignal(signum: number): string
  /**
   * Splits a string into a maximum of `max_tokens` pieces, using the given
   * `delimiter`. If `max_tokens` is reached, the remainder of `string` is
   * appended to the last token.
   *
   * As an example, the result of `g_strsplit (":a:bc::d:", ":", -1)` is an array
   * containing the six strings "", "a", "bc", "", "d" and "".
   *
   * As a special case, the result of splitting the empty string "" is an empty
   * array, not an array containing a single string. The reason for this
   * special case is that being able to represent an empty array is typically
   * more useful than consistent handling of empty elements. If you do need
   * to represent empty elements, you'll need to check for the empty string
   * before calling `g_strsplit()`.
   * @param string a string to split
   * @param delimiter a string which specifies the places at which to split   the string. The delimiter is not included in any of the resulting   strings, unless `max_tokens` is reached.
   * @param maxTokens the maximum number of pieces to split `string` into   If this is less than 1, the string is split completely
   * @returns a newly-allocated array of strings, freed with   [func@GLib.strfreev]
   */
  function strsplit(
    string: string,
    delimiter: string,
    maxTokens: number
  ): string[]
  /**
   * Splits `string` into a number of tokens not containing any of the characters
   * in `delimiters`. A token is the (possibly empty) longest string that does not
   * contain any of the characters in `delimiters`. If `max_tokens` is reached, the
   * remainder is appended to the last token.
   *
   * For example, the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is an
   * array containing the three strings "abc", "def", and "ghi".
   *
   * The result of g_strsplit_set (":def/ghi:", ":/", -1) is an array containing
   * the four strings "", "def", "ghi", and "".
   *
   * As a special case, the result of splitting the empty string "" is an empty
   * array, not an array containing a single string. The reason for this
   * special case is that being able to represent an empty array is typically
   * more useful than consistent handling of empty elements. If you do need
   * to represent empty elements, you'll need to check for the empty string
   * before calling `g_strsplit_set()`.
   *
   * Note that this function works on bytes not characters, so it can't be used
   * to delimit UTF-8 strings for anything but ASCII characters.
   * @param string a string to split
   * @param delimiters a string containing characters that are used to split the   string. Can be empty, which will result in no string splitting
   * @param maxTokens the maximum number of tokens to split `string` into.   If this is less than 1, the string is split completely
   * @returns a newly-allocated array of strings. Use   [func@GLib.strfreev] to free it.
   */
  function strsplitSet(
    string: string,
    delimiters: string,
    maxTokens: number
  ): string[]
  /**
   * Searches the string `haystack` for the first occurrence
   * of the string `needle,` limiting the length of the search
   * to `haystack_len` or a nul terminator byte (whichever is reached first).
   *
   * A length of `-1` can be used to mean “search the entire string”, like
   * `strstr()`.
   * @param haystack a string to search in
   * @param haystackLen the maximum length of `haystack` in bytes, or `-1` to   search it entirely
   * @param needle the string to search for
   * @returns a pointer to the found occurrence, or `NULL` if not found
   */
  function strstrLen(
    haystack: string,
    haystackLen: number,
    needle: string
  ): string | null
  /**
   * Converts a string to a floating point value.
   *
   * It calls the standard `strtod()` function to handle the conversion, but
   * if the string is not completely converted it attempts the conversion
   * again with [func`GLib`.ascii_strtod], and returns the best match.
   *
   * This function should seldom be used. The normal situation when reading
   * numbers not for human consumption is to use [func`GLib`.ascii_strtod]. Only when
   * you know that you must expect both locale formatted and C formatted numbers
   * should you use this. Make sure that you don't pass strings such as comma
   * separated lists of values, since the commas may be interpreted as a decimal
   * point in some locales, causing unexpected results.
   * @param nptr the string to convert to a numeric value
   * @returns the converted value
   */
  function strtod(nptr: string): [/* returnType */ number, /* endptr */ string]
  /**
   * Converts a string to upper case.
   * @param string the string to convert
   * @returns the string
   */
  function strup(string: string | null): string | null
  /**
   * Checks if an array of strings contains the string `str` according to
   * [func`GLib`.str_equal]. `strv` must not be `NULL`.
   * @param strv an array of strings to search in
   * @param str the string to search for
   * @returns true if @str is an element of @strv
   */
  function strvContains(strv: string[], str: string): boolean
  /**
   * Checks if two arrays of strings contain exactly the same elements in
   * exactly the same order.
   *
   * Elements are compared using [func`GLib`.str_equal]. To match independently
   * of order, sort the arrays first (using [func`GLib`.qsort_with_data]
   * or similar).
   *
   * Elements are compared using [func`GLib`.str_equal]. To match independently
   * of order, sort the arrays first (using [func`GLib`.qsort_with_data]
   * or similar).
   *
   * Two empty arrays are considered equal. Neither `strv1` nor `strv2` may be
   * `NULL`.
   * @param strv1 an array of strings to compare to `strv2`
   * @param strv2 an array of strings to compare to `strv1`
   * @returns true if @strv1 and @strv2 are equal
   */
  function strvEqual(strv1: string[], strv2: string[]): boolean
  function strvGetType(): GObject.GType
  /**
   * Returns the length of an array of strings. `str_array` must not be `NULL`.
   * @param strArray an array of strings
   * @returns length of @str_array
   */
  function strvLength(strArray: string[]): number
  /**
   * Create a new test case, similar to g_test_create_case(). However
   * the test is assumed to use no fixture, and test suites are automatically
   * created on the fly and added to the root fixture, based on the
   * slash-separated portions of `testpath`. The `test_data` argument
   * will be passed as first argument to `test_func`.
   *
   * If `testpath` includes the component "subprocess" anywhere in it,
   * the test will be skipped by default, and only run if explicitly
   * required via the `-p` command-line option or g_test_trap_subprocess().
   *
   * No component of `testpath` may start with a dot (`.`) if the
   * %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to
   * do so even if it isn’t.
   * @param testpath /-separated test case path name for the test.
   * @param testData Test data argument for the test function.
   * @param testFunc The test function to invoke for this test.
   */
  function testAddDataFunc(
    testpath: string,
    testData: any | null,
    testFunc: TestDataFunc
  ): void
  /**
   * Create a new test case, as with g_test_add_data_func(), but freeing
   * `test_data` after the test run is complete.
   * @param testpath /-separated test case path name for the test.
   * @param testData Test data argument for the test function.
   * @param testFunc The test function to invoke for this test.
   */
  function testAddDataFuncFull(
    testpath: string,
    testData: any | null,
    testFunc: TestDataFunc
  ): void
  /**
   * Create a new test case, similar to g_test_create_case(). However
   * the test is assumed to use no fixture, and test suites are automatically
   * created on the fly and added to the root fixture, based on the
   * slash-separated portions of `testpath`.
   *
   * If `testpath` includes the component "subprocess" anywhere in it,
   * the test will be skipped by default, and only run if explicitly
   * required via the `-p` command-line option or g_test_trap_subprocess().
   *
   * No component of `testpath` may start with a dot (`.`) if the
   * %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to
   * do so even if it isn’t.
   * @param testpath /-separated test case path name for the test.
   * @param testFunc The test function to invoke for this test.
   */
  function testAddFunc(testpath: string, testFunc: TestFunc): void
  function testAssertExpectedMessagesInternal(
    domain: string,
    file: string,
    line: number,
    func: string
  ): void
  /**
   * This function adds a message to test reports that
   * associates a bug URI with a test case.
   *
   * Bug URIs are constructed from a base URI set with g_test_bug_base()
   * and `bug_uri_snippet`. If g_test_bug_base() has not been called, it is
   * assumed to be the empty string, so a full URI can be provided to
   * g_test_bug() instead.
   *
   * Since GLib 2.70, the base URI is not prepended to `bug_uri_snippet` if it
   * is already a valid URI.
   * @param bugUriSnippet Bug specific bug tracker URI or URI portion.
   */
  function testBug(bugUriSnippet: string): void
  /**
   * Specify the base URI for bug reports.
   *
   * The base URI is used to construct bug report messages for
   * g_test_message() when g_test_bug() is called.
   * Calling this function outside of a test case sets the
   * default base URI for all test cases. Calling it from within
   * a test case changes the base URI for the scope of the test
   * case only.
   * Bug URIs are constructed by appending a bug specific URI
   * portion to `uri_pattern,` or by replacing the special string
   * `%s` within `uri_pattern` if that is present.
   *
   * If g_test_bug_base() is not called, bug URIs are formed solely
   * from the value provided by g_test_bug().
   * @param uriPattern the base pattern for bug URIs
   */
  function testBugBase(uriPattern: string): void
  /**
   * Attempt to disable system crash reporting infrastructure.
   *
   * This function should be called before exercising code paths that are
   * expected or intended to crash, to avoid wasting resources in system-wide
   * crash collection infrastructure such as systemd-coredump or abrt.
   */
  function testDisableCrashReporting(): void
  /**
   * Indicates that a message with the given `log_domain` and `log_level,`
   * with text matching `pattern,` is expected to be logged.
   *
   * When this message is logged, it will not be printed, and the test case will
   * not abort.
   *
   * This API may only be used with the old logging API ([func`GLib`.log] without
   * `G_LOG_USE_STRUCTURED` defined). It will not work with the structured logging
   * API. See [Testing for Messages](logging.html#testing-for-messages).
   *
   * Use [func`GLib`.test_assert_expected_messages] to assert that all
   * previously-expected messages have been seen and suppressed.
   *
   * You can call this multiple times in a row, if multiple messages are
   * expected as a result of a single call. (The messages must appear in
   * the same order as the calls to [func`GLib`.test_expect_message].)
   *
   * For example:
   *
   * ```c
   * // g_main_context_push_thread_default() should fail if the
   * // context is already owned by another thread.
   * g_test_expect_message (G_LOG_DOMAIN,
   *                        G_LOG_LEVEL_CRITICAL,
   *                        "assertion*acquired_context*failed");
   * g_main_context_push_thread_default (bad_context);
   * g_test_assert_expected_messages ();
   * ```
   *
   * Note that you cannot use this to test [func`GLib`.error] messages, since
   * [func`GLib`.error] intentionally never returns even if the program doesn’t
   * abort; use [func`GLib`.test_trap_subprocess] in this case.
   *
   * If messages at [flags`GLib`.LogLevelFlags.LEVEL_DEBUG] are emitted, but not explicitly
   * expected via [func`GLib`.test_expect_message] then they will be ignored.
   * @param logDomain the log domain of the message
   * @param logLevel the log level of the message
   * @param pattern a glob-style pattern (see [type`GLib`.PatternSpec])
   */
  function testExpectMessage(
    logDomain: string | null,
    logLevel: LogLevelFlags,
    pattern: string
  ): void
  /**
   * Indicates that a test failed. This function can be called
   * multiple times from the same test. You can use this function
   * if your test failed in a recoverable way.
   *
   * Do not use this function if the failure of a test could cause
   * other tests to malfunction.
   *
   * Calling this function will not stop the test from running, you
   * need to return from the test function yourself. So you can
   * produce additional diagnostic messages or even continue running
   * the test.
   *
   * If not called from inside a test, this function does nothing.
   *
   * Note that unlike g_test_skip() and g_test_incomplete(), this
   * function does not log a message alongside the test failure.
   * If details of the test failure are available, either log them with
   * g_test_message() before g_test_fail(), or use g_test_fail_printf()
   * instead.
   */
  function testFail(): void
  /**
   * Returns whether a test has already failed. This will
   * be the case when g_test_fail(), g_test_incomplete()
   * or g_test_skip() have been called, but also if an
   * assertion has failed.
   *
   * This can be useful to return early from a test if
   * continuing after a failed assertion might be harmful.
   *
   * The return value of this function is only meaningful
   * if it is called from inside a test function.
   * @returns %TRUE if the test has failed
   */
  function testFailed(): boolean
  /**
   * Gets the pathname of the directory containing test files of the type
   * specified by `file_type`.
   *
   * This is approximately the same as calling g_test_build_filename("."),
   * but you don't need to free the return value.
   * @param fileType the type of file (built vs. distributed)
   * @returns the path of the directory, owned by GLib
   */
  function testGetDir(fileType: TestFileType): string
  /**
   * Gets the test path for the test currently being run.
   *
   * In essence, it will be the same string passed as the first argument to
   * e.g. g_test_add() when the test was added.
   *
   * This function returns a valid string only within a test function.
   *
   * Note that this is a test path, not a file system path.
   * @returns the test path for the test currently being run
   */
  function testGetPath(): string
  /**
   * Indicates that a test failed because of some incomplete
   * functionality. This function can be called multiple times
   * from the same test.
   *
   * Calling this function will not stop the test from running, you
   * need to return from the test function yourself. So you can
   * produce additional diagnostic messages or even continue running
   * the test.
   *
   * If not called from inside a test, this function does nothing.
   * @param msg explanation
   */
  function testIncomplete(msg: string | null): void
  function testLogTypeName(logType: TestLogType): string
  /**
   * Enqueues a callback `destroy_func` to be executed during the next test case
   * teardown phase.
   *
   * This is most useful to auto destroy allocated test resources at the end of a
   * test run. Resources are released in reverse queue order, that means
   * enqueueing callback `A` before callback `B` will cause `B()` to be called
   * before `A()` during teardown.
   * @param destroyFunc Destroy callback for teardown phase.
   * @param destroyData Destroy callback data.
   */
  function testQueueDestroy(
    destroyFunc: DestroyNotify,
    destroyData: any | null
  ): void
  /**
   * Enqueue a pointer to be released with g_free() during the next
   * teardown phase. This is equivalent to calling g_test_queue_destroy()
   * with a destroy callback of g_free().
   * @param gfreePointer the pointer to be stored.
   */
  function testQueueFree(gfreePointer: any | null): void
  /**
   * Get a reproducible random floating point number,
   * see g_test_rand_int() for details on test case random numbers.
   * @returns a random number from the seeded random number generator.
   */
  function testRandDouble(): number
  /**
   * Get a reproducible random floating pointer number out of a specified range,
   * see g_test_rand_int() for details on test case random numbers.
   * @param rangeStart the minimum value returned by this function
   * @param rangeEnd the minimum value not returned by this function
   * @returns a number with @range_start <= number < @range_end.
   */
  function testRandDoubleRange(rangeStart: number, rangeEnd: number): number
  /**
   * Get a reproducible random integer number.
   *
   * The random numbers generated by the g_test_rand_*() family of functions
   * change with every new test program start, unless the --seed option is
   * given when starting test programs.
   *
   * For individual test cases however, the random number generator is
   * reseeded, to avoid dependencies between tests and to make --seed
   * effective for all test cases.
   * @returns a random number from the seeded random number generator.
   */
  function testRandInt(): number
  /**
   * Get a reproducible random integer number out of a specified range,
   * see g_test_rand_int() for details on test case random numbers.
   * @param begin the minimum value returned by this function
   * @param end the smallest value not to be returned by this function
   * @returns a number with @begin <= number < @end.
   */
  function testRandIntRange(begin: number, end: number): number
  /**
   * Runs all tests under the toplevel suite which can be retrieved
   * with g_test_get_root(). Similar to g_test_run_suite(), the test
   * cases to be run are filtered according to test path arguments
   * (`-p testpath` and `-s testpath`) as parsed by g_test_init().
   * g_test_run_suite() or g_test_run() may only be called once in a
   * program.
   *
   * In general, the tests and sub-suites within each suite are run in
   * the order in which they are defined. However, note that prior to
   * GLib 2.36, there was a bug in the `g_test_add_*`
   * functions which caused them to create multiple suites with the same
   * name, meaning that if you created tests "/foo/simple",
   * "/bar/simple", and "/foo/using-bar" in that order, they would get
   * run in that order (since g_test_run() would run the first "/foo"
   * suite, then the "/bar" suite, then the second "/foo" suite). As of
   * 2.36, this bug is fixed, and adding the tests in that order would
   * result in a running order of "/foo/simple", "/foo/using-bar",
   * "/bar/simple". If this new ordering is sub-optimal (because it puts
   * more-complicated tests before simpler ones, making it harder to
   * figure out exactly what has failed), you can fix it by changing the
   * test paths to group tests by suite in a way that will result in the
   * desired running order. Eg, "/simple/foo", "/simple/bar",
   * "/complex/foo-using-bar".
   *
   * However, you should never make the actual result of a test depend
   * on the order that tests are run in. If you need to ensure that some
   * particular code runs before or after a given test case, use
   * g_test_add(), which lets you specify setup and teardown functions.
   *
   * If all tests are skipped or marked as incomplete (expected failures),
   * this function will return 0 if producing TAP output, or 77 (treated
   * as "skip test" by Automake) otherwise.
   * @returns 0 on success, 1 on failure (assuming it returns at all),   0 or 77 if all tests were skipped with g_test_skip() and/or   g_test_incomplete()
   */
  function testRun(): number
  /**
   * Execute the tests within `suite` and all nested #GTestSuites.
   * The test suites to be executed are filtered according to
   * test path arguments (`-p testpath` and `-s testpath`) as parsed by
   * g_test_init(). See the g_test_run() documentation for more
   * information on the order that tests are run in.
   *
   * g_test_run_suite() or g_test_run() may only be called once
   * in a program.
   * @param suite a #GTestSuite
   * @returns 0 on success
   */
  function testRunSuite(suite: TestSuite): number
  /**
   * Changes the behaviour of the various `g_assert_*()` macros,
   * g_test_assert_expected_messages() and the various
   * `g_test_trap_assert_*()` macros to not abort to program, but instead
   * call g_test_fail() and continue. (This also changes the behavior of
   * g_test_fail() so that it will not cause the test program to abort
   * after completing the failed test.)
   *
   * Note that the g_assert_not_reached() and g_assert() macros are not
   * affected by this.
   *
   * This function can only be called after g_test_init().
   */
  function testSetNonfatalAssertions(): void
  /**
   * Indicates that a test was skipped.
   *
   * Calling this function will not stop the test from running, you
   * need to return from the test function yourself. So you can
   * produce additional diagnostic messages or even continue running
   * the test.
   *
   * If not called from inside a test, this function does nothing.
   * @param msg explanation
   */
  function testSkip(msg: string | null): void
  /**
   * Returns %TRUE (after g_test_init() has been called) if the test
   * program is running under g_test_trap_subprocess().
   * @returns %TRUE if the test program is running under g_test_trap_subprocess().
   */
  function testSubprocess(): boolean
  /**
   * Set the summary for a test, which describes what the test checks, and how it
   * goes about checking it. This may be included in test report output, and is
   * useful documentation for anyone reading the source code or modifying a test
   * in future. It must be a single line.
   *
   * This should be called at the top of a test function.
   *
   * For example:
   *
   * ```c
   * static void
   * test_array_sort (void)
   * {
   *   g_test_summary ("Test my_array_sort() sorts the array correctly and stably, "
   *                   "including testing zero length and one-element arrays.");
   *
   *   …
   * }
   * ```
   *
   * @param summary One or two sentences summarising what the test checks, and how it    checks it.
   */
  function testSummary(summary: string): void
  /**
   * Get the number of seconds since the last start of the timer with
   * g_test_timer_start().
   * @returns the time since the last start of the timer in seconds, as a double
   */
  function testTimerElapsed(): number
  /**
   * Report the last result of g_test_timer_elapsed().
   * @returns the last result of g_test_timer_elapsed(), as a double
   */
  function testTimerLast(): number
  /**
   * Start a timing test. Call g_test_timer_elapsed() when the task is supposed
   * to be done. Call this function again to restart the timer.
   */
  function testTimerStart(): void
  function testTrapAssertions(
    domain: string,
    file: string,
    line: number,
    func: string,
    assertionFlags: number,
    pattern: string
  ): void
  /**
   * Fork the current test program to execute a test case that might
   * not return or that might abort.
   *
   * If `usec_timeout` is non-0, the forked test case is aborted and
   * considered failing if its run time exceeds it.
   *
   * The forking behavior can be configured with the #GTestTrapFlags flags.
   *
   * In the following example, the test code forks, the forked child
   * process produces some sample output and exits successfully.
   * The forking parent process then asserts successful child program
   * termination and validates child program outputs.
   *
   *
   * ```c
   *   static void
   *   test_fork_patterns (void)
   *   {
   *     if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
   *       {
   *         g_print ("some stdout text: somagic17\n");
   *         g_printerr ("some stderr text: semagic43\n");
   *         exit (0); // successful test run
   *       }
   *     g_test_trap_assert_passed ();
   *     g_test_trap_assert_stdout ("*somagic17*");
   *     g_test_trap_assert_stderr ("*semagic43*");
   *   }
   * ```
   *
   * @param usecTimeout Timeout for the forked test in micro seconds.
   * @param testTrapFlags Flags to modify forking behaviour.
   * @returns %TRUE for the forked child and %FALSE for the executing parent process.
   */
  function testTrapFork(
    usecTimeout: number,
    testTrapFlags: TestTrapFlags
  ): boolean
  /**
   * Check the result of the last g_test_trap_subprocess() call.
   * @returns %TRUE if the last test subprocess terminated successfully.
   */
  function testTrapHasPassed(): boolean
  /**
   * Check the result of the last g_test_trap_subprocess() call.
   * @returns %TRUE if the last test subprocess got killed due to a timeout.
   */
  function testTrapReachedTimeout(): boolean
  /**
   * Respawns the test program to run only `test_path` in a subprocess.
   *
   * This is equivalent to calling g_test_trap_subprocess_with_envp() with `envp`
   * set to %NULL. See the documentation for that function for full details.
   * @param testPath Test to run in a subprocess
   * @param usecTimeout Timeout for the subprocess test in micro seconds.
   * @param testFlags Flags to modify subprocess behaviour.
   */
  function testTrapSubprocess(
    testPath: string | null,
    usecTimeout: number,
    testFlags: TestSubprocessFlags
  ): void
  /**
   * Respawns the test program to run only `test_path` in a subprocess with the
   * given `envp` environment.
   *
   * This can be used for a test case that might not return, or that
   * might abort.
   *
   * If `test_path` is %NULL then the same test is re-run in a subprocess.
   * You can use g_test_subprocess() to determine whether the test is in
   * a subprocess or not.
   *
   * `test_path` can also be the name of the parent test, followed by
   * "`/subprocess/`" and then a name for the specific subtest (or just
   * ending with "`/subprocess`" if the test only has one child test);
   * tests with names of this form will automatically be skipped in the
   * parent process.
   *
   * If `envp` is %NULL, the parent process’ environment will be inherited.
   *
   * If `usec_timeout` is non-0, the test subprocess is aborted and
   * considered failing if its run time exceeds it.
   *
   * The subprocess behavior can be configured with the
   * #GTestSubprocessFlags flags.
   *
   * You can use methods such as g_test_trap_assert_passed(),
   * g_test_trap_assert_failed(), and g_test_trap_assert_stderr() to
   * check the results of the subprocess. (But note that
   * g_test_trap_assert_stdout() and g_test_trap_assert_stderr()
   * cannot be used if `test_flags` specifies that the child should
   * inherit the parent stdout/stderr.)
   *
   * If your `main ()` needs to behave differently in
   * the subprocess, you can call g_test_subprocess() (after calling
   * g_test_init()) to see whether you are in a subprocess.
   *
   * Internally, this function tracks the child process using
   * g_child_watch_source_new(), so your process must not ignore `SIGCHLD`, and
   * must not attempt to watch or wait for the child process via another
   * mechanism.
   *
   * The following example tests that calling
   * `my_object_new(1000000)` will abort with an error
   * message.
   *
   *
   * ```c
   *   static void
   *   test_create_large_object (void)
   *   {
   *     if (g_test_subprocess ())
   *       {
   *         my_object_new (1000000);
   *         return;
   *       }
   *
   *     // Reruns this same test in a subprocess
   *     g_test_trap_subprocess (NULL, 0, G_TEST_SUBPROCESS_DEFAULT);
   *     g_test_trap_assert_failed ();
   *     g_test_trap_assert_stderr ("*ERROR*too large*");
   *   }
   *
   *   static void
   *   test_different_username (void)
   *   {
   *     if (g_test_subprocess ())
   *       {
   *         // Code under test goes here
   *         g_message ("Username is now simulated as %s", g_getenv ("USER"));
   *         return;
   *       }
   *
   *     // Reruns this same test in a subprocess
   *     g_autoptr(GStrv) envp = g_get_environ ();
   *     envp = g_environ_setenv (g_steal_pointer (&envp), "USER", "charlie", TRUE);
   *     g_test_trap_subprocess_with_envp (NULL, envp, 0, G_TEST_SUBPROCESS_DEFAULT);
   *     g_test_trap_assert_passed ();
   *     g_test_trap_assert_stdout ("Username is now simulated as charlie");
   *   }
   *
   *   int
   *   main (int argc, char **argv)
   *   {
   *     g_test_init (&argc, &argv, NULL);
   *
   *     g_test_add_func ("/myobject/create-large-object",
   *                      test_create_large_object);
   *     g_test_add_func ("/myobject/different-username",
   *                      test_different_username);
   *     return g_test_run ();
   *   }
   * ```
   *
   * @param testPath Test to run in a subprocess
   * @param envp Environment   to run the test in, or %NULL to inherit the parent’s environment. This must   be in the GLib filename encoding.
   * @param usecTimeout Timeout for the subprocess test in micro seconds.
   * @param testFlags Flags to modify subprocess behaviour.
   */
  function testTrapSubprocessWithEnvp(
    testPath: string | null,
    envp: string[] | null,
    usecTimeout: number,
    testFlags: TestSubprocessFlags
  ): void
  function threadErrorQuark(): Quark
  /**
   * Terminates the current thread.
   *
   * If another thread is waiting for us using g_thread_join() then the
   * waiting thread will be woken up and get `retval` as the return value
   * of g_thread_join().
   *
   * Calling g_thread_exit() with a parameter `retval` is equivalent to
   * returning `retval` from the function `func,` as given to g_thread_new().
   *
   * You must only call g_thread_exit() from a thread that you created
   * yourself with g_thread_new() or related APIs. You must not call
   * this function from a thread created with another threading library
   * or or from within a #GThreadPool.
   * @param retval the return value of this thread
   */
  function threadExit(retval: any | null): void
  /**
   * This function will return the maximum `interval` that a
   * thread will wait in the thread pool for new tasks before
   * being stopped.
   *
   * If this function returns 0, threads waiting in the thread
   * pool for new work are not stopped.
   * @returns the maximum @interval (milliseconds) to wait     for new tasks in the thread pool before stopping the     thread
   */
  function threadPoolGetMaxIdleTime(): number
  /**
   * Returns the maximal allowed number of unused threads.
   * @returns the maximal number of unused threads
   */
  function threadPoolGetMaxUnusedThreads(): number
  /**
   * Returns the number of currently unused threads.
   * @returns the number of currently unused threads
   */
  function threadPoolGetNumUnusedThreads(): number
  /**
   * This function will set the maximum `interval` that a thread
   * waiting in the pool for new tasks can be idle for before
   * being stopped. This function is similar to calling
   * g_thread_pool_stop_unused_threads() on a regular timeout,
   * except this is done on a per thread basis.
   *
   * By setting `interval` to 0, idle threads will not be stopped.
   *
   * The default value is 15000 (15 seconds).
   * @param interval the maximum `interval` (in milliseconds)     a thread can be idle
   */
  function threadPoolSetMaxIdleTime(interval: number): void
  /**
   * Sets the maximal number of unused threads to `max_threads`.
   * If `max_threads` is -1, no limit is imposed on the number
   * of unused threads.
   *
   * The default value is 2.
   * @param maxThreads maximal number of unused threads
   */
  function threadPoolSetMaxUnusedThreads(maxThreads: number): void
  /**
   * Stops all currently unused threads. This does not change the
   * maximal number of unused threads. This function can be used to
   * regularly stop all unused threads e.g. from g_timeout_add().
   */
  function threadPoolStopUnusedThreads(): void
  /**
   * This function returns the #GThread corresponding to the
   * current thread. Note that this function does not increase
   * the reference count of the returned struct.
   *
   * This function will return a #GThread even for threads that
   * were not created by GLib (i.e. those created by other threading
   * APIs). This may be useful for thread identification purposes
   * (i.e. comparisons) but you must not use GLib functions (such
   * as g_thread_join()) on these threads.
   * @returns the #GThread representing the current thread
   */
  function threadSelf(): Thread
  /**
   * Causes the calling thread to voluntarily relinquish the CPU, so
   * that other threads can run.
   *
   * This function is often used as a method to make busy wait less evil.
   */
  function threadYield(): void
  /**
   * Converts a string containing an ISO 8601 encoded date and time
   * to a #GTimeVal and puts it into `time_`.
   *
   * `iso_date` must include year, month, day, hours, minutes, and
   * seconds. It can optionally include fractions of a second and a time
   * zone indicator. (In the absence of any time zone indication, the
   * timestamp is assumed to be in local time.)
   *
   * Any leading or trailing space in `iso_date` is ignored.
   *
   * This function was deprecated, along with #GTimeVal itself, in GLib 2.62.
   * Equivalent functionality is available using code like:
   *
   * ```
   * GDateTime *dt = g_date_time_new_from_iso8601 (iso8601_string, NULL);
   * gint64 time_val = g_date_time_to_unix (dt);
   * g_date_time_unref (dt);
   * ```
   *
   * @param isoDate an ISO 8601 encoded date string
   * @returns %TRUE if the conversion was successful.
   */
  function timeValFromIso8601(
    isoDate: string
  ): [/* returnType */ boolean, /* time */ TimeVal]
  /**
   * Sets a function to be called at regular intervals, with the given
   * priority.  The function is called repeatedly until it returns
   * %FALSE, at which point the timeout is automatically destroyed and
   * the function will not be called again.  The `notify` function is
   * called when the timeout is destroyed.  The first call to the
   * function will be at the end of the first `interval`.
   *
   * Note that timeout functions may be delayed, due to the processing of other
   * event sources. Thus they should not be relied on for precise timing.
   * After each call to the timeout function, the time of the next
   * timeout is recalculated based on the current time and the given interval
   * (it does not try to 'catch up' time lost in delays).
   *
   * See [memory management of sources][mainloop-memory-management] for details
   * on how to handle the return value and memory management of `data`.
   *
   * This internally creates a main loop source using g_timeout_source_new()
   * and attaches it to the global #GMainContext using g_source_attach(), so
   * the callback will be invoked in whichever thread is running that main
   * context. You can do these steps manually if you need greater control or to
   * use a custom main context.
   *
   * The interval given is in terms of monotonic time, not wall clock time.
   * See g_get_monotonic_time().
   * @param priority the priority of the timeout source. Typically this will be in   the range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
   * @param interval the time between calls to the function, in milliseconds   (1/1000ths of a second)
   * @param function_ function to call
   * @returns the ID (greater than 0) of the event source.
   */
  function timeoutAdd(
    priority: number,
    interval: number,
    function_: SourceFunc
  ): number
  /**
   * Sets a function to be called at regular intervals, with `priority`.
   *
   * The function is called repeatedly until it returns %G_SOURCE_REMOVE
   * or %FALSE, at which point the timeout is automatically destroyed and
   * the function will not be called again.
   *
   * Unlike g_timeout_add(), this function operates at whole second granularity.
   * The initial starting point of the timer is determined by the implementation
   * and the implementation is expected to group multiple timers together so that
   * they fire all at the same time. To allow this grouping, the `interval` to the
   * first timer is rounded and can deviate up to one second from the specified
   * interval. Subsequent timer iterations will generally run at the specified
   * interval.
   *
   * Note that timeout functions may be delayed, due to the processing of other
   * event sources. Thus they should not be relied on for precise timing.
   * After each call to the timeout function, the time of the next
   * timeout is recalculated based on the current time and the given `interval`
   *
   * See [memory management of sources][mainloop-memory-management] for details
   * on how to handle the return value and memory management of `data`.
   *
   * If you want timing more precise than whole seconds, use g_timeout_add()
   * instead.
   *
   * The grouping of timers to fire at the same time results in a more power
   * and CPU efficient behavior so if your timer is in multiples of seconds
   * and you don't require the first timer exactly one second from now, the
   * use of g_timeout_add_seconds() is preferred over g_timeout_add().
   *
   * This internally creates a main loop source using
   * g_timeout_source_new_seconds() and attaches it to the main loop context
   * using g_source_attach(). You can do these steps manually if you need
   * greater control.
   *
   * It is safe to call this function from any thread.
   *
   * The interval given is in terms of monotonic time, not wall clock
   * time.  See g_get_monotonic_time().
   * @param priority the priority of the timeout source. Typically this will be in   the range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
   * @param interval the time between calls to the function, in seconds
   * @param function_ function to call
   * @returns the ID (greater than 0) of the event source.
   */
  function timeoutAddSeconds(
    priority: number,
    interval: number,
    function_: SourceFunc
  ): number
  /**
   * Creates a new timeout source.
   *
   * The source will not initially be associated with any #GMainContext
   * and must be added to one with g_source_attach() before it will be
   * executed.
   *
   * The interval given is in terms of monotonic time, not wall clock
   * time.  See g_get_monotonic_time().
   * @param interval the timeout interval in milliseconds.
   * @returns the newly-created timeout source
   */
  function timeoutSourceNew(interval: number): Source
  /**
   * Creates a new timeout source.
   *
   * The source will not initially be associated with any #GMainContext
   * and must be added to one with g_source_attach() before it will be
   * executed.
   *
   * The scheduling granularity/accuracy of this timeout source will be
   * in seconds.
   *
   * The interval given is in terms of monotonic time, not wall clock time.
   * See g_get_monotonic_time().
   * @param interval the timeout interval in seconds
   * @returns the newly-created timeout source
   */
  function timeoutSourceNewSeconds(interval: number): Source
  /**
   * Returns the height of a #GTrashStack.
   *
   * Note that execution of this function is of O(N) complexity
   * where N denotes the number of items on the stack.
   * @param stackP a #GTrashStack
   * @returns the height of the stack
   */
  function trashStackHeight(stackP: TrashStack): number
  /**
   * Returns the element at the top of a #GTrashStack
   * which may be %NULL.
   * @param stackP a #GTrashStack
   * @returns the element at the top of the stack
   */
  function trashStackPeek(stackP: TrashStack): any | null
  /**
   * Pops a piece of memory off a #GTrashStack.
   * @param stackP a #GTrashStack
   * @returns the element at the top of the stack
   */
  function trashStackPop(stackP: TrashStack): any | null
  /**
   * Pushes a piece of memory onto a #GTrashStack.
   * @param stackP a #GTrashStack
   * @param dataP the piece of memory to push on the stack
   */
  function trashStackPush(stackP: TrashStack, dataP: any): void
  /**
   * Attempts to allocate `n_bytes,` and returns %NULL on failure.
   * Contrast with g_malloc(), which aborts the program on failure.
   * @param nBytes number of bytes to allocate.
   * @returns the allocated memory, or %NULL.
   */
  function tryMalloc(nBytes: number): any | null
  /**
   * Attempts to allocate `n_bytes,` initialized to 0's, and returns %NULL on
   * failure. Contrast with g_malloc0(), which aborts the program on failure.
   * @param nBytes number of bytes to allocate
   * @returns the allocated memory, or %NULL
   */
  function tryMalloc0(nBytes: number): any | null
  /**
   * This function is similar to g_try_malloc0(), allocating (`n_blocks` * `n_block_bytes)` bytes,
   * but care is taken to detect possible overflow during multiplication.
   * @param nBlocks the number of blocks to allocate
   * @param nBlockBytes the size of each block in bytes
   * @returns the allocated memory, or %NULL
   */
  function tryMalloc0N(nBlocks: number, nBlockBytes: number): any | null
  /**
   * This function is similar to g_try_malloc(), allocating (`n_blocks` * `n_block_bytes)` bytes,
   * but care is taken to detect possible overflow during multiplication.
   * @param nBlocks the number of blocks to allocate
   * @param nBlockBytes the size of each block in bytes
   * @returns the allocated memory, or %NULL.
   */
  function tryMallocN(nBlocks: number, nBlockBytes: number): any | null
  /**
   * Attempts to realloc `mem` to a new size, `n_bytes,` and returns %NULL
   * on failure. Contrast with g_realloc(), which aborts the program
   * on failure.
   *
   * If `mem` is %NULL, behaves the same as g_try_malloc().
   * @param mem previously-allocated memory, or %NULL.
   * @param nBytes number of bytes to allocate.
   * @returns the allocated memory, or %NULL.
   */
  function tryRealloc(mem: any | null, nBytes: number): any | null
  /**
   * This function is similar to g_try_realloc(), allocating (`n_blocks` * `n_block_bytes)` bytes,
   * but care is taken to detect possible overflow during multiplication.
   * @param mem previously-allocated memory, or %NULL.
   * @param nBlocks the number of blocks to allocate
   * @param nBlockBytes the size of each block in bytes
   * @returns the allocated memory, or %NULL.
   */
  function tryReallocN(
    mem: any | null,
    nBlocks: number,
    nBlockBytes: number
  ): any | null
  /**
   * Convert a string from UCS-4 to UTF-16. A 0 character will be
   * added to the result after the converted text.
   * @param str a UCS-4 encoded string
   * @returns a pointer to a newly allocated UTF-16 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
   */
  function ucs4ToUtf16(
    str: string[]
  ): [
    /* returnType */ number,
    /* itemsRead */ number,
    /* itemsWritten */ number,
  ]
  /**
   * Convert a string from a 32-bit fixed width representation as UCS-4.
   * to UTF-8. The result will be terminated with a 0 byte.
   * @param str a UCS-4 encoded string
   * @returns a pointer to a newly allocated UTF-8 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set. In that case, @items_read     will be set to the position of the first invalid input character.
   */
  function ucs4ToUtf8(
    str: string[]
  ): [
    /* returnType */ string | null,
    /* itemsRead */ number,
    /* itemsWritten */ number,
  ]
  /**
   * Determines the break type of `c`. `c` should be a Unicode character
   * (to derive a character from UTF-8 encoded text, use
   * g_utf8_get_char()). The break type is used to find word and line
   * breaks ("text boundaries"), Pango implements the Unicode boundary
   * resolution algorithms and normally you would use a function such
   * as pango_break() instead of caring about break types yourself.
   * @param c a Unicode character
   * @returns the break type of @c
   */
  function unicharBreakType(c: string): UnicodeBreakType
  /**
   * Determines the canonical combining class of a Unicode character.
   * @param uc a Unicode character
   * @returns the combining class of the character
   */
  function unicharCombiningClass(uc: string): number
  /**
   * Performs a single composition step of the
   * Unicode canonical composition algorithm.
   *
   * This function includes algorithmic Hangul Jamo composition,
   * but it is not exactly the inverse of g_unichar_decompose().
   * No composition can have either of `a` or `b` equal to zero.
   * To be precise, this function composes if and only if
   * there exists a Primary Composite P which is canonically
   * equivalent to the sequence <`a,``b>`.  See the Unicode
   * Standard for the definition of Primary Composite.
   *
   * If `a` and `b` do not compose a new character, `ch` is set to zero.
   *
   * See
   * [UAX#15](http://unicode.org/reports/tr15/)
   * for details.
   * @param a a Unicode character
   * @param b a Unicode character
   * @returns %TRUE if the characters could be composed
   */
  function unicharCompose(
    a: string,
    b: string
  ): [/* returnType */ boolean, /* ch */ string]
  /**
   * Performs a single decomposition step of the
   * Unicode canonical decomposition algorithm.
   *
   * This function does not include compatibility
   * decompositions. It does, however, include algorithmic
   * Hangul Jamo decomposition, as well as 'singleton'
   * decompositions which replace a character by a single
   * other character. In the case of singletons *`b` will
   * be set to zero.
   *
   * If `ch` is not decomposable, *`a` is set to `ch` and *`b`
   * is set to zero.
   *
   * Note that the way Unicode decomposition pairs are
   * defined, it is guaranteed that `b` would not decompose
   * further, but `a` may itself decompose.  To get the full
   * canonical decomposition for `ch,` one would need to
   * recursively call this function on `a`.  Or use
   * g_unichar_fully_decompose().
   *
   * See
   * [UAX#15](http://unicode.org/reports/tr15/)
   * for details.
   * @param ch a Unicode character
   * @returns %TRUE if the character could be decomposed
   */
  function unicharDecompose(
    ch: string
  ): [/* returnType */ boolean, /* a */ string, /* b */ string]
  /**
   * Determines the numeric value of a character as a decimal
   * digit.
   * @param c a Unicode character
   * @returns If @c is a decimal digit (according to g_unichar_isdigit()), its numeric value. Otherwise, -1.
   */
  function unicharDigitValue(c: string): number
  /**
   * Computes the canonical or compatibility decomposition of a
   * Unicode character.  For compatibility decomposition,
   * pass %TRUE for `compat;` for canonical decomposition
   * pass %FALSE for `compat`.
   *
   * The decomposed sequence is placed in `result`.  Only up to
   * `result_len` characters are written into `result`.  The length
   * of the full decomposition (irrespective of `result_len)` is
   * returned by the function.  For canonical decomposition,
   * currently all decompositions are of length at most 4, but
   * this may change in the future (very unlikely though).
   * At any rate, Unicode does guarantee that a buffer of length
   * 18 is always enough for both compatibility and canonical
   * decompositions, so that is the size recommended. This is provided
   * as %G_UNICHAR_MAX_DECOMPOSITION_LENGTH.
   *
   * See
   * [UAX#15](http://unicode.org/reports/tr15/)
   * for details.
   * @param ch a Unicode character.
   * @param compat whether perform canonical or compatibility decomposition
   * @param resultLen length of `result`
   * @returns the length of the full decomposition.
   */
  function unicharFullyDecompose(
    ch: string,
    compat: boolean,
    resultLen: number
  ): [/* returnType */ number, /* result */ string]
  /**
   * In Unicode, some characters are "mirrored". This means that their
   * images are mirrored horizontally in text that is laid out from right
   * to left. For instance, "(" would become its mirror image, ")", in
   * right-to-left text.
   *
   * If `ch` has the Unicode mirrored property and there is another unicode
   * character that typically has a glyph that is the mirror image of `ch'`s
   * glyph and `mirrored_ch` is set, it puts that character in the address
   * pointed to by `mirrored_ch`.  Otherwise the original character is put.
   * @param ch a Unicode character
   * @returns %TRUE if @ch has a mirrored character, %FALSE otherwise
   */
  function unicharGetMirrorChar(
    ch: string
  ): [/* returnType */ boolean, /* mirroredCh */ string]
  /**
   * Looks up the #GUnicodeScript for a particular character (as defined
   * by Unicode Standard Annex \#24). No check is made for `ch` being a
   * valid Unicode character; if you pass in invalid character, the
   * result is undefined.
   *
   * This function is equivalent to pango_script_for_unichar() and the
   * two are interchangeable.
   * @param ch a Unicode character
   * @returns the #GUnicodeScript for the character.
   */
  function unicharGetScript(ch: string): UnicodeScript
  /**
   * Determines whether a character is alphanumeric.
   * Given some UTF-8 text, obtain a character value
   * with g_utf8_get_char().
   * @param c a Unicode character
   * @returns %TRUE if @c is an alphanumeric character
   */
  function unicharIsalnum(c: string): boolean
  /**
   * Determines whether a character is alphabetic (i.e. a letter).
   * Given some UTF-8 text, obtain a character value with
   * g_utf8_get_char().
   * @param c a Unicode character
   * @returns %TRUE if @c is an alphabetic character
   */
  function unicharIsalpha(c: string): boolean
  /**
   * Determines whether a character is a control character.
   * Given some UTF-8 text, obtain a character value with
   * g_utf8_get_char().
   * @param c a Unicode character
   * @returns %TRUE if @c is a control character
   */
  function unicharIscntrl(c: string): boolean
  /**
   * Determines if a given character is assigned in the Unicode
   * standard.
   * @param c a Unicode character
   * @returns %TRUE if the character has an assigned value
   */
  function unicharIsdefined(c: string): boolean
  /**
   * Determines whether a character is numeric (i.e. a digit).  This
   * covers ASCII 0-9 and also digits in other languages/scripts.  Given
   * some UTF-8 text, obtain a character value with g_utf8_get_char().
   * @param c a Unicode character
   * @returns %TRUE if @c is a digit
   */
  function unicharIsdigit(c: string): boolean
  /**
   * Determines whether a character is printable and not a space
   * (returns %FALSE for control characters, format characters, and
   * spaces). g_unichar_isprint() is similar, but returns %TRUE for
   * spaces. Given some UTF-8 text, obtain a character value with
   * g_utf8_get_char().
   * @param c a Unicode character
   * @returns %TRUE if @c is printable unless it's a space
   */
  function unicharIsgraph(c: string): boolean
  /**
   * Determines whether a character is a lowercase letter.
   * Given some UTF-8 text, obtain a character value with
   * g_utf8_get_char().
   * @param c a Unicode character
   * @returns %TRUE if @c is a lowercase letter
   */
  function unicharIslower(c: string): boolean
  /**
   * Determines whether a character is a mark (non-spacing mark,
   * combining mark, or enclosing mark in Unicode speak).
   * Given some UTF-8 text, obtain a character value
   * with g_utf8_get_char().
   *
   * Note: in most cases where isalpha characters are allowed,
   * ismark characters should be allowed to as they are essential
   * for writing most European languages as well as many non-Latin
   * scripts.
   * @param c a Unicode character
   * @returns %TRUE if @c is a mark character
   */
  function unicharIsmark(c: string): boolean
  /**
   * Determines whether a character is printable.
   * Unlike g_unichar_isgraph(), returns %TRUE for spaces.
   * Given some UTF-8 text, obtain a character value with
   * g_utf8_get_char().
   * @param c a Unicode character
   * @returns %TRUE if @c is printable
   */
  function unicharIsprint(c: string): boolean
  /**
   * Determines whether a character is punctuation or a symbol.
   * Given some UTF-8 text, obtain a character value with
   * g_utf8_get_char().
   * @param c a Unicode character
   * @returns %TRUE if @c is a punctuation or symbol character
   */
  function unicharIspunct(c: string): boolean
  /**
   * Determines whether a character is a space, tab, or line separator
   * (newline, carriage return, etc.).  Given some UTF-8 text, obtain a
   * character value with g_utf8_get_char().
   *
   * (Note: don't use this to do word breaking; you have to use
   * Pango or equivalent to get word breaking right, the algorithm
   * is fairly complex.)
   * @param c a Unicode character
   * @returns %TRUE if @c is a space character
   */
  function unicharIsspace(c: string): boolean
  /**
   * Determines if a character is titlecase. Some characters in
   * Unicode which are composites, such as the DZ digraph
   * have three case variants instead of just two. The titlecase
   * form is used at the beginning of a word where only the
   * first letter is capitalized. The titlecase form of the DZ
   * digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.
   * @param c a Unicode character
   * @returns %TRUE if the character is titlecase
   */
  function unicharIstitle(c: string): boolean
  /**
   * Determines if a character is uppercase.
   * @param c a Unicode character
   * @returns %TRUE if @c is an uppercase character
   */
  function unicharIsupper(c: string): boolean
  /**
   * Determines if a character is typically rendered in a double-width
   * cell.
   * @param c a Unicode character
   * @returns %TRUE if the character is wide
   */
  function unicharIswide(c: string): boolean
  /**
   * Determines if a character is typically rendered in a double-width
   * cell under legacy East Asian locales.  If a character is wide according to
   * g_unichar_iswide(), then it is also reported wide with this function, but
   * the converse is not necessarily true. See the
   * [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
   * for details.
   *
   * If a character passes the g_unichar_iswide() test then it will also pass
   * this test, but not the other way around.  Note that some characters may
   * pass both this test and g_unichar_iszerowidth().
   * @param c a Unicode character
   * @returns %TRUE if the character is wide in legacy East Asian locales
   */
  function unicharIswideCjk(c: string): boolean
  /**
   * Determines if a character is a hexadecimal digit.
   * @param c a Unicode character.
   * @returns %TRUE if the character is a hexadecimal digit
   */
  function unicharIsxdigit(c: string): boolean
  /**
   * Determines if a given character typically takes zero width when rendered.
   * The return value is %TRUE for all non-spacing and enclosing marks
   * (e.g., combining accents), format characters, zero-width
   * space, but not U+00AD SOFT HYPHEN.
   *
   * A typical use of this function is with one of g_unichar_iswide() or
   * g_unichar_iswide_cjk() to determine the number of cells a string occupies
   * when displayed on a grid display (terminals).  However, note that not all
   * terminals support zero-width rendering of zero-width marks.
   * @param c a Unicode character
   * @returns %TRUE if the character has zero width
   */
  function unicharIszerowidth(c: string): boolean
  /**
   * Converts a single character to UTF-8.
   * @param c a Unicode character code
   * @returns number of bytes written
   */
  function unicharToUtf8(
    c: string
  ): [/* returnType */ number, /* outbuf */ string]
  /**
   * Converts a character to lower case.
   * @param c a Unicode character.
   * @returns the result of converting @c to lower case.               If @c is not an upperlower or titlecase character,               or has no lowercase equivalent @c is returned unchanged.
   */
  function unicharTolower(c: string): string
  /**
   * Converts a character to the titlecase.
   * @param c a Unicode character
   * @returns the result of converting @c to titlecase.               If @c is not an uppercase or lowercase character,               @c is returned unchanged.
   */
  function unicharTotitle(c: string): string
  /**
   * Converts a character to uppercase.
   * @param c a Unicode character
   * @returns the result of converting @c to uppercase.               If @c is not a lowercase or titlecase character,               or has no upper case equivalent @c is returned unchanged.
   */
  function unicharToupper(c: string): string
  /**
   * Classifies a Unicode character by type.
   * @param c a Unicode character
   * @returns the type of the character.
   */
  function unicharType(c: string): UnicodeType
  /**
   * Checks whether `ch` is a valid Unicode character. Some possible
   * integer values of `ch` will not be valid. 0 is considered a valid
   * character, though it's normally a string terminator.
   * @param ch a Unicode character
   * @returns %TRUE if @ch is a valid Unicode character
   */
  function unicharValidate(ch: string): boolean
  /**
   * Determines the numeric value of a character as a hexadecimal
   * digit.
   * @param c a Unicode character
   * @returns If @c is a hex digit (according to g_unichar_isxdigit()), its numeric value. Otherwise, -1.
   */
  function unicharXdigitValue(c: string): number
  /**
   * Computes the canonical decomposition of a Unicode character.
   * @param ch a Unicode character.
   * @param resultLen location to store the length of the return value.
   * @returns a newly allocated string of Unicode characters.   @result_len is set to the resulting length of the string.
   */
  function unicodeCanonicalDecomposition(ch: string, resultLen: number): string
  /**
   * Computes the canonical ordering of a string in-place.
   * This rearranges decomposed characters in the string
   * according to their combining classes.  See the Unicode
   * manual for more information.
   * @param string a UCS-4 encoded string.
   */
  function unicodeCanonicalOrdering(string: string[]): void
  /**
   * Looks up the Unicode script for `iso1`5924.  ISO 15924 assigns four-letter
   * codes to scripts.  For example, the code for Arabic is 'Arab'.
   * This function accepts four letter codes encoded as a `guint3`2 in a
   * big-endian fashion.  That is, the code expected for Arabic is
   * 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
   *
   * See
   * [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
   * for details.
   * @param iso15924 a Unicode script
   * @returns the Unicode script for @iso15924, or   of %G_UNICODE_SCRIPT_INVALID_CODE if @iso15924 is zero and   %G_UNICODE_SCRIPT_UNKNOWN if @iso15924 is unknown.
   */
  function unicodeScriptFromIso15924(iso15924: number): UnicodeScript
  /**
   * Looks up the ISO 15924 code for `script`.  ISO 15924 assigns four-letter
   * codes to scripts.  For example, the code for Arabic is 'Arab'.  The
   * four letter codes are encoded as a `guint3`2 by this function in a
   * big-endian fashion.  That is, the code returned for Arabic is
   * 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
   *
   * See
   * [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
   * for details.
   * @param script a Unicode script
   * @returns the ISO 15924 code for @script, encoded as an integer,   of zero if @script is %G_UNICODE_SCRIPT_INVALID_CODE or   ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood.
   */
  function unicodeScriptToIso15924(script: UnicodeScript): number
  function unixErrorQuark(): Quark
  /**
   * Sets a function to be called when the IO condition, as specified by
   * `condition` becomes true for `fd`.
   *
   * This is the same as g_unix_fd_add(), except that it allows you to
   * specify a non-default priority and a provide a #GDestroyNotify for
   * `user_data`.
   * @param priority the priority of the source
   * @param fd a file descriptor
   * @param condition IO conditions to watch for on `fd`
   * @param function_ a #GUnixFDSourceFunc
   * @returns the ID (greater than 0) of the event source
   */
  function unixFdAddFull(
    priority: number,
    fd: number,
    condition: IOCondition,
    function_: UnixFDSourceFunc
  ): number
  /**
   * Creates a #GSource to watch for a particular I/O condition on a file
   * descriptor.
   *
   * The source will never close the `fd` — you must do it yourself.
   *
   * Any callback attached to the returned #GSource must have type
   * #GUnixFDSourceFunc.
   * @param fd a file descriptor
   * @param condition I/O conditions to watch for on `fd`
   * @returns the newly created #GSource
   */
  function unixFdSourceNew(fd: number, condition: IOCondition): Source
  /**
   * Get the `passwd` file entry for the given `user_name` using `getpwnam_r()`.
   * This can fail if the given `user_name` doesn’t exist.
   *
   * The returned `struct passwd` has been allocated using g_malloc() and should
   * be freed using g_free(). The strings referenced by the returned struct are
   * included in the same allocation, so are valid until the `struct passwd` is
   * freed.
   *
   * This function is safe to call from multiple threads concurrently.
   *
   * You will need to include `pwd.h` to get the definition of `struct passwd`.
   * @param userName the username to get the passwd file entry for
   * @returns passwd entry, or %NULL on error; free the returned    value with g_free()
   */
  function unixGetPasswdEntry(userName: string): any | null
  /**
   * Similar to the UNIX pipe() call, but on modern systems like Linux
   * uses the pipe2() system call, which atomically creates a pipe with
   * the configured flags.
   *
   * As of GLib 2.78, the supported flags are `O_CLOEXEC`/`FD_CLOEXEC` (see below)
   * and `O_NONBLOCK`. Prior to GLib 2.78, only `FD_CLOEXEC` was supported — if
   * you wanted to configure `O_NONBLOCK` then that had to be done separately with
   * `fcntl()`.
   *
   * Since GLib 2.80, the constants %G_UNIX_PIPE_END_READ and
   * %G_UNIX_PIPE_END_WRITE can be used as mnemonic indexes in `fds`.
   *
   * It is a programmer error to call this function with unsupported flags, and a
   * critical warning will be raised.
   *
   * As of GLib 2.78, it is preferred to pass `O_CLOEXEC` in, rather than
   * `FD_CLOEXEC`, as that matches the underlying `pipe()` API more closely. Prior
   * to 2.78, only `FD_CLOEXEC` was supported. Support for `FD_CLOEXEC` may be
   * deprecated and removed in future.
   * @param fds Array of two integers
   * @param flags Bitfield of file descriptor flags, as for fcntl()
   * @returns %TRUE on success, %FALSE if not (and errno will be set).
   */
  function unixOpenPipe(fds: number[], flags: number): boolean
  /**
   * Control the non-blocking state of the given file descriptor,
   * according to `nonblock`. On most systems this uses %O_NONBLOCK, but
   * on some older ones may use %O_NDELAY.
   * @param fd A file descriptor
   * @param nonblock If %TRUE, set the descriptor to be non-blocking
   * @returns %TRUE if successful
   */
  function unixSetFdNonblocking(fd: number, nonblock: boolean): boolean
  /**
   * A convenience function for g_unix_signal_source_new(), which
   * attaches to the default #GMainContext.  You can remove the watch
   * using g_source_remove().
   * @param priority the priority of the signal source. Typically this will be in            the range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
   * @param signum Signal number
   * @param handler Callback
   * @returns An ID (greater than 0) for the event source
   */
  function unixSignalAdd(
    priority: number,
    signum: number,
    handler: SourceFunc
  ): number
  /**
   * Create a #GSource that will be dispatched upon delivery of the UNIX
   * signal `signum`.  In GLib versions before 2.36, only `SIGHUP`, `SIGINT`,
   * `SIGTERM` can be monitored.  In GLib 2.36, `SIGUSR1` and `SIGUSR2`
   * were added. In GLib 2.54, `SIGWINCH` was added.
   *
   * Note that unlike the UNIX default, all sources which have created a
   * watch will be dispatched, regardless of which underlying thread
   * invoked g_unix_signal_source_new().
   *
   * For example, an effective use of this function is to handle `SIGTERM`
   * cleanly; flushing any outstanding files, and then calling
   * g_main_loop_quit().  It is not safe to do any of this from a regular
   * UNIX signal handler; such a handler may be invoked while malloc() or
   * another library function is running, causing reentrancy issues if the
   * handler attempts to use those functions.  None of the GLib/GObject
   * API is safe against this kind of reentrancy.
   *
   * The interaction of this source when combined with native UNIX
   * functions like sigprocmask() is not defined.
   *
   * The source will not initially be associated with any #GMainContext
   * and must be added to one with g_source_attach() before it will be
   * executed.
   * @param signum A signal number
   * @returns A newly created #GSource
   */
  function unixSignalSourceNew(signum: number): Source
  /**
   * A wrapper for the POSIX unlink() function. The unlink() function
   * deletes a name from the filesystem. If this was the last link to the
   * file and no processes have it opened, the diskspace occupied by the
   * file is freed.
   *
   * See your C library manual for more details about unlink(). Note
   * that on Windows, it is in general not possible to delete files that
   * are open to some process, or mapped into memory.
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @returns 0 if the name was successfully deleted, -1 if an error    occurred
   */
  function unlink(filename: string): number
  /**
   * Removes an environment variable from the environment.
   *
   * Note that on some systems, when variables are overwritten, the
   * memory used for the previous variables and its value isn't reclaimed.
   *
   * You should be mindful of the fact that environment variable handling
   * in UNIX is not thread-safe, and your program may crash if one thread
   * calls g_unsetenv() while another thread is calling getenv(). (And note
   * that many functions, such as gettext(), call getenv() internally.) This
   * function is only safe to use at the very start of your program, before
   * creating any other threads (or creating objects that create worker
   * threads of their own).
   *
   * If you need to set up the environment for a child process, you can
   * use g_get_environ() to get an environment array, modify that with
   * g_environ_setenv() and g_environ_unsetenv(), and then pass that
   * array directly to execvpe(), g_spawn_async(), or the like.
   * @param variable the environment variable to remove, must     not contain '='
   */
  function unsetenv(variable: string): void
  /**
   * Creates a new #GUri from the given components according to `flags`.
   *
   * See also g_uri_build_with_user(), which allows specifying the
   * components of the "userinfo" separately.
   * @param flags flags describing how to build the #GUri
   * @param scheme the URI scheme
   * @param userinfo the userinfo component, or %NULL
   * @param host the host component, or %NULL
   * @param port the port, or `-1`
   * @param path the path component
   * @param query the query component, or %NULL
   * @param fragment the fragment, or %NULL
   * @returns a new #GUri
   */
  function uriBuild(
    flags: UriFlags,
    scheme: string,
    userinfo: string | null,
    host: string | null,
    port: number,
    path: string,
    query: string | null,
    fragment: string | null
  ): Uri
  /**
   * Creates a new #GUri from the given components according to `flags`
   * (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The `flags` must be
   * coherent with the passed values, in particular use `%`-encoded values with
   * %G_URI_FLAGS_ENCODED.
   *
   * In contrast to g_uri_build(), this allows specifying the components
   * of the ‘userinfo’ field separately. Note that `user` must be non-%NULL
   * if either `password` or `auth_params` is non-%NULL.
   * @param flags flags describing how to build the #GUri
   * @param scheme the URI scheme
   * @param user the user component of the userinfo, or %NULL
   * @param password the password component of the userinfo, or %NULL
   * @param authParams the auth params of the userinfo, or %NULL
   * @param host the host component, or %NULL
   * @param port the port, or `-1`
   * @param path the path component
   * @param query the query component, or %NULL
   * @param fragment the fragment, or %NULL
   * @returns a new #GUri
   */
  function uriBuildWithUser(
    flags: UriFlags,
    scheme: string,
    user: string | null,
    password: string | null,
    authParams: string | null,
    host: string | null,
    port: number,
    path: string,
    query: string | null,
    fragment: string | null
  ): Uri
  function uriErrorQuark(): Quark
  /**
   * Escapes arbitrary data for use in a URI.
   *
   * Normally all characters that are not ‘unreserved’ (i.e. ASCII
   * alphanumerical characters plus dash, dot, underscore and tilde) are
   * escaped. But if you specify characters in `reserved_chars_allowed`
   * they are not escaped. This is useful for the ‘reserved’ characters
   * in the URI specification, since those are allowed unescaped in some
   * portions of a URI.
   *
   * Though technically incorrect, this will also allow escaping nul
   * bytes as `%``00`.
   * @param unescaped the unescaped input data.
   * @param reservedCharsAllowed a string of reserved   characters that are allowed to be used, or %NULL.
   * @returns an escaped version of @unescaped.     The returned string should be freed when no longer needed.
   */
  function uriEscapeBytes(
    unescaped: number[],
    reservedCharsAllowed: string | null
  ): string | null
  /**
   * Escapes a string for use in a URI.
   *
   * Normally all characters that are not "unreserved" (i.e. ASCII
   * alphanumerical characters plus dash, dot, underscore and tilde) are
   * escaped. But if you specify characters in `reserved_chars_allowed`
   * they are not escaped. This is useful for the "reserved" characters
   * in the URI specification, since those are allowed unescaped in some
   * portions of a URI.
   * @param unescaped the unescaped input string.
   * @param reservedCharsAllowed a string of reserved   characters that are allowed to be used, or %NULL.
   * @param allowUtf8 %TRUE if the result can include UTF-8 characters.
   * @returns an escaped version of @unescaped. The returned string should be freed when no longer needed.
   */
  function uriEscapeString(
    unescaped: string,
    reservedCharsAllowed: string | null,
    allowUtf8: boolean
  ): string | null
  /**
   * Parses `uri_string` according to `flags,` to determine whether it is a valid
   * [absolute URI](#relative-and-absolute-uris), i.e. it does not need to be resolved
   * relative to another URI using g_uri_parse_relative().
   *
   * If it’s not a valid URI, an error is returned explaining how it’s invalid.
   *
   * See g_uri_split(), and the definition of #GUriFlags, for more
   * information on the effect of `flags`.
   * @param uriString a string containing an absolute URI
   * @param flags flags for parsing `uri_string`
   * @returns %TRUE if @uri_string is a valid absolute URI, %FALSE on error.
   */
  function uriIsValid(uriString: string, flags: UriFlags): boolean
  /**
   * Joins the given components together according to `flags` to create
   * an absolute URI string. `path` may not be %NULL (though it may be the empty
   * string).
   *
   * When `host` is present, `path` must either be empty or begin with a slash (`/`)
   * character. When `host` is not present, `path` cannot begin with two slash
   * characters (`//`). See
   * [RFC 3986, section 3](https://tools.ietf.org/html/rfc3986#section-3).
   *
   * See also g_uri_join_with_user(), which allows specifying the
   * components of the ‘userinfo’ separately.
   *
   * %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
   * in `flags`.
   * @param flags flags describing how to build the URI string
   * @param scheme the URI scheme, or %NULL
   * @param userinfo the userinfo component, or %NULL
   * @param host the host component, or %NULL
   * @param port the port, or `-1`
   * @param path the path component
   * @param query the query component, or %NULL
   * @param fragment the fragment, or %NULL
   * @returns an absolute URI string
   */
  function uriJoin(
    flags: UriFlags,
    scheme: string | null,
    userinfo: string | null,
    host: string | null,
    port: number,
    path: string,
    query: string | null,
    fragment: string | null
  ): string | null
  /**
   * Joins the given components together according to `flags` to create
   * an absolute URI string. `path` may not be %NULL (though it may be the empty
   * string).
   *
   * In contrast to g_uri_join(), this allows specifying the components
   * of the ‘userinfo’ separately. It otherwise behaves the same.
   *
   * %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
   * in `flags`.
   * @param flags flags describing how to build the URI string
   * @param scheme the URI scheme, or %NULL
   * @param user the user component of the userinfo, or %NULL
   * @param password the password component of the userinfo, or   %NULL
   * @param authParams the auth params of the userinfo, or   %NULL
   * @param host the host component, or %NULL
   * @param port the port, or `-1`
   * @param path the path component
   * @param query the query component, or %NULL
   * @param fragment the fragment, or %NULL
   * @returns an absolute URI string
   */
  function uriJoinWithUser(
    flags: UriFlags,
    scheme: string | null,
    user: string | null,
    password: string | null,
    authParams: string | null,
    host: string | null,
    port: number,
    path: string,
    query: string | null,
    fragment: string | null
  ): string | null
  /**
   * Splits an URI list conforming to the text/uri-list
   * mime type defined in RFC 2483 into individual URIs,
   * discarding any comments. The URIs are not validated.
   * @param uriList an URI list
   * @returns a newly allocated %NULL-terminated list   of strings holding the individual URIs. The array should be freed   with g_strfreev().
   */
  function uriListExtractUris(uriList: string): string[]
  /**
   * Parses `uri_string` according to `flags`. If the result is not a
   * valid [absolute URI](#relative-and-absolute-uris), it will be discarded, and an
   * error returned.
   * @param uriString a string representing an absolute URI
   * @param flags flags describing how to parse `uri_string`
   * @returns a new #GUri, or NULL on error.
   */
  function uriParse(uriString: string, flags: UriFlags): Uri
  /**
   * Many URI schemes include one or more attribute/value pairs as part of the URI
   * value. This method can be used to parse them into a hash table. When an
   * attribute has multiple occurrences, the last value is the final returned
   * value. If you need to handle repeated attributes differently, use
   * #GUriParamsIter.
   *
   * The `params` string is assumed to still be `%`-encoded, but the returned
   * values will be fully decoded. (Thus it is possible that the returned values
   * may contain `=` or `separators,` if the value was encoded in the input.)
   * Invalid `%`-encoding is treated as with the %G_URI_FLAGS_PARSE_RELAXED
   * rules for g_uri_parse(). (However, if `params` is the path or query string
   * from a #GUri that was parsed without %G_URI_FLAGS_PARSE_RELAXED and
   * %G_URI_FLAGS_ENCODED, then you already know that it does not contain any
   * invalid encoding.)
   *
   * %G_URI_PARAMS_WWW_FORM is handled as documented for g_uri_params_iter_init().
   *
   * If %G_URI_PARAMS_CASE_INSENSITIVE is passed to `flags,` attributes will be
   * compared case-insensitively, so a params string `attr=123&Attr=456` will only
   * return a single attribute–value pair, `Attr=456`. Case will be preserved in
   * the returned attributes.
   *
   * If `params` cannot be parsed (for example, it contains two `separators`
   * characters in a row), then `error` is set and %NULL is returned.
   * @param params a `%`-encoded string containing `attribute=value`   parameters
   * @param length the length of `params,` or `-1` if it is nul-terminated
   * @param separators the separator byte character set between parameters. (usually   `&`, but sometimes `;` or both `&;`). Note that this function works on   bytes not characters, so it can't be used to delimit UTF-8 strings for   anything but ASCII characters. You may pass an empty set, in which case   no splitting will occur.
   * @param flags flags to modify the way the parameters are handled.
   * @returns A hash table of attribute/value pairs, with both names and values     fully-decoded; or %NULL on error.
   */
  function uriParseParams(
    params: string,
    length: number,
    separators: string,
    flags: UriParamsFlags
  ): HashTable
  /**
   * Gets the scheme portion of a URI string.
   * [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
   * as:
   *
   * ```
   * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
   * ```
   *
   * Common schemes include `file`, `https`, `svn+ssh`, etc.
   * @param uri a valid URI.
   * @returns The ‘scheme’ component of the URI, or     %NULL on error. The returned string should be freed when no longer needed.
   */
  function uriParseScheme(uri: string): string | null
  /**
   * Gets the scheme portion of a URI string.
   * [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
   * as:
   *
   * ```
   * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
   * ```
   *
   * Common schemes include `file`, `https`, `svn+ssh`, etc.
   *
   * Unlike g_uri_parse_scheme(), the returned scheme is normalized to
   * all-lowercase and does not need to be freed.
   * @param uri a valid URI.
   * @returns The ‘scheme’ component of the URI, or     %NULL on error. The returned string is normalized to all-lowercase, and     interned via g_intern_string(), so it does not need to be freed.
   */
  function uriPeekScheme(uri: string): string | null
  /**
   * Parses `uri_ref` according to `flags` and, if it is a
   * [relative URI](#relative-and-absolute-uris), resolves it relative to
   * `base_uri_string`. If the result is not a valid absolute URI, it will be
   * discarded, and an error returned.
   *
   * (If `base_uri_string` is %NULL, this just returns `uri_ref,` or
   * %NULL if `uri_ref` is invalid or not absolute.)
   * @param baseUriString a string representing a base URI
   * @param uriRef a string representing a relative or absolute URI
   * @param flags flags describing how to parse `uri_ref`
   * @returns the resolved URI string, or NULL on error.
   */
  function uriResolveRelative(
    baseUriString: string | null,
    uriRef: string,
    flags: UriFlags
  ): string | null
  /**
   * Parses `uri_ref` (which can be an
   * [absolute or relative URI](#relative-and-absolute-uris)) according to `flags,` and
   * returns the pieces. Any component that doesn't appear in `uri_ref` will be
   * returned as %NULL (but note that all URIs always have a path component,
   * though it may be the empty string).
   *
   * If `flags` contains %G_URI_FLAGS_ENCODED, then `%`-encoded characters in
   * `uri_ref` will remain encoded in the output strings. (If not,
   * then all such characters will be decoded.) Note that decoding will
   * only work if the URI components are ASCII or UTF-8, so you will
   * need to use %G_URI_FLAGS_ENCODED if they are not.
   *
   * Note that the %G_URI_FLAGS_HAS_PASSWORD and
   * %G_URI_FLAGS_HAS_AUTH_PARAMS `flags` are ignored by g_uri_split(),
   * since it always returns only the full userinfo; use
   * g_uri_split_with_user() if you want it split up.
   * @param uriRef a string containing a relative or absolute URI
   * @param flags flags for parsing `uri_ref`
   * @returns %TRUE if @uri_ref parsed successfully, %FALSE   on error.
   */
  function uriSplit(
    uriRef: string,
    flags: UriFlags
  ): [
    /* returnType */ boolean,
    /* scheme */ string | null,
    /* userinfo */ string | null,
    /* host */ string | null,
    /* port */ number,
    /* path */ string,
    /* query */ string | null,
    /* fragment */ string | null,
  ]
  /**
   * Parses `uri_string` (which must be an [absolute URI](#relative-and-absolute-uris))
   * according to `flags,` and returns the pieces relevant to connecting to a host.
   * See the documentation for g_uri_split() for more details; this is
   * mostly a wrapper around that function with simpler arguments.
   * However, it will return an error if `uri_string` is a relative URI,
   * or does not contain a hostname component.
   * @param uriString a string containing an absolute URI
   * @param flags flags for parsing `uri_string`
   * @returns %TRUE if @uri_string parsed successfully,   %FALSE on error.
   */
  function uriSplitNetwork(
    uriString: string,
    flags: UriFlags
  ): [
    /* returnType */ boolean,
    /* scheme */ string | null,
    /* host */ string | null,
    /* port */ number,
  ]
  /**
   * Parses `uri_ref` (which can be an
   * [absolute or relative URI](#relative-and-absolute-uris)) according to `flags,` and
   * returns the pieces. Any component that doesn't appear in `uri_ref` will be
   * returned as %NULL (but note that all URIs always have a path component,
   * though it may be the empty string).
   *
   * See g_uri_split(), and the definition of #GUriFlags, for more
   * information on the effect of `flags`. Note that `password` will only
   * be parsed out if `flags` contains %G_URI_FLAGS_HAS_PASSWORD, and
   * `auth_params` will only be parsed out if `flags` contains
   * %G_URI_FLAGS_HAS_AUTH_PARAMS.
   * @param uriRef a string containing a relative or absolute URI
   * @param flags flags for parsing `uri_ref`
   * @returns %TRUE if @uri_ref parsed successfully, %FALSE   on error.
   */
  function uriSplitWithUser(
    uriRef: string,
    flags: UriFlags
  ): [
    /* returnType */ boolean,
    /* scheme */ string | null,
    /* user */ string | null,
    /* password */ string | null,
    /* authParams */ string | null,
    /* host */ string | null,
    /* port */ number,
    /* path */ string,
    /* query */ string | null,
    /* fragment */ string | null,
  ]
  /**
   * Unescapes a segment of an escaped string as binary data.
   *
   * Note that in contrast to g_uri_unescape_string(), this does allow
   * nul bytes to appear in the output.
   *
   * If any of the characters in `illegal_characters` appears as an escaped
   * character in `escaped_string,` then that is an error and %NULL will be
   * returned. This is useful if you want to avoid for instance having a slash
   * being expanded in an escaped path element, which might confuse pathname
   * handling.
   * @param escapedString A URI-escaped string
   * @param length the length (in bytes) of `escaped_string` to escape, or `-1` if it   is nul-terminated.
   * @param illegalCharacters a string of illegal characters   not to be allowed, or %NULL.
   * @returns an unescaped version of @escaped_string     or %NULL on error (if decoding failed, using %G_URI_ERROR_FAILED error     code). The returned #GBytes should be unreffed when no longer needed.
   */
  function uriUnescapeBytes(
    escapedString: string,
    length: number,
    illegalCharacters: string | null
  ): any
  /**
   * Unescapes a segment of an escaped string.
   *
   * If any of the characters in `illegal_characters` or the NUL
   * character appears as an escaped character in `escaped_string,` then
   * that is an error and %NULL will be returned. This is useful if you
   * want to avoid for instance having a slash being expanded in an
   * escaped path element, which might confuse pathname handling.
   *
   * Note: `NUL` byte is not accepted in the output, in contrast to
   * g_uri_unescape_bytes().
   * @param escapedString A string, may be %NULL
   * @param escapedStringEnd Pointer to end of `escaped_string,`   may be %NULL
   * @param illegalCharacters An optional string of illegal   characters not to be allowed, may be %NULL
   * @returns an unescaped version of @escaped_string, or %NULL on error. The returned string should be freed when no longer needed.  As a special case if %NULL is given for @escaped_string, this function will return %NULL.
   */
  function uriUnescapeSegment(
    escapedString: string | null,
    escapedStringEnd: string | null,
    illegalCharacters: string | null
  ): string | null
  /**
   * Unescapes a whole escaped string.
   *
   * If any of the characters in `illegal_characters` or the NUL
   * character appears as an escaped character in `escaped_string,` then
   * that is an error and %NULL will be returned. This is useful if you
   * want to avoid for instance having a slash being expanded in an
   * escaped path element, which might confuse pathname handling.
   * @param escapedString an escaped string to be unescaped.
   * @param illegalCharacters a string of illegal characters   not to be allowed, or %NULL.
   * @returns an unescaped version of @escaped_string. The returned string should be freed when no longer needed.
   */
  function uriUnescapeString(
    escapedString: string,
    illegalCharacters: string | null
  ): string | null
  /**
   * Pauses the current thread for the given number of microseconds.
   *
   * There are 1 million microseconds per second (represented by the
   * %G_USEC_PER_SEC macro). g_usleep() may have limited precision,
   * depending on hardware and operating system; don't rely on the exact
   * length of the sleep.
   * @param microseconds number of microseconds to pause
   */
  function usleep(microseconds: number): void
  /**
   * Convert a string from UTF-16 to UCS-4. The result will be
   * nul-terminated.
   * @param str a UTF-16 encoded string
   * @returns a pointer to a newly allocated UCS-4 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
   */
  function utf16ToUcs4(
    str: number[]
  ): [
    /* returnType */ string,
    /* itemsRead */ number,
    /* itemsWritten */ number,
  ]
  /**
   * Convert a string from UTF-16 to UTF-8. The result will be
   * terminated with a 0 byte.
   *
   * Note that the input is expected to be already in native endianness,
   * an initial byte-order-mark character is not handled specially.
   * g_convert() can be used to convert a byte buffer of UTF-16 data of
   * ambiguous endianness.
   *
   * Further note that this function does not validate the result
   * string; it may e.g. include embedded NUL characters. The only
   * validation done by this function is to ensure that the input can
   * be correctly interpreted as UTF-16, i.e. it doesn't contain
   * unpaired surrogates or partial character sequences.
   * @param str a UTF-16 encoded string
   * @returns a pointer to a newly allocated UTF-8 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
   */
  function utf16ToUtf8(
    str: number[]
  ): [
    /* returnType */ string | null,
    /* itemsRead */ number,
    /* itemsWritten */ number,
  ]
  /**
   * Converts a string into a form that is independent of case. The
   * result will not correspond to any particular case, but can be
   * compared for equality or ordered with the results of calling
   * g_utf8_casefold() on other strings.
   *
   * Note that calling g_utf8_casefold() followed by g_utf8_collate() is
   * only an approximation to the correct linguistic case insensitive
   * ordering, though it is a fairly good one. Getting this exactly
   * right would require a more sophisticated collation function that
   * takes case sensitivity into account. GLib does not currently
   * provide such a function.
   * @param str a UTF-8 encoded string
   * @param len length of `str,` in bytes, or -1 if `str` is nul-terminated.
   * @returns a newly allocated string, that is a   case independent form of @str.
   */
  function utf8Casefold(str: string, len: number): string | null
  /**
   * Compares two strings for ordering using the linguistically
   * correct rules for the [current locale][setlocale].
   * When sorting a large number of strings, it will be significantly
   * faster to obtain collation keys with g_utf8_collate_key() and
   * compare the keys with strcmp() when sorting instead of sorting
   * the original strings.
   *
   * If the two strings are not comparable due to being in different collation
   * sequences, the result is undefined. This can happen if the strings are in
   * different language scripts, for example.
   * @param str1 a UTF-8 encoded string
   * @param str2 a UTF-8 encoded string
   * @returns < 0 if @str1 compares before @str2,   0 if they compare equal, > 0 if @str1 compares after @str2.
   */
  function utf8Collate(str1: string, str2: string): number
  /**
   * Converts a string into a collation key that can be compared
   * with other collation keys produced by the same function using
   * strcmp().
   *
   * The results of comparing the collation keys of two strings
   * with strcmp() will always be the same as comparing the two
   * original keys with g_utf8_collate().
   *
   * Note that this function depends on the [current locale][setlocale].
   * @param str a UTF-8 encoded string.
   * @param len length of `str,` in bytes, or -1 if `str` is nul-terminated.
   * @returns a newly allocated string. This string should   be freed with g_free() when you are done with it.
   */
  function utf8CollateKey(str: string, len: number): string | null
  /**
   * Converts a string into a collation key that can be compared
   * with other collation keys produced by the same function using strcmp().
   *
   * In order to sort filenames correctly, this function treats the dot '.'
   * as a special case. Most dictionary orderings seem to consider it
   * insignificant, thus producing the ordering "event.c" "eventgenerator.c"
   * "event.h" instead of "event.c" "event.h" "eventgenerator.c". Also, we
   * would like to treat numbers intelligently so that "file1" "file10" "file5"
   * is sorted as "file1" "file5" "file10".
   *
   * Note that this function depends on the [current locale][setlocale].
   * @param str a UTF-8 encoded string.
   * @param len length of `str,` in bytes, or -1 if `str` is nul-terminated.
   * @returns a newly allocated string. This string should   be freed with g_free() when you are done with it.
   */
  function utf8CollateKeyForFilename(str: string, len: number): string | null
  /**
   * Finds the start of the next UTF-8 character in the string after `p`.
   *
   * `p` does not have to be at the beginning of a UTF-8 character. No check
   * is made to see if the character found is actually valid other than
   * it starts with an appropriate byte.
   *
   * If `end` is %NULL, the return value will never be %NULL: if the end of the
   * string is reached, a pointer to the terminating nul byte is returned. If
   * `end` is non-%NULL, the return value will be %NULL if the end of the string
   * is reached.
   * @param p a pointer to a position within a UTF-8 encoded string
   * @param end a pointer to the byte following the end of the string,     or %NULL to indicate that the string is nul-terminated
   * @returns a pointer to the found character or %NULL if @end is    set and is reached
   */
  function utf8FindNextChar(p: string, end: string | null): string | null
  /**
   * Given a position `p` with a UTF-8 encoded string `str,` find the start
   * of the previous UTF-8 character starting before `p`. Returns %NULL if no
   * UTF-8 characters are present in `str` before `p`.
   *
   * `p` does not have to be at the beginning of a UTF-8 character. No check
   * is made to see if the character found is actually valid other than
   * it starts with an appropriate byte.
   * @param str pointer to the beginning of a UTF-8 encoded string
   * @param p pointer to some position within `str`
   * @returns a pointer to the found character or %NULL.
   */
  function utf8FindPrevChar(str: string, p: string): string | null
  /**
   * Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
   *
   * If `p` does not point to a valid UTF-8 encoded character, results
   * are undefined. If you are not sure that the bytes are complete
   * valid Unicode characters, you should use g_utf8_get_char_validated()
   * instead.
   * @param p a pointer to Unicode character encoded as UTF-8
   * @returns the resulting character
   */
  function utf8GetChar(p: string): string
  /**
   * Convert a sequence of bytes encoded as UTF-8 to a Unicode character.
   * This function checks for incomplete characters, for invalid characters
   * such as characters that are out of the range of Unicode, and for
   * overlong encodings of valid characters.
   *
   * Note that g_utf8_get_char_validated() returns (gunichar)-2 if
   * `max_len` is positive and any of the bytes in the first UTF-8 character
   * sequence are nul.
   * @param p a pointer to Unicode character encoded as UTF-8
   * @param maxLen the maximum number of bytes to read, or -1 if `p` is nul-terminated
   * @returns the resulting character. If @p points to a partial     sequence at the end of a string that could begin a valid     character (or if @max_len is zero), returns (gunichar)-2;     otherwise, if @p does not point to a valid UTF-8 encoded     Unicode character, returns (gunichar)-1.
   */
  function utf8GetCharValidated(p: string, maxLen: number): string
  /**
   * If the provided string is valid UTF-8, return a copy of it. If not,
   * return a copy in which bytes that could not be interpreted as valid Unicode
   * are replaced with the Unicode replacement character (U+FFFD).
   *
   * For example, this is an appropriate function to use if you have received
   * a string that was incorrectly declared to be UTF-8, and you need a valid
   * UTF-8 version of it that can be logged or displayed to the user, with the
   * assumption that it is close enough to ASCII or UTF-8 to be mostly
   * readable as-is.
   * @param str string to coerce into UTF-8
   * @param len the maximum length of `str` to use, in bytes. If `len` < 0,     then the string is nul-terminated.
   * @returns a valid UTF-8 string whose content resembles @str
   */
  function utf8MakeValid(str: string, len: number): string | null
  /**
   * Converts a string into canonical form, standardizing
   * such issues as whether a character with an accent
   * is represented as a base character and combining
   * accent or as a single precomposed character. The
   * string has to be valid UTF-8, otherwise %NULL is
   * returned. You should generally call g_utf8_normalize()
   * before comparing two Unicode strings.
   *
   * The normalization mode %G_NORMALIZE_DEFAULT only
   * standardizes differences that do not affect the
   * text content, such as the above-mentioned accent
   * representation. %G_NORMALIZE_ALL also standardizes
   * the "compatibility" characters in Unicode, such
   * as SUPERSCRIPT THREE to the standard forms
   * (in this case DIGIT THREE). Formatting information
   * may be lost but for most text operations such
   * characters should be considered the same.
   *
   * %G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE
   * are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL,
   * but returned a result with composed forms rather
   * than a maximally decomposed form. This is often
   * useful if you intend to convert the string to
   * a legacy encoding or pass it to a system with
   * less capable Unicode handling.
   * @param str a UTF-8 encoded string.
   * @param len length of `str,` in bytes, or -1 if `str` is nul-terminated.
   * @param mode the type of normalization to perform.
   * @returns a newly allocated string, that   is the normalized form of @str, or %NULL if @str   is not valid UTF-8.
   */
  function utf8Normalize(
    str: string,
    len: number,
    mode: NormalizeMode
  ): string | null
  /**
   * Converts from an integer character offset to a pointer to a position
   * within the string.
   *
   * Since 2.10, this function allows to pass a negative `offset` to
   * step backwards. It is usually worth stepping backwards from the end
   * instead of forwards if `offset` is in the last fourth of the string,
   * since moving forward is about 3 times faster than moving backward.
   *
   * Note that this function doesn't abort when reaching the end of `str`.
   * Therefore you should be sure that `offset` is within string boundaries
   * before calling that function. Call g_utf8_strlen() when unsure.
   * This limitation exists as this function is called frequently during
   * text rendering and therefore has to be as fast as possible.
   * @param str a UTF-8 encoded string
   * @param offset a character offset within `str`
   * @returns the resulting pointer
   */
  function utf8OffsetToPointer(str: string, offset: number): string | null
  /**
   * Converts from a pointer to position within a string to an integer
   * character offset.
   *
   * Since 2.10, this function allows `pos` to be before `str,` and returns
   * a negative offset in this case.
   * @param str a UTF-8 encoded string
   * @param pos a pointer to a position within `str`
   * @returns the resulting character offset
   */
  function utf8PointerToOffset(str: string, pos: string): number
  /**
   * Finds the previous UTF-8 character in the string before `p`.
   *
   * `p` does not have to be at the beginning of a UTF-8 character. No check
   * is made to see if the character found is actually valid other than
   * it starts with an appropriate byte. If `p` might be the first
   * character of the string, you must use g_utf8_find_prev_char() instead.
   * @param p a pointer to a position within a UTF-8 encoded string
   * @returns a pointer to the found character
   */
  function utf8PrevChar(p: string): string | null
  /**
   * Finds the leftmost occurrence of the given Unicode character
   * in a UTF-8 encoded string, while limiting the search to `len` bytes.
   * If `len` is -1, allow unbounded search.
   * @param p a nul-terminated UTF-8 encoded string
   * @param len the maximum length of `p`
   * @param c a Unicode character
   * @returns %NULL if the string does not contain the character,     otherwise, a pointer to the start of the leftmost occurrence     of the character in the string.
   */
  function utf8Strchr(p: string, len: number, c: string): string | null
  /**
   * Converts all Unicode characters in the string that have a case
   * to lowercase. The exact manner that this is done depends
   * on the current locale, and may result in the number of
   * characters in the string changing.
   * @param str a UTF-8 encoded string
   * @param len length of `str,` in bytes, or -1 if `str` is nul-terminated.
   * @returns a newly allocated string, with all characters    converted to lowercase.
   */
  function utf8Strdown(str: string, len: number): string | null
  /**
   * Computes the length of the string in characters, not including
   * the terminating nul character. If the `max'`th byte falls in the
   * middle of a character, the last (partial) character is not counted.
   * @param p pointer to the start of a UTF-8 encoded string
   * @param max the maximum number of bytes to examine. If `max`       is less than 0, then the string is assumed to be       nul-terminated. If `max` is 0, `p` will not be examined and       may be %NULL. If `max` is greater than 0, up to `max`       bytes are examined
   * @returns the length of the string in characters
   */
  function utf8Strlen(p: string, max: number): number
  /**
   * Like the standard C strncpy() function, but copies a given number
   * of characters instead of a given number of bytes. The `src` string
   * must be valid UTF-8 encoded text. (Use g_utf8_validate() on all
   * text before trying to use UTF-8 utility functions with it.)
   *
   * Note you must ensure `dest` is at least 4 * `n` + 1 to fit the
   * largest possible UTF-8 characters
   * @param dest buffer to fill with characters from `src`
   * @param src UTF-8 encoded string
   * @param n character count
   * @returns @dest
   */
  function utf8Strncpy(
    dest: string | null,
    src: string,
    n: number
  ): string | null
  /**
   * Find the rightmost occurrence of the given Unicode character
   * in a UTF-8 encoded string, while limiting the search to `len` bytes.
   * If `len` is -1, allow unbounded search.
   * @param p a nul-terminated UTF-8 encoded string
   * @param len the maximum length of `p`
   * @param c a Unicode character
   * @returns %NULL if the string does not contain the character,     otherwise, a pointer to the start of the rightmost occurrence     of the character in the string.
   */
  function utf8Strrchr(p: string, len: number, c: string): string | null
  /**
   * Reverses a UTF-8 string. `str` must be valid UTF-8 encoded text.
   * (Use g_utf8_validate() on all text before trying to use UTF-8
   * utility functions with it.)
   *
   * This function is intended for programmatic uses of reversed strings.
   * It pays no attention to decomposed characters, combining marks, byte
   * order marks, directional indicators (LRM, LRO, etc) and similar
   * characters which might need special handling when reversing a string
   * for display purposes.
   *
   * Note that unlike g_strreverse(), this function returns
   * newly-allocated memory, which should be freed with g_free() when
   * no longer needed.
   * @param str a UTF-8 encoded string
   * @param len the maximum length of `str` to use, in bytes. If `len` < 0,     then the string is nul-terminated.
   * @returns a newly-allocated string which is the reverse of @str
   */
  function utf8Strreverse(str: string, len: number): string | null
  /**
   * Converts all Unicode characters in the string that have a case
   * to uppercase. The exact manner that this is done depends
   * on the current locale, and may result in the number of
   * characters in the string increasing. (For instance, the
   * German ess-zet will be changed to SS.)
   * @param str a UTF-8 encoded string
   * @param len length of `str,` in bytes, or -1 if `str` is nul-terminated.
   * @returns a newly allocated string, with all characters    converted to uppercase.
   */
  function utf8Strup(str: string, len: number): string | null
  /**
   * Copies a substring out of a UTF-8 encoded string.
   * The substring will contain `end_pos` - `start_pos` characters.
   *
   * Since GLib 2.72, `-1` can be passed to `end_pos` to indicate the
   * end of the string.
   * @param str a UTF-8 encoded string
   * @param startPos a character offset within `str`
   * @param endPos another character offset within `str,`   or `-1` to indicate the end of the string
   * @returns a newly allocated copy of the requested     substring. Free with g_free() when no longer needed.
   */
  function utf8Substring(
    str: string,
    startPos: number,
    endPos: number
  ): string | null
  /**
   * Convert a string from UTF-8 to a 32-bit fixed width
   * representation as UCS-4. A trailing 0 character will be added to the
   * string after the converted text.
   * @param str a UTF-8 encoded string
   * @param len the maximum length of `str` to use, in bytes. If `len` < 0,     then the string is nul-terminated.
   * @returns a pointer to a newly allocated UCS-4 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
   */
  function utf8ToUcs4(
    str: string,
    len: number
  ): [
    /* returnType */ string,
    /* itemsRead */ number,
    /* itemsWritten */ number,
  ]
  /**
   * Convert a string from UTF-8 to a 32-bit fixed width
   * representation as UCS-4, assuming valid UTF-8 input.
   * This function is roughly twice as fast as g_utf8_to_ucs4()
   * but does no error checking on the input. A trailing 0 character
   * will be added to the string after the converted text.
   * @param str a UTF-8 encoded string
   * @param len the maximum length of `str` to use, in bytes. If `len` < 0,     then the string is nul-terminated.
   * @returns a pointer to a newly allocated UCS-4 string.     This value must be freed with g_free().
   */
  function utf8ToUcs4Fast(
    str: string,
    len: number
  ): [/* returnType */ string, /* itemsWritten */ number]
  /**
   * Convert a string from UTF-8 to UTF-16. A 0 character will be
   * added to the result after the converted text.
   * @param str a UTF-8 encoded string
   * @param len the maximum length (number of bytes) of `str` to use.     If `len` < 0, then the string is nul-terminated.
   * @returns a pointer to a newly allocated UTF-16 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
   */
  function utf8ToUtf16(
    str: string,
    len: number
  ): [
    /* returnType */ number,
    /* itemsRead */ number,
    /* itemsWritten */ number,
  ]
  /**
   * Cuts off the middle of the string, preserving half of `truncate_length`
   * characters at the beginning and half at the end.
   *
   * If `string` is already short enough, this returns a copy of `string`.
   * If `truncate_length` is `0`, an empty string is returned.
   * @param string a nul-terminated UTF-8 encoded string
   * @param truncateLength the new size of `string,` in characters, including the ellipsis character
   * @returns a newly-allocated copy of @string ellipsized in the middle
   */
  function utf8TruncateMiddle(
    string: string,
    truncateLength: number
  ): string | null
  /**
   * Validates UTF-8 encoded text. `str` is the text to validate;
   * if `str` is nul-terminated, then `max_len` can be -1, otherwise
   * `max_len` should be the number of bytes to validate.
   * If `end` is non-%NULL, then the end of the valid range
   * will be stored there (i.e. the start of the first invalid
   * character if some bytes were invalid, or the end of the text
   * being validated otherwise).
   *
   * Note that g_utf8_validate() returns %FALSE if `max_len` is
   * positive and any of the `max_len` bytes are nul.
   *
   * Returns %TRUE if all of `str` was valid. Many GLib and GTK
   * routines require valid UTF-8 as input; so data read from a file
   * or the network should be checked with g_utf8_validate() before
   * doing anything else with it.
   * @param str a pointer to character data
   * @returns %TRUE if the text was valid UTF-8
   */
  function utf8Validate(
    str: number[]
  ): [/* returnType */ boolean, /* end */ string]
  /**
   * Validates UTF-8 encoded text.
   *
   * As with g_utf8_validate(), but `max_len` must be set, and hence this function
   * will always return %FALSE if any of the bytes of `str` are nul.
   * @param str a pointer to character data
   * @returns %TRUE if the text was valid UTF-8
   */
  function utf8ValidateLen(
    str: number[]
  ): [/* returnType */ boolean, /* end */ string]
  /**
   * A wrapper for the POSIX utime() function. The utime() function
   * sets the access and modification timestamps of a file.
   *
   * See your C library manual for more details about how utime() works
   * on your system.
   * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
   * @param utb a pointer to a struct utimbuf.
   * @returns 0 if the operation was successful, -1 if an error occurred
   */
  function utime(filename: string, utb: any | null): number
  /**
   * Parses the string `str` and verify if it is a UUID.
   *
   * The function accepts the following syntax:
   *
   * - simple forms (e.g. `f81d4fae-7dec-11d0-a765-00a0c91e6bf6`)
   *
   * Note that hyphens are required within the UUID string itself,
   * as per the aforementioned RFC.
   * @param str a string representing a UUID
   * @returns %TRUE if @str is a valid UUID, %FALSE otherwise.
   */
  function uuidStringIsValid(str: string): boolean
  /**
   * Generates a random UUID (RFC 4122 version 4) as a string. It has the same
   * randomness guarantees as #GRand, so must not be used for cryptographic
   * purposes such as key generation, nonces, salts or one-time pads.
   * @returns A string that should be freed with g_free().
   */
  function uuidStringRandom(): string | null
  function variantGetGtype(): GObject.GType
  /**
   * Determines if a given string is a valid D-Bus object path.  You
   * should ensure that a string is a valid D-Bus object path before
   * passing it to g_variant_new_object_path().
   *
   * A valid object path starts with `/` followed by zero or more
   * sequences of characters separated by `/` characters.  Each sequence
   * must contain only the characters `[A-Z][a-z][0-9]_`.  No sequence
   * (including the one following the final `/` character) may be empty.
   * @param string a normal C nul-terminated string
   * @returns %TRUE if @string is a D-Bus object path
   */
  function variantIsObjectPath(string: string): boolean
  /**
   * Determines if a given string is a valid D-Bus type signature.  You
   * should ensure that a string is a valid D-Bus type signature before
   * passing it to g_variant_new_signature().
   *
   * D-Bus type signatures consist of zero or more definite #GVariantType
   * strings in sequence.
   * @param string a normal C nul-terminated string
   * @returns %TRUE if @string is a D-Bus type signature
   */
  function variantIsSignature(string: string): boolean
  /**
   * Parses a #GVariant from a text representation.
   *
   * A single #GVariant is parsed from the content of `text`.
   *
   * The format is described [here](gvariant-text-format.html).
   *
   * The memory at `limit` will never be accessed and the parser behaves as
   * if the character at `limit` is the nul terminator.  This has the
   * effect of bounding `text`.
   *
   * If `endptr` is non-%NULL then `text` is permitted to contain data
   * following the value that this function parses and `endptr` will be
   * updated to point to the first character past the end of the text
   * parsed by this function.  If `endptr` is %NULL and there is extra data
   * then an error is returned.
   *
   * If `type` is non-%NULL then the value will be parsed to have that
   * type.  This may result in additional parse errors (in the case that
   * the parsed value doesn't fit the type) but may also result in fewer
   * errors (in the case that the type would have been ambiguous, such as
   * with empty arrays).
   *
   * In the event that the parsing is successful, the resulting #GVariant
   * is returned. It is never floating, and must be freed with
   * [method`GLib`.Variant.unref].
   *
   * In case of any error, %NULL will be returned.  If `error` is non-%NULL
   * then it will be set to reflect the error that occurred.
   *
   * Officially, the language understood by the parser is “any string
   * produced by [method`GLib`.Variant.print]”. This explicitly includes
   * `g_variant_print()`’s annotated types like `int64 -1000`.
   *
   * There may be implementation specific restrictions on deeply nested values,
   * which would result in a %G_VARIANT_PARSE_ERROR_RECURSION error. #GVariant is
   * guaranteed to handle nesting up to at least 64 levels.
   * @param type a #GVariantType, or %NULL
   * @param text a string containing a GVariant in text form
   * @param limit a pointer to the end of `text,` or %NULL
   * @param endptr a location to store the end pointer, or %NULL
   * @returns a non-floating reference to a #GVariant, or %NULL
   */
  function variantParse(
    type: VariantType | null,
    text: string,
    limit: string | null,
    endptr: string | null
  ): Variant
  /**
   * Pretty-prints a message showing the context of a #GVariant parse
   * error within the string for which parsing was attempted.
   *
   * The resulting string is suitable for output to the console or other
   * monospace media where newlines are treated in the usual way.
   *
   * The message will typically look something like one of the following:
   *
   *
   * ```
   * unterminated string constant:
   *   (1, 2, 3, 'abc
   *             ^^^^
   * ```
   *
   *
   * or
   *
   *
   * ```
   * unable to find a common type:
   *   [1, 2, 3, 'str']
   *    ^        ^^^^^
   * ```
   *
   *
   * The format of the message may change in a future version.
   *
   * `error` must have come from a failed attempt to g_variant_parse() and
   * `source_str` must be exactly the same string that caused the error.
   * If `source_str` was not nul-terminated when you passed it to
   * g_variant_parse() then you must add nul termination before using this
   * function.
   * @param error a #GError from the #GVariantParseError domain
   * @param sourceStr the string that was given to the parser
   * @returns the printed message
   */
  function variantParseErrorPrintContext(
    error: Error,
    sourceStr: string
  ): string | null
  function variantParseErrorQuark(): Quark
  /**
   * Same as g_variant_error_quark().
   */
  function variantParserGetErrorQuark(): Quark
  function variantTypeChecked(typeString: string): VariantType
  function variantTypeStringGetDepth(typeString: string): number
  /**
   * Checks if `type_string` is a valid GVariant type string.  This call is
   * equivalent to calling g_variant_type_string_scan() and confirming
   * that the following character is a nul terminator.
   * @param typeString a pointer to any string
   * @returns %TRUE if @type_string is exactly one valid type string Since 2.24
   */
  function variantTypeStringIsValid(typeString: string): boolean
  /**
   * Scan for a single complete and valid GVariant type string in `string`.
   * The memory pointed to by `limit` (or bytes beyond it) is never
   * accessed.
   *
   * If a valid type string is found, `endptr` is updated to point to the
   * first character past the end of the string that was found and %TRUE
   * is returned.
   *
   * If there is no valid type string starting at `string,` or if the type
   * string does not end before `limit` then %FALSE is returned.
   *
   * For the simple case of checking if a string is a valid type string,
   * see g_variant_type_string_is_valid().
   * @param string a pointer to any string
   * @param limit the end of `string,` or %NULL
   * @returns %TRUE if a valid type string was found
   */
  function variantTypeStringScan(
    string: string,
    limit: string | null
  ): [/* returnType */ boolean, /* endptr */ string]
  /**
   * Specifies the type of the `value_destroy_func` and `key_destroy_func`
   * functions passed to g_cache_new(). The functions are passed a
   * pointer to the #GCache key or #GCache value and should free any
   * memory and other resources associated with it.
   * @callback
   * @param value the #GCache value to destroy
   */
  interface CacheDestroyFunc {
    (value: any | null): void
  }
  /**
   * Specifies the type of the `key_dup_func` function passed to
   * g_cache_new(). The function is passed a key
   * (__not__ a value as the prototype implies) and
   * should return a duplicate of the key.
   * @callback
   * @param value the #GCache key to destroy (__not__ a         #GCache value as it seems)
   * @returns a copy of the #GCache key
   */
  interface CacheDupFunc {
    (value: any | null): any | null
  }
  /**
   * Specifies the type of the `value_new_func` function passed to
   * g_cache_new(). It is passed a #GCache key and should create the
   * value corresponding to the key.
   * @callback
   * @param key a #GCache key
   * @returns a new #GCache value corresponding to the key.
   */
  interface CacheNewFunc {
    (key: any | null): any | null
  }
  /**
   * Prototype of a #GChildWatchSource callback, called when a child
   * process has exited.
   *
   * To interpret `wait_status,` see the documentation
   * for g_spawn_check_wait_status(). In particular,
   * on Unix platforms, note that it is usually not equal
   * to the integer passed to `exit()` or returned from `main()`.
   * @callback
   * @param pid the process id of the child process
   * @param waitStatus Status information about the child process, encoded               in a platform-specific manner
   */
  interface ChildWatchFunc {
    (pid: Pid, waitStatus: number): void
  }
  /**
   * Specifies the type of function passed to g_clear_handle_id().
   * The implementation is expected to free the resource identified
   * by `handle_id;` for instance, if `handle_id` is a #GSource ID,
   * g_source_remove() can be used.
   * @callback
   * @param handleId the handle ID to clear
   */
  interface ClearHandleFunc {
    (handleId: number): void
  }
  /**
   * Specifies the type of a comparison function used to compare two
   * values.  The function should return a negative integer if the first
   * value comes before the second, 0 if they are equal, or a positive
   * integer if the first value comes after the second.
   * @callback
   * @param a a value
   * @param b a value to compare with
   * @returns negative value if @a < @b; zero if @a = @b; positive          value if @a > @b
   */
  interface CompareDataFunc {
    (a: any | null, b: any | null): number
  }
  /**
   * Specifies the type of a comparison function used to compare two
   * values.  The function should return a negative integer if the first
   * value comes before the second, 0 if they are equal, or a positive
   * integer if the first value comes after the second.
   * @callback
   * @param a a value
   * @param b a value to compare with
   * @returns negative value if @a < @b; zero if @a = @b; positive          value if @a > @b
   */
  interface CompareFunc {
    (a: any | null, b: any | null): number
  }
  /**
   * Specifies the type of the function passed to g_completion_new(). It
   * should return the string corresponding to the given target item.
   * This is used when you use data structures as #GCompletion items.
   * @callback
   * @param item the completion item.
   * @returns the string corresponding to the item.
   */
  interface CompletionFunc {
    (item: any | null): string | null
  }
  /**
   * Specifies the type of the function passed to
   * g_completion_set_compare(). This is used when you use strings as
   * #GCompletion items.
   * @callback
   * @param s1 string to compare with `s2`.
   * @param s2 string to compare with `s1`.
   * @param n maximal number of bytes to compare.
   * @returns an integer less than, equal to, or greater than zero if          the first @n bytes of @s1 is found, respectively, to be          less than, to match, or to be greater than the first @n          bytes of @s2.
   */
  interface CompletionStrncmpFunc {
    (s1: string, s2: string, n: number): number
  }
  /**
   * A function of this signature is used to copy the node data
   * when doing a deep-copy of a tree.
   * @callback
   * @param src A pointer to the data which should be copied
   * @param data Additional data
   * @returns A pointer to the copy
   */
  interface CopyFunc {
    (src: any, data: any | null): any
  }
  /**
   * Specifies the type of function passed to g_dataset_foreach(). It is
   * called with each #GQuark id and associated data element, together
   * with the `user_data` parameter supplied to g_dataset_foreach().
   * @callback
   * @param keyId the #GQuark id to identifying the data element.
   * @param data the data element.
   */
  interface DataForeachFunc {
    (keyId: Quark, data: any | null): void
  }
  /**
   * Specifies the type of function which is called when a data element
   * is destroyed. It is passed the pointer to the data element and
   * should free any memory and resources allocated for it.
   * @callback
   * @param data the data element.
   */
  interface DestroyNotify {
    (data: any | null): void
  }
  /**
   * The type of functions that are used to 'duplicate' an object.
   * What this means depends on the context, it could just be
   * incrementing the reference count, if `data` is a ref-counted
   * object.
   * @callback
   * @param data the data to duplicate
   * @returns a duplicate of data
   */
  interface DuplicateFunc {
    (data: any | null): any | null
  }
  /**
   * Specifies the type of a function used to test two values for
   * equality. The function should return %TRUE if both values are equal
   * and %FALSE otherwise.
   * @callback
   * @param a a value
   * @param b a value to compare with
   * @returns %TRUE if @a = @b; %FALSE otherwise
   */
  interface EqualFunc {
    (a: any | null, b: any | null): boolean
  }
  /**
   * Specifies the type of a function used to test two values for
   * equality. The function should return %TRUE if both values are equal
   * and %FALSE otherwise.
   *
   * This is a version of #GEqualFunc which provides a `user_data` closure from
   * the caller.
   * @callback
   * @param a a value
   * @param b a value to compare with
   * @returns %TRUE if @a = @b; %FALSE otherwise
   */
  interface EqualFuncFull {
    (a: any | null, b: any | null): boolean
  }
  /**
   * Specifies the type of function which is called when an extended
   * error instance is freed. It is passed the error pointer about to be
   * freed, and should free the error's private data fields.
   *
   * Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it
   * already takes care of getting the private data from `error`.
   * @callback
   * @param error extended error to clear
   */
  interface ErrorClearFunc {
    (error: Error): void
  }
  /**
   * Specifies the type of function which is called when an extended
   * error instance is copied. It is passed the pointer to the
   * destination error and source error, and should copy only the fields
   * of the private data from `src_error` to `dest_error`.
   *
   * Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it
   * already takes care of getting the private data from `src_error` and
   * `dest_error`.
   * @callback
   * @param srcError source extended error
   * @param destError destination extended error
   */
  interface ErrorCopyFunc {
    (srcError: Error, destError: Error): void
  }
  /**
   * Specifies the type of function which is called just after an
   * extended error instance is created and its fields filled. It should
   * only initialize the fields in the private data, which can be
   * received with the generated `*_get_private()` function.
   *
   * Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it
   * already takes care of getting the private data from `error`.
   * @callback
   * @param error extended error
   */
  interface ErrorInitFunc {
    (error: Error): void
  }
  /**
   * Declares a type of function which takes an arbitrary
   * data pointer argument and has no return value. It is
   * not currently used in GLib or GTK.
   * @callback
   * @param data a data pointer
   */
  interface FreeFunc {
    (data: any | null): void
  }
  /**
   * Specifies the type of functions passed to g_list_foreach() and
   * g_slist_foreach().
   * @callback
   * @param data the element's data
   */
  interface Func {
    (data: any | null): void
  }
  /**
   * Specifies the type of the function passed to g_hash_table_foreach().
   * It is called with each key/value pair, together with the `user_data`
   * parameter which is passed to g_hash_table_foreach().
   * @callback
   * @param key a key
   * @param value the value corresponding to the key
   */
  interface HFunc {
    (key: any | null, value: any | null): void
  }
  /**
   * Specifies the type of the function passed to
   * g_hash_table_foreach_remove(). It is called with each key/value
   * pair, together with the `user_data` parameter passed to
   * g_hash_table_foreach_remove(). It should return %TRUE if the
   * key/value pair should be removed from the #GHashTable.
   * @callback
   * @param key a key
   * @param value the value associated with the key
   * @returns %TRUE if the key/value pair should be removed from the     #GHashTable
   */
  interface HRFunc {
    (key: any | null, value: any | null): boolean
  }
  /**
   * Specifies the type of the hash function which is passed to
   * g_hash_table_new() when a #GHashTable is created.
   *
   * The function is passed a key and should return a #guint hash value.
   * The functions g_direct_hash(), g_int_hash() and g_str_hash() provide
   * hash functions which can be used when the key is a #gpointer, #gint*,
   * and #gchar* respectively.
   *
   * g_direct_hash() is also the appropriate hash function for keys
   * of the form `GINT_TO_POINTER (n)` (or similar macros).
   *
   * A good hash functions should produce
   * hash values that are evenly distributed over a fairly large range.
   * The modulus is taken with the hash table size (a prime number) to
   * find the 'bucket' to place each key into. The function should also
   * be very fast, since it is called for each key lookup.
   *
   * Note that the hash functions provided by GLib have these qualities,
   * but are not particularly robust against manufactured keys that
   * cause hash collisions. Therefore, you should consider choosing
   * a more secure hash function when using a GHashTable with keys
   * that originate in untrusted data (such as HTTP requests).
   * Using g_str_hash() in that situation might make your application
   * vulnerable to
   * [Algorithmic Complexity Attacks](https://lwn.net/Articles/474912/).
   *
   * The key to choosing a good hash is unpredictability.  Even
   * cryptographic hashes are very easy to find collisions for when the
   * remainder is taken modulo a somewhat predictable prime number.  There
   * must be an element of randomness that an attacker is unable to guess.
   * @callback
   * @param key a key
   * @returns the hash value corresponding to the key
   */
  interface HashFunc {
    (key: any | null): number
  }
  /**
   * Defines the type of a hook function that can be invoked
   * by g_hook_list_invoke_check().
   * @callback
   * @param data the data field of the #GHook is passed to the hook function here
   * @returns %FALSE if the #GHook should be destroyed
   */
  interface HookCheckFunc {
    (data: any | null): boolean
  }
  /**
   * Defines the type of function used by g_hook_list_marshal_check().
   * @callback
   * @param hook a #GHook
   * @param marshalData user data
   * @returns %FALSE if @hook should be destroyed
   */
  interface HookCheckMarshaller {
    (hook: Hook, marshalData: any | null): boolean
  }
  /**
   * Defines the type of function used to compare #GHook elements in
   * g_hook_insert_sorted().
   * @callback
   * @param newHook the #GHook being inserted
   * @param sibling the #GHook to compare with `new_hook`
   * @returns a value <= 0 if @new_hook should be before @sibling
   */
  interface HookCompareFunc {
    (newHook: Hook, sibling: Hook): number
  }
  /**
   * Defines the type of function to be called when a hook in a
   * list of hooks gets finalized.
   * @callback
   * @param hookList a #GHookList
   * @param hook the hook in `hook_list` that gets finalized
   */
  interface HookFinalizeFunc {
    (hookList: HookList, hook: Hook): void
  }
  /**
   * Defines the type of the function passed to g_hook_find().
   * @callback
   * @param hook a #GHook
   * @param data user data passed to g_hook_find_func()
   * @returns %TRUE if the required #GHook has been found
   */
  interface HookFindFunc {
    (hook: Hook, data: any | null): boolean
  }
  /**
   * Defines the type of a hook function that can be invoked
   * by g_hook_list_invoke().
   * @callback
   * @param data the data field of the #GHook is passed to the hook function here
   */
  interface HookFunc {
    (data: any | null): void
  }
  /**
   * Defines the type of function used by g_hook_list_marshal().
   * @callback
   * @param hook a #GHook
   * @param marshalData user data
   */
  interface HookMarshaller {
    (hook: Hook, marshalData: any | null): void
  }
  /**
   * Specifies the type of function passed to g_io_add_watch() or
   * g_io_add_watch_full(), which is called when the requested condition
   * on a #GIOChannel is satisfied.
   * @callback
   * @param source the #GIOChannel event source
   * @param condition the condition which has been satisfied
   * @param data user data set in g_io_add_watch() or g_io_add_watch_full()
   * @returns the function should return %FALSE if the event source          should be removed
   */
  interface IOFunc {
    (source: IOChannel, condition: IOCondition, data: any | null): boolean
  }
  /**
   * Specifies the prototype of log handler functions.
   *
   * The default log handler, [func`GLib`.log_default_handler], automatically appends a
   * new-line character to `message` when printing it. It is advised that any
   * custom log handler functions behave similarly, so that logging calls in user
   * code do not need modifying to add a new-line character to the message if the
   * log handler is changed.
   *
   * This is not used if structured logging is enabled; see
   * [Using Structured Logging](logging.html#using-structured-logging).
   * @callback
   * @param logDomain the log domain of the message
   * @param logLevel the log level of the message (including the   fatal and recursion flags)
   * @param message the message to process
   */
  interface LogFunc {
    (logDomain: string, logLevel: LogLevelFlags, message: string): void
  }
  /**
   * Writer function for log entries. A log entry is a collection of one or more
   * #GLogFields, using the standard [field names from journal
   * specification](https://www.freedesktop.org/software/systemd/man/systemd.journal-fields.html).
   * See g_log_structured() for more information.
   *
   * Writer functions must ignore fields which they do not recognise, unless they
   * can write arbitrary binary output, as field values may be arbitrary binary.
   *
   * `log_level` is guaranteed to be included in `fields` as the `PRIORITY` field,
   * but is provided separately for convenience of deciding whether or where to
   * output the log entry.
   *
   * Writer functions should return %G_LOG_WRITER_HANDLED if they handled the log
   * message successfully or if they deliberately ignored it. If there was an
   * error handling the message (for example, if the writer function is meant to
   * send messages to a remote logging server and there is a network error), it
   * should return %G_LOG_WRITER_UNHANDLED. This allows writer functions to be
   * chained and fall back to simpler handlers in case of failure.
   * @callback
   * @param logLevel log level of the message
   * @param fields fields forming the message
   * @returns %G_LOG_WRITER_HANDLED if the log entry was handled successfully;   %G_LOG_WRITER_UNHANDLED otherwise
   */
  interface LogWriterFunc {
    (logLevel: LogLevelFlags, fields: LogField[]): LogWriterOutput
  }
  /**
   * Specifies the type of function passed to g_node_children_foreach().
   * The function is called with each child node, together with the user
   * data passed to g_node_children_foreach().
   * @callback
   * @param node a #GNode.
   * @param data user data passed to g_node_children_foreach().
   */
  interface NodeForeachFunc {
    (node: Node, data: any | null): void
  }
  /**
   * Specifies the type of function passed to g_node_traverse(). The
   * function is called with each of the nodes visited, together with the
   * user data passed to g_node_traverse(). If the function returns
   * %TRUE, then the traversal is stopped.
   * @callback
   * @param node a #GNode.
   * @param data user data passed to g_node_traverse().
   * @returns %TRUE to stop the traversal.
   */
  interface NodeTraverseFunc {
    (node: Node, data: any | null): boolean
  }
  /**
   * The type of function to be passed as callback for %G_OPTION_ARG_CALLBACK
   * options.
   * @callback
   * @param optionName The name of the option being parsed. This will be either a  single dash followed by a single letter (for a short name) or two dashes  followed by a long option name.
   * @param value The value to be parsed.
   * @param data User data added to the #GOptionGroup containing the option when it  was created with g_option_group_new()
   * @returns %TRUE if the option was successfully parsed, %FALSE if an error  occurred, in which case @error should be set with g_set_error()
   */
  interface OptionArgFunc {
    (optionName: string, value: string, data: any | null): boolean
  }
  /**
   * The type of function to be used as callback when a parse error occurs.
   * @callback
   * @param context The active #GOptionContext
   * @param group The group to which the function belongs
   * @param data User data added to the #GOptionGroup containing the option when it  was created with g_option_group_new()
   */
  interface OptionErrorFunc {
    (context: OptionContext, group: OptionGroup, data: any | null): void
  }
  /**
   * The type of function that can be called before and after parsing.
   * @callback
   * @param context The active #GOptionContext
   * @param group The group to which the function belongs
   * @param data User data added to the #GOptionGroup containing the option when it  was created with g_option_group_new()
   * @returns %TRUE if the function completed successfully, %FALSE if an error  occurred, in which case @error should be set with g_set_error()
   */
  interface OptionParseFunc {
    (context: OptionContext, group: OptionGroup, data: any | null): boolean
  }
  /**
   * Specifies the type of function passed to g_main_context_set_poll_func().
   * The semantics of the function should match those of the poll() system call.
   * @callback
   * @param ufds an array of #GPollFD elements
   * @param nfsd the number of elements in `ufds`
   * @param timeout the maximum time to wait for an event of the file descriptors.     A negative value indicates an infinite timeout.
   * @returns the number of #GPollFD elements which have events or errors     reported, or -1 if an error occurred.
   */
  interface PollFunc {
    (ufds: PollFD, nfsd: number, timeout: number): number
  }
  /**
   * Specifies the type of the print handler functions.
   * These are called with the complete formatted string to output.
   * @callback
   * @param string the message to output
   */
  interface PrintFunc {
    (string: string): void
  }
  /**
   * Specifies the type of the function passed to g_regex_replace_eval().
   * It is called for each occurrence of the pattern in the string passed
   * to g_regex_replace_eval(), and it should append the replacement to
   * `result`.
   * @callback
   * @param matchInfo the #GMatchInfo generated by the match.     Use g_match_info_get_regex() and g_match_info_get_string() if you     need the #GRegex or the matched string.
   * @param result a #GString containing the new string
   * @returns %FALSE to continue the replacement process, %TRUE to stop it
   */
  interface RegexEvalCallback {
    (matchInfo: MatchInfo, result: String): boolean
  }
  /**
   * Specifies the type of the message handler function.
   * @callback
   * @param scanner a #GScanner
   * @param message the message
   * @param error %TRUE if the message signals an error,     %FALSE if it signals a warning.
   */
  interface ScannerMsgFunc {
    (scanner: Scanner, message: string | null, error: boolean): void
  }
  /**
   * A #GSequenceIterCompareFunc is a function used to compare iterators.
   * It must return zero if the iterators compare equal, a negative value
   * if `a` comes before `b,` and a positive value if `b` comes before `a`.
   * @callback
   * @param a a #GSequenceIter
   * @param b a #GSequenceIter
   * @param data user data
   * @returns zero if the iterators are equal, a negative value if @a     comes before @b, and a positive value if @b comes before @a.
   */
  interface SequenceIterCompareFunc {
    (a: SequenceIter, b: SequenceIter, data: any | null): number
  }
  /**
   * Dispose function for `source`. See g_source_set_dispose_function() for
   * details.
   * @callback
   * @param source #GSource that is currently being disposed
   */
  interface SourceDisposeFunc {
    (source: Source): void
  }
  /**
   * This is just a placeholder for #GClosureMarshal,
   * which cannot be used here for dependency reasons.
   * @callback
   */
  interface SourceDummyMarshal {
    (): void
  }
  /**
   * Specifies the type of function passed to g_timeout_add(),
   * g_timeout_add_full(), g_idle_add(), and g_idle_add_full().
   *
   * When calling g_source_set_callback(), you may need to cast a function of a
   * different type to this type. Use G_SOURCE_FUNC() to avoid warnings about
   * incompatible function types.
   * @callback
   * @returns %FALSE if the source should be removed. %G_SOURCE_CONTINUE and %G_SOURCE_REMOVE are more memorable names for the return value.
   */
  interface SourceFunc {
    (): boolean
  }
  /**
   * A source function that is only called once before being removed from the main
   * context automatically.
   *
   * See: g_idle_add_once(), g_timeout_add_once()
   * @callback
   */
  interface SourceOnceFunc {
    (): void
  }
  /**
   * Specifies the type of the setup function passed to g_spawn_async(),
   * g_spawn_sync() and g_spawn_async_with_pipes(), which can, in very
   * limited ways, be used to affect the child's execution.
   *
   * On POSIX platforms, the function is called in the child after GLib
   * has performed all the setup it plans to perform, but before calling
   * exec(). Actions taken in this function will only affect the child,
   * not the parent.
   *
   * On Windows, the function is called in the parent. Its usefulness on
   * Windows is thus questionable. In many cases executing the child setup
   * function in the parent can have ill effects, and you should be very
   * careful when porting software to Windows that uses child setup
   * functions.
   *
   * However, even on POSIX, you are extremely limited in what you can
   * safely do from a #GSpawnChildSetupFunc, because any mutexes that were
   * held by other threads in the parent process at the time of the fork()
   * will still be locked in the child process, and they will never be
   * unlocked (since the threads that held them don't exist in the child).
   * POSIX allows only async-signal-safe functions (see signal(7)) to be
   * called in the child between fork() and exec(), which drastically limits
   * the usefulness of child setup functions.
   *
   * In particular, it is not safe to call any function which may
   * call malloc(), which includes POSIX functions such as setenv().
   * If you need to set up the child environment differently from
   * the parent, you should use g_get_environ(), g_environ_setenv(),
   * and g_environ_unsetenv(), and then pass the complete environment
   * list to the `g_spawn...` function.
   * @callback
   * @param data user data passed to the function.
   */
  interface SpawnChildSetupFunc {
    (data: any | null): void
  }
  /**
   * The type used for test case functions that take an extra pointer
   * argument.
   * @callback
   */
  interface TestDataFunc {
    (): void
  }
  /**
   * The type used for functions that operate on test fixtures.  This is
   * used for the fixture setup and teardown functions as well as for the
   * testcases themselves.
   *
   * `user_data` is a pointer to the data that was given when registering
   * the test case.
   *
   * `fixture` will be a pointer to the area of memory allocated by the
   * test framework, of the size requested.  If the requested size was
   * zero then `fixture` will be equal to `user_data`.
   * @callback
   * @param fixture the test fixture
   */
  interface TestFixtureFunc {
    (fixture: any): void
  }
  /**
   * The type used for test case functions.
   * @callback
   */
  interface TestFunc {
    (): void
  }
  /**
   * Specifies the prototype of fatal log handler functions.
   * @callback
   * @param logDomain the log domain of the message
   * @param logLevel the log level of the message (including the fatal and recursion flags)
   * @param message the message to process
   * @returns %TRUE if the program should abort, %FALSE otherwise
   */
  interface TestLogFatalFunc {
    (logDomain: string, logLevel: LogLevelFlags, message: string): boolean
  }
  /**
   * Specifies the type of the `func` functions passed to g_thread_new()
   * or g_thread_try_new().
   * @callback
   * @param data data passed to the thread
   * @returns the return value of the thread
   */
  interface ThreadFunc {
    (data: any | null): any | null
  }
  /**
   * The type of functions which are used to translate user-visible
   * strings, for <option>--help</option> output.
   * @callback
   * @param str the untranslated string
   * @param data user data specified when installing the function, e.g.  in g_option_group_set_translate_func()
   * @returns a translation of the string for the current locale.  The returned string is owned by GLib and must not be freed.
   */
  interface TranslateFunc {
    (str: string, data: any | null): string
  }
  /**
   * Specifies the type of function passed to g_tree_traverse(). It is
   * passed the key and value of each node, together with the `user_data`
   * parameter passed to g_tree_traverse(). If the function returns
   * %TRUE, the traversal is stopped.
   * @callback
   * @param key a key of a #GTree node
   * @param value the value corresponding to the key
   * @param data user data passed to g_tree_traverse()
   * @returns %TRUE to stop the traversal
   */
  interface TraverseFunc {
    (key: any | null, value: any | null, data: any | null): boolean
  }
  /**
   * Specifies the type of function passed to g_tree_foreach_node(). It is
   * passed each node, together with the `user_data` parameter passed to
   * g_tree_foreach_node(). If the function returns %TRUE, the traversal is
   * stopped.
   * @callback
   * @param node a #GTreeNode
   * @param data user data passed to g_tree_foreach_node()
   * @returns %TRUE to stop the traversal
   */
  interface TraverseNodeFunc {
    (node: TreeNode, data: any | null): boolean
  }
  /**
   * The type of functions to be called when a UNIX fd watch source
   * triggers.
   * @callback
   * @param fd the fd that triggered the event
   * @param condition the IO conditions reported on `fd`
   * @returns %FALSE if the source should be removed
   */
  interface UnixFDSourceFunc {
    (fd: number, condition: IOCondition): boolean
  }
  /**
   * Declares a type of function which takes no arguments
   * and has no return value. It is used to specify the type
   * function passed to g_atexit().
   * @callback
   */
  interface VoidFunc {
    (): void
  }
  interface Allocator {
    // Owm methods of GLib-2.0.GLib.Allocator

    free(): void
  }

  class Allocator {
    // Own properties of GLib-2.0.GLib.Allocator

    static name: string
  }

  interface Array {
    // Own fields of GLib-2.0.GLib.Array

    /**
     * a pointer to the element data. The data may be moved as
     *     elements are added to the #GArray.
     * @field
     */
    data: string | null
    /**
     * the number of elements in the #GArray not including the
     *     possible terminating zero element.
     * @field
     */
    len: number
  }

  /**
   * Contains the public fields of a GArray.
   * @record
   */
  class Array {
    // Own properties of GLib-2.0.GLib.Array

    static name: string
  }

  interface AsyncQueue {
    // Owm methods of GLib-2.0.GLib.AsyncQueue

    /**
     * Returns the length of the queue.
     *
     * Actually this function returns the number of data items in
     * the queue minus the number of waiting threads, so a negative
     * value means waiting threads, and a positive value means available
     * entries in the `queue`. A return value of 0 could mean n entries
     * in the queue and n threads waiting. This can happen due to locking
     * of the queue or due to scheduling.
     * @returns the length of the @queue
     */
    length(): number
    /**
     * Returns the length of the queue.
     *
     * Actually this function returns the number of data items in
     * the queue minus the number of waiting threads, so a negative
     * value means waiting threads, and a positive value means available
     * entries in the `queue`. A return value of 0 could mean n entries
     * in the queue and n threads waiting. This can happen due to locking
     * of the queue or due to scheduling.
     *
     * This function must be called while holding the `queue'`s lock.
     * @returns the length of the @queue.
     */
    lengthUnlocked(): number
    /**
     * Acquires the `queue'`s lock. If another thread is already
     * holding the lock, this call will block until the lock
     * becomes available.
     *
     * Call g_async_queue_unlock() to drop the lock again.
     *
     * While holding the lock, you can only call the
     * g_async_queue_*_unlocked() functions on `queue`. Otherwise,
     * deadlock may occur.
     */
    lock(): void
    /**
     * Pops data from the `queue`. If `queue` is empty, this function
     * blocks until data becomes available.
     * @returns data from the queue
     */
    pop(): any | null
    /**
     * Pops data from the `queue`. If `queue` is empty, this function
     * blocks until data becomes available.
     *
     * This function must be called while holding the `queue'`s lock.
     * @returns data from the queue.
     */
    popUnlocked(): any | null
    /**
     * Pushes the `data` into the `queue`.
     *
     * The `data` parameter must not be %NULL.
     * @param data data to push onto the `queue`
     */
    push(data: any): void
    /**
     * Pushes the `item` into the `queue`. `item` must not be %NULL.
     * In contrast to g_async_queue_push(), this function
     * pushes the new item ahead of the items already in the queue,
     * so that it will be the next one to be popped off the queue.
     * @param item data to push into the `queue`
     */
    pushFront(item: any): void
    /**
     * Pushes the `item` into the `queue`. `item` must not be %NULL.
     * In contrast to g_async_queue_push_unlocked(), this function
     * pushes the new item ahead of the items already in the queue,
     * so that it will be the next one to be popped off the queue.
     *
     * This function must be called while holding the `queue'`s lock.
     * @param item data to push into the `queue`
     */
    pushFrontUnlocked(item: any): void
    /**
     * Inserts `data` into `queue` using `func` to determine the new
     * position.
     *
     * This function requires that the `queue` is sorted before pushing on
     * new elements, see g_async_queue_sort().
     *
     * This function will lock `queue` before it sorts the queue and unlock
     * it when it is finished.
     *
     * For an example of `func` see g_async_queue_sort().
     * @param data the `data` to push into the `queue`
     * @param func the #GCompareDataFunc is used to sort `queue`
     */
    pushSorted(data: any, func: CompareDataFunc): void
    /**
     * Inserts `data` into `queue` using `func` to determine the new
     * position.
     *
     * The sort function `func` is passed two elements of the `queue`.
     * It should return 0 if they are equal, a negative value if the
     * first element should be higher in the `queue` or a positive value
     * if the first element should be lower in the `queue` than the second
     * element.
     *
     * This function requires that the `queue` is sorted before pushing on
     * new elements, see g_async_queue_sort().
     *
     * This function must be called while holding the `queue'`s lock.
     *
     * For an example of `func` see g_async_queue_sort().
     * @param data the data to push into the `queue`
     * @param func the #GCompareDataFunc is used to sort `queue`
     */
    pushSortedUnlocked(data: any | null, func: CompareDataFunc): void
    /**
     * Pushes the `data` into the `queue`.
     *
     * The `data` parameter must not be %NULL.
     *
     * This function must be called while holding the `queue'`s lock.
     * @param data data to push onto the `queue`
     */
    pushUnlocked(data: any): void
    /**
     * Increases the reference count of the asynchronous `queue` by 1.
     */
    refUnlocked(): void
    /**
     * Remove an item from the queue.
     * @param item the data to remove from the `queue`
     * @returns %TRUE if the item was removed
     */
    remove(item: any): boolean
    /**
     * Remove an item from the queue.
     *
     * This function must be called while holding the `queue'`s lock.
     * @param item the data to remove from the `queue`
     * @returns %TRUE if the item was removed
     */
    removeUnlocked(item: any | null): boolean
    /**
     * Sorts `queue` using `func`.
     *
     * The sort function `func` is passed two elements of the `queue`.
     * It should return 0 if they are equal, a negative value if the
     * first element should be higher in the `queue` or a positive value
     * if the first element should be lower in the `queue` than the second
     * element.
     *
     * This function will lock `queue` before it sorts the queue and unlock
     * it when it is finished.
     *
     * If you were sorting a list of priority numbers to make sure the
     * lowest priority would be at the top of the queue, you could use:
     *
     * ```c
     *  gint32 id1;
     *  gint32 id2;
     *
     *  id1 = GPOINTER_TO_INT (element1);
     *  id2 = GPOINTER_TO_INT (element2);
     *
     *  return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
     * ```
     *
     * @param func the #GCompareDataFunc is used to sort `queue`
     */
    sort(func: CompareDataFunc): void
    /**
     * Sorts `queue` using `func`.
     *
     * The sort function `func` is passed two elements of the `queue`.
     * It should return 0 if they are equal, a negative value if the
     * first element should be higher in the `queue` or a positive value
     * if the first element should be lower in the `queue` than the second
     * element.
     *
     * This function must be called while holding the `queue'`s lock.
     * @param func the #GCompareDataFunc is used to sort `queue`
     */
    sortUnlocked(func: CompareDataFunc): void
    /**
     * Pops data from the `queue`. If the queue is empty, blocks until
     * `end_time` or until data becomes available.
     *
     * If no data is received before `end_time,` %NULL is returned.
     *
     * To easily calculate `end_time,` a combination of g_get_real_time()
     * and g_time_val_add() can be used.
     * @param endTime a #GTimeVal, determining the final time
     * @returns data from the queue or %NULL, when no data is   received before @end_time.
     */
    timedPop(endTime: TimeVal): any | null
    /**
     * Pops data from the `queue`. If the queue is empty, blocks until
     * `end_time` or until data becomes available.
     *
     * If no data is received before `end_time,` %NULL is returned.
     *
     * To easily calculate `end_time,` a combination of g_get_real_time()
     * and g_time_val_add() can be used.
     *
     * This function must be called while holding the `queue'`s lock.
     * @param endTime a #GTimeVal, determining the final time
     * @returns data from the queue or %NULL, when no data is   received before @end_time.
     */
    timedPopUnlocked(endTime: TimeVal): any | null
    /**
     * Pops data from the `queue`. If the queue is empty, blocks for
     * `timeout` microseconds, or until data becomes available.
     *
     * If no data is received before the timeout, %NULL is returned.
     * @param timeout the number of microseconds to wait
     * @returns data from the queue or %NULL, when no data is   received before the timeout.
     */
    timeoutPop(timeout: number): any | null
    /**
     * Pops data from the `queue`. If the queue is empty, blocks for
     * `timeout` microseconds, or until data becomes available.
     *
     * If no data is received before the timeout, %NULL is returned.
     *
     * This function must be called while holding the `queue'`s lock.
     * @param timeout the number of microseconds to wait
     * @returns data from the queue or %NULL, when no data is   received before the timeout.
     */
    timeoutPopUnlocked(timeout: number): any | null
    /**
     * Tries to pop data from the `queue`. If no data is available,
     * %NULL is returned.
     * @returns data from the queue or %NULL, when no data is   available immediately.
     */
    tryPop(): any | null
    /**
     * Tries to pop data from the `queue`. If no data is available,
     * %NULL is returned.
     *
     * This function must be called while holding the `queue'`s lock.
     * @returns data from the queue or %NULL, when no data is   available immediately.
     */
    tryPopUnlocked(): any | null
    /**
     * Releases the queue's lock.
     *
     * Calling this function when you have not acquired
     * the with g_async_queue_lock() leads to undefined
     * behaviour.
     */
    unlock(): void
    /**
     * Decreases the reference count of the asynchronous `queue` by 1.
     *
     * If the reference count went to 0, the `queue` will be destroyed
     * and the memory allocated will be freed. So you are not allowed
     * to use the `queue` afterwards, as it might have disappeared.
     * You do not need to hold the lock to call this function.
     */
    unref(): void
    /**
     * Decreases the reference count of the asynchronous `queue` by 1
     * and releases the lock. This function must be called while holding
     * the `queue'`s lock. If the reference count went to 0, the `queue`
     * will be destroyed and the memory allocated will be freed.
     */
    unrefAndUnlock(): void
  }

  /**
   * An opaque data structure which represents an asynchronous queue.
   *
   * It should only be accessed through the `g_async_queue_*` functions.
   * @record
   */
  class AsyncQueue {
    // Own properties of GLib-2.0.GLib.AsyncQueue

    static name: string
  }

  interface BookmarkFile {
    // Owm methods of GLib-2.0.GLib.BookmarkFile

    /**
     * Adds the application with `name` and `exec` to the list of
     * applications that have registered a bookmark for `uri` into
     * `bookmark`.
     *
     * Every bookmark inside a #GBookmarkFile must have at least an
     * application registered.  Each application must provide a name, a
     * command line useful for launching the bookmark, the number of times
     * the bookmark has been registered by the application and the last
     * time the application registered this bookmark.
     *
     * If `name` is %NULL, the name of the application will be the
     * same returned by g_get_application_name(); if `exec` is %NULL, the
     * command line will be a composition of the program name as
     * returned by g_get_prgname() and the "\%u" modifier, which will be
     * expanded to the bookmark's URI.
     *
     * This function will automatically take care of updating the
     * registrations count and timestamping in case an application
     * with the same `name` had already registered a bookmark for
     * `uri` inside `bookmark`.
     *
     * If no bookmark for `uri` is found, one is created.
     * @param uri a valid URI
     * @param name the name of the application registering the bookmark   or %NULL
     * @param exec command line to be used to launch the bookmark or %NULL
     */
    addApplication(uri: string, name: string | null, exec: string | null): void
    /**
     * Adds `group` to the list of groups to which the bookmark for `uri`
     * belongs to.
     *
     * If no bookmark for `uri` is found then it is created.
     * @param uri a valid URI
     * @param group the group name to be added
     */
    addGroup(uri: string, group: string): void
    /**
     * Deeply copies a `bookmark` #GBookmarkFile object to a new one.
     * @returns the copy of @bookmark. Use   g_bookmark_free() when finished using it.
     */
    copy(): BookmarkFile
    /**
     * Frees a #GBookmarkFile.
     */
    free(): void
    /**
     * Gets the time the bookmark for `uri` was added to `bookmark`
     *
     * In the event the URI cannot be found, -1 is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns a timestamp
     */
    getAdded(uri: string): any
    /**
     * Gets the time the bookmark for `uri` was added to `bookmark`
     *
     * In the event the URI cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns a #GDateTime
     */
    getAddedDateTime(uri: string): DateTime
    /**
     * Gets the registration information of `app_name` for the bookmark for
     * `uri`.  See g_bookmark_file_set_application_info() for more information about
     * the returned data.
     *
     * The string returned in `app_exec` must be freed.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
     * event that no application with name `app_name` has registered a bookmark
     * for `uri,`  %FALSE is returned and error is set to
     * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
     * the command line fails, an error of the %G_SHELL_ERROR domain is
     * set and %FALSE is returned.
     * @param uri a valid URI
     * @param name an application's name
     * @returns %TRUE on success.
     */
    getAppInfo(
      uri: string,
      name: string
    ): [
      /* returnType */ boolean,
      /* exec */ string,
      /* count */ number,
      /* stamp */ any,
    ]
    /**
     * Gets the registration information of `app_name` for the bookmark for
     * `uri`.  See g_bookmark_file_set_application_info() for more information about
     * the returned data.
     *
     * The string returned in `app_exec` must be freed.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
     * event that no application with name `app_name` has registered a bookmark
     * for `uri,`  %FALSE is returned and error is set to
     * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
     * the command line fails, an error of the %G_SHELL_ERROR domain is
     * set and %FALSE is returned.
     * @param uri a valid URI
     * @param name an application's name
     * @returns %TRUE on success.
     */
    getApplicationInfo(
      uri: string,
      name: string
    ): [
      /* returnType */ boolean,
      /* exec */ string,
      /* count */ number,
      /* stamp */ DateTime,
    ]
    /**
     * Retrieves the names of the applications that have registered the
     * bookmark for `uri`.
     *
     * In the event the URI cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns a newly allocated %NULL-terminated array of strings.   Use g_strfreev() to free it.
     */
    getApplications(uri: string): string[]
    /**
     * Retrieves the description of the bookmark for `uri`.
     *
     * In the event the URI cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns a newly allocated string or %NULL if the specified   URI cannot be found.
     */
    getDescription(uri: string): string | null
    /**
     * Retrieves the list of group names of the bookmark for `uri`.
     *
     * In the event the URI cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     *
     * The returned array is %NULL terminated, so `length` may optionally
     * be %NULL.
     * @param uri a valid URI
     * @returns a newly allocated %NULL-terminated array of group names.   Use g_strfreev() to free it.
     */
    getGroups(uri: string): string[]
    /**
     * Gets the icon of the bookmark for `uri`.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns %TRUE if the icon for the bookmark for the URI was found.   You should free the returned strings.
     */
    getIcon(
      uri: string
    ): [/* returnType */ boolean, /* href */ string, /* mimeType */ string]
    /**
     * Gets whether the private flag of the bookmark for `uri` is set.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
     * event that the private flag cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
     * @param uri a valid URI
     * @returns %TRUE if the private flag is set, %FALSE otherwise.
     */
    getIsPrivate(uri: string): boolean
    /**
     * Retrieves the MIME type of the resource pointed by `uri`.
     *
     * In the event the URI cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
     * event that the MIME type cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
     * @param uri a valid URI
     * @returns a newly allocated string or %NULL if the specified   URI cannot be found.
     */
    getMimeType(uri: string): string | null
    /**
     * Gets the time when the bookmark for `uri` was last modified.
     *
     * In the event the URI cannot be found, -1 is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns a timestamp
     */
    getModified(uri: string): any
    /**
     * Gets the time when the bookmark for `uri` was last modified.
     *
     * In the event the URI cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns a #GDateTime
     */
    getModifiedDateTime(uri: string): DateTime
    /**
     * Gets the number of bookmarks inside `bookmark`.
     * @returns the number of bookmarks
     */
    getSize(): number
    /**
     * Returns the title of the bookmark for `uri`.
     *
     * If `uri` is %NULL, the title of `bookmark` is returned.
     *
     * In the event the URI cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI or %NULL
     * @returns a newly allocated string or %NULL if the specified   URI cannot be found.
     */
    getTitle(uri: string | null): string | null
    /**
     * Returns all URIs of the bookmarks in the bookmark file `bookmark`.
     * The array of returned URIs will be %NULL-terminated, so `length` may
     * optionally be %NULL.
     * @returns a newly allocated %NULL-terminated array of strings.   Use g_strfreev() to free it.
     */
    getUris(): string[]
    /**
     * Gets the time the bookmark for `uri` was last visited.
     *
     * In the event the URI cannot be found, -1 is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns a timestamp.
     */
    getVisited(uri: string): any
    /**
     * Gets the time the bookmark for `uri` was last visited.
     *
     * In the event the URI cannot be found, %NULL is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @returns a #GDateTime
     */
    getVisitedDateTime(uri: string): DateTime
    /**
     * Checks whether the bookmark for `uri` inside `bookmark` has been
     * registered by application `name`.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @param name the name of the application
     * @returns %TRUE if the application @name was found
     */
    hasApplication(uri: string, name: string): boolean
    /**
     * Checks whether `group` appears in the list of groups to which
     * the bookmark for `uri` belongs to.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param uri a valid URI
     * @param group the group name to be searched
     * @returns %TRUE if @group was found.
     */
    hasGroup(uri: string, group: string): boolean
    /**
     * Looks whether the desktop bookmark has an item with its URI set to `uri`.
     * @param uri a valid URI
     * @returns %TRUE if @uri is inside @bookmark, %FALSE otherwise
     */
    hasItem(uri: string): boolean
    /**
     * Loads a bookmark file from memory into an empty #GBookmarkFile
     * structure.  If the object cannot be created then `error` is set to a
     * #GBookmarkFileError.
     * @param data desktop bookmarks    loaded in memory
     * @returns %TRUE if a desktop bookmark could be loaded.
     */
    loadFromData(data: number[]): boolean
    /**
     * This function looks for a desktop bookmark file named `file` in the
     * paths returned from g_get_user_data_dir() and g_get_system_data_dirs(),
     * loads the file into `bookmark` and returns the file's full path in
     * `full_path`.  If the file could not be loaded then `error` is
     * set to either a #GFileError or #GBookmarkFileError.
     * @param file a relative path to a filename to open and parse
     * @returns %TRUE if a key file could be loaded, %FALSE otherwise
     */
    loadFromDataDirs(
      file: string
    ): [/* returnType */ boolean, /* fullPath */ string]
    /**
     * Loads a desktop bookmark file into an empty #GBookmarkFile structure.
     * If the file could not be loaded then `error` is set to either a #GFileError
     * or #GBookmarkFileError.
     * @param filename the path of a filename to load, in the     GLib file name encoding
     * @returns %TRUE if a desktop bookmark file could be loaded
     */
    loadFromFile(filename: string): boolean
    /**
     * Changes the URI of a bookmark item from `old_uri` to `new_uri`.  Any
     * existing bookmark for `new_uri` will be overwritten.  If `new_uri` is
     * %NULL, then the bookmark is removed.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * @param oldUri a valid URI
     * @param newUri a valid URI, or %NULL
     * @returns %TRUE if the URI was successfully changed
     */
    moveItem(oldUri: string, newUri: string | null): boolean
    /**
     * Removes application registered with `name` from the list of applications
     * that have registered a bookmark for `uri` inside `bookmark`.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * In the event that no application with name `app_name` has registered
     * a bookmark for `uri,`  %FALSE is returned and error is set to
     * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.
     * @param uri a valid URI
     * @param name the name of the application
     * @returns %TRUE if the application was successfully removed.
     */
    removeApplication(uri: string, name: string): boolean
    /**
     * Removes `group` from the list of groups to which the bookmark
     * for `uri` belongs to.
     *
     * In the event the URI cannot be found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
     * In the event no group was defined, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
     * @param uri a valid URI
     * @param group the group name to be removed
     * @returns %TRUE if @group was successfully removed.
     */
    removeGroup(uri: string, group: string): boolean
    /**
     * Removes the bookmark for `uri` from the bookmark file `bookmark`.
     * @param uri a valid URI
     * @returns %TRUE if the bookmark was removed successfully.
     */
    removeItem(uri: string): boolean
    /**
     * Sets the time the bookmark for `uri` was added into `bookmark`.
     *
     * If no bookmark for `uri` is found then it is created.
     * @param uri a valid URI
     * @param added a timestamp or -1 to use the current time
     */
    setAdded(uri: string, added: any): void
    /**
     * Sets the time the bookmark for `uri` was added into `bookmark`.
     *
     * If no bookmark for `uri` is found then it is created.
     * @param uri a valid URI
     * @param added a #GDateTime
     */
    setAddedDateTime(uri: string, added: DateTime): void
    /**
     * Sets the meta-data of application `name` inside the list of
     * applications that have registered a bookmark for `uri` inside
     * `bookmark`.
     *
     * You should rarely use this function; use g_bookmark_file_add_application()
     * and g_bookmark_file_remove_application() instead.
     *
     * `name` can be any UTF-8 encoded string used to identify an
     * application.
     * `exec` can have one of these two modifiers: "\%f", which will
     * be expanded as the local file name retrieved from the bookmark's
     * URI; "\%u", which will be expanded as the bookmark's URI.
     * The expansion is done automatically when retrieving the stored
     * command line using the g_bookmark_file_get_application_info() function.
     * `count` is the number of times the application has registered the
     * bookmark; if is < 0, the current registration count will be increased
     * by one, if is 0, the application with `name` will be removed from
     * the list of registered applications.
     * `stamp` is the Unix time of the last registration; if it is -1, the
     * current time will be used.
     *
     * If you try to remove an application by setting its registration count to
     * zero, and no bookmark for `uri` is found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly,
     * in the event that no application `name` has registered a bookmark
     * for `uri,`  %FALSE is returned and error is set to
     * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.  Otherwise, if no bookmark
     * for `uri` is found, one is created.
     * @param uri a valid URI
     * @param name an application's name
     * @param exec an application's command line
     * @param count the number of registrations done for this application
     * @param stamp the time of the last registration for this application
     * @returns %TRUE if the application's meta-data was successfully   changed.
     */
    setAppInfo(
      uri: string,
      name: string,
      exec: string,
      count: number,
      stamp: any
    ): boolean
    /**
     * Sets the meta-data of application `name` inside the list of
     * applications that have registered a bookmark for `uri` inside
     * `bookmark`.
     *
     * You should rarely use this function; use g_bookmark_file_add_application()
     * and g_bookmark_file_remove_application() instead.
     *
     * `name` can be any UTF-8 encoded string used to identify an
     * application.
     * `exec` can have one of these two modifiers: "\%f", which will
     * be expanded as the local file name retrieved from the bookmark's
     * URI; "\%u", which will be expanded as the bookmark's URI.
     * The expansion is done automatically when retrieving the stored
     * command line using the g_bookmark_file_get_application_info() function.
     * `count` is the number of times the application has registered the
     * bookmark; if is < 0, the current registration count will be increased
     * by one, if is 0, the application with `name` will be removed from
     * the list of registered applications.
     * `stamp` is the Unix time of the last registration.
     *
     * If you try to remove an application by setting its registration count to
     * zero, and no bookmark for `uri` is found, %FALSE is returned and
     * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly,
     * in the event that no application `name` has registered a bookmark
     * for `uri,`  %FALSE is returned and error is set to
     * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.  Otherwise, if no bookmark
     * for `uri` is found, one is created.
     * @param uri a valid URI
     * @param name an application's name
     * @param exec an application's command line
     * @param count the number of registrations done for this application
     * @param stamp the time of the last registration for this application,    which may be %NULL if `count` is 0
     * @returns %TRUE if the application's meta-data was successfully   changed.
     */
    setApplicationInfo(
      uri: string,
      name: string,
      exec: string,
      count: number,
      stamp: DateTime | null
    ): boolean
    /**
     * Sets `description` as the description of the bookmark for `uri`.
     *
     * If `uri` is %NULL, the description of `bookmark` is set.
     *
     * If a bookmark for `uri` cannot be found then it is created.
     * @param uri a valid URI or %NULL
     * @param description a string
     */
    setDescription(uri: string | null, description: string): void
    /**
     * Sets a list of group names for the item with URI `uri`.  Each previously
     * set group name list is removed.
     *
     * If `uri` cannot be found then an item for it is created.
     * @param uri an item's URI
     * @param groups an array of    group names, or %NULL to remove all groups
     */
    setGroups(uri: string, groups: string[] | null): void
    /**
     * Sets the icon for the bookmark for `uri`. If `href` is %NULL, unsets
     * the currently set icon. `href` can either be a full URL for the icon
     * file or the icon name following the Icon Naming specification.
     *
     * If no bookmark for `uri` is found one is created.
     * @param uri a valid URI
     * @param href the URI of the icon for the bookmark, or %NULL
     * @param mimeType the MIME type of the icon for the bookmark
     */
    setIcon(uri: string, href: string | null, mimeType: string): void
    /**
     * Sets the private flag of the bookmark for `uri`.
     *
     * If a bookmark for `uri` cannot be found then it is created.
     * @param uri a valid URI
     * @param isPrivate %TRUE if the bookmark should be marked as private
     */
    setIsPrivate(uri: string, isPrivate: boolean): void
    /**
     * Sets `mime_type` as the MIME type of the bookmark for `uri`.
     *
     * If a bookmark for `uri` cannot be found then it is created.
     * @param uri a valid URI
     * @param mimeType a MIME type
     */
    setMimeType(uri: string, mimeType: string): void
    /**
     * Sets the last time the bookmark for `uri` was last modified.
     *
     * If no bookmark for `uri` is found then it is created.
     *
     * The "modified" time should only be set when the bookmark's meta-data
     * was actually changed.  Every function of #GBookmarkFile that
     * modifies a bookmark also changes the modification time, except for
     * g_bookmark_file_set_visited_date_time().
     * @param uri a valid URI
     * @param modified a timestamp or -1 to use the current time
     */
    setModified(uri: string, modified: any): void
    /**
     * Sets the last time the bookmark for `uri` was last modified.
     *
     * If no bookmark for `uri` is found then it is created.
     *
     * The "modified" time should only be set when the bookmark's meta-data
     * was actually changed.  Every function of #GBookmarkFile that
     * modifies a bookmark also changes the modification time, except for
     * g_bookmark_file_set_visited_date_time().
     * @param uri a valid URI
     * @param modified a #GDateTime
     */
    setModifiedDateTime(uri: string, modified: DateTime): void
    /**
     * Sets `title` as the title of the bookmark for `uri` inside the
     * bookmark file `bookmark`.
     *
     * If `uri` is %NULL, the title of `bookmark` is set.
     *
     * If a bookmark for `uri` cannot be found then it is created.
     * @param uri a valid URI or %NULL
     * @param title a UTF-8 encoded string
     */
    setTitle(uri: string | null, title: string): void
    /**
     * Sets the time the bookmark for `uri` was last visited.
     *
     * If no bookmark for `uri` is found then it is created.
     *
     * The "visited" time should only be set if the bookmark was launched,
     * either using the command line retrieved by g_bookmark_file_get_application_info()
     * or by the default application for the bookmark's MIME type, retrieved
     * using g_bookmark_file_get_mime_type().  Changing the "visited" time
     * does not affect the "modified" time.
     * @param uri a valid URI
     * @param visited a timestamp or -1 to use the current time
     */
    setVisited(uri: string, visited: any): void
    /**
     * Sets the time the bookmark for `uri` was last visited.
     *
     * If no bookmark for `uri` is found then it is created.
     *
     * The "visited" time should only be set if the bookmark was launched,
     * either using the command line retrieved by g_bookmark_file_get_application_info()
     * or by the default application for the bookmark's MIME type, retrieved
     * using g_bookmark_file_get_mime_type().  Changing the "visited" time
     * does not affect the "modified" time.
     * @param uri a valid URI
     * @param visited a #GDateTime
     */
    setVisitedDateTime(uri: string, visited: DateTime): void
    /**
     * This function outputs `bookmark` as a string.
     * @returns a newly allocated string holding the contents of the #GBookmarkFile
     */
    toData(): number[]
    /**
     * This function outputs `bookmark` into a file.  The write process is
     * guaranteed to be atomic by using g_file_set_contents() internally.
     * @param filename path of the output file
     * @returns %TRUE if the file was successfully written.
     */
    toFile(filename: string): boolean
  }

  /**
   * `GBookmarkFile` lets you parse, edit or create files containing bookmarks.
   *
   * Bookmarks refer to a URI, along with some meta-data about the resource
   * pointed by the URI like its MIME type, the application that is registering
   * the bookmark and the icon that should be used to represent the bookmark.
   * The data is stored using the
   * [Desktop Bookmark Specification](http://www.gnome.org/~ebassi/bookmark-spec).
   *
   * The syntax of the bookmark files is described in detail inside the
   * Desktop Bookmark Specification, here is a quick summary: bookmark
   * files use a sub-class of the XML Bookmark Exchange Language
   * specification, consisting of valid UTF-8 encoded XML, under the
   * `<xbel>` root element; each bookmark is stored inside a
   * `<bookmark>` element, using its URI: no relative paths can
   * be used inside a bookmark file. The bookmark may have a user defined
   * title and description, to be used instead of the URI. Under the
   * `<metadata>` element, with its owner attribute set to
   * `http://freedesktop.org`, is stored the meta-data about a resource
   * pointed by its URI. The meta-data consists of the resource's MIME
   * type; the applications that have registered a bookmark; the groups
   * to which a bookmark belongs to; a visibility flag, used to set the
   * bookmark as "private" to the applications and groups that has it
   * registered; the URI and MIME type of an icon, to be used when
   * displaying the bookmark inside a GUI.
   *
   * Here is an example of a bookmark file:
   * [bookmarks.xbel](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/glib/tests/bookmarks.xbel)
   *
   * A bookmark file might contain more than one bookmark; each bookmark
   * is accessed through its URI.
   *
   * The important caveat of bookmark files is that when you add a new
   * bookmark you must also add the application that is registering it, using
   * [method`GLib`.BookmarkFile.add_application] or [method`GLib`.BookmarkFile.set_application_info].
   * If a bookmark has no applications then it won't be dumped when creating
   * the on disk representation, using [method`GLib`.BookmarkFile.to_data] or
   * [method`GLib`.BookmarkFile.to_file].
   * @record
   */
  class BookmarkFile {
    // Own properties of GLib-2.0.GLib.BookmarkFile

    static name: string

    // Constructors of GLib-2.0.GLib.BookmarkFile

    /**
     * Creates a new empty #GBookmarkFile object.
     *
     * Use g_bookmark_file_load_from_file(), g_bookmark_file_load_from_data()
     * or g_bookmark_file_load_from_data_dirs() to read an existing bookmark
     * file.
     * @constructor
     * @returns an empty #GBookmarkFile
     */
    constructor()
    /**
     * Creates a new empty #GBookmarkFile object.
     *
     * Use g_bookmark_file_load_from_file(), g_bookmark_file_load_from_data()
     * or g_bookmark_file_load_from_data_dirs() to read an existing bookmark
     * file.
     * @constructor
     * @returns an empty #GBookmarkFile
     */
    static new(): BookmarkFile
    static errorQuark(): Quark
  }

  interface ByteArray {
    // Own fields of GLib-2.0.GLib.ByteArray

    /**
     * a pointer to the element data. The data may be moved as
     *     elements are added to the #GByteArray
     * @field
     */
    data: number
    /**
     * the number of elements in the #GByteArray
     * @field
     */
    len: number
  }

  /**
   * Contains the public fields of a GByteArray.
   * @record
   */
  class ByteArray {
    // Own properties of GLib-2.0.GLib.ByteArray

    static name: string

    // Constructors of GLib-2.0.GLib.ByteArray

    /**
     * Creates a new #GByteArray with a reference count of 1.
     * @returns the new #GByteArray
     */
    static new(): number[]
    /**
     * Creates a byte array containing the `data`.
     * After this call, `data` belongs to the #GByteArray and may no longer be
     * modified by the caller. The memory of `data` has to be dynamically
     * allocated and will eventually be freed with g_free().
     *
     * Do not use it if `len` is greater than %G_MAXUINT. #GByteArray
     * stores the length of its data in #guint, which may be shorter than
     * #gsize.
     * @param data byte data for the array
     * @returns a new #GByteArray
     */
    static newTake(data: number[]): number[]
    /**
     * Adds the given bytes to the end of the #GByteArray.
     * The array will grow in size automatically if necessary.
     * @param array a #GByteArray
     * @param data the byte data to be added
     * @param len the number of bytes to add
     * @returns the #GByteArray
     */
    static append(array: number[], data: number, len: number): number[]
    /**
     * Frees the memory allocated by the #GByteArray. If `free_segment` is
     * %TRUE it frees the actual byte data. If the reference count of
     * `array` is greater than one, the #GByteArray wrapper is preserved but
     * the size of `array` will be set to zero.
     * @param array a #GByteArray
     * @param freeSegment if %TRUE the actual byte data is freed as well
     * @returns the element data if @free_segment is %FALSE, otherwise          %NULL.  The element data should be freed using g_free().
     */
    static free(array: number[], freeSegment: boolean): number
    /**
     * Transfers the data from the #GByteArray into a new immutable #GBytes.
     *
     * The #GByteArray is freed unless the reference count of `array` is greater
     * than one, the #GByteArray wrapper is preserved but the size of `array`
     * will be set to zero.
     *
     * This is identical to using g_bytes_new_take() and g_byte_array_free()
     * together.
     * @param array a #GByteArray
     * @returns a new immutable #GBytes representing same     byte data that was in the array
     */
    static freeToBytes(array: number[]): any
    /**
     * Adds the given data to the start of the #GByteArray.
     * The array will grow in size automatically if necessary.
     * @param array a #GByteArray
     * @param data the byte data to be added
     * @param len the number of bytes to add
     * @returns the #GByteArray
     */
    static prepend(array: number[], data: number, len: number): number[]
    /**
     * Atomically increments the reference count of `array` by one.
     * This function is thread-safe and may be called from any thread.
     * @param array A #GByteArray
     * @returns The passed in #GByteArray
     */
    static ref(array: number[]): number[]
    /**
     * Removes the byte at the given index from a #GByteArray.
     * The following bytes are moved down one place.
     * @param array a #GByteArray
     * @param index the index of the byte to remove
     * @returns the #GByteArray
     */
    static removeIndex(array: number[], index: number): number[]
    /**
     * Removes the byte at the given index from a #GByteArray. The last
     * element in the array is used to fill in the space, so this function
     * does not preserve the order of the #GByteArray. But it is faster
     * than g_byte_array_remove_index().
     * @param array a #GByteArray
     * @param index the index of the byte to remove
     * @returns the #GByteArray
     */
    static removeIndexFast(array: number[], index: number): number[]
    /**
     * Removes the given number of bytes starting at the given index from a
     * #GByteArray.  The following elements are moved to close the gap.
     * @param array a `GByteArray`
     * @param index the index of the first byte to remove
     * @param length the number of bytes to remove
     * @returns the #GByteArray
     */
    static removeRange(array: number[], index: number, length: number): number[]
    /**
     * Sets the size of the #GByteArray, expanding it if necessary.
     * @param array a #GByteArray
     * @param length the new size of the #GByteArray
     * @returns the #GByteArray
     */
    static setSize(array: number[], length: number): number[]
    /**
     * Creates a new #GByteArray with `reserved_size` bytes preallocated.
     * This avoids frequent reallocation, if you are going to add many
     * bytes to the array. Note however that the size of the array is still
     * 0.
     * @param reservedSize number of bytes preallocated
     * @returns the new #GByteArray
     */
    static sizedNew(reservedSize: number): number[]
    /**
     * Sorts a byte array, using `compare_func` which should be a
     * qsort()-style comparison function (returns less than zero for first
     * arg is less than second arg, zero for equal, greater than zero if
     * first arg is greater than second arg).
     *
     * If two array elements compare equal, their order in the sorted array
     * is undefined. If you want equal elements to keep their order (i.e.
     * you want a stable sort) you can write a comparison function that,
     * if two elements would otherwise compare equal, compares them by
     * their addresses.
     * @param array a #GByteArray
     * @param compareFunc comparison function
     */
    static sort(array: number[], compareFunc: CompareFunc): void
    /**
     * Like g_byte_array_sort(), but the comparison function takes an extra
     * user data argument.
     * @param array a #GByteArray
     * @param compareFunc comparison function
     */
    static sortWithData(array: number[], compareFunc: CompareDataFunc): void
    /**
     * Frees the data in the array and resets the size to zero, while
     * the underlying array is preserved for use elsewhere and returned
     * to the caller.
     * @param array a #GByteArray.
     * @returns the element data, which should be     freed using g_free().
     */
    static steal(array: number[]): [/* returnType */ number, /* len */ number]
    /**
     * Atomically decrements the reference count of `array` by one. If the
     * reference count drops to 0, all memory allocated by the array is
     * released. This function is thread-safe and may be called from any
     * thread.
     * @param array A #GByteArray
     */
    static unref(array: number[]): void
  }

  interface Bytes {
    // Owm methods of GLib-2.0.GLib.Bytes

    /**
     * Compares the two #GBytes values.
     *
     * This function can be used to sort GBytes instances in lexicographical order.
     *
     * If `bytes1` and `bytes2` have different length but the shorter one is a
     * prefix of the longer one then the shorter one is considered to be less than
     * the longer one. Otherwise the first byte where both differ is used for
     * comparison. If `bytes1` has a smaller value at that position it is
     * considered less, otherwise greater than `bytes2`.
     * @param bytes2 a pointer to a #GBytes to compare with `bytes1`
     * @returns a negative value if @bytes1 is less than @bytes2, a positive value          if @bytes1 is greater than @bytes2, and zero if @bytes1 is equal to          @bytes2
     */
    compare(bytes2: any): number
    /**
     * Compares the two #GBytes values being pointed to and returns
     * %TRUE if they are equal.
     *
     * This function can be passed to g_hash_table_new() as the `key_equal_func`
     * parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable.
     * @param bytes2 a pointer to a #GBytes to compare with `bytes1`
     * @returns %TRUE if the two keys match.
     */
    equal(bytes2: any): boolean
    /**
     * Get the byte data in the #GBytes. This data should not be modified.
     *
     * This function will always return the same pointer for a given #GBytes.
     *
     * %NULL may be returned if `size` is 0. This is not guaranteed, as the #GBytes
     * may represent an empty string with `data` non-%NULL and `size` as 0. %NULL will
     * not be returned if `size` is non-zero.
     * @returns a pointer to the byte data, or %NULL
     */
    getData(): number[] | null
    /**
     * Gets a pointer to a region in `bytes`.
     *
     * The region starts at `offset` many bytes from the start of the data
     * and contains `n_elements` many elements of `element_size` size.
     *
     * `n_elements` may be zero, but `element_size` must always be non-zero.
     * Ideally, `element_size` is a static constant (eg: sizeof a struct).
     *
     * This function does careful bounds checking (including checking for
     * arithmetic overflows) and returns a non-%NULL pointer if the
     * specified region lies entirely within the `bytes`. If the region is
     * in some way out of range, or if an overflow has occurred, then %NULL
     * is returned.
     *
     * Note: it is possible to have a valid zero-size region. In this case,
     * the returned pointer will be equal to the base pointer of the data of
     * `bytes,` plus `offset`.  This will be non-%NULL except for the case
     * where `bytes` itself was a zero-sized region.  Since it is unlikely
     * that you will be using this function to check for a zero-sized region
     * in a zero-sized `bytes,` %NULL effectively always means "error".
     * @param elementSize a non-zero element size
     * @param offset an offset to the start of the region within the `bytes`
     * @param nElements the number of elements in the region
     * @returns the requested region, or %NULL in case of an error
     */
    getRegion(
      elementSize: number,
      offset: number,
      nElements: number
    ): any | null
    /**
     * Get the size of the byte data in the #GBytes.
     *
     * This function will always return the same value for a given #GBytes.
     * @returns the size
     */
    getSize(): number
    /**
     * Creates an integer hash code for the byte data in the #GBytes.
     *
     * This function can be passed to g_hash_table_new() as the `key_hash_func`
     * parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable.
     * @returns a hash value corresponding to the key.
     */
    hash(): number
    /**
     * Creates a #GBytes which is a subsection of another #GBytes. The `offset` +
     * `length` may not be longer than the size of `bytes`.
     *
     * A reference to `bytes` will be held by the newly created #GBytes until
     * the byte data is no longer needed.
     *
     * Since 2.56, if `offset` is 0 and `length` matches the size of `bytes,` then
     * `bytes` will be returned with the reference count incremented by 1. If `bytes`
     * is a slice of another #GBytes, then the resulting #GBytes will reference
     * the same #GBytes instead of `bytes`. This allows consumers to simplify the
     * usage of #GBytes when asynchronously writing to streams.
     * @param offset offset which subsection starts at
     * @param length length of subsection
     * @returns a new #GBytes
     */
    newFromBytes(offset: number, length: number): any
    /**
     * Increase the reference count on `bytes`.
     * @returns the #GBytes
     */
    ref(): any
    /**
     * Releases a reference on `bytes`.  This may result in the bytes being
     * freed. If `bytes` is %NULL, it will return immediately.
     */
    unref(): void
    /**
     * Unreferences the bytes, and returns a new mutable #GByteArray containing
     * the same byte data.
     *
     * As an optimization, the byte data is transferred to the array without copying
     * if this was the last reference to bytes and bytes was created with
     * g_bytes_new(), g_bytes_new_take() or g_byte_array_free_to_bytes(). In all
     * other cases the data is copied.
     *
     * Do not use it if `bytes` contains more than %G_MAXUINT
     * bytes. #GByteArray stores the length of its data in #guint, which
     * may be shorter than #gsize, that `bytes` is using.
     * @returns a new mutable #GByteArray containing the same byte data
     */
    unrefToArray(): number[]
    /**
     * Unreferences the bytes, and returns a pointer the same byte data
     * contents.
     *
     * As an optimization, the byte data is returned without copying if this was
     * the last reference to bytes and bytes was created with g_bytes_new(),
     * g_bytes_new_take() or g_byte_array_free_to_bytes(). In all other cases the
     * data is copied.
     * @returns a pointer to the same byte data, which should be          freed with g_free()
     */
    unrefToData(): number[]
  }

  /**
   * A simple refcounted data type representing an immutable sequence of zero or
   * more bytes from an unspecified origin.
   *
   * The purpose of a #GBytes is to keep the memory region that it holds
   * alive for as long as anyone holds a reference to the bytes.  When
   * the last reference count is dropped, the memory is released. Multiple
   * unrelated callers can use byte data in the #GBytes without coordinating
   * their activities, resting assured that the byte data will not change or
   * move while they hold a reference.
   *
   * A #GBytes can come from many different origins that may have
   * different procedures for freeing the memory region.  Examples are
   * memory from g_malloc(), from memory slices, from a #GMappedFile or
   * memory from other allocators.
   *
   * #GBytes work well as keys in #GHashTable. Use g_bytes_equal() and
   * g_bytes_hash() as parameters to g_hash_table_new() or g_hash_table_new_full().
   * #GBytes can also be used as keys in a #GTree by passing the g_bytes_compare()
   * function to g_tree_new().
   *
   * The data pointed to by this bytes must not be modified. For a mutable
   * array of bytes see #GByteArray. Use g_bytes_unref_to_array() to create a
   * mutable array for a #GBytes sequence. To create an immutable #GBytes from
   * a mutable #GByteArray, use the g_byte_array_free_to_bytes() function.
   * @record
   */
  class Bytes {
    // Own properties of GLib-2.0.GLib.Bytes

    static name: string

    // Constructors of GLib-2.0.GLib.Bytes

    /**
     * Creates a new #GBytes from `data`.
     *
     * `data` is copied. If `size` is 0, `data` may be %NULL.
     * @constructor
     * @param data the data to be used for the bytes
     * @returns a new #GBytes
     */
    constructor(data: number[] | null)
    /**
     * Creates a new #GBytes from `data`.
     *
     * `data` is copied. If `size` is 0, `data` may be %NULL.
     * @constructor
     * @param data the data to be used for the bytes
     * @returns a new #GBytes
     */
    static new(data: number[] | null): Bytes
    /**
     * Creates a new #GBytes from `data`.
     *
     * After this call, `data` belongs to the #GBytes and may no longer be
     * modified by the caller. The memory of `data` has to be dynamically
     * allocated and will eventually be freed with g_free().
     *
     * For creating #GBytes with memory from other allocators, see
     * g_bytes_new_with_free_func().
     *
     * `data` may be %NULL if `size` is 0.
     * @constructor
     * @param data the data to be used for the bytes
     * @returns a new #GBytes
     */
    static newTake(data: number[] | null): Bytes
  }

  interface Cache {
    // Owm methods of GLib-2.0.GLib.Cache

    /**
     * Frees the memory allocated for the #GCache.
     *
     * Note that it does not destroy the keys and values which were
     * contained in the #GCache.
     */
    destroy(): void
    /**
     * Gets the value corresponding to the given key, creating it if
     * necessary. It first checks if the value already exists in the
     * #GCache, by using the `key_equal_func` function passed to
     * g_cache_new(). If it does already exist it is returned, and its
     * reference count is increased by one. If the value does not currently
     * exist, if is created by calling the `value_new_func`. The key is
     * duplicated by calling `key_dup_func` and the duplicated key and value
     * are inserted into the #GCache.
     * @param key a key describing a #GCache object
     * @returns a pointer to a #GCache value
     */
    insert(key: any | null): any | null
    /**
     * Calls the given function for each of the keys in the #GCache.
     *
     * NOTE `func` is passed three parameters, the value and key of a cache
     * entry and the `user_data`. The order of value and key is different
     * from the order in which g_hash_table_foreach() passes key-value
     * pairs to its callback function !
     * @param func the function to call with each #GCache key
     */
    keyForeach(func: HFunc): void
    /**
     * Decreases the reference count of the given value. If it drops to 0
     * then the value and its corresponding key are destroyed, using the
     * `value_destroy_func` and `key_destroy_func` passed to g_cache_new().
     * @param value the value to remove
     */
    remove(value: any | null): void
    /**
     * Calls the given function for each of the values in the #GCache.
     * @param func the function to call with each #GCache value
     */
    valueForeach(func: HFunc): void
  }

  /**
   * A `GCache` allows sharing of complex data structures, in order to
   * save system resources.
   *
   * `GCache` uses keys and values. A `GCache` key describes the properties
   * of a particular resource. A `GCache` value is the actual resource.
   *
   * `GCache` has been marked as deprecated, since this API is rarely
   * used and not very actively maintained.
   * @record
   */
  class Cache {
    // Own properties of GLib-2.0.GLib.Cache

    static name: string
  }

  interface Checksum {
    // Owm methods of GLib-2.0.GLib.Checksum

    /**
     * Copies a #GChecksum. If `checksum` has been closed, by calling
     * g_checksum_get_string() or g_checksum_get_digest(), the copied
     * checksum will be closed as well.
     * @returns the copy of the passed #GChecksum. Use   g_checksum_free() when finished using it.
     */
    copy(): Checksum
    /**
     * Frees the memory allocated for `checksum`.
     */
    free(): void
    /**
     * Gets the digest as a hexadecimal string.
     *
     * Once this function has been called the #GChecksum can no longer be
     * updated with g_checksum_update().
     *
     * The hexadecimal characters will be lower case.
     * @returns the hexadecimal representation of the checksum. The   returned string is owned by the checksum and should not be modified   or freed.
     */
    getString(): string
    /**
     * Resets the state of the `checksum` back to its initial state.
     */
    reset(): void
    /**
     * Feeds `data` into an existing #GChecksum. The checksum must still be
     * open, that is g_checksum_get_string() or g_checksum_get_digest() must
     * not have been called on `checksum`.
     * @param data buffer used to compute the checksum
     */
    update(data: number[]): void
  }

  /**
   * GLib provides a generic API for computing checksums (or ‘digests’)
   * for a sequence of arbitrary bytes, using various hashing algorithms
   * like MD5, SHA-1 and SHA-256. Checksums are commonly used in various
   * environments and specifications.
   *
   * To create a new `GChecksum`, use [ctor`GLib`.Checksum.new]. To free
   * a `GChecksum`, use [method`GLib`.Checksum.free].
   *
   * GLib supports incremental checksums using the `GChecksum` data
   * structure, by calling [method`GLib`.Checksum.update] as long as there’s data
   * available and then using [method`GLib`.Checksum.get_string] or
   * [method`GLib`.Checksum.get_digest] to compute the checksum and return it
   * either as a string in hexadecimal form, or as a raw sequence of bytes. To
   * compute the checksum for binary blobs and nul-terminated strings in
   * one go, use the convenience functions [func`GLib`.compute_checksum_for_data]
   * and [func`GLib`.compute_checksum_for_string], respectively.
   * @record
   */
  class Checksum {
    // Own properties of GLib-2.0.GLib.Checksum

    static name: string

    // Constructors of GLib-2.0.GLib.Checksum

    /**
     * Creates a new #GChecksum, using the checksum algorithm `checksum_type`.
     * If the `checksum_type` is not known, %NULL is returned.
     * A #GChecksum can be used to compute the checksum, or digest, of an
     * arbitrary binary blob, using different hashing algorithms.
     *
     * A #GChecksum works by feeding a binary blob through g_checksum_update()
     * until there is data to be checked; the digest can then be extracted
     * using g_checksum_get_string(), which will return the checksum as a
     * hexadecimal string; or g_checksum_get_digest(), which will return a
     * vector of raw bytes. Once either g_checksum_get_string() or
     * g_checksum_get_digest() have been called on a #GChecksum, the checksum
     * will be closed and it won't be possible to call g_checksum_update()
     * on it anymore.
     * @constructor
     * @param checksumType the desired type of checksum
     * @returns the newly created #GChecksum, or %NULL.   Use g_checksum_free() to free the memory allocated by it.
     */
    constructor(checksumType: ChecksumType)
    /**
     * Creates a new #GChecksum, using the checksum algorithm `checksum_type`.
     * If the `checksum_type` is not known, %NULL is returned.
     * A #GChecksum can be used to compute the checksum, or digest, of an
     * arbitrary binary blob, using different hashing algorithms.
     *
     * A #GChecksum works by feeding a binary blob through g_checksum_update()
     * until there is data to be checked; the digest can then be extracted
     * using g_checksum_get_string(), which will return the checksum as a
     * hexadecimal string; or g_checksum_get_digest(), which will return a
     * vector of raw bytes. Once either g_checksum_get_string() or
     * g_checksum_get_digest() have been called on a #GChecksum, the checksum
     * will be closed and it won't be possible to call g_checksum_update()
     * on it anymore.
     * @constructor
     * @param checksumType the desired type of checksum
     * @returns the newly created #GChecksum, or %NULL.   Use g_checksum_free() to free the memory allocated by it.
     */
    static new(checksumType: ChecksumType): Checksum
    /**
     * Gets the length in bytes of digests of type `checksum_type`
     * @param checksumType a #GChecksumType
     * @returns the checksum length, or -1 if @checksum_type is not supported.
     */
    static typeGetLength(checksumType: ChecksumType): number
  }

  interface Completion {
    // Own fields of GLib-2.0.GLib.Completion

    /**
     * list of target items (strings or data structures).
     * @field
     */
    items: any[]
    /**
     * function which is called to get the string associated with a
     *        target item. It is %NULL if the target items are strings.
     * @field
     */
    func: CompletionFunc
    /**
     * the last prefix passed to g_completion_complete() or
     *          g_completion_complete_utf8().
     * @field
     */
    prefix: string | null
    /**
     * the list of items which begin with `prefix`.
     * @field
     */
    cache: any[]
    /**
     * The function to use when comparing strings.  Use
     *                g_completion_set_compare() to modify this function.
     * @field
     */
    strncmpFunc: CompletionStrncmpFunc

    // Owm methods of GLib-2.0.GLib.Completion

    /**
     * Removes all items from the #GCompletion. The items are not freed, so if the
     * memory was dynamically allocated, it should be freed after calling this
     * function.
     */
    clearItems(): void
    /**
     * Attempts to complete the string `prefix` using the #GCompletion target items.
     * In contrast to g_completion_complete(), this function returns the largest common
     * prefix that is a valid UTF-8 string, omitting a possible common partial
     * character.
     *
     * You should use this function instead of g_completion_complete() if your
     * items are UTF-8 strings.
     * @param prefix the prefix string, typically used by the user, which is compared    with each of the items
     * @param newPrefix if non-%NULL, returns the longest prefix which is common to all    items that matched `prefix,` or %NULL if no items matched `prefix`.    This string should be freed when no longer needed.
     * @returns the list of items whose strings begin with @prefix. This should not be changed.
     */
    completeUtf8(prefix: string, newPrefix: string | null): string[]
    /**
     * Frees all memory used by the #GCompletion. The items are not freed, so if
     * the memory was dynamically allocated, it should be freed after calling this
     * function.
     */
    free(): void
  }

  /**
   * `GCompletion` provides support for automatic completion of a string
   * using any group of target strings. It is typically used for file
   * name completion as is common in many UNIX shells.
   *
   * A `GCompletion` is created using [func`GLib`.Completion.new]. Target items are
   * added and removed with [method`GLib`.Completion.add_items],
   * [method`GLib`.Completion.remove_items] and
   * [method`GLib`.Completion.clear_items]. A completion attempt is requested with
   * [method`GLib`.Completion.complete] or [method`GLib`.Completion.complete_utf8].
   * When no longer needed, the `GCompletion` is freed with
   * [method`GLib`.Completion.free].
   *
   * Items in the completion can be simple strings (e.g. filenames), or
   * pointers to arbitrary data structures. If data structures are used
   * you must provide a [type`GLib`.CompletionFunc] in [func`GLib`.Completion.new],
   * which retrieves the item’s string from the data structure. You can change
   * the way in which strings are compared by setting a different
   * [type`GLib`.CompletionStrncmpFunc] in [method`GLib`.Completion.set_compare].
   *
   * `GCompletion` has been marked as deprecated, since this API is rarely
   * used and not very actively maintained.
   * @record
   */
  class Completion {
    // Own properties of GLib-2.0.GLib.Completion

    static name: string
  }

  interface Cond {
    // Owm methods of GLib-2.0.GLib.Cond

    /**
     * If threads are waiting for `cond,` all of them are unblocked.
     * If no threads are waiting for `cond,` this function has no effect.
     * It is good practice to lock the same mutex as the waiting threads
     * while calling this function, though not required.
     */
    broadcast(): void
    /**
     * Frees the resources allocated to a #GCond with g_cond_init().
     *
     * This function should not be used with a #GCond that has been
     * statically allocated.
     *
     * Calling g_cond_clear() for a #GCond on which threads are
     * blocking leads to undefined behaviour.
     */
    clear(): void
    /**
     * Initialises a #GCond so that it can be used.
     *
     * This function is useful to initialise a #GCond that has been
     * allocated as part of a larger structure.  It is not necessary to
     * initialise a #GCond that has been statically allocated.
     *
     * To undo the effect of g_cond_init() when a #GCond is no longer
     * needed, use g_cond_clear().
     *
     * Calling g_cond_init() on an already-initialised #GCond leads
     * to undefined behaviour.
     */
    init(): void
    /**
     * If threads are waiting for `cond,` at least one of them is unblocked.
     * If no threads are waiting for `cond,` this function has no effect.
     * It is good practice to hold the same lock as the waiting thread
     * while calling this function, though not required.
     */
    signal(): void
    /**
     * Atomically releases `mutex` and waits until `cond` is signalled.
     * When this function returns, `mutex` is locked again and owned by the
     * calling thread.
     *
     * When using condition variables, it is possible that a spurious wakeup
     * may occur (ie: g_cond_wait() returns even though g_cond_signal() was
     * not called).  It's also possible that a stolen wakeup may occur.
     * This is when g_cond_signal() is called, but another thread acquires
     * `mutex` before this thread and modifies the state of the program in
     * such a way that when g_cond_wait() is able to return, the expected
     * condition is no longer met.
     *
     * For this reason, g_cond_wait() must always be used in a loop.  See
     * the documentation for #GCond for a complete example.
     * @param mutex a #GMutex that is currently locked
     */
    wait(mutex: Mutex): void
    /**
     * Waits until either `cond` is signalled or `end_time` has passed.
     *
     * As with g_cond_wait() it is possible that a spurious or stolen wakeup
     * could occur.  For that reason, waiting on a condition variable should
     * always be in a loop, based on an explicitly-checked predicate.
     *
     * %TRUE is returned if the condition variable was signalled (or in the
     * case of a spurious wakeup).  %FALSE is returned if `end_time` has
     * passed.
     *
     * The following code shows how to correctly perform a timed wait on a
     * condition variable (extending the example presented in the
     * documentation for #GCond):
     *
     *
     * ```c
     * gpointer
     * pop_data_timed (void)
     * {
     *   gint64 end_time;
     *   gpointer data;
     *
     *   g_mutex_lock (&data_mutex);
     *
     *   end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND;
     *   while (!current_data)
     *     if (!g_cond_wait_until (&data_cond, &data_mutex, end_time))
     *       {
     *         // timeout has passed.
     *         g_mutex_unlock (&data_mutex);
     *         return NULL;
     *       }
     *
     *   // there is data for us
     *   data = current_data;
     *   current_data = NULL;
     *
     *   g_mutex_unlock (&data_mutex);
     *
     *   return data;
     * }
     * ```
     *
     *
     * Notice that the end time is calculated once, before entering the
     * loop and reused.  This is the motivation behind the use of absolute
     * time on this API -- if a relative time of 5 seconds were passed
     * directly to the call and a spurious wakeup occurred, the program would
     * have to start over waiting again (which would lead to a total wait
     * time of more than 5 seconds).
     * @param mutex a #GMutex that is currently locked
     * @param endTime the monotonic time to wait until
     * @returns %TRUE on a signal, %FALSE on a timeout
     */
    waitUntil(mutex: Mutex, endTime: number): boolean
  }

  /**
   * The #GCond struct is an opaque data structure that represents a
   * condition. Threads can block on a #GCond if they find a certain
   * condition to be false. If other threads change the state of this
   * condition they signal the #GCond, and that causes the waiting
   * threads to be woken up.
   *
   * Consider the following example of a shared variable.  One or more
   * threads can wait for data to be published to the variable and when
   * another thread publishes the data, it can signal one of the waiting
   * threads to wake up to collect the data.
   *
   * Here is an example for using GCond to block a thread until a condition
   * is satisfied:
   *
   * ```c
   *   gpointer current_data = NULL;
   *   GMutex data_mutex;
   *   GCond data_cond;
   *
   *   void
   *   push_data (gpointer data)
   *   {
   *     g_mutex_lock (&data_mutex);
   *     current_data = data;
   *     g_cond_signal (&data_cond);
   *     g_mutex_unlock (&data_mutex);
   *   }
   *
   *   gpointer
   *   pop_data (void)
   *   {
   *     gpointer data;
   *
   *     g_mutex_lock (&data_mutex);
   *     while (!current_data)
   *       g_cond_wait (&data_cond, &data_mutex);
   *     data = current_data;
   *     current_data = NULL;
   *     g_mutex_unlock (&data_mutex);
   *
   *     return data;
   *   }
   * ```
   *
   * Whenever a thread calls pop_data() now, it will wait until
   * current_data is non-%NULL, i.e. until some other thread
   * has called push_data().
   *
   * The example shows that use of a condition variable must always be
   * paired with a mutex.  Without the use of a mutex, there would be a
   * race between the check of `current_data` by the while loop in
   * pop_data() and waiting. Specifically, another thread could set
   * `current_data` after the check, and signal the cond (with nobody
   * waiting on it) before the first thread goes to sleep. #GCond is
   * specifically useful for its ability to release the mutex and go
   * to sleep atomically.
   *
   * It is also important to use the g_cond_wait() and g_cond_wait_until()
   * functions only inside a loop which checks for the condition to be
   * true.  See g_cond_wait() for an explanation of why the condition may
   * not be true even after it returns.
   *
   * If a #GCond is allocated in static storage then it can be used
   * without initialisation.  Otherwise, you should call g_cond_init()
   * on it and g_cond_clear() when done.
   *
   * A #GCond should only be accessed via the g_cond_ functions.
   * @record
   */
  class Cond {
    // Own properties of GLib-2.0.GLib.Cond

    static name: string
  }

  interface Data {}

  /**
   * An opaque data structure that represents a keyed data list.
   *
   * See also: [Keyed data lists](datalist-and-dataset.html).
   * @record
   */
  class Data {
    // Own properties of GLib-2.0.GLib.Data

    static name: string
  }

  interface Date {
    // Own fields of GLib-2.0.GLib.Date

    /**
     * the Julian representation of the date
     * @field
     */
    julianDays: number
    /**
     * this bit is set if `julian_days` is valid
     * @field
     */
    julian: number
    /**
     * this is set if `day,` `month` and `year` are valid
     * @field
     */
    dmy: number
    /**
     * the day of the day-month-year representation of the date,
     *   as a number between 1 and 31
     * @field
     */
    day: number
    /**
     * the month of the day-month-year representation of the date,
     *   as a number between 1 and 12
     * @field
     */
    month: number
    /**
     * the year of the day-month-year representation of the date
     * @field
     */
    year: number

    // Owm methods of GLib-2.0.GLib.Date

    /**
     * Increments a date some number of days.
     * To move forward by weeks, add weeks*7 days.
     * The date must be valid.
     * @param nDays number of days to move the date forward
     */
    addDays(nDays: number): void
    /**
     * Increments a date by some number of months.
     * If the day of the month is greater than 28,
     * this routine may change the day of the month
     * (because the destination month may not have
     * the current day in it). The date must be valid.
     * @param nMonths number of months to move forward
     */
    addMonths(nMonths: number): void
    /**
     * Increments a date by some number of years.
     * If the date is February 29, and the destination
     * year is not a leap year, the date will be changed
     * to February 28. The date must be valid.
     * @param nYears number of years to move forward
     */
    addYears(nYears: number): void
    /**
     * If `date` is prior to `min_date,` sets `date` equal to `min_date`.
     * If `date` falls after `max_date,` sets `date` equal to `max_date`.
     * Otherwise, `date` is unchanged.
     * Either of `min_date` and `max_date` may be %NULL.
     * All non-%NULL dates must be valid.
     * @param minDate minimum accepted value for `date`
     * @param maxDate maximum accepted value for `date`
     */
    clamp(minDate: Date, maxDate: Date): void
    /**
     * Initializes one or more #GDate structs to a safe but invalid
     * state. The cleared dates will not represent an existing date, but will
     * not contain garbage. Useful to init a date declared on the stack.
     * Validity can be tested with g_date_valid().
     * @param nDates number of dates to clear
     */
    clear(nDates: number): void
    /**
     * qsort()-style comparison function for dates.
     * Both dates must be valid.
     * @param rhs second date to compare
     * @returns 0 for equal, less than zero if @lhs is less than @rhs,     greater than zero if @lhs is greater than @rhs
     */
    compare(rhs: Date): number
    /**
     * Copies a GDate to a newly-allocated GDate. If the input was invalid
     * (as determined by g_date_valid()), the invalid state will be copied
     * as is into the new object.
     * @returns a newly-allocated #GDate initialized from @date
     */
    copy(): Date
    /**
     * Computes the number of days between two dates.
     * If `date2` is prior to `date1`, the returned value is negative.
     * Both dates must be valid.
     * @param date2 the second date
     * @returns the number of days between @date1 and @date2
     */
    daysBetween(date2: Date): number
    /**
     * Frees a #GDate returned from g_date_new().
     */
    free(): void
    /**
     * Returns the day of the month. The date must be valid.
     * @returns day of the month
     */
    getDay(): DateDay
    /**
     * Returns the day of the year, where Jan 1 is the first day of the
     * year. The date must be valid.
     * @returns day of the year
     */
    getDayOfYear(): number
    /**
     * Returns the week of the year, where weeks are interpreted according
     * to ISO 8601.
     * @returns ISO 8601 week number of the year.
     */
    getIso8601WeekOfYear(): number
    /**
     * Returns the Julian day or "serial number" of the #GDate. The
     * Julian day is simply the number of days since January 1, Year 1; i.e.,
     * January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2,
     * etc. The date must be valid.
     * @returns Julian day
     */
    getJulian(): number
    /**
     * Returns the week of the year, where weeks are understood to start on
     * Monday. If the date is before the first Monday of the year, return 0.
     * The date must be valid.
     * @returns week of the year
     */
    getMondayWeekOfYear(): number
    /**
     * Returns the month of the year. The date must be valid.
     * @returns month of the year as a #GDateMonth
     */
    getMonth(): DateMonth
    /**
     * Returns the week of the year during which this date falls, if
     * weeks are understood to begin on Sunday. The date must be valid.
     * Can return 0 if the day is before the first Sunday of the year.
     * @returns week number
     */
    getSundayWeekOfYear(): number
    /**
     * Returns the day of the week for a #GDate. The date must be valid.
     * @returns day of the week as a #GDateWeekday.
     */
    getWeekday(): DateWeekday
    /**
     * Returns the year of a #GDate. The date must be valid.
     * @returns year in which the date falls
     */
    getYear(): DateYear
    /**
     * Returns %TRUE if the date is on the first of a month.
     * The date must be valid.
     * @returns %TRUE if the date is the first of the month
     */
    isFirstOfMonth(): boolean
    /**
     * Returns %TRUE if the date is the last day of the month.
     * The date must be valid.
     * @returns %TRUE if the date is the last day of the month
     */
    isLastOfMonth(): boolean
    /**
     * Checks if `date1` is less than or equal to `date2`,
     * and swap the values if this is not the case.
     * @param date2 the second date
     */
    order(date2: Date): void
    /**
     * Sets the day of the month for a #GDate. If the resulting
     * day-month-year triplet is invalid, the date will be invalid.
     * @param day day to set
     */
    setDay(day: DateDay): void
    /**
     * Sets the value of a #GDate from a day, month, and year.
     * The day-month-year triplet must be valid; if you aren't
     * sure it is, call g_date_valid_dmy() to check before you
     * set it.
     * @param day day
     * @param month month
     * @param y year
     */
    setDmy(day: DateDay, month: DateMonth, y: DateYear): void
    /**
     * Sets the value of a #GDate from a Julian day number.
     * @param julianDate Julian day number (days since January 1, Year 1)
     */
    setJulian(julianDate: number): void
    /**
     * Sets the month of the year for a #GDate.  If the resulting
     * day-month-year triplet is invalid, the date will be invalid.
     * @param month month to set
     */
    setMonth(month: DateMonth): void
    /**
     * Parses a user-inputted string `str,` and try to figure out what date it
     * represents, taking the [current locale][setlocale] into account. If the
     * string is successfully parsed, the date will be valid after the call.
     * Otherwise, it will be invalid. You should check using g_date_valid()
     * to see whether the parsing succeeded.
     *
     * This function is not appropriate for file formats and the like; it
     * isn't very precise, and its exact behavior varies with the locale.
     * It's intended to be a heuristic routine that guesses what the user
     * means by a given string (and it does work pretty well in that
     * capacity).
     * @param str string to parse
     */
    setParse(str: string): void
    /**
     * Sets the value of a date from a #GTime value.
     * The time to date conversion is done using the user's current timezone.
     * @param time #GTime value to set.
     */
    setTime(time: Time): void
    /**
     * Sets the value of a date to the date corresponding to a time
     * specified as a time_t. The time to date conversion is done using
     * the user's current timezone.
     *
     * To set the value of a date to the current day, you could write:
     *
     * ```c
     *  time_t now = time (NULL);
     *  if (now == (time_t) -1)
     *    // handle the error
     *  g_date_set_time_t (date, now);
     * ```
     *
     * @param timet time_t value to set
     */
    setTimeT(timet: any): void
    /**
     * Sets the value of a date from a #GTimeVal value.  Note that the
     * `tv_usec` member is ignored, because #GDate can't make use of the
     * additional precision.
     *
     * The time to date conversion is done using the user's current timezone.
     * @param timeval #GTimeVal value to set
     */
    setTimeVal(timeval: TimeVal): void
    /**
     * Sets the year for a #GDate. If the resulting day-month-year
     * triplet is invalid, the date will be invalid.
     * @param year year to set
     */
    setYear(year: DateYear): void
    /**
     * Moves a date some number of days into the past.
     * To move by weeks, just move by weeks*7 days.
     * The date must be valid.
     * @param nDays number of days to move
     */
    subtractDays(nDays: number): void
    /**
     * Moves a date some number of months into the past.
     * If the current day of the month doesn't exist in
     * the destination month, the day of the month
     * may change. The date must be valid.
     * @param nMonths number of months to move
     */
    subtractMonths(nMonths: number): void
    /**
     * Moves a date some number of years into the past.
     * If the current day doesn't exist in the destination
     * year (i.e. it's February 29 and you move to a non-leap-year)
     * then the day is changed to February 29. The date
     * must be valid.
     * @param nYears number of years to move
     */
    subtractYears(nYears: number): void
    /**
     * Fills in the date-related bits of a struct tm using the `date` value.
     * Initializes the non-date parts with something safe but meaningless.
     * @param tm struct tm to fill
     */
    toStructTm(tm: any): void
    /**
     * Returns %TRUE if the #GDate represents an existing day. The date must not
     * contain garbage; it should have been initialized with g_date_clear()
     * if it wasn't allocated by one of the g_date_new() variants.
     * @returns Whether the date is valid
     */
    valid(): boolean
  }

  /**
   * `GDate` is a struct for calendrical calculations.
   *
   * The `GDate` data structure represents a day between January 1, Year 1,
   * and sometime a few thousand years in the future (right now it will go
   * to the year 65535 or so, but [method`GLib`.Date.set_parse] only parses up to the
   * year 8000 or so - just count on "a few thousand"). `GDate` is meant to
   * represent everyday dates, not astronomical dates or historical dates
   * or ISO timestamps or the like. It extrapolates the current Gregorian
   * calendar forward and backward in time; there is no attempt to change
   * the calendar to match time periods or locations. `GDate` does not store
   * time information; it represents a day.
   *
   * The `GDate` implementation has several nice features; it is only a
   * 64-bit struct, so storing large numbers of dates is very efficient. It
   * can keep both a Julian and day-month-year representation of the date,
   * since some calculations are much easier with one representation or the
   * other. A Julian representation is simply a count of days since some
   * fixed day in the past; for #GDate the fixed day is January 1, 1 AD.
   * ("Julian" dates in the #GDate API aren't really Julian dates in the
   * technical sense; technically, Julian dates count from the start of the
   * Julian period, Jan 1, 4713 BC).
   *
   * `GDate` is simple to use. First you need a "blank" date; you can get a
   * dynamically allocated date from [ctor`GLib`.Date.new], or you can declare an
   * automatic variable or array and initialize it by calling [method`GLib`.Date.clear].
   * A cleared date is safe; it's safe to call [method`GLib`.Date.set_dmy] and the other
   * mutator functions to initialize the value of a cleared date. However, a cleared date
   * is initially invalid, meaning that it doesn't represent a day that exists.
   * It is undefined to call any of the date calculation routines on an invalid date.
   * If you obtain a date from a user or other unpredictable source, you should check
   * its validity with the [method`GLib`.Date.valid] predicate. [method`GLib`.Date.valid]
   * is also used to check for errors with [method`GLib`.Date.set_parse] and other functions
   * that can fail. Dates can be invalidated by calling [method`GLib`.Date.clear] again.
   *
   * It is very important to use the API to access the `GDate` struct. Often only the
   * day-month-year or only the Julian representation is valid. Sometimes neither is valid.
   * Use the API.
   *
   * GLib also features `GDateTime` which represents a precise time.
   * @record
   */
  class Date {
    // Own properties of GLib-2.0.GLib.Date

    static name: string

    // Constructors of GLib-2.0.GLib.Date

    /**
     * Allocates a #GDate and initializes
     * it to a safe state. The new date will
     * be cleared (as if you'd called g_date_clear()) but invalid (it won't
     * represent an existing day). Free the return value with g_date_free().
     * @constructor
     * @returns a newly-allocated #GDate
     */
    constructor()
    /**
     * Allocates a #GDate and initializes
     * it to a safe state. The new date will
     * be cleared (as if you'd called g_date_clear()) but invalid (it won't
     * represent an existing day). Free the return value with g_date_free().
     * @constructor
     * @returns a newly-allocated #GDate
     */
    static new(): Date
    /**
     * Create a new #GDate representing the given day-month-year triplet.
     *
     * The triplet you pass in must represent a valid date. Use g_date_valid_dmy()
     * if needed to validate it. The returned #GDate is guaranteed to be non-%NULL
     * and valid.
     * @constructor
     * @param day day of the month
     * @param month month of the year
     * @param year year
     * @returns a newly-allocated #GDate   initialized with @day, @month, and @year
     */
    static newDmy(day: DateDay, month: DateMonth, year: DateYear): Date
    /**
     * Create a new #GDate representing the given Julian date.
     *
     * The `julian_day` you pass in must be valid. Use g_date_valid_julian() if
     * needed to validate it. The returned #GDate is guaranteed to be non-%NULL and
     * valid.
     * @constructor
     * @param julianDay days since January 1, Year 1
     * @returns a newly-allocated #GDate initialized   with @julian_day
     */
    static newJulian(julianDay: number): Date
    /**
     * Returns the number of days in a month, taking leap
     * years into account.
     * @param month month
     * @param year year
     * @returns number of days in @month during the @year
     */
    static getDaysInMonth(month: DateMonth, year: DateYear): number
    /**
     * Returns the number of weeks in the year, where weeks
     * are taken to start on Monday. Will be 52 or 53. The
     * date must be valid. (Years always have 52 7-day periods,
     * plus 1 or 2 extra days depending on whether it's a leap
     * year. This function is basically telling you how many
     * Mondays are in the year, i.e. there are 53 Mondays if
     * one of the extra days happens to be a Monday.)
     * @param year a year
     * @returns number of Mondays in the year
     */
    static getMondayWeeksInYear(year: DateYear): number
    /**
     * Returns the number of weeks in the year, where weeks
     * are taken to start on Sunday. Will be 52 or 53. The
     * date must be valid. (Years always have 52 7-day periods,
     * plus 1 or 2 extra days depending on whether it's a leap
     * year. This function is basically telling you how many
     * Sundays are in the year, i.e. there are 53 Sundays if
     * one of the extra days happens to be a Sunday.)
     * @param year year to count weeks in
     * @returns the number of weeks in @year
     */
    static getSundayWeeksInYear(year: DateYear): number
    /**
     * Returns %TRUE if the year is a leap year.
     *
     * For the purposes of this function, leap year is every year
     * divisible by 4 unless that year is divisible by 100. If it
     * is divisible by 100 it would be a leap year only if that year
     * is also divisible by 400.
     * @param year year to check
     * @returns %TRUE if the year is a leap year
     */
    static isLeapYear(year: DateYear): boolean
    /**
     * Generates a printed representation of the date, in a
     * [locale][setlocale]-specific way.
     * Works just like the platform's C library strftime() function,
     * but only accepts date-related formats; time-related formats
     * give undefined results. Date must be valid. Unlike strftime()
     * (which uses the locale encoding), works on a UTF-8 format
     * string and stores a UTF-8 result.
     *
     * This function does not provide any conversion specifiers in
     * addition to those implemented by the platform's C library.
     * For example, don't expect that using g_date_strftime() would
     * make the \%F provided by the C99 strftime() work on Windows
     * where the C library only complies to C89.
     * @param s destination buffer
     * @param slen buffer size
     * @param format format string
     * @param date valid #GDate
     * @returns number of characters written to the buffer, or 0 the buffer was too small
     */
    static strftime(
      s: string | null,
      slen: number,
      format: string,
      date: Date
    ): number
    /**
     * Returns %TRUE if the day of the month is valid (a day is valid if it's
     * between 1 and 31 inclusive).
     * @param day day to check
     * @returns %TRUE if the day is valid
     */
    static validDay(day: DateDay): boolean
    /**
     * Returns %TRUE if the day-month-year triplet forms a valid, existing day
     * in the range of days #GDate understands (Year 1 or later, no more than
     * a few thousand years in the future).
     * @param day day
     * @param month month
     * @param year year
     * @returns %TRUE if the date is a valid one
     */
    static validDmy(day: DateDay, month: DateMonth, year: DateYear): boolean
    /**
     * Returns %TRUE if the Julian day is valid. Anything greater than zero
     * is basically a valid Julian, though there is a 32-bit limit.
     * @param julianDate Julian day to check
     * @returns %TRUE if the Julian day is valid
     */
    static validJulian(julianDate: number): boolean
    /**
     * Returns %TRUE if the month value is valid. The 12 #GDateMonth
     * enumeration values are the only valid months.
     * @param month month
     * @returns %TRUE if the month is valid
     */
    static validMonth(month: DateMonth): boolean
    /**
     * Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration
     * values are the only valid weekdays.
     * @param weekday weekday
     * @returns %TRUE if the weekday is valid
     */
    static validWeekday(weekday: DateWeekday): boolean
    /**
     * Returns %TRUE if the year is valid. Any year greater than 0 is valid,
     * though there is a 16-bit limit to what #GDate will understand.
     * @param year year
     * @returns %TRUE if the year is valid
     */
    static validYear(year: DateYear): boolean
  }

  interface DateTime {
    // Owm methods of GLib-2.0.GLib.DateTime

    /**
     * Creates a copy of `datetime` and adds the specified timespan to the copy.
     * @param timespan a #GTimeSpan
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    add(timespan: TimeSpan): DateTime | null
    /**
     * Creates a copy of `datetime` and adds the specified number of days to the
     * copy. Add negative values to subtract days.
     * @param days the number of days
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    addDays(days: number): DateTime | null
    /**
     * Creates a new #GDateTime adding the specified values to the current date and
     * time in `datetime`. Add negative values to subtract.
     * @param years the number of years to add
     * @param months the number of months to add
     * @param days the number of days to add
     * @param hours the number of hours to add
     * @param minutes the number of minutes to add
     * @param seconds the number of seconds to add
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    addFull(
      years: number,
      months: number,
      days: number,
      hours: number,
      minutes: number,
      seconds: number
    ): DateTime | null
    /**
     * Creates a copy of `datetime` and adds the specified number of hours.
     * Add negative values to subtract hours.
     * @param hours the number of hours to add
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    addHours(hours: number): DateTime | null
    /**
     * Creates a copy of `datetime` adding the specified number of minutes.
     * Add negative values to subtract minutes.
     * @param minutes the number of minutes to add
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    addMinutes(minutes: number): DateTime | null
    /**
     * Creates a copy of `datetime` and adds the specified number of months to the
     * copy. Add negative values to subtract months.
     *
     * The day of the month of the resulting #GDateTime is clamped to the number
     * of days in the updated calendar month. For example, if adding 1 month to
     * 31st January 2018, the result would be 28th February 2018. In 2020 (a leap
     * year), the result would be 29th February.
     * @param months the number of months
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    addMonths(months: number): DateTime | null
    /**
     * Creates a copy of `datetime` and adds the specified number of seconds.
     * Add negative values to subtract seconds.
     * @param seconds the number of seconds to add
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    addSeconds(seconds: number): DateTime | null
    /**
     * Creates a copy of `datetime` and adds the specified number of weeks to the
     * copy. Add negative values to subtract weeks.
     * @param weeks the number of weeks
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    addWeeks(weeks: number): DateTime | null
    /**
     * Creates a copy of `datetime` and adds the specified number of years to the
     * copy. Add negative values to subtract years.
     *
     * As with g_date_time_add_months(), if the resulting date would be 29th
     * February on a non-leap year, the day will be clamped to 28th February.
     * @param years the number of years
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    addYears(years: number): DateTime | null
    /**
     * A comparison function for #GDateTimes that is suitable
     * as a #GCompareFunc. Both #GDateTimes must be non-%NULL.
     * @param dt2 second #GDateTime to compare
     * @returns -1, 0 or 1 if @dt1 is less than, equal to or greater   than @dt2.
     */
    compare(dt2: DateTime): number
    /**
     * Calculates the difference in time between `end` and `begin`.  The
     * #GTimeSpan that is returned is effectively `end` - `begin` (ie:
     * positive if the first parameter is larger).
     * @param begin a #GDateTime
     * @returns the difference between the two #GDateTime, as a time   span expressed in microseconds.
     */
    difference(begin: DateTime): TimeSpan
    /**
     * Checks to see if `dt1` and `dt2` are equal.
     *
     * Equal here means that they represent the same moment after converting
     * them to the same time zone.
     * @param dt2 a #GDateTime
     * @returns %TRUE if @dt1 and @dt2 are equal
     */
    equal(dt2: DateTime): boolean
    /**
     * Creates a newly allocated string representing the requested `format`.
     *
     * The format strings understood by this function are a subset of the
     * `strftime()` format language as specified by C99.  The `%D`, `%U` and `%W`
     * conversions are not supported, nor is the `E` modifier.  The GNU
     * extensions `%k`, `%l`, `%s` and `%P` are supported, however, as are the
     * `0`, `_` and `-` modifiers. The Python extension `%f` is also supported.
     *
     * In contrast to `strftime()`, this function always produces a UTF-8
     * string, regardless of the current locale.  Note that the rendering of
     * many formats is locale-dependent and may not match the `strftime()`
     * output exactly.
     *
     * The following format specifiers are supported:
     *
     * - `%a`: the abbreviated weekday name according to the current locale
     * - `%A`: the full weekday name according to the current locale
     * - `%b`: the abbreviated month name according to the current locale
     * - `%B`: the full month name according to the current locale
     * - `%c`: the preferred date and time representation for the current locale
     * - `%C`: the century number (year/100) as a 2-digit integer (00-99)
     * - `%d`: the day of the month as a decimal number (range 01 to 31)
     * - `%e`: the day of the month as a decimal number (range 1 to 31);
     *   single digits are preceded by a figure space (U+2007)
     * - `%F`: equivalent to `%Y-%m-%d` (the ISO 8601 date format)
     * - `%g`: the last two digits of the ISO 8601 week-based year as a
     *   decimal number (00-99). This works well with `%V` and `%u`.
     * - `%G`: the ISO 8601 week-based year as a decimal number. This works
     *   well with `%V` and `%u`.
     * - `%h`: equivalent to `%b`
     * - `%H`: the hour as a decimal number using a 24-hour clock (range 00 to 23)
     * - `%I`: the hour as a decimal number using a 12-hour clock (range 01 to 12)
     * - `%j`: the day of the year as a decimal number (range 001 to 366)
     * - `%k`: the hour (24-hour clock) as a decimal number (range 0 to 23);
     *   single digits are preceded by a figure space (U+2007)
     * - `%l`: the hour (12-hour clock) as a decimal number (range 1 to 12);
     *   single digits are preceded by a figure space (U+2007)
     * - `%m`: the month as a decimal number (range 01 to 12)
     * - `%M`: the minute as a decimal number (range 00 to 59)
     * - `%f`: the microsecond as a decimal number (range 000000 to 999999)
     * - `%p`: either ‘AM’ or ‘PM’ according to the given time value, or the
     *   corresponding  strings for the current locale.  Noon is treated as
     *   ‘PM’ and midnight as ‘AM’. Use of this format specifier is discouraged, as
     *   many locales have no concept of AM/PM formatting. Use `%c` or `%X` instead.
     * - `%P`: like `%p` but lowercase: ‘am’ or ‘pm’ or a corresponding string for
     *   the current locale. Use of this format specifier is discouraged, as
     *   many locales have no concept of AM/PM formatting. Use `%c` or `%X` instead.
     * - `%r`: the time in a.m. or p.m. notation. Use of this format specifier is
     *   discouraged, as many locales have no concept of AM/PM formatting. Use `%c`
     *   or `%X` instead.
     * - `%R`: the time in 24-hour notation (`%H:%M`)
     * - `%s`: the number of seconds since the Epoch, that is, since 1970-01-01
     *   00:00:00 UTC
     * - `%S`: the second as a decimal number (range 00 to 60)
     * - `%t`: a tab character
     * - `%T`: the time in 24-hour notation with seconds (`%H:%M:%S`)
     * - `%u`: the ISO 8601 standard day of the week as a decimal, range 1 to 7,
     *    Monday being 1. This works well with `%G` and `%V`.
     * - `%V`: the ISO 8601 standard week number of the current year as a decimal
     *   number, range 01 to 53, where week 1 is the first week that has at
     *   least 4 days in the new year. See g_date_time_get_week_of_year().
     *   This works well with `%G` and `%u`.
     * - `%w`: the day of the week as a decimal, range 0 to 6, Sunday being 0.
     *   This is not the ISO 8601 standard format — use `%u` instead.
     * - `%x`: the preferred date representation for the current locale without
     *   the time
     * - `%X`: the preferred time representation for the current locale without
     *   the date
     * - `%y`: the year as a decimal number without the century
     * - `%Y`: the year as a decimal number including the century
     * - `%z`: the time zone as an offset from UTC (`+hhmm`)
     * - `%:z`: the time zone as an offset from UTC (`+hh:mm`).
     *   This is a gnulib `strftime()` extension. Since: 2.38
     * - `%::z`: the time zone as an offset from UTC (`+hh:mm:ss`). This is a
     *   gnulib `strftime()` extension. Since: 2.38
     * - `%:::z`: the time zone as an offset from UTC, with `:` to necessary
     *   precision (e.g., `-04`, `+05:30`). This is a gnulib `strftime()` extension. Since: 2.38
     * - `%Z`: the time zone or name or abbreviation
     * - `%%`: a literal `%` character
     *
     * Some conversion specifications can be modified by preceding the
     * conversion specifier by one or more modifier characters.
     *
     * The following modifiers are supported for many of the numeric
     * conversions:
     *
     * - `O`: Use alternative numeric symbols, if the current locale supports those.
     * - `_`: Pad a numeric result with spaces. This overrides the default padding
     *   for the specifier.
     * - `-`: Do not pad a numeric result. This overrides the default padding
     *   for the specifier.
     * - `0`: Pad a numeric result with zeros. This overrides the default padding
     *   for the specifier.
     *
     * The following modifiers are supported for many of the alphabetic conversions:
     *
     * - `^`: Use upper case if possible. This is a gnulib `strftime()` extension.
     *   Since: 2.80
     * - `#`: Use opposite case if possible. This is a gnulib `strftime()`
     *   extension. Since: 2.80
     *
     * Additionally, when `O` is used with `B`, `b`, or `h`, it produces the alternative
     * form of a month name. The alternative form should be used when the month
     * name is used without a day number (e.g., standalone). It is required in
     * some languages (Baltic, Slavic, Greek, and more) due to their grammatical
     * rules. For other languages there is no difference. `%OB` is a GNU and BSD
     * `strftime()` extension expected to be added to the future POSIX specification,
     * `%Ob` and `%Oh` are GNU `strftime()` extensions. Since: 2.56
     *
     * Since GLib 2.80, when `E` is used with `%c`, `%C`, `%x`, `%X`, `%y` or `%Y`,
     * the date is formatted using an alternate era representation specific to the
     * locale. This is typically used for the Thai solar calendar or Japanese era
     * names, for example.
     *
     * - `%Ec`: the preferred date and time representation for the current locale,
     *   using the alternate era representation
     * - `%EC`: the name of the era
     * - `%Ex`: the preferred date representation for the current locale without
     *   the time, using the alternate era representation
     * - `%EX`: the preferred time representation for the current locale without
     *   the date, using the alternate era representation
     * - `%Ey`: the year since the beginning of the era denoted by the `%EC`
     *   specifier
     * - `%EY`: the full alternative year representation
     * @param format a valid UTF-8 string, containing the format for the          #GDateTime
     * @returns a newly allocated string formatted to    the requested format or %NULL in the case that there was an error (such    as a format specifier not being supported in the current locale). The    string should be freed with g_free().
     */
    format(format: string): string | null
    /**
     * Format `datetime` in [ISO 8601 format](https://en.wikipedia.org/wiki/ISO_8601),
     * including the date, time and time zone, and return that as a UTF-8 encoded
     * string.
     *
     * Since GLib 2.66, this will output to sub-second precision if needed.
     * @returns a newly allocated string formatted in   ISO 8601 format or %NULL in the case that there was an error. The string   should be freed with g_free().
     */
    formatIso8601(): string | null
    /**
     * Retrieves the day of the month represented by `datetime` in the gregorian
     * calendar.
     * @returns the day of the month
     */
    getDayOfMonth(): number
    /**
     * Retrieves the ISO 8601 day of the week on which `datetime` falls (1 is
     * Monday, 2 is Tuesday... 7 is Sunday).
     * @returns the day of the week
     */
    getDayOfWeek(): number
    /**
     * Retrieves the day of the year represented by `datetime` in the Gregorian
     * calendar.
     * @returns the day of the year
     */
    getDayOfYear(): number
    /**
     * Retrieves the hour of the day represented by `datetime`
     * @returns the hour of the day
     */
    getHour(): number
    /**
     * Retrieves the microsecond of the date represented by `datetime`
     * @returns the microsecond of the second
     */
    getMicrosecond(): number
    /**
     * Retrieves the minute of the hour represented by `datetime`
     * @returns the minute of the hour
     */
    getMinute(): number
    /**
     * Retrieves the month of the year represented by `datetime` in the Gregorian
     * calendar.
     * @returns the month represented by @datetime
     */
    getMonth(): number
    /**
     * Retrieves the second of the minute represented by `datetime`
     * @returns the second represented by @datetime
     */
    getSecond(): number
    /**
     * Retrieves the number of seconds since the start of the last minute,
     * including the fractional part.
     * @returns the number of seconds
     */
    getSeconds(): number
    /**
     * Get the time zone for this `datetime`.
     * @returns the time zone
     */
    getTimezone(): TimeZone
    /**
     * Determines the time zone abbreviation to be used at the time and in
     * the time zone of `datetime`.
     *
     * For example, in Toronto this is currently "EST" during the winter
     * months and "EDT" during the summer months when daylight savings
     * time is in effect.
     * @returns the time zone abbreviation. The returned          string is owned by the #GDateTime and it should not be          modified or freed
     */
    getTimezoneAbbreviation(): string
    /**
     * Determines the offset to UTC in effect at the time and in the time
     * zone of `datetime`.
     *
     * The offset is the number of microseconds that you add to UTC time to
     * arrive at local time for the time zone (ie: negative numbers for time
     * zones west of GMT, positive numbers for east).
     *
     * If `datetime` represents UTC time, then the offset is always zero.
     * @returns the number of microseconds that should be added to UTC to          get the local time
     */
    getUtcOffset(): TimeSpan
    /**
     * Returns the ISO 8601 week-numbering year in which the week containing
     * `datetime` falls.
     *
     * This function, taken together with g_date_time_get_week_of_year() and
     * g_date_time_get_day_of_week() can be used to determine the full ISO
     * week date on which `datetime` falls.
     *
     * This is usually equal to the normal Gregorian year (as returned by
     * g_date_time_get_year()), except as detailed below:
     *
     * For Thursday, the week-numbering year is always equal to the usual
     * calendar year.  For other days, the number is such that every day
     * within a complete week (Monday to Sunday) is contained within the
     * same week-numbering year.
     *
     * For Monday, Tuesday and Wednesday occurring near the end of the year,
     * this may mean that the week-numbering year is one greater than the
     * calendar year (so that these days have the same week-numbering year
     * as the Thursday occurring early in the next year).
     *
     * For Friday, Saturday and Sunday occurring near the start of the year,
     * this may mean that the week-numbering year is one less than the
     * calendar year (so that these days have the same week-numbering year
     * as the Thursday occurring late in the previous year).
     *
     * An equivalent description is that the week-numbering year is equal to
     * the calendar year containing the majority of the days in the current
     * week (Monday to Sunday).
     *
     * Note that January 1 0001 in the proleptic Gregorian calendar is a
     * Monday, so this function never returns 0.
     * @returns the ISO 8601 week-numbering year for @datetime
     */
    getWeekNumberingYear(): number
    /**
     * Returns the ISO 8601 week number for the week containing `datetime`.
     * The ISO 8601 week number is the same for every day of the week (from
     * Moday through Sunday).  That can produce some unusual results
     * (described below).
     *
     * The first week of the year is week 1.  This is the week that contains
     * the first Thursday of the year.  Equivalently, this is the first week
     * that has more than 4 of its days falling within the calendar year.
     *
     * The value 0 is never returned by this function.  Days contained
     * within a year but occurring before the first ISO 8601 week of that
     * year are considered as being contained in the last week of the
     * previous year.  Similarly, the final days of a calendar year may be
     * considered as being part of the first ISO 8601 week of the next year
     * if 4 or more days of that week are contained within the new year.
     * @returns the ISO 8601 week number for @datetime.
     */
    getWeekOfYear(): number
    /**
     * Retrieves the year represented by `datetime` in the Gregorian calendar.
     * @returns the year represented by @datetime
     */
    getYear(): number
    /**
     * Retrieves the Gregorian day, month, and year of a given #GDateTime.
     */
    getYmd(): [/* year */ number, /* month */ number, /* day */ number]
    /**
     * Hashes `datetime` into a #guint, suitable for use within #GHashTable.
     * @returns a #guint containing the hash
     */
    hash(): number
    /**
     * Determines if daylight savings time is in effect at the time and in
     * the time zone of `datetime`.
     * @returns %TRUE if daylight savings time is in effect
     */
    isDaylightSavings(): boolean
    /**
     * Atomically increments the reference count of `datetime` by one.
     * @returns the #GDateTime with the reference count increased
     */
    ref(): DateTime
    /**
     * Creates a new #GDateTime corresponding to the same instant in time as
     * `datetime,` but in the local time zone.
     *
     * This call is equivalent to calling g_date_time_to_timezone() with the
     * time zone returned by g_time_zone_new_local().
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    toLocal(): DateTime | null
    /**
     * Stores the instant in time that `datetime` represents into `tv`.
     *
     * The time contained in a #GTimeVal is always stored in the form of
     * seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the time
     * zone associated with `datetime`.
     *
     * On systems where 'long' is 32bit (ie: all 32bit systems and all
     * Windows systems), a #GTimeVal is incapable of storing the entire
     * range of values that #GDateTime is capable of expressing.  On those
     * systems, this function returns %FALSE to indicate that the time is
     * out of range.
     *
     * On systems where 'long' is 64bit, this function never fails.
     * @param tv a #GTimeVal to modify
     * @returns %TRUE if successful, else %FALSE
     */
    toTimeval(tv: TimeVal): boolean
    /**
     * Create a new #GDateTime corresponding to the same instant in time as
     * `datetime,` but in the time zone `tz`.
     *
     * This call can fail in the case that the time goes out of bounds.  For
     * example, converting 0001-01-01 00:00:00 UTC to a time zone west of
     * Greenwich will fail (due to the year 0 being out of range).
     * @param tz the new #GTimeZone
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    toTimezone(tz: TimeZone): DateTime | null
    /**
     * Gives the Unix time corresponding to `datetime,` rounding down to the
     * nearest second.
     *
     * Unix time is the number of seconds that have elapsed since 1970-01-01
     * 00:00:00 UTC, regardless of the time zone associated with `datetime`.
     * @returns the Unix time corresponding to @datetime
     */
    toUnix(): number
    /**
     * Gives the Unix time corresponding to `datetime,` in microseconds.
     *
     * Unix time is the number of microseconds that have elapsed since 1970-01-01
     * 00:00:00 UTC, regardless of the time zone associated with `datetime`.
     * @returns the Unix time corresponding to @datetime
     */
    toUnixUsec(): number
    /**
     * Creates a new #GDateTime corresponding to the same instant in time as
     * `datetime,` but in UTC.
     *
     * This call is equivalent to calling g_date_time_to_timezone() with the
     * time zone returned by g_time_zone_new_utc().
     * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
     */
    toUtc(): DateTime | null
    /**
     * Atomically decrements the reference count of `datetime` by one.
     *
     * When the reference count reaches zero, the resources allocated by
     * `datetime` are freed
     */
    unref(): void
  }

  /**
   * `GDateTime` is a structure that combines a Gregorian date and time
   * into a single structure.
   *
   * `GDateTime` provides many conversion and methods to manipulate dates and times.
   * Time precision is provided down to microseconds and the time can range
   * (proleptically) from 0001-01-01 00:00:00 to 9999-12-31 23:59:59.999999.
   * `GDateTime` follows POSIX time in the sense that it is oblivious to leap
   * seconds.
   *
   * `GDateTime` is an immutable object; once it has been created it cannot
   * be modified further. All modifiers will create a new `GDateTime`.
   * Nearly all such functions can fail due to the date or time going out
   * of range, in which case %NULL will be returned.
   *
   * `GDateTime` is reference counted: the reference count is increased by calling
   * [method`GLib`.DateTime.ref] and decreased by calling [method`GLib`.DateTime.unref].
   * When the reference count drops to 0, the resources allocated by the `GDateTime`
   * structure are released.
   *
   * Many parts of the API may produce non-obvious results. As an
   * example, adding two months to January 31st will yield March 31st
   * whereas adding one month and then one month again will yield either
   * March 28th or March 29th.  Also note that adding 24 hours is not
   * always the same as adding one day (since days containing daylight
   * savings time transitions are either 23 or 25 hours in length).
   * @record
   */
  class DateTime {
    // Own properties of GLib-2.0.GLib.DateTime

    static name: string

    // Constructors of GLib-2.0.GLib.DateTime

    /**
     * Creates a new #GDateTime corresponding to the given date and time in
     * the time zone `tz`.
     *
     * The `year` must be between 1 and 9999, `month` between 1 and 12 and `day`
     * between 1 and 28, 29, 30 or 31 depending on the month and the year.
     *
     * `hour` must be between 0 and 23 and `minute` must be between 0 and 59.
     *
     * `seconds` must be at least 0.0 and must be strictly less than 60.0.
     * It will be rounded down to the nearest microsecond.
     *
     * If the given time is not representable in the given time zone (for
     * example, 02:30 on March 14th 2010 in Toronto, due to daylight savings
     * time) then the time will be rounded up to the nearest existing time
     * (in this case, 03:00).  If this matters to you then you should verify
     * the return value for containing the same as the numbers you gave.
     *
     * In the case that the given time is ambiguous in the given time zone
     * (for example, 01:30 on November 7th 2010 in Toronto, due to daylight
     * savings time) then the time falling within standard (ie:
     * non-daylight) time is taken.
     *
     * It not considered a programmer error for the values to this function
     * to be out of range, but in the case that they are, the function will
     * return %NULL.
     *
     * You should release the return value by calling g_date_time_unref()
     * when you are done with it.
     * @constructor
     * @param tz a #GTimeZone
     * @param year the year component of the date
     * @param month the month component of the date
     * @param day the day component of the date
     * @param hour the hour component of the date
     * @param minute the minute component of the date
     * @param seconds the number of seconds past the minute
     * @returns a new #GDateTime, or %NULL
     */
    constructor(
      tz: TimeZone,
      year: number,
      month: number,
      day: number,
      hour: number,
      minute: number,
      seconds: number
    )
    /**
     * Creates a new #GDateTime corresponding to the given date and time in
     * the time zone `tz`.
     *
     * The `year` must be between 1 and 9999, `month` between 1 and 12 and `day`
     * between 1 and 28, 29, 30 or 31 depending on the month and the year.
     *
     * `hour` must be between 0 and 23 and `minute` must be between 0 and 59.
     *
     * `seconds` must be at least 0.0 and must be strictly less than 60.0.
     * It will be rounded down to the nearest microsecond.
     *
     * If the given time is not representable in the given time zone (for
     * example, 02:30 on March 14th 2010 in Toronto, due to daylight savings
     * time) then the time will be rounded up to the nearest existing time
     * (in this case, 03:00).  If this matters to you then you should verify
     * the return value for containing the same as the numbers you gave.
     *
     * In the case that the given time is ambiguous in the given time zone
     * (for example, 01:30 on November 7th 2010 in Toronto, due to daylight
     * savings time) then the time falling within standard (ie:
     * non-daylight) time is taken.
     *
     * It not considered a programmer error for the values to this function
     * to be out of range, but in the case that they are, the function will
     * return %NULL.
     *
     * You should release the return value by calling g_date_time_unref()
     * when you are done with it.
     * @constructor
     * @param tz a #GTimeZone
     * @param year the year component of the date
     * @param month the month component of the date
     * @param day the day component of the date
     * @param hour the hour component of the date
     * @param minute the minute component of the date
     * @param seconds the number of seconds past the minute
     * @returns a new #GDateTime, or %NULL
     */
    static new(
      tz: TimeZone,
      year: number,
      month: number,
      day: number,
      hour: number,
      minute: number,
      seconds: number
    ): DateTime
    /**
     * Creates a #GDateTime corresponding to the given
     * [ISO 8601 formatted string](https://en.wikipedia.org/wiki/ISO_8601)
     * `text`. ISO 8601 strings of the form <date><sep><time><tz> are supported, with
     * some extensions from [RFC 3339](https://tools.ietf.org/html/rfc3339) as
     * mentioned below.
     *
     * Note that as #GDateTime "is oblivious to leap seconds", leap seconds information
     * in an ISO-8601 string will be ignored, so a `23:59:60` time would be parsed as
     * `23:59:59`.
     *
     * <sep> is the separator and can be either 'T', 't' or ' '. The latter two
     * separators are an extension from
     * [RFC 3339](https://tools.ietf.org/html/rfc3339#section-5.6).
     *
     * <date> is in the form:
     *
     * - `YYYY-MM-DD` - Year/month/day, e.g. 2016-08-24.
     * - `YYYYMMDD` - Same as above without dividers.
     * - `YYYY-DDD` - Ordinal day where DDD is from 001 to 366, e.g. 2016-237.
     * - `YYYYDDD` - Same as above without dividers.
     * - `YYYY-Www-D` - Week day where ww is from 01 to 52 and D from 1-7,
     *   e.g. 2016-W34-3.
     * - `YYYYWwwD` - Same as above without dividers.
     *
     * <time> is in the form:
     *
     * - `hh:mm:ss(.sss)` - Hours, minutes, seconds (subseconds), e.g. 22:10:42.123.
     * - `hhmmss(.sss)` - Same as above without dividers.
     *
     * <tz> is an optional timezone suffix of the form:
     *
     * - `Z` - UTC.
     * - `+hh:mm` or `-hh:mm` - Offset from UTC in hours and minutes, e.g. +12:00.
     * - `+hh` or `-hh` - Offset from UTC in hours, e.g. +12.
     *
     * If the timezone is not provided in `text` it must be provided in `default_tz`
     * (this field is otherwise ignored).
     *
     * This call can fail (returning %NULL) if `text` is not a valid ISO 8601
     * formatted string.
     *
     * You should release the return value by calling g_date_time_unref()
     * when you are done with it.
     * @constructor
     * @param text an ISO 8601 formatted time string.
     * @param defaultTz a #GTimeZone to use if the text doesn't contain a                          timezone, or %NULL.
     * @returns a new #GDateTime, or %NULL
     */
    static newFromIso8601(text: string, defaultTz: TimeZone | null): DateTime
    /**
     * Creates a #GDateTime corresponding to the given #GTimeVal `tv` in the
     * local time zone.
     *
     * The time contained in a #GTimeVal is always stored in the form of
     * seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the
     * local time offset.
     *
     * This call can fail (returning %NULL) if `tv` represents a time outside
     * of the supported range of #GDateTime.
     *
     * You should release the return value by calling g_date_time_unref()
     * when you are done with it.
     * @constructor
     * @param tv a #GTimeVal
     * @returns a new #GDateTime, or %NULL
     */
    static newFromTimevalLocal(tv: TimeVal): DateTime
    /**
     * Creates a #GDateTime corresponding to the given #GTimeVal `tv` in UTC.
     *
     * The time contained in a #GTimeVal is always stored in the form of
     * seconds elapsed since 1970-01-01 00:00:00 UTC.
     *
     * This call can fail (returning %NULL) if `tv` represents a time outside
     * of the supported range of #GDateTime.
     *
     * You should release the return value by calling g_date_time_unref()
     * when you are done with it.
     * @constructor
     * @param tv a #GTimeVal
     * @returns a new #GDateTime, or %NULL
     */
    static newFromTimevalUtc(tv: TimeVal): DateTime
    /**
     * Creates a #GDateTime corresponding to the given Unix time `t` in the
     * local time zone.
     *
     * Unix time is the number of seconds that have elapsed since 1970-01-01
     * 00:00:00 UTC, regardless of the local time offset.
     *
     * This call can fail (returning %NULL) if `t` represents a time outside
     * of the supported range of #GDateTime.
     *
     * You should release the return value by calling g_date_time_unref()
     * when you are done with it.
     * @constructor
     * @param t the Unix time
     * @returns a new #GDateTime, or %NULL
     */
    static newFromUnixLocal(t: number): DateTime
    /**
     * Creates a [struct`GLib`.DateTime] corresponding to the given Unix time `t` in the
     * local time zone.
     *
     * Unix time is the number of microseconds that have elapsed since 1970-01-01
     * 00:00:00 UTC, regardless of the local time offset.
     *
     * This call can fail (returning `NULL`) if `t` represents a time outside
     * of the supported range of #GDateTime.
     *
     * You should release the return value by calling [method`GLib`.DateTime.unref]
     * when you are done with it.
     * @constructor
     * @param usecs the Unix time in microseconds
     * @returns a new [struct@GLib.DateTime], or `NULL`
     */
    static newFromUnixLocalUsec(usecs: number): DateTime
    /**
     * Creates a #GDateTime corresponding to the given Unix time `t` in UTC.
     *
     * Unix time is the number of seconds that have elapsed since 1970-01-01
     * 00:00:00 UTC.
     *
     * This call can fail (returning %NULL) if `t` represents a time outside
     * of the supported range of #GDateTime.
     *
     * You should release the return value by calling g_date_time_unref()
     * when you are done with it.
     * @constructor
     * @param t the Unix time
     * @returns a new #GDateTime, or %NULL
     */
    static newFromUnixUtc(t: number): DateTime
    /**
     * Creates a [struct`GLib`.DateTime] corresponding to the given Unix time `t` in UTC.
     *
     * Unix time is the number of microseconds that have elapsed since 1970-01-01
     * 00:00:00 UTC.
     *
     * This call can fail (returning `NULL`) if `t` represents a time outside
     * of the supported range of #GDateTime.
     *
     * You should release the return value by calling [method`GLib`.DateTime.unref]
     * when you are done with it.
     * @constructor
     * @param usecs the Unix time in microseconds
     * @returns a new [struct@GLib.DateTime], or `NULL`
     */
    static newFromUnixUtcUsec(usecs: number): DateTime
    /**
     * Creates a new #GDateTime corresponding to the given date and time in
     * the local time zone.
     *
     * This call is equivalent to calling g_date_time_new() with the time
     * zone returned by g_time_zone_new_local().
     * @constructor
     * @param year the year component of the date
     * @param month the month component of the date
     * @param day the day component of the date
     * @param hour the hour component of the date
     * @param minute the minute component of the date
     * @param seconds the number of seconds past the minute
     * @returns a #GDateTime, or %NULL
     */
    static newLocal(
      year: number,
      month: number,
      day: number,
      hour: number,
      minute: number,
      seconds: number
    ): DateTime
    /**
     * Creates a #GDateTime corresponding to this exact instant in the given
     * time zone `tz`.  The time is as accurate as the system allows, to a
     * maximum accuracy of 1 microsecond.
     *
     * This function will always succeed unless GLib is still being used after the
     * year 9999.
     *
     * You should release the return value by calling g_date_time_unref()
     * when you are done with it.
     * @constructor
     * @param tz a #GTimeZone
     * @returns a new #GDateTime, or %NULL
     */
    static newNow(tz: TimeZone): DateTime
    /**
     * Creates a #GDateTime corresponding to this exact instant in the local
     * time zone.
     *
     * This is equivalent to calling g_date_time_new_now() with the time
     * zone returned by g_time_zone_new_local().
     * @constructor
     * @returns a new #GDateTime, or %NULL
     */
    static newNowLocal(): DateTime
    /**
     * Creates a #GDateTime corresponding to this exact instant in UTC.
     *
     * This is equivalent to calling g_date_time_new_now() with the time
     * zone returned by g_time_zone_new_utc().
     * @constructor
     * @returns a new #GDateTime, or %NULL
     */
    static newNowUtc(): DateTime
    /**
     * Creates a new #GDateTime corresponding to the given date and time in
     * UTC.
     *
     * This call is equivalent to calling g_date_time_new() with the time
     * zone returned by g_time_zone_new_utc().
     * @constructor
     * @param year the year component of the date
     * @param month the month component of the date
     * @param day the day component of the date
     * @param hour the hour component of the date
     * @param minute the minute component of the date
     * @param seconds the number of seconds past the minute
     * @returns a #GDateTime, or %NULL
     */
    static newUtc(
      year: number,
      month: number,
      day: number,
      hour: number,
      minute: number,
      seconds: number
    ): DateTime
  }

  interface DebugKey {
    // Own fields of GLib-2.0.GLib.DebugKey

    /**
     * the string
     * @field
     */
    key: string
    /**
     * the flag
     * @field
     */
    value: number
  }

  /**
   * Associates a string with a bit flag.
   * Used in g_parse_debug_string().
   * @record
   */
  class DebugKey {
    // Own properties of GLib-2.0.GLib.DebugKey

    static name: string
  }

  interface Dir {
    // Owm methods of GLib-2.0.GLib.Dir

    /**
     * Closes the directory immediately and decrements the reference count.
     *
     * Once the reference count reaches zero, the `GDir` structure itself will be
     * freed. Prior to GLib 2.80, `GDir` was not reference counted.
     *
     * It is an error to call any of the `GDir` methods other than
     * [method`GLib`.Dir.ref] and [method`GLib`.Dir.unref] on a `GDir` after calling
     * [method`GLib`.Dir.close] on it.
     */
    close(): void
    /**
     * Retrieves the name of another entry in the directory, or %NULL.
     * The order of entries returned from this function is not defined,
     * and may vary by file system or other operating-system dependent
     * factors.
     *
     * %NULL may also be returned in case of errors. On Unix, you can
     * check `errno` to find out if %NULL was returned because of an error.
     *
     * On Unix, the '.' and '..' entries are omitted, and the returned
     * name is in the on-disk encoding.
     *
     * On Windows, as is true of all GLib functions which operate on
     * filenames, the returned name is in UTF-8.
     * @returns The entry's name or %NULL if there are no   more entries. The return value is owned by GLib and   must not be modified or freed.
     */
    readName(): string
    /**
     * Increment the reference count of `dir`.
     * @returns the same pointer as `dir`
     */
    ref(): Dir
    /**
     * Resets the given directory. The next call to g_dir_read_name()
     * will return the first entry again.
     */
    rewind(): void
    /**
     * Decrements the reference count of `dir`.
     *
     * Once the reference count reaches zero, the directory will be closed and all
     * resources associated with it will be freed. If [method`GLib`.Dir.close] is
     * called when the reference count is greater than zero, the directory is closed
     * but the `GDir` structure will not be freed until its reference count reaches
     * zero.
     *
     * It is an error to call any of the `GDir` methods other than
     * [method`GLib`.Dir.ref] and [method`GLib`.Dir.unref] on a `GDir` after calling
     * [method`GLib`.Dir.close] on it.
     */
    unref(): void
  }

  /**
   * An opaque structure representing an opened directory.
   * @record
   */
  class Dir {
    // Own properties of GLib-2.0.GLib.Dir

    static name: string

    // Constructors of GLib-2.0.GLib.Dir

    /**
     * Opens a directory for reading. The names of the files in the
     * directory can then be retrieved using g_dir_read_name().  Note
     * that the ordering is not defined.
     * @constructor
     * @param path the path to the directory you are interested in. On Unix         in the on-disk encoding. On Windows in UTF-8
     * @param flags Currently must be set to 0. Reserved for future use.
     * @returns a newly allocated #GDir on success, %NULL on failure.   If non-%NULL, you must free the result with g_dir_close()   when you are finished with it.
     */
    static open(path: string, flags: number): Dir
    /**
     * Creates a subdirectory in the preferred directory for temporary
     * files (as returned by g_get_tmp_dir()).
     *
     * `tmpl` should be a string in the GLib file name encoding containing
     * a sequence of six 'X' characters, as the parameter to g_mkstemp().
     * However, unlike these functions, the template should only be a
     * basename, no directory components are allowed. If template is
     * %NULL, a default template is used.
     *
     * Note that in contrast to g_mkdtemp() (and mkdtemp()) `tmpl` is not
     * modified, and might thus be a read-only literal string.
     * @param tmpl Template for directory name,   as in g_mkdtemp(), basename only, or %NULL for a default template
     * @returns The actual name used. This string   should be freed with g_free() when not needed any longer and is   is in the GLib file name encoding. In case of errors, %NULL is   returned and @error will be set.
     */
    static makeTmp(tmpl: string | null): string
  }

  interface Error {
    // Own fields of GLib-2.0.GLib.Error

    /**
     * error domain, e.g. %G_FILE_ERROR
     * @field
     */
    domain: Quark
    /**
     * error code, e.g. %G_FILE_ERROR_NOENT
     * @field
     */
    code: number
    /**
     * human-readable informative error message
     * @field
     */
    message: string | null

    // Owm methods of GLib-2.0.GLib.Error

    /**
     * Makes a copy of `error`.
     * @returns a new #GError
     */
    copy(): Error
    /**
     * Frees a #GError and associated resources.
     */
    free(): void
    /**
     * Returns %TRUE if `error` matches `domain` and `code,` %FALSE
     * otherwise. In particular, when `error` is %NULL, %FALSE will
     * be returned.
     *
     * If `domain` contains a `FAILED` (or otherwise generic) error code,
     * you should generally not check for it explicitly, but should
     * instead treat any not-explicitly-recognized error code as being
     * equivalent to the `FAILED` code. This way, if the domain is
     * extended in the future to provide a more specific error code for
     * a certain case, your code will still work.
     * @param domain an error domain
     * @param code an error code
     * @returns whether @error has @domain and @code
     */
    matches(domain: Quark, code: number): boolean
  }

  /**
   * The `GError` structure contains information about
   * an error that has occurred.
   * @record
   */
  class Error {
    // Own properties of GLib-2.0.GLib.Error

    static name: string

    // Constructors of GLib-2.0.GLib.Error

    /**
     * Creates a new #GError; unlike g_error_new(), `message` is
     * not a printf()-style format string. Use this function if
     * `message` contains text you don't have control over,
     * that could include printf() escape sequences.
     * @constructor
     * @param domain error domain
     * @param code error code
     * @param message error message
     * @returns a new #GError
     */
    static newLiteral(domain: Quark, code: number, message: string): Error
    /**
     * This function registers an extended #GError domain.
     * `error_type_name` will be duplicated. Otherwise does the same as
     * g_error_domain_register_static().
     * @param errorTypeName string to create a #GQuark from
     * @param errorTypePrivateSize size of the private error data in bytes
     * @param errorTypeInit function initializing fields of the private error data
     * @param errorTypeCopy function copying fields of the private error data
     * @param errorTypeClear function freeing fields of the private error data
     * @returns #GQuark representing the error domain
     */
    static domainRegister(
      errorTypeName: string,
      errorTypePrivateSize: number,
      errorTypeInit: ErrorInitFunc,
      errorTypeCopy: ErrorCopyFunc,
      errorTypeClear: ErrorClearFunc
    ): Quark
    /**
     * This function registers an extended #GError domain.
     *
     * `error_type_name` should not be freed. `error_type_private_size` must
     * be greater than 0.
     *
     * `error_type_init` receives an initialized #GError and should then initialize
     * the private data.
     *
     * `error_type_copy` is a function that receives both original and a copy
     * #GError and should copy the fields of the private error data. The standard
     * #GError fields are already handled.
     *
     * `error_type_clear` receives the pointer to the error, and it should free the
     * fields of the private error data. It should not free the struct itself though.
     *
     * Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it
     * already takes care of passing valid information to this function.
     * @param errorTypeName static string to create a #GQuark from
     * @param errorTypePrivateSize size of the private error data in bytes
     * @param errorTypeInit function initializing fields of the private error data
     * @param errorTypeCopy function copying fields of the private error data
     * @param errorTypeClear function freeing fields of the private error data
     * @returns #GQuark representing the error domain
     */
    static domainRegisterStatic(
      errorTypeName: string,
      errorTypePrivateSize: number,
      errorTypeInit: ErrorInitFunc,
      errorTypeCopy: ErrorCopyFunc,
      errorTypeClear: ErrorClearFunc
    ): Quark
  }

  interface HashTable<
    A = symbol | string | number,
    B = string | number | boolean,
  > {}

  /**
   * The #GHashTable struct is an opaque data structure to represent a
   * [Hash Table][glib-Hash-Tables]. It should only be accessed via the
   * following functions.
   * @record
   */
  class HashTable<A = symbol | string | number, B = string | number | boolean> {
    // Own properties of GLib-2.0.GLib.HashTable

    static name: string

    // Constructors of GLib-2.0.GLib.HashTable

    /**
     * Creates a new #GHashTable like g_hash_table_new_full() with a reference
     * count of 1.
     *
     * It inherits the hash function, the key equal function, the key destroy function,
     * as well as the value destroy function, from `other_hash_table`.
     *
     * The returned hash table will be empty; it will not contain the keys
     * or values from `other_hash_table`.
     * @param otherHashTable Another #GHashTable
     * @returns a new #GHashTable
     */
    static newSimilar(otherHashTable: HashTable): HashTable
    /**
     * This is a convenience function for using a #GHashTable as a set.  It
     * is equivalent to calling g_hash_table_replace() with `key` as both the
     * key and the value.
     *
     * In particular, this means that if `key` already exists in the hash table, then
     * the old copy of `key` in the hash table is freed and `key` replaces it in the
     * table.
     *
     * When a hash table only ever contains keys that have themselves as the
     * corresponding value it is able to be stored more efficiently.  See
     * the discussion in the section description.
     *
     * Starting from GLib 2.40, this function returns a boolean value to
     * indicate whether the newly added value was already in the hash table
     * or not.
     * @param hashTable a #GHashTable
     * @param key a key to insert
     * @returns %TRUE if the key did not exist yet
     */
    static add(hashTable: HashTable, key: any | null): boolean
    /**
     * Checks if `key` is in `hash_table`.
     * @param hashTable a #GHashTable
     * @param key a key to check
     * @returns %TRUE if @key is in @hash_table, %FALSE otherwise.
     */
    static contains(hashTable: HashTable, key: any | null): boolean
    /**
     * Destroys all keys and values in the #GHashTable and decrements its
     * reference count by 1. If keys and/or values are dynamically allocated,
     * you should either free them first or create the #GHashTable with destroy
     * notifiers using g_hash_table_new_full(). In the latter case the destroy
     * functions you supplied will be called on all keys and values during the
     * destruction phase.
     * @param hashTable a #GHashTable
     */
    static destroy(hashTable: HashTable): void
    /**
     * Calls the given function for key/value pairs in the #GHashTable
     * until `predicate` returns %TRUE. The function is passed the key
     * and value of each pair, and the given `user_data` parameter. The
     * hash table may not be modified while iterating over it (you can't
     * add/remove items).
     *
     * Note, that hash tables are really only optimized for forward
     * lookups, i.e. g_hash_table_lookup(). So code that frequently issues
     * g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of
     * once per every entry in a hash table) should probably be reworked
     * to use additional or different data structures for reverse lookups
     * (keep in mind that an O(n) find/foreach operation issued for all n
     * values in a hash table ends up needing O(n*n) operations).
     * @param hashTable a #GHashTable
     * @param predicate function to test the key/value pairs for a certain property
     * @returns The value of the first key/value pair is returned,     for which @predicate evaluates to %TRUE. If no pair with the     requested property is found, %NULL is returned.
     */
    static find(hashTable: HashTable, predicate: HRFunc): any | null
    /**
     * Calls the given function for each of the key/value pairs in the
     * #GHashTable.  The function is passed the key and value of each
     * pair, and the given `user_data` parameter.  The hash table may not
     * be modified while iterating over it (you can't add/remove
     * items). To remove all items matching a predicate, use
     * g_hash_table_foreach_remove().
     *
     * The order in which g_hash_table_foreach() iterates over the keys/values in
     * the hash table is not defined.
     *
     * See g_hash_table_find() for performance caveats for linear
     * order searches in contrast to g_hash_table_lookup().
     * @param hashTable a #GHashTable
     * @param func the function to call for each key/value pair
     */
    static foreach(hashTable: HashTable, func: HFunc): void
    /**
     * Calls the given function for each key/value pair in the
     * #GHashTable. If the function returns %TRUE, then the key/value
     * pair is removed from the #GHashTable. If you supplied key or
     * value destroy functions when creating the #GHashTable, they are
     * used to free the memory allocated for the removed keys and values.
     *
     * See #GHashTableIter for an alternative way to loop over the
     * key/value pairs in the hash table.
     * @param hashTable a #GHashTable
     * @param func the function to call for each key/value pair
     * @returns the number of key/value pairs removed
     */
    static foreachRemove(hashTable: HashTable, func: HRFunc): number
    /**
     * Calls the given function for each key/value pair in the
     * #GHashTable. If the function returns %TRUE, then the key/value
     * pair is removed from the #GHashTable, but no key or value
     * destroy functions are called.
     *
     * See #GHashTableIter for an alternative way to loop over the
     * key/value pairs in the hash table.
     * @param hashTable a #GHashTable
     * @param func the function to call for each key/value pair
     * @returns the number of key/value pairs removed.
     */
    static foreachSteal(hashTable: HashTable, func: HRFunc): number
    /**
     * Inserts a new key and value into a #GHashTable.
     *
     * If the key already exists in the #GHashTable its current
     * value is replaced with the new value. If you supplied a
     * `value_destroy_func` when creating the #GHashTable, the old
     * value is freed using that function. If you supplied a
     * `key_destroy_func` when creating the #GHashTable, the passed
     * key is freed using that function.
     *
     * Starting from GLib 2.40, this function returns a boolean value to
     * indicate whether the newly added value was already in the hash table
     * or not.
     * @param hashTable a #GHashTable
     * @param key a key to insert
     * @param value the value to associate with the key
     * @returns %TRUE if the key did not exist yet
     */
    static insert(
      hashTable: HashTable,
      key: any | null,
      value: any | null
    ): boolean
    /**
     * Looks up a key in a #GHashTable. Note that this function cannot
     * distinguish between a key that is not present and one which is present
     * and has the value %NULL. If you need this distinction, use
     * g_hash_table_lookup_extended().
     * @param hashTable a #GHashTable
     * @param key the key to look up
     * @returns the associated value, or %NULL if the key is not found
     */
    static lookup(hashTable: HashTable, key: any | null): any | null
    /**
     * Looks up a key in the #GHashTable, returning the original key and the
     * associated value and a #gboolean which is %TRUE if the key was found. This
     * is useful if you need to free the memory allocated for the original key,
     * for example before calling g_hash_table_remove().
     *
     * You can actually pass %NULL for `lookup_key` to test
     * whether the %NULL key exists, provided the hash and equal functions
     * of `hash_table` are %NULL-safe.
     * @param hashTable a #GHashTable
     * @param lookupKey the key to look up
     * @returns %TRUE if the key was found in the #GHashTable
     */
    static lookupExtended(
      hashTable: HashTable,
      lookupKey: any | null
    ): [
      /* returnType */ boolean,
      /* origKey */ any | null,
      /* value */ any | null,
    ]
    /**
     * Atomically increments the reference count of `hash_table` by one.
     * This function is MT-safe and may be called from any thread.
     * @param hashTable a valid #GHashTable
     * @returns the passed in #GHashTable
     */
    static ref(hashTable: HashTable): HashTable
    /**
     * Removes a key and its associated value from a #GHashTable.
     *
     * If the #GHashTable was created using g_hash_table_new_full(), the
     * key and value are freed using the supplied destroy functions, otherwise
     * you have to make sure that any dynamically allocated values are freed
     * yourself.
     * @param hashTable a #GHashTable
     * @param key the key to remove
     * @returns %TRUE if the key was found and removed from the #GHashTable
     */
    static remove(hashTable: HashTable, key: any | null): boolean
    /**
     * Removes all keys and their associated values from a #GHashTable.
     *
     * If the #GHashTable was created using g_hash_table_new_full(),
     * the keys and values are freed using the supplied destroy functions,
     * otherwise you have to make sure that any dynamically allocated
     * values are freed yourself.
     * @param hashTable a #GHashTable
     */
    static removeAll(hashTable: HashTable): void
    /**
     * Inserts a new key and value into a #GHashTable similar to
     * g_hash_table_insert(). The difference is that if the key
     * already exists in the #GHashTable, it gets replaced by the
     * new key. If you supplied a `value_destroy_func` when creating
     * the #GHashTable, the old value is freed using that function.
     * If you supplied a `key_destroy_func` when creating the
     * #GHashTable, the old key is freed using that function.
     *
     * Starting from GLib 2.40, this function returns a boolean value to
     * indicate whether the newly added value was already in the hash table
     * or not.
     * @param hashTable a #GHashTable
     * @param key a key to insert
     * @param value the value to associate with the key
     * @returns %TRUE if the key did not exist yet
     */
    static replace(
      hashTable: HashTable,
      key: any | null,
      value: any | null
    ): boolean
    /**
     * Returns the number of elements contained in the #GHashTable.
     * @param hashTable a #GHashTable
     * @returns the number of key/value pairs in the #GHashTable.
     */
    static size(hashTable: HashTable): number
    /**
     * Removes a key and its associated value from a #GHashTable without
     * calling the key and value destroy functions.
     * @param hashTable a #GHashTable
     * @param key the key to remove
     * @returns %TRUE if the key was found and removed from the #GHashTable
     */
    static steal(hashTable: HashTable, key: any | null): boolean
    /**
     * Removes all keys and their associated values from a #GHashTable
     * without calling the key and value destroy functions.
     * @param hashTable a #GHashTable
     */
    static stealAll(hashTable: HashTable): void
    /**
     * Looks up a key in the #GHashTable, stealing the original key and the
     * associated value and returning %TRUE if the key was found. If the key was
     * not found, %FALSE is returned.
     *
     * If found, the stolen key and value are removed from the hash table without
     * calling the key and value destroy functions, and ownership is transferred to
     * the caller of this method, as with g_hash_table_steal(). That is the case
     * regardless whether `stolen_key` or `stolen_value` output parameters are
     * requested.
     *
     * You can pass %NULL for `lookup_key,` provided the hash and equal functions
     * of `hash_table` are %NULL-safe.
     *
     * The dictionary implementation optimizes for having all values identical to
     * their keys, for example by using g_hash_table_add(). When stealing both the
     * key and the value from such a dictionary, the value will be %NULL.
     * @param hashTable a #GHashTable
     * @param lookupKey the key to look up
     * @returns %TRUE if the key was found in the #GHashTable
     */
    static stealExtended(
      hashTable: HashTable,
      lookupKey: any | null
    ): [
      /* returnType */ boolean,
      /* stolenKey */ any | null,
      /* stolenValue */ any | null,
    ]
    /**
     * Atomically decrements the reference count of `hash_table` by one.
     * If the reference count drops to 0, all keys and values will be
     * destroyed, and all memory allocated by the hash table is released.
     * This function is MT-safe and may be called from any thread.
     * @param hashTable a valid #GHashTable
     */
    static unref(hashTable: HashTable): void
  }

  interface HashTableIter {
    // Owm methods of GLib-2.0.GLib.HashTableIter

    /**
     * Returns the #GHashTable associated with `iter`.
     * @returns the #GHashTable associated with @iter.
     */
    getHashTable(): HashTable
    /**
     * Initializes a key/value pair iterator and associates it with
     * `hash_table`. Modifying the hash table after calling this function
     * invalidates the returned iterator.
     *
     * The iteration order of a #GHashTableIter over the keys/values in a hash
     * table is not defined.
     *
     *
     * ```c
     * GHashTableIter iter;
     * gpointer key, value;
     *
     * g_hash_table_iter_init (&iter, hash_table);
     * while (g_hash_table_iter_next (&iter, &key, &value))
     *   {
     *     // do something with key and value
     *   }
     * ```
     *
     * @param hashTable a #GHashTable
     */
    init(hashTable: HashTable): void
    /**
     * Advances `iter` and retrieves the key and/or value that are now
     * pointed to as a result of this advancement. If %FALSE is returned,
     * `key` and `value` are not set, and the iterator becomes invalid.
     * @returns %FALSE if the end of the #GHashTable has been reached.
     */
    next(): [
      /* returnType */ boolean,
      /* key */ any | null,
      /* value */ any | null,
    ]
    /**
     * Removes the key/value pair currently pointed to by the iterator
     * from its associated #GHashTable. Can only be called after
     * g_hash_table_iter_next() returned %TRUE, and cannot be called
     * more than once for the same key/value pair.
     *
     * If the #GHashTable was created using g_hash_table_new_full(),
     * the key and value are freed using the supplied destroy functions,
     * otherwise you have to make sure that any dynamically allocated
     * values are freed yourself.
     *
     * It is safe to continue iterating the #GHashTable afterward:
     *
     * ```c
     * while (g_hash_table_iter_next (&iter, &key, &value))
     *   {
     *     if (condition)
     *       g_hash_table_iter_remove (&iter);
     *   }
     * ```
     *
     */
    remove(): void
    /**
     * Replaces the value currently pointed to by the iterator
     * from its associated #GHashTable. Can only be called after
     * g_hash_table_iter_next() returned %TRUE.
     *
     * If you supplied a `value_destroy_func` when creating the
     * #GHashTable, the old value is freed using that function.
     * @param value the value to replace with
     */
    replace(value: any | null): void
    /**
     * Removes the key/value pair currently pointed to by the
     * iterator from its associated #GHashTable, without calling
     * the key and value destroy functions. Can only be called
     * after g_hash_table_iter_next() returned %TRUE, and cannot
     * be called more than once for the same key/value pair.
     */
    steal(): void
  }

  /**
   * A GHashTableIter structure represents an iterator that can be used
   * to iterate over the elements of a #GHashTable. GHashTableIter
   * structures are typically allocated on the stack and then initialized
   * with g_hash_table_iter_init().
   *
   * The iteration order of a #GHashTableIter over the keys/values in a hash
   * table is not defined.
   * @record
   */
  class HashTableIter {
    // Own properties of GLib-2.0.GLib.HashTableIter

    static name: string
  }

  interface Hmac {
    // Owm methods of GLib-2.0.GLib.Hmac

    /**
     * Copies a #GHmac. If `hmac` has been closed, by calling
     * g_hmac_get_string() or g_hmac_get_digest(), the copied
     * HMAC will be closed as well.
     * @returns the copy of the passed #GHmac. Use g_hmac_unref()   when finished using it.
     */
    copy(): Hmac
    /**
     * Gets the digest from `checksum` as a raw binary array and places it
     * into `buffer`. The size of the digest depends on the type of checksum.
     *
     * Once this function has been called, the #GHmac is closed and can
     * no longer be updated with g_checksum_update().
     * @param buffer output buffer
     */
    getDigest(buffer: number[]): void
    /**
     * Gets the HMAC as a hexadecimal string.
     *
     * Once this function has been called the #GHmac can no longer be
     * updated with g_hmac_update().
     *
     * The hexadecimal characters will be lower case.
     * @returns the hexadecimal representation of the HMAC. The   returned string is owned by the HMAC and should not be modified   or freed.
     */
    getString(): string
    /**
     * Atomically increments the reference count of `hmac` by one.
     *
     * This function is MT-safe and may be called from any thread.
     * @returns the passed in #GHmac.
     */
    ref(): Hmac
    /**
     * Atomically decrements the reference count of `hmac` by one.
     *
     * If the reference count drops to 0, all keys and values will be
     * destroyed, and all memory allocated by the hash table is released.
     * This function is MT-safe and may be called from any thread.
     * Frees the memory allocated for `hmac`.
     */
    unref(): void
    /**
     * Feeds `data` into an existing #GHmac.
     *
     * The HMAC must still be open, that is g_hmac_get_string() or
     * g_hmac_get_digest() must not have been called on `hmac`.
     * @param data buffer used to compute the checksum
     */
    update(data: number[]): void
  }

  /**
   * HMACs should be used when producing a cookie or hash based on data
   * and a key. Simple mechanisms for using SHA1 and other algorithms to
   * digest a key and data together are vulnerable to various security
   * issues.
   * [HMAC](http://en.wikipedia.org/wiki/HMAC)
   * uses algorithms like SHA1 in a secure way to produce a digest of a
   * key and data.
   *
   * Both the key and data are arbitrary byte arrays of bytes or characters.
   *
   * Support for HMAC Digests has been added in GLib 2.30, and support for SHA-512
   * in GLib 2.42. Support for SHA-384 was added in GLib 2.52.
   *
   * To create a new `GHmac`, use [ctor`GLib`.Hmac.new]. To free a `GHmac`, use
   * [method`GLib`.Hmac.unref].
   * @record
   */
  class Hmac {
    // Own properties of GLib-2.0.GLib.Hmac

    static name: string

    // Constructors of GLib-2.0.GLib.Hmac

    /**
     * Creates a new #GHmac, using the digest algorithm `digest_type`.
     * If the `digest_type` is not known, %NULL is returned.
     * A #GHmac can be used to compute the HMAC of a key and an
     * arbitrary binary blob, using different hashing algorithms.
     *
     * A #GHmac works by feeding a binary blob through g_hmac_update()
     * until the data is complete; the digest can then be extracted
     * using g_hmac_get_string(), which will return the checksum as a
     * hexadecimal string; or g_hmac_get_digest(), which will return a
     * array of raw bytes. Once either g_hmac_get_string() or
     * g_hmac_get_digest() have been called on a #GHmac, the HMAC
     * will be closed and it won't be possible to call g_hmac_update()
     * on it anymore.
     *
     * Support for digests of type %G_CHECKSUM_SHA512 has been added in GLib 2.42.
     * Support for %G_CHECKSUM_SHA384 was added in GLib 2.52.
     * @constructor
     * @param digestType the desired type of digest
     * @param key the key for the HMAC
     * @returns the newly created #GHmac, or %NULL.   Use g_hmac_unref() to free the memory allocated by it.
     */
    constructor(digestType: ChecksumType, key: number[])
    /**
     * Creates a new #GHmac, using the digest algorithm `digest_type`.
     * If the `digest_type` is not known, %NULL is returned.
     * A #GHmac can be used to compute the HMAC of a key and an
     * arbitrary binary blob, using different hashing algorithms.
     *
     * A #GHmac works by feeding a binary blob through g_hmac_update()
     * until the data is complete; the digest can then be extracted
     * using g_hmac_get_string(), which will return the checksum as a
     * hexadecimal string; or g_hmac_get_digest(), which will return a
     * array of raw bytes. Once either g_hmac_get_string() or
     * g_hmac_get_digest() have been called on a #GHmac, the HMAC
     * will be closed and it won't be possible to call g_hmac_update()
     * on it anymore.
     *
     * Support for digests of type %G_CHECKSUM_SHA512 has been added in GLib 2.42.
     * Support for %G_CHECKSUM_SHA384 was added in GLib 2.52.
     * @constructor
     * @param digestType the desired type of digest
     * @param key the key for the HMAC
     * @returns the newly created #GHmac, or %NULL.   Use g_hmac_unref() to free the memory allocated by it.
     */
    static new(digestType: ChecksumType, key: number[]): Hmac
  }

  interface Hook {
    // Own fields of GLib-2.0.GLib.Hook

    /**
     * data which is passed to func when this hook is invoked
     * @field
     */
    data: any
    /**
     * pointer to the next hook in the list
     * @field
     */
    next: Hook
    /**
     * pointer to the previous hook in the list
     * @field
     */
    prev: Hook
    /**
     * the reference count of this hook
     * @field
     */
    refCount: number
    /**
     * the id of this hook, which is unique within its list
     * @field
     */
    hookId: number
    /**
     * flags which are set for this hook. See #GHookFlagMask for
     *     predefined flags
     * @field
     */
    flags: number
    /**
     * the function to call when this hook is invoked. The possible
     *     signatures for this function are #GHookFunc and #GHookCheckFunc
     * @field
     */
    func: any
    /**
     * the default `finalize_hook` function of a #GHookList calls
     *     this member of the hook that is being finalized
     * @field
     */
    destroy: DestroyNotify

    // Owm methods of GLib-2.0.GLib.Hook

    /**
     * Compares the ids of two #GHook elements, returning a negative value
     * if the second id is greater than the first.
     * @param sibling a #GHook to compare with `new_hook`
     * @returns a value <= 0 if the id of @sibling is >= the id of @new_hook
     */
    compareIds(sibling: Hook): number
  }

  /**
   * The #GHook struct represents a single hook function in a #GHookList.
   * @record
   */
  class Hook {
    // Own properties of GLib-2.0.GLib.Hook

    static name: string

    // Constructors of GLib-2.0.GLib.Hook

    /**
     * Destroys a #GHook, given its ID.
     * @param hookList a #GHookList
     * @param hookId a hook ID
     * @returns %TRUE if the #GHook was found in the #GHookList and destroyed
     */
    static destroy(hookList: HookList, hookId: number): boolean
    /**
     * Removes one #GHook from a #GHookList, marking it
     * inactive and calling g_hook_unref() on it.
     * @param hookList a #GHookList
     * @param hook the #GHook to remove
     */
    static destroyLink(hookList: HookList, hook: Hook): void
    /**
     * Calls the #GHookList `finalize_hook` function if it exists,
     * and frees the memory allocated for the #GHook.
     * @param hookList a #GHookList
     * @param hook the #GHook to free
     */
    static free(hookList: HookList, hook: Hook): void
    /**
     * Inserts a #GHook into a #GHookList, before a given #GHook.
     * @param hookList a #GHookList
     * @param sibling the #GHook to insert the new #GHook before
     * @param hook the #GHook to insert
     */
    static insertBefore(
      hookList: HookList,
      sibling: Hook | null,
      hook: Hook
    ): void
    /**
     * Inserts a #GHook into a #GHookList, sorted by the given function.
     * @param hookList a #GHookList
     * @param hook the #GHook to insert
     * @param func the comparison function used to sort the #GHook elements
     */
    static insertSorted(
      hookList: HookList,
      hook: Hook,
      func: HookCompareFunc
    ): void
    /**
     * Prepends a #GHook on the start of a #GHookList.
     * @param hookList a #GHookList
     * @param hook the #GHook to add to the start of `hook_list`
     */
    static prepend(hookList: HookList, hook: Hook): void
    /**
     * Decrements the reference count of a #GHook.
     * If the reference count falls to 0, the #GHook is removed
     * from the #GHookList and g_hook_free() is called to free it.
     * @param hookList a #GHookList
     * @param hook the #GHook to unref
     */
    static unref(hookList: HookList, hook: Hook): void
  }

  interface HookList {
    // Own fields of GLib-2.0.GLib.HookList

    /**
     * the next free #GHook id
     * @field
     */
    seqId: number
    /**
     * the size of the #GHookList elements, in bytes
     * @field
     */
    hookSize: number
    /**
     * 1 if the #GHookList has been initialized
     * @field
     */
    isSetup: number
    /**
     * the first #GHook element in the list
     * @field
     */
    hooks: Hook
    /**
     * unused
     * @field
     */
    dummy3: any
    /**
     * the function to call to finalize a #GHook element.
     *     The default behaviour is to call the hooks `destroy` function
     * @field
     */
    finalizeHook: HookFinalizeFunc
    /**
     * unused
     * @field
     */
    dummy: any[]

    // Owm methods of GLib-2.0.GLib.HookList

    /**
     * Removes all the #GHook elements from a #GHookList.
     */
    clear(): void
    /**
     * Initializes a #GHookList.
     * This must be called before the #GHookList is used.
     * @param hookSize the size of each element in the #GHookList,     typically `sizeof (GHook)`.
     */
    init(hookSize: number): void
    /**
     * Calls all of the #GHook functions in a #GHookList.
     * @param mayRecurse %TRUE if functions which are already running     (e.g. in another thread) can be called. If set to %FALSE,     these are skipped
     */
    invoke(mayRecurse: boolean): void
    /**
     * Calls all of the #GHook functions in a #GHookList.
     * Any function which returns %FALSE is removed from the #GHookList.
     * @param mayRecurse %TRUE if functions which are already running     (e.g. in another thread) can be called. If set to %FALSE,     these are skipped
     */
    invokeCheck(mayRecurse: boolean): void
    /**
     * Calls a function on each valid #GHook.
     * @param mayRecurse %TRUE if hooks which are currently running     (e.g. in another thread) are considered valid. If set to %FALSE,     these are skipped
     * @param marshaller the function to call for each #GHook
     */
    marshal(mayRecurse: boolean, marshaller: HookMarshaller): void
    /**
     * Calls a function on each valid #GHook and destroys it if the
     * function returns %FALSE.
     * @param mayRecurse %TRUE if hooks which are currently running     (e.g. in another thread) are considered valid. If set to %FALSE,     these are skipped
     * @param marshaller the function to call for each #GHook
     */
    marshalCheck(mayRecurse: boolean, marshaller: HookCheckMarshaller): void
  }

  /**
   * The #GHookList struct represents a list of hook functions.
   * @record
   */
  class HookList {
    // Own properties of GLib-2.0.GLib.HookList

    static name: string
  }

  interface IConv {}

  /**
   * The GIConv struct wraps an iconv() conversion descriptor. It contains
   * private data and should only be accessed using the following functions.
   * @record
   */
  class IConv {
    // Own properties of GLib-2.0.GLib.IConv

    static name: string
  }

  interface IOChannel {
    // Owm methods of GLib-2.0.GLib.IOChannel

    /**
     * Close an IO channel. Any pending data to be written will be
     * flushed, ignoring errors. The channel will not be freed until the
     * last reference is dropped using g_io_channel_unref().
     */
    close(): void
    /**
     * Flushes the write buffer for the GIOChannel.
     * @returns the status of the operation: One of   %G_IO_STATUS_NORMAL, %G_IO_STATUS_AGAIN, or   %G_IO_STATUS_ERROR.
     */
    flush(): IOStatus
    /**
     * This function returns a #GIOCondition depending on whether there
     * is data to be read/space to write data in the internal buffers in
     * the #GIOChannel. Only the flags %G_IO_IN and %G_IO_OUT may be set.
     * @returns A #GIOCondition
     */
    getBufferCondition(): IOCondition
    /**
     * Gets the buffer size.
     * @returns the size of the buffer.
     */
    getBufferSize(): number
    /**
     * Returns whether `channel` is buffered.
     * @returns %TRUE if the @channel is buffered.
     */
    getBuffered(): boolean
    /**
     * Returns whether the file/socket/whatever associated with `channel`
     * will be closed when `channel` receives its final unref and is
     * destroyed. The default value of this is %TRUE for channels created
     * by g_io_channel_new_file (), and %FALSE for all other channels.
     * @returns %TRUE if the channel will be closed, %FALSE otherwise.
     */
    getCloseOnUnref(): boolean
    /**
     * Gets the encoding for the input/output of the channel.
     * The internal encoding is always UTF-8. The encoding %NULL
     * makes the channel safe for binary data.
     * @returns A string containing the encoding, this string is   owned by GLib and must not be freed.
     */
    getEncoding(): string
    /**
     * Gets the current flags for a #GIOChannel, including read-only
     * flags such as %G_IO_FLAG_IS_READABLE.
     *
     * The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITABLE
     * are cached for internal use by the channel when it is created.
     * If they should change at some later point (e.g. partial shutdown
     * of a socket with the UNIX shutdown() function), the user
     * should immediately call g_io_channel_get_flags() to update
     * the internal values of these flags.
     * @returns the flags which are set on the channel
     */
    getFlags(): IOFlags
    /**
     * This returns the string that #GIOChannel uses to determine
     * where in the file a line break occurs. A value of %NULL
     * indicates autodetection.
     * @returns The line termination string. This value   is owned by GLib and must not be freed.
     */
    getLineTerm(): [/* returnType */ string, /* length */ number]
    /**
     * Initializes a #GIOChannel struct.
     *
     * This is called by each of the above functions when creating a
     * #GIOChannel, and so is not often needed by the application
     * programmer (unless you are creating a new type of #GIOChannel).
     */
    init(): void
    /**
     * Reads data from a #GIOChannel.
     * @param buf a buffer to read the data into (which should be at least       count bytes long)
     * @param count the number of bytes to read from the #GIOChannel
     * @param bytesRead returns the number of bytes actually read
     * @returns %G_IO_ERROR_NONE if the operation was successful.
     */
    read(buf: string | null, count: number, bytesRead: number): IOError
    /**
     * Replacement for g_io_channel_read() with the new API.
     * @returns the status of the operation.
     */
    readChars(): [
      /* returnType */ IOStatus,
      /* buf */ number[],
      /* bytesRead */ number,
    ]
    /**
     * Reads a line, including the terminating character(s),
     * from a #GIOChannel into a newly-allocated string.
     * `str_return` will contain allocated memory if the return
     * is %G_IO_STATUS_NORMAL.
     * @returns the status of the operation.
     */
    readLine(): [
      /* returnType */ IOStatus,
      /* strReturn */ string | null,
      /* length */ number,
      /* terminatorPos */ number,
    ]
    /**
     * Reads a line from a #GIOChannel, using a #GString as a buffer.
     * @param buffer a #GString into which the line will be written.          If `buffer` already contains data, the old data will          be overwritten.
     * @param terminatorPos location to store position of line terminator, or %NULL
     * @returns the status of the operation.
     */
    readLineString(buffer: String, terminatorPos: number | null): IOStatus
    /**
     * Reads all the remaining data from the file.
     * @returns %G_IO_STATUS_NORMAL on success.     This function never returns %G_IO_STATUS_EOF.
     */
    readToEnd(): [/* returnType */ IOStatus, /* strReturn */ number[]]
    /**
     * Reads a Unicode character from `channel`.
     * This function cannot be called on a channel with %NULL encoding.
     * @returns a #GIOStatus
     */
    readUnichar(): [/* returnType */ IOStatus, /* thechar */ string]
    /**
     * Increments the reference count of a #GIOChannel.
     * @returns the @channel that was passed in (since 2.6)
     */
    ref(): IOChannel
    /**
     * Sets the current position in the #GIOChannel, similar to the standard
     * library function fseek().
     * @param offset an offset, in bytes, which is added to the position specified          by `type`
     * @param type the position in the file, which can be %G_SEEK_CUR (the current        position), %G_SEEK_SET (the start of the file), or %G_SEEK_END        (the end of the file)
     * @returns %G_IO_ERROR_NONE if the operation was successful.
     */
    seek(offset: number, type: SeekType): IOError
    /**
     * Replacement for g_io_channel_seek() with the new API.
     * @param offset The offset in bytes from the position specified by `type`
     * @param type a #GSeekType. The type %G_SEEK_CUR is only allowed in those                      cases where a call to g_io_channel_set_encoding ()                      is allowed. See the documentation for                      g_io_channel_set_encoding () for details.
     * @returns the status of the operation.
     */
    seekPosition(offset: number, type: SeekType): IOStatus
    /**
     * Sets the buffer size.
     * @param size the size of the buffer, or 0 to let GLib pick a good size
     */
    setBufferSize(size: number): void
    /**
     * The buffering state can only be set if the channel's encoding
     * is %NULL. For any other encoding, the channel must be buffered.
     *
     * A buffered channel can only be set unbuffered if the channel's
     * internal buffers have been flushed. Newly created channels or
     * channels which have returned %G_IO_STATUS_EOF
     * not require such a flush. For write-only channels, a call to
     * g_io_channel_flush () is sufficient. For all other channels,
     * the buffers may be flushed by a call to g_io_channel_seek_position ().
     * This includes the possibility of seeking with seek type %G_SEEK_CUR
     * and an offset of zero. Note that this means that socket-based
     * channels cannot be set unbuffered once they have had data
     * read from them.
     *
     * On unbuffered channels, it is safe to mix read and write
     * calls from the new and old APIs, if this is necessary for
     * maintaining old code.
     *
     * The default state of the channel is buffered.
     * @param buffered whether to set the channel buffered or unbuffered
     */
    setBuffered(buffered: boolean): void
    /**
     * Whether to close the channel on the final unref of the #GIOChannel
     * data structure. The default value of this is %TRUE for channels
     * created by g_io_channel_new_file (), and %FALSE for all other channels.
     *
     * Setting this flag to %TRUE for a channel you have already closed
     * can cause problems when the final reference to the #GIOChannel is dropped.
     * @param doClose Whether to close the channel on the final unref of            the GIOChannel data structure.
     */
    setCloseOnUnref(doClose: boolean): void
    /**
     * Sets the encoding for the input/output of the channel.
     * The internal encoding is always UTF-8. The default encoding
     * for the external file is UTF-8.
     *
     * The encoding %NULL is safe to use with binary data.
     *
     * The encoding can only be set if one of the following conditions
     * is true:
     *
     * - The channel was just created, and has not been written to or read from yet.
     *
     * - The channel is write-only.
     *
     * - The channel is a file, and the file pointer was just repositioned
     *   by a call to g_io_channel_seek_position(). (This flushes all the
     *   internal buffers.)
     *
     * - The current encoding is %NULL or UTF-8.
     *
     * - One of the (new API) read functions has just returned %G_IO_STATUS_EOF
     *   (or, in the case of g_io_channel_read_to_end(), %G_IO_STATUS_NORMAL).
     *
     * -  One of the functions g_io_channel_read_chars() or
     *    g_io_channel_read_unichar() has returned %G_IO_STATUS_AGAIN or
     *    %G_IO_STATUS_ERROR. This may be useful in the case of
     *    %G_CONVERT_ERROR_ILLEGAL_SEQUENCE.
     *    Returning one of these statuses from g_io_channel_read_line(),
     *    g_io_channel_read_line_string(), or g_io_channel_read_to_end()
     *    does not guarantee that the encoding can be changed.
     *
     * Channels which do not meet one of the above conditions cannot call
     * g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if
     * they are "seekable", cannot call g_io_channel_write_chars() after
     * calling one of the API "read" functions.
     * @param encoding the encoding type
     * @returns %G_IO_STATUS_NORMAL if the encoding was successfully set
     */
    setEncoding(encoding: string | null): IOStatus
    /**
     * Sets the (writeable) flags in `channel` to (`flags` & %G_IO_FLAG_SET_MASK).
     * @param flags the flags to set on the IO channel
     * @returns the status of the operation.
     */
    setFlags(flags: IOFlags): IOStatus
    /**
     * This sets the string that #GIOChannel uses to determine
     * where in the file a line break occurs.
     * @param lineTerm The line termination string. Use %NULL for             autodetect.  Autodetection breaks on "\n", "\r\n", "\r", "\0",             and the Unicode paragraph separator. Autodetection should not be             used for anything other than file-based channels.
     * @param length The length of the termination string. If -1 is passed, the          string is assumed to be nul-terminated. This option allows          termination strings with embedded nuls.
     */
    setLineTerm(lineTerm: string | null, length: number): void
    /**
     * Close an IO channel. Any pending data to be written will be
     * flushed if `flush` is %TRUE. The channel will not be freed until the
     * last reference is dropped using g_io_channel_unref().
     * @param flush if %TRUE, flush pending
     * @returns the status of the operation.
     */
    shutdown(flush: boolean): IOStatus
    /**
     * Returns the file descriptor of the #GIOChannel.
     *
     * On Windows this function returns the file descriptor or socket of
     * the #GIOChannel.
     * @returns the file descriptor of the #GIOChannel.
     */
    unixGetFd(): number
    /**
     * Decrements the reference count of a #GIOChannel.
     */
    unref(): void
    /**
     * Writes data to a #GIOChannel.
     * @param buf the buffer containing the data to write
     * @param count the number of bytes to write
     * @param bytesWritten the number of bytes actually written
     * @returns %G_IO_ERROR_NONE if the operation was successful.
     */
    write(buf: string, count: number, bytesWritten: number): IOError
    /**
     * Replacement for g_io_channel_write() with the new API.
     *
     * On seekable channels with encodings other than %NULL or UTF-8, generic
     * mixing of reading and writing is not allowed. A call to g_io_channel_write_chars ()
     * may only be made on a channel from which data has been read in the
     * cases described in the documentation for g_io_channel_set_encoding ().
     * @param buf a buffer to write data from
     * @param count the size of the buffer. If -1, the buffer         is taken to be a nul-terminated string.
     * @returns the status of the operation.
     */
    writeChars(
      buf: number[],
      count: number
    ): [/* returnType */ IOStatus, /* bytesWritten */ number]
    /**
     * Writes a Unicode character to `channel`.
     * This function cannot be called on a channel with %NULL encoding.
     * @param thechar a character
     * @returns a #GIOStatus
     */
    writeUnichar(thechar: string): IOStatus
  }

  /**
   * The `GIOChannel` data type aims to provide a portable method for
   * using file descriptors, pipes, and sockets, and integrating them
   * into the main event loop (see [struct`GLib`.MainContext]). Currently,
   * full support is available on UNIX platforms; support for Windows
   * is only partially complete.
   *
   * To create a new `GIOChannel` on UNIX systems use
   * [ctor`GLib`.IOChannel.unix_new]. This works for plain file descriptors,
   * pipes and sockets. Alternatively, a channel can be created for a
   * file in a system independent manner using [ctor`GLib`.IOChannel.new_file].
   *
   * Once a `GIOChannel` has been created, it can be used in a generic
   * manner with the functions [method`GLib`.IOChannel.read_chars],
   * [method`GLib`.IOChannel.write_chars], [method`GLib`.IOChannel.seek_position],
   * and [method`GLib`.IOChannel.shutdown].
   *
   * To add a `GIOChannel` to the main event loop, use [func`GLib`.io_add_watch] or
   * [func`GLib`.io_add_watch_full]. Here you specify which events you are
   * interested in on the `GIOChannel`, and provide a function to be called
   * whenever these events occur.
   *
   * `GIOChannel` instances are created with an initial reference count of 1.
   * [method`GLib`.IOChannel.ref] and [method`GLib`.IOChannel.unref] can be used to
   * increment or decrement the reference count respectively. When the
   * reference count falls to 0, the `GIOChannel` is freed. (Though it
   * isn’t closed automatically, unless it was created using
   * [ctor`GLib`.IOChannel.new_file].) Using [func`GLib`.io_add_watch] or
   * [func`GLib`.io_add_watch_full] increments a channel’s reference count.
   *
   * The new functions [method`GLib`.IOChannel.read_chars],
   * [method`GLib`.IOChannel.read_line], [method`GLib`.IOChannel.read_line_string],
   * [method`GLib`.IOChannel.read_to_end], [method`GLib`.IOChannel.write_chars],
   * [method`GLib`.IOChannel.seek_position], and [method`GLib`.IOChannel.flush]
   * should not be mixed with the deprecated functions
   * [method`GLib`.IOChannel.read], [method`GLib`.IOChannel.write], and
   * [method`GLib`.IOChannel.seek] on the same channel.
   * @record
   */
  class IOChannel {
    // Own properties of GLib-2.0.GLib.IOChannel

    static name: string

    // Constructors of GLib-2.0.GLib.IOChannel

    /**
     * Open a file `filename` as a #GIOChannel using mode `mode`. This
     * channel will be closed when the last reference to it is dropped,
     * so there is no need to call g_io_channel_close() (though doing
     * so will not cause problems, as long as no attempt is made to
     * access the channel after it is closed).
     * @constructor
     * @param filename A string containing the name of a file
     * @param mode One of "r", "w", "a", "r+", "w+", "a+". These have        the same meaning as in fopen()
     * @returns A #GIOChannel on success, %NULL on failure.
     */
    static newFile(filename: string, mode: string): IOChannel
    /**
     * Creates a new #GIOChannel given a file descriptor. On UNIX systems
     * this works for plain files, pipes, and sockets.
     *
     * The returned #GIOChannel has a reference count of 1.
     *
     * The default encoding for #GIOChannel is UTF-8. If your application
     * is reading output from a command using via pipe, you may need to set
     * the encoding to the encoding of the current locale (see
     * g_get_charset()) with the g_io_channel_set_encoding() function.
     * By default, the fd passed will not be closed when the final reference
     * to the #GIOChannel data structure is dropped.
     *
     * If you want to read raw binary data without interpretation, then
     * call the g_io_channel_set_encoding() function with %NULL for the
     * encoding argument.
     *
     * This function is available in GLib on Windows, too, but you should
     * avoid using it on Windows. The domain of file descriptors and
     * sockets overlap. There is no way for GLib to know which one you mean
     * in case the argument you pass to this function happens to be both a
     * valid file descriptor and socket. If that happens a warning is
     * issued, and GLib assumes that it is the file descriptor you mean.
     * @constructor
     * @param fd a file descriptor.
     * @returns a new #GIOChannel.
     */
    static unixNew(fd: number): IOChannel
    /**
     * Converts an `errno` error number to a #GIOChannelError.
     * @param en an `errno` error number, e.g. `EINVAL`
     * @returns a #GIOChannelError error number, e.g.      %G_IO_CHANNEL_ERROR_INVAL.
     */
    static errorFromErrno(en: number): IOChannelError
    static errorQuark(): Quark
  }

  interface IOFuncs {
    // Own fields of GLib-2.0.GLib.IOFuncs

    /**
     * reads raw bytes from the channel.  This is called from
     *           various functions such as g_io_channel_read_chars() to
     *           read raw bytes from the channel.  Encoding and buffering
     *           issues are dealt with at a higher level.
     * @field
     */
    ioRead: (
      channel: IOChannel,
      buf: string | null,
      count: number,
      bytesRead: number
    ) => IOStatus
    /**
     * writes raw bytes to the channel.  This is called from
     *            various functions such as g_io_channel_write_chars() to
     *            write raw bytes to the channel.  Encoding and buffering
     *            issues are dealt with at a higher level.
     * @field
     */
    ioWrite: (
      channel: IOChannel,
      buf: string,
      count: number,
      bytesWritten: number
    ) => IOStatus
    /**
     * seeks the channel.  This is called from
     *           g_io_channel_seek() on channels that support it.
     * @field
     */
    ioSeek: (channel: IOChannel, offset: number, type: SeekType) => IOStatus
    /**
     * closes the channel.  This is called from
     *            g_io_channel_close() after flushing the buffers.
     * @field
     */
    ioClose: (channel: IOChannel) => IOStatus
    /**
     * creates a watch on the channel.  This call
     *                   corresponds directly to g_io_create_watch().
     * @field
     */
    ioCreateWatch: (channel: IOChannel, condition: IOCondition) => Source
    /**
     * called from g_io_channel_unref() when the channel needs to
     *           be freed.  This function must free the memory associated
     *           with the channel, including freeing the #GIOChannel
     *           structure itself.  The channel buffers have been flushed
     *           and possibly `io_close` has been called by the time this
     *           function is called.
     * @field
     */
    ioFree: (channel: IOChannel) => void
    /**
     * sets the #GIOFlags on the channel.  This is called
     *                from g_io_channel_set_flags() with all flags except
     *                for %G_IO_FLAG_APPEND and %G_IO_FLAG_NONBLOCK masked
     *                out.
     * @field
     */
    ioSetFlags: (channel: IOChannel, flags: IOFlags) => IOStatus
    /**
     * gets the #GIOFlags for the channel.  This function
     *                need only return the %G_IO_FLAG_APPEND and
     *                %G_IO_FLAG_NONBLOCK flags; g_io_channel_get_flags()
     *                automatically adds the others as appropriate.
     * @field
     */
    ioGetFlags: (channel: IOChannel) => IOFlags
  }

  /**
   * A table of functions used to handle different types of #GIOChannel
   * in a generic way.
   * @record
   */
  class IOFuncs {
    // Own properties of GLib-2.0.GLib.IOFuncs

    static name: string
  }

  interface KeyFile {
    // Owm methods of GLib-2.0.GLib.KeyFile

    /**
     * Returns the value associated with `key` under `group_name` as a
     * boolean.
     *
     * If `key` cannot be found then %FALSE is returned and `error` is set
     * to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value
     * associated with `key` cannot be interpreted as a boolean then %FALSE
     * is returned and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
     * @param groupName a group name
     * @param key a key
     * @returns the value associated with the key as a boolean,    or %FALSE if the key was not found or could not be parsed.
     */
    getBoolean(groupName: string, key: string): boolean
    /**
     * Returns the values associated with `key` under `group_name` as
     * booleans.
     *
     * If `key` cannot be found then %NULL is returned and `error` is set to
     * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
     * with `key` cannot be interpreted as booleans then %NULL is returned
     * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
     * @param groupName a group name
     * @param key a key
     * @returns the values associated with the key as a list of booleans, or %NULL if the    key was not found or could not be parsed. The returned list of booleans    should be freed with g_free() when no longer needed.
     */
    getBooleanList(groupName: string, key: string): boolean[]
    /**
     * Retrieves a comment above `key` from `group_name`.
     * If `key` is %NULL then `comment` will be read from above
     * `group_name`. If both `key` and `group_name` are %NULL, then
     * `comment` will be read from above the first group in the file.
     *
     * Note that the returned string does not include the '#' comment markers,
     * but does include any whitespace after them (on each line). It includes
     * the line breaks between lines, but does not include the final line break.
     * @param groupName a group name, or %NULL
     * @param key a key
     * @returns a comment that should be freed with g_free()
     */
    getComment(groupName: string | null, key: string | null): string | null
    /**
     * Returns the value associated with `key` under `group_name` as a
     * double. If `group_name` is %NULL, the start_group is used.
     *
     * If `key` cannot be found then 0.0 is returned and `error` is set to
     * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
     * with `key` cannot be interpreted as a double then 0.0 is returned
     * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
     * @param groupName a group name
     * @param key a key
     * @returns the value associated with the key as a double, or     0.0 if the key was not found or could not be parsed.
     */
    getDouble(groupName: string, key: string): number
    /**
     * Returns the values associated with `key` under `group_name` as
     * doubles.
     *
     * If `key` cannot be found then %NULL is returned and `error` is set to
     * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
     * with `key` cannot be interpreted as doubles then %NULL is returned
     * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
     * @param groupName a group name
     * @param key a key
     * @returns the values associated with the key as a list of doubles, or %NULL if the     key was not found or could not be parsed. The returned list of doubles     should be freed with g_free() when no longer needed.
     */
    getDoubleList(groupName: string, key: string): number[]
    /**
     * Returns all groups in the key file loaded with `key_file`.
     * The array of returned groups will be %NULL-terminated, so
     * `length` may optionally be %NULL.
     * @returns a newly-allocated %NULL-terminated array of strings.   Use g_strfreev() to free it.
     */
    getGroups(): [/* returnType */ string[], /* length */ number]
    /**
     * Returns the value associated with `key` under `group_name` as a signed
     * 64-bit integer. This is similar to g_key_file_get_integer() but can return
     * 64-bit results without truncation.
     * @param groupName a non-%NULL group name
     * @param key a non-%NULL key
     * @returns the value associated with the key as a signed 64-bit integer, or 0 if the key was not found or could not be parsed.
     */
    getInt64(groupName: string, key: string): number
    /**
     * Returns the value associated with `key` under `group_name` as an
     * integer.
     *
     * If `key` cannot be found then 0 is returned and `error` is set to
     * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
     * with `key` cannot be interpreted as an integer, or is out of range
     * for a #gint, then 0 is returned
     * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
     * @param groupName a group name
     * @param key a key
     * @returns the value associated with the key as an integer, or     0 if the key was not found or could not be parsed.
     */
    getInteger(groupName: string, key: string): number
    /**
     * Returns the values associated with `key` under `group_name` as
     * integers.
     *
     * If `key` cannot be found then %NULL is returned and `error` is set to
     * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
     * with `key` cannot be interpreted as integers, or are out of range for
     * #gint, then %NULL is returned
     * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
     * @param groupName a group name
     * @param key a key
     * @returns the values associated with the key as a list of integers, or %NULL if     the key was not found or could not be parsed. The returned list of     integers should be freed with g_free() when no longer needed.
     */
    getIntegerList(groupName: string, key: string): number[]
    /**
     * Returns all keys for the group name `group_name`.  The array of
     * returned keys will be %NULL-terminated, so `length` may
     * optionally be %NULL. In the event that the `group_name` cannot
     * be found, %NULL is returned and `error` is set to
     * %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
     * @param groupName a group name
     * @returns a newly-allocated %NULL-terminated array of strings.     Use g_strfreev() to free it.
     */
    getKeys(groupName: string): [/* returnType */ string[], /* length */ number]
    /**
     * Returns the actual locale which the result of
     * g_key_file_get_locale_string() or g_key_file_get_locale_string_list()
     * came from.
     *
     * If calling g_key_file_get_locale_string() or
     * g_key_file_get_locale_string_list() with exactly the same `key_file,`
     * `group_name,` `key` and `locale,` the result of those functions will
     * have originally been tagged with the locale that is the result of
     * this function.
     * @param groupName a group name
     * @param key a key
     * @param locale a locale identifier or %NULL
     * @returns the locale from the file, or %NULL if the key was not   found or the entry in the file was was untranslated
     */
    getLocaleForKey(
      groupName: string,
      key: string,
      locale: string | null
    ): string | null
    /**
     * Returns the value associated with `key` under `group_name`
     * translated in the given `locale` if available.  If `locale` is
     * %NULL then the current locale is assumed.
     *
     * If `locale` is to be non-%NULL, or if the current locale will change over
     * the lifetime of the #GKeyFile, it must be loaded with
     * %G_KEY_FILE_KEEP_TRANSLATIONS in order to load strings for all locales.
     *
     * If `key` cannot be found then %NULL is returned and `error` is set
     * to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated
     * with `key` cannot be interpreted or no suitable translation can
     * be found then the untranslated value is returned.
     * @param groupName a group name
     * @param key a key
     * @param locale a locale identifier or %NULL
     * @returns a newly allocated string or %NULL if the specified   key cannot be found.
     */
    getLocaleString(
      groupName: string,
      key: string,
      locale: string | null
    ): string | null
    /**
     * Returns the values associated with `key` under `group_name`
     * translated in the given `locale` if available.  If `locale` is
     * %NULL then the current locale is assumed.
     *
     * If `locale` is to be non-%NULL, or if the current locale will change over
     * the lifetime of the #GKeyFile, it must be loaded with
     * %G_KEY_FILE_KEEP_TRANSLATIONS in order to load strings for all locales.
     *
     * If `key` cannot be found then %NULL is returned and `error` is set
     * to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated
     * with `key` cannot be interpreted or no suitable translations
     * can be found then the untranslated values are returned. The
     * returned array is %NULL-terminated, so `length` may optionally
     * be %NULL.
     * @param groupName a group name
     * @param key a key
     * @param locale a locale identifier or %NULL
     * @returns a newly allocated %NULL-terminated string array   or %NULL if the key isn't found. The string array should be freed   with g_strfreev().
     */
    getLocaleStringList(
      groupName: string,
      key: string,
      locale: string | null
    ): string[]
    /**
     * Returns the name of the start group of the file.
     * @returns The start group of the key file.
     */
    getStartGroup(): string | null
    /**
     * Returns the string value associated with `key` under `group_name`.
     * Unlike g_key_file_get_value(), this function handles escape sequences
     * like \s.
     *
     * In the event the key cannot be found, %NULL is returned and
     * `error` is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
     * event that the `group_name` cannot be found, %NULL is returned
     * and `error` is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
     * @param groupName a group name
     * @param key a key
     * @returns a newly allocated string or %NULL if the specified   key cannot be found.
     */
    getString(groupName: string, key: string): string | null
    /**
     * Returns the values associated with `key` under `group_name`.
     *
     * In the event the key cannot be found, %NULL is returned and
     * `error` is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
     * event that the `group_name` cannot be found, %NULL is returned
     * and `error` is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
     * @param groupName a group name
     * @param key a key
     * @returns a %NULL-terminated string array or %NULL if the specified  key cannot be found. The array should be freed with g_strfreev().
     */
    getStringList(groupName: string, key: string): string[]
    /**
     * Returns the value associated with `key` under `group_name` as an unsigned
     * 64-bit integer. This is similar to g_key_file_get_integer() but can return
     * large positive results without truncation.
     * @param groupName a non-%NULL group name
     * @param key a non-%NULL key
     * @returns the value associated with the key as an unsigned 64-bit integer, or 0 if the key was not found or could not be parsed.
     */
    getUint64(groupName: string, key: string): number
    /**
     * Returns the raw value associated with `key` under `group_name`.
     * Use g_key_file_get_string() to retrieve an unescaped UTF-8 string.
     *
     * In the event the key cannot be found, %NULL is returned and
     * `error` is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
     * event that the `group_name` cannot be found, %NULL is returned
     * and `error` is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
     * @param groupName a group name
     * @param key a key
     * @returns a newly allocated string or %NULL if the specified  key cannot be found.
     */
    getValue(groupName: string, key: string): string | null
    /**
     * Looks whether the key file has the group `group_name`.
     * @param groupName a group name
     * @returns %TRUE if @group_name is a part of @key_file, %FALSE otherwise.
     */
    hasGroup(groupName: string): boolean
    /**
     * Loads a key file from the data in `bytes` into an empty #GKeyFile structure.
     * If the object cannot be created then %error is set to a #GKeyFileError.
     * @param bytes a #GBytes
     * @param flags flags from #GKeyFileFlags
     * @returns %TRUE if a key file could be loaded, %FALSE otherwise
     */
    loadFromBytes(bytes: any, flags: KeyFileFlags): boolean
    /**
     * Loads a key file from memory into an empty #GKeyFile structure.
     * If the object cannot be created then %error is set to a #GKeyFileError.
     * @param data key file loaded in memory
     * @param length the length of `data` in bytes (or (gsize)-1 if data is nul-terminated)
     * @param flags flags from #GKeyFileFlags
     * @returns %TRUE if a key file could be loaded, %FALSE otherwise
     */
    loadFromData(data: string, length: number, flags: KeyFileFlags): boolean
    /**
     * This function looks for a key file named `file` in the paths
     * returned from g_get_user_data_dir() and g_get_system_data_dirs(),
     * loads the file into `key_file` and returns the file's full path in
     * `full_path`.  If the file could not be loaded then an %error is
     * set to either a #GFileError or #GKeyFileError.
     * @param file a relative path to a filename to open and parse
     * @param flags flags from #GKeyFileFlags
     * @returns %TRUE if a key file could be loaded, %FALSE otherwise
     */
    loadFromDataDirs(
      file: string,
      flags: KeyFileFlags
    ): [/* returnType */ boolean, /* fullPath */ string]
    /**
     * This function looks for a key file named `file` in the paths
     * specified in `search_dirs,` loads the file into `key_file` and
     * returns the file's full path in `full_path`.
     *
     * If the file could not be found in any of the `search_dirs,`
     * %G_KEY_FILE_ERROR_NOT_FOUND is returned. If
     * the file is found but the OS returns an error when opening or reading the
     * file, a %G_FILE_ERROR is returned. If there is a problem parsing the file, a
     * %G_KEY_FILE_ERROR is returned.
     * @param file a relative path to a filename to open and parse
     * @param searchDirs %NULL-terminated array of directories to search
     * @param flags flags from #GKeyFileFlags
     * @returns %TRUE if a key file could be loaded, %FALSE otherwise
     */
    loadFromDirs(
      file: string,
      searchDirs: string[],
      flags: KeyFileFlags
    ): [/* returnType */ boolean, /* fullPath */ string]
    /**
     * Loads a key file into an empty #GKeyFile structure.
     *
     * If the OS returns an error when opening or reading the file, a
     * %G_FILE_ERROR is returned. If there is a problem parsing the file, a
     * %G_KEY_FILE_ERROR is returned.
     *
     * This function will never return a %G_KEY_FILE_ERROR_NOT_FOUND error. If the
     * `file` is not found, %G_FILE_ERROR_NOENT is returned.
     * @param file the path of a filename to load, in the GLib filename encoding
     * @param flags flags from #GKeyFileFlags
     * @returns %TRUE if a key file could be loaded, %FALSE otherwise
     */
    loadFromFile(file: string, flags: KeyFileFlags): boolean
    /**
     * Removes a comment above `key` from `group_name`.
     * If `key` is %NULL then `comment` will be removed above `group_name`.
     * If both `key` and `group_name` are %NULL, then `comment` will
     * be removed above the first group in the file.
     * @param groupName a group name, or %NULL
     * @param key a key
     * @returns %TRUE if the comment was removed, %FALSE otherwise
     */
    removeComment(groupName: string | null, key: string | null): boolean
    /**
     * Removes the specified group, `group_name,`
     * from the key file.
     * @param groupName a group name
     * @returns %TRUE if the group was removed, %FALSE otherwise
     */
    removeGroup(groupName: string): boolean
    /**
     * Removes `key` in `group_name` from the key file.
     * @param groupName a group name
     * @param key a key name to remove
     * @returns %TRUE if the key was removed, %FALSE otherwise
     */
    removeKey(groupName: string, key: string): boolean
    /**
     * Writes the contents of `key_file` to `filename` using
     * g_file_set_contents(). If you need stricter guarantees about durability of
     * the written file than are provided by g_file_set_contents(), use
     * g_file_set_contents_full() with the return value of g_key_file_to_data().
     *
     * This function can fail for any of the reasons that
     * g_file_set_contents() may fail.
     * @param filename the name of the file to write to
     * @returns %TRUE if successful, else %FALSE with @error set
     */
    saveToFile(filename: string): boolean
    /**
     * Associates a new boolean value with `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param value %TRUE or %FALSE
     */
    setBoolean(groupName: string, key: string, value: boolean): void
    /**
     * Associates a list of boolean values with `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * If `group_name` is %NULL, the start_group is used.
     * @param groupName a group name
     * @param key a key
     * @param list an array of boolean values
     */
    setBooleanList(groupName: string, key: string, list: boolean[]): void
    /**
     * Places a comment above `key` from `group_name`.
     *
     * If `key` is %NULL then `comment` will be written above `group_name`.
     * If both `key` and `group_name`  are %NULL, then `comment` will be
     * written above the first group in the file.
     *
     * Note that this function prepends a '#' comment marker to
     * each line of `comment`.
     * @param groupName a group name, or %NULL
     * @param key a key
     * @param comment a comment
     * @returns %TRUE if the comment was written, %FALSE otherwise
     */
    setComment(
      groupName: string | null,
      key: string | null,
      comment: string
    ): boolean
    /**
     * Associates a new double value with `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param value a double value
     */
    setDouble(groupName: string, key: string, value: number): void
    /**
     * Associates a list of double values with `key` under
     * `group_name`.  If `key` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param list an array of double values
     */
    setDoubleList(groupName: string, key: string, list: number[]): void
    /**
     * Associates a new integer value with `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param value an integer value
     */
    setInt64(groupName: string, key: string, value: number): void
    /**
     * Associates a new integer value with `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param value an integer value
     */
    setInteger(groupName: string, key: string, value: number): void
    /**
     * Associates a list of integer values with `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param list an array of integer values
     */
    setIntegerList(groupName: string, key: string, list: number[]): void
    /**
     * Sets the character which is used to separate
     * values in lists. Typically ';' or ',' are used
     * as separators. The default list separator is ';'.
     * @param separator the separator
     */
    setListSeparator(separator: number): void
    /**
     * Associates a string value for `key` and `locale` under `group_name`.
     * If the translation for `key` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param locale a locale identifier
     * @param string a string
     */
    setLocaleString(
      groupName: string,
      key: string,
      locale: string,
      string: string
    ): void
    /**
     * Associates a list of string values for `key` and `locale` under
     * `group_name`.  If the translation for `key` cannot be found then
     * it is created.
     * @param groupName a group name
     * @param key a key
     * @param locale a locale identifier
     * @param list a %NULL-terminated array of locale string values
     */
    setLocaleStringList(
      groupName: string,
      key: string,
      locale: string,
      list: string[]
    ): void
    /**
     * Associates a new string value with `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * If `group_name` cannot be found then it is created.
     * Unlike g_key_file_set_value(), this function handles characters
     * that need escaping, such as newlines.
     * @param groupName a group name
     * @param key a key
     * @param string a string
     */
    setString(groupName: string, key: string, string: string): void
    /**
     * Associates a list of string values for `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * If `group_name` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param list an array of string values
     */
    setStringList(groupName: string, key: string, list: string[]): void
    /**
     * Associates a new integer value with `key` under `group_name`.
     * If `key` cannot be found then it is created.
     * @param groupName a group name
     * @param key a key
     * @param value an integer value
     */
    setUint64(groupName: string, key: string, value: number): void
    /**
     * Associates a new value with `key` under `group_name`.
     *
     * If `key` cannot be found then it is created. If `group_name` cannot
     * be found then it is created. To set an UTF-8 string which may contain
     * characters that need escaping (such as newlines or spaces), use
     * g_key_file_set_string().
     * @param groupName a group name
     * @param key a key
     * @param value a string
     */
    setValue(groupName: string, key: string, value: string): void
    /**
     * This function outputs `key_file` as a string.
     *
     * Note that this function never reports an error,
     * so it is safe to pass %NULL as `error`.
     * @returns a newly allocated string holding   the contents of the #GKeyFile
     */
    toData(): [/* returnType */ string | null, /* length */ number]
    /**
     * Decreases the reference count of `key_file` by 1. If the reference count
     * reaches zero, frees the key file and all its allocated memory.
     */
    unref(): void
  }

  /**
   * `GKeyFile` parses .ini-like config files.
   *
   * `GKeyFile` lets you parse, edit or create files containing groups of
   * key-value pairs, which we call "key files" for lack of a better name.
   * Several freedesktop.org specifications use key files now, e.g the
   * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
   * and the [Icon Theme Specification](http://freedesktop.org/Standards/icon-theme-spec).
   *
   * The syntax of key files is described in detail in the
   * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec),
   * here is a quick summary: Key files consists of groups of key-value pairs, interspersed
   * with comments.
   *
   * ```txt
   * # this is just an example
   * # there can be comments before the first group
   *
   * [First Group]
   *
   * Name=Key File Example\tthis value shows\nescaping
   *
   * # localized strings are stored in multiple key-value pairs
   * Welcome=Hello
   * Welcome[de]=Hallo
   * Welcome[fr_FR]=Bonjour
   * Welcome[it]=Ciao
   *
   * [Another Group]
   *
   * Numbers=2;20;-200;0
   *
   * Booleans=true;false;true;true
   * ```
   *
   * Lines beginning with a '#' and blank lines are considered comments.
   *
   * Groups are started by a header line containing the group name enclosed
   * in '[' and ']', and ended implicitly by the start of the next group or
   * the end of the file. Each key-value pair must be contained in a group.
   *
   * Key-value pairs generally have the form `key=value`, with the exception
   * of localized strings, which have the form `key[locale]=value`, with a
   * locale identifier of the form `lang_COUNTRY`MODIFIER`` where `COUNTRY`
   * and `MODIFIER` are optional. Space before and after the '=' character
   * are ignored. Newline, tab, carriage return and backslash characters in
   * value are escaped as `\n`, `\t`, `\r`, and `\\\\`, respectively. To preserve
   * leading spaces in values, these can also be escaped as `\s`.
   *
   * Key files can store strings (possibly with localized variants), integers,
   * booleans and lists of these. Lists are separated by a separator character,
   * typically ';' or ','. To use the list separator character in a value in
   * a list, it has to be escaped by prefixing it with a backslash.
   *
   * This syntax is obviously inspired by the .ini files commonly met
   * on Windows, but there are some important differences:
   *
   * - .ini files use the ';' character to begin comments,
   *   key files use the '#' character.
   *
   * - Key files do not allow for ungrouped keys meaning only
   *   comments can precede the first group.
   *
   * - Key files are always encoded in UTF-8.
   *
   * - Key and Group names are case-sensitive. For example, a group called
   *   [GROUP] is a different from [group].
   *
   * - .ini files don't have a strongly typed boolean entry type,
   *    they only have GetProfileInt(). In key files, only
   *    true and false (in lower case) are allowed.
   *
   * Note that in contrast to the
   * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec),
   * groups in key files may contain the same key multiple times; the last entry wins.
   * Key files may also contain multiple groups with the same name; they are merged
   * together. Another difference is that keys and group names in key files are not
   * restricted to ASCII characters.
   *
   * Here is an example of loading a key file and reading a value:
   *
   * ```c
   * g_autoptr(GError) error = NULL;
   * g_autoptr(GKeyFile) key_file = g_key_file_new ();
   *
   * if (!g_key_file_load_from_file (key_file, "key-file.ini", flags, &error))
   *   {
   *     if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
   *       g_warning ("Error loading key file: %s", error->message);
   *     return;
   *   }
   *
   * g_autofree gchar *val = g_key_file_get_string (key_file, "Group Name", "SomeKey", &error);
   * if (val == NULL &&
   *     !g_error_matches (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND))
   *   {
   *     g_warning ("Error finding key in key file: %s", error->message);
   *     return;
   *   }
   * else if (val == NULL)
   *   {
   *     // Fall back to a default value.
   *     val = g_strdup ("default-value");
   *   }
   * ```
   *
   * Here is an example of creating and saving a key file:
   *
   * ```c
   * g_autoptr(GKeyFile) key_file = g_key_file_new ();
   * const gchar *val = …;
   * g_autoptr(GError) error = NULL;
   *
   * g_key_file_set_string (key_file, "Group Name", "SomeKey", val);
   *
   * // Save as a file.
   * if (!g_key_file_save_to_file (key_file, "key-file.ini", &error))
   *   {
   *     g_warning ("Error saving key file: %s", error->message);
   *     return;
   *   }
   *
   * // Or store to a GBytes for use elsewhere.
   * gsize data_len;
   * g_autofree guint8 *data = (guint8 *) g_key_file_to_data (key_file, &data_len, &error);
   * if (data == NULL)
   *   {
   *     g_warning ("Error saving key file: %s", error->message);
   *     return;
   *   }
   * g_autoptr(GBytes) bytes = g_bytes_new_take (g_steal_pointer (&data), data_len);
   * ```
   * @record
   */
  class KeyFile {
    // Own properties of GLib-2.0.GLib.KeyFile

    static name: string

    // Constructors of GLib-2.0.GLib.KeyFile

    /**
     * Creates a new empty #GKeyFile object. Use
     * g_key_file_load_from_file(), g_key_file_load_from_data(),
     * g_key_file_load_from_dirs() or g_key_file_load_from_data_dirs() to
     * read an existing key file.
     * @constructor
     * @returns an empty #GKeyFile.
     */
    constructor()
    /**
     * Creates a new empty #GKeyFile object. Use
     * g_key_file_load_from_file(), g_key_file_load_from_data(),
     * g_key_file_load_from_dirs() or g_key_file_load_from_data_dirs() to
     * read an existing key file.
     * @constructor
     * @returns an empty #GKeyFile.
     */
    static new(): KeyFile
    static errorQuark(): Quark
  }

  interface List<A = any> {
    // Own fields of GLib-2.0.GLib.List

    /**
     * holds the element's data, which can be a pointer to any kind
     *        of data, or any integer value using the
     *        [Type Conversion Macros][glib-Type-Conversion-Macros]
     * @field
     */
    data: any
    /**
     * contains the link to the next element in the list
     * @field
     */
    next: any[]
    /**
     * contains the link to the previous element in the list
     * @field
     */
    prev: any[]
  }

  /**
   * The #GList struct is used for each element in a doubly-linked list.
   * @record
   */
  class List<A = any> {
    // Own properties of GLib-2.0.GLib.List

    static name: string

    // Constructors of GLib-2.0.GLib.List

    static popAllocator(): void
    static pushAllocator(allocator: Allocator): void
  }

  interface LogField {
    // Own fields of GLib-2.0.GLib.LogField

    /**
     * field name (UTF-8 string)
     * @field
     */
    key: string
    /**
     * field value (arbitrary bytes)
     * @field
     */
    value: any
    /**
     * length of `value,` in bytes, or -1 if it is nul-terminated
     * @field
     */
    length: number
  }

  /**
   * Structure representing a single field in a structured log entry. See
   * g_log_structured() for details.
   *
   * Log fields may contain arbitrary values, including binary with embedded nul
   * bytes. If the field contains a string, the string must be UTF-8 encoded and
   * have a trailing nul byte. Otherwise, `length` must be set to a non-negative
   * value.
   * @record
   */
  class LogField {
    // Own properties of GLib-2.0.GLib.LogField

    static name: string
  }

  interface MainContext {
    // Owm methods of GLib-2.0.GLib.MainContext

    /**
     * Tries to become the owner of the specified context.
     * If some other thread is the owner of the context,
     * returns %FALSE immediately. Ownership is properly
     * recursive: the owner can require ownership again
     * and will release ownership when g_main_context_release()
     * is called as many times as g_main_context_acquire().
     *
     * You must be the owner of a context before you
     * can call g_main_context_prepare(), g_main_context_query(),
     * g_main_context_check(), g_main_context_dispatch(), g_main_context_release().
     *
     * Since 2.76 `context` can be %NULL to use the global-default
     * main context.
     * @returns %TRUE if the operation succeeded, and   this thread is now the owner of @context.
     */
    acquire(): boolean
    /**
     * Adds a file descriptor to the set of file descriptors polled for
     * this context. This will very seldom be used directly. Instead
     * a typical event source will use g_source_add_unix_fd() instead.
     * @param fd a #GPollFD structure holding information about a file      descriptor to watch.
     * @param priority the priority for this file descriptor which should be      the same as the priority used for g_source_attach() to ensure that the      file descriptor is polled whenever the results may be needed.
     */
    addPoll(fd: PollFD, priority: number): void
    /**
     * Passes the results of polling back to the main loop. You should be
     * careful to pass `fds` and its length `n_fds` as received from
     * g_main_context_query(), as this functions relies on assumptions
     * on how `fds` is filled.
     *
     * You must have successfully acquired the context with
     * g_main_context_acquire() before you may call this function.
     *
     * Since 2.76 `context` can be %NULL to use the global-default
     * main context.
     * @param maxPriority the maximum numerical priority of sources to check
     * @param fds array of #GPollFD's that was passed to       the last call to g_main_context_query()
     * @returns %TRUE if some sources are ready to be dispatched.
     */
    check(maxPriority: number, fds: PollFD[]): boolean
    /**
     * Dispatches all pending sources.
     *
     * You must have successfully acquired the context with
     * g_main_context_acquire() before you may call this function.
     *
     * Since 2.76 `context` can be %NULL to use the global-default
     * main context.
     */
    dispatch(): void
    /**
     * Finds a source with the given source functions and user data.  If
     * multiple sources exist with the same source function and user data,
     * the first one found will be returned.
     * @param funcs the `source_funcs` passed to g_source_new().
     * @param userData the user data from the callback.
     * @returns the source, if one was found, otherwise %NULL
     */
    findSourceByFuncsUserData(funcs: SourceFuncs, userData: any | null): Source
    /**
     * Finds a #GSource given a pair of context and ID.
     *
     * It is a programmer error to attempt to look up a non-existent source.
     *
     * More specifically: source IDs can be reissued after a source has been
     * destroyed and therefore it is never valid to use this function with a
     * source ID which may have already been removed.  An example is when
     * scheduling an idle to run in another thread with g_idle_add(): the
     * idle may already have run and been removed by the time this function
     * is called on its (now invalid) source ID.  This source ID may have
     * been reissued, leading to the operation being performed against the
     * wrong source.
     * @param sourceId the source ID, as returned by g_source_get_id().
     * @returns the #GSource
     */
    findSourceById(sourceId: number): Source
    /**
     * Finds a source with the given user data for the callback.  If
     * multiple sources exist with the same user data, the first
     * one found will be returned.
     * @param userData the user_data for the callback.
     * @returns the source, if one was found, otherwise %NULL
     */
    findSourceByUserData(userData: any | null): Source
    /**
     * Invokes a function in such a way that `context` is owned during the
     * invocation of `function`.
     *
     * This function is the same as g_main_context_invoke() except that it
     * lets you specify the priority in case `function` ends up being
     * scheduled as an idle and also lets you give a #GDestroyNotify for `data`.
     *
     * `notify` should not assume that it is called from any particular
     * thread or with any particular context acquired.
     * @param priority the priority at which to run `function`
     * @param function_ function to call
     */
    invokeFull(priority: number, function_: SourceFunc): void
    /**
     * Determines whether this thread holds the (recursive)
     * ownership of this #GMainContext. This is useful to
     * know before waiting on another thread that may be
     * blocking to get ownership of `context`.
     * @returns %TRUE if current thread is owner of @context.
     */
    isOwner(): boolean
    /**
     * Runs a single iteration for the given main loop. This involves
     * checking to see if any event sources are ready to be processed,
     * then if no events sources are ready and `may_block` is %TRUE, waiting
     * for a source to become ready, then dispatching the highest priority
     * events sources that are ready. Otherwise, if `may_block` is %FALSE
     * sources are not waited to become ready, only those highest priority
     * events sources will be dispatched (if any), that are ready at this
     * given moment without further waiting.
     *
     * Note that even when `may_block` is %TRUE, it is still possible for
     * g_main_context_iteration() to return %FALSE, since the wait may
     * be interrupted for other reasons than an event source becoming ready.
     * @param mayBlock whether the call may block.
     * @returns %TRUE if events were dispatched.
     */
    iteration(mayBlock: boolean): boolean
    /**
     * Checks if any sources have pending events for the given context.
     * @returns %TRUE if events are pending.
     */
    pending(): boolean
    /**
     * Pops `context` off the thread-default context stack (verifying that
     * it was on the top of the stack).
     */
    popThreadDefault(): void
    /**
     * Prepares to poll sources within a main loop. The resulting information
     * for polling is determined by calling g_main_context_query ().
     *
     * You must have successfully acquired the context with
     * g_main_context_acquire() before you may call this function.
     * @returns %TRUE if some source is ready to be dispatched               prior to polling.
     */
    prepare(): [/* returnType */ boolean, /* priority */ number]
    /**
     * Acquires `context` and sets it as the thread-default context for the
     * current thread. This will cause certain asynchronous operations
     * (such as most [gio][gio]-based I/O) which are
     * started in this thread to run under `context` and deliver their
     * results to its main loop, rather than running under the global
     * default main context in the main thread. Note that calling this function
     * changes the context returned by g_main_context_get_thread_default(),
     * not the one returned by g_main_context_default(), so it does not affect
     * the context used by functions like g_idle_add().
     *
     * Normally you would call this function shortly after creating a new
     * thread, passing it a #GMainContext which will be run by a
     * #GMainLoop in that thread, to set a new default context for all
     * async operations in that thread. In this case you may not need to
     * ever call g_main_context_pop_thread_default(), assuming you want the
     * new #GMainContext to be the default for the whole lifecycle of the
     * thread.
     *
     * If you don't have control over how the new thread was created (e.g.
     * in the new thread isn't newly created, or if the thread life
     * cycle is managed by a #GThreadPool), it is always suggested to wrap
     * the logic that needs to use the new #GMainContext inside a
     * g_main_context_push_thread_default() / g_main_context_pop_thread_default()
     * pair, otherwise threads that are re-used will end up never explicitly
     * releasing the #GMainContext reference they hold.
     *
     * In some cases you may want to schedule a single operation in a
     * non-default context, or temporarily use a non-default context in
     * the main thread. In that case, you can wrap the call to the
     * asynchronous operation inside a
     * g_main_context_push_thread_default() /
     * g_main_context_pop_thread_default() pair, but it is up to you to
     * ensure that no other asynchronous operations accidentally get
     * started while the non-default context is active.
     *
     * Beware that libraries that predate this function may not correctly
     * handle being used from a thread with a thread-default context. Eg,
     * see g_file_supports_thread_contexts().
     */
    pushThreadDefault(): void
    /**
     * Determines information necessary to poll this main loop. You should
     * be careful to pass the resulting `fds` array and its length `n_fds`
     * as is when calling g_main_context_check(), as this function relies
     * on assumptions made when the array is filled.
     *
     * You must have successfully acquired the context with
     * g_main_context_acquire() before you may call this function.
     * @param maxPriority maximum priority source to check
     * @returns the number of records actually stored in @fds,   or, if more than @n_fds records need to be stored, the number   of records that need to be stored.
     */
    query(
      maxPriority: number
    ): [/* returnType */ number, /* timeout */ number, /* fds */ PollFD[]]
    /**
     * Increases the reference count on a #GMainContext object by one.
     * @returns the @context that was passed in (since 2.6)
     */
    ref(): MainContext
    /**
     * Releases ownership of a context previously acquired by this thread
     * with g_main_context_acquire(). If the context was acquired multiple
     * times, the ownership will be released only when g_main_context_release()
     * is called as many times as it was acquired.
     *
     * You must have successfully acquired the context with
     * g_main_context_acquire() before you may call this function.
     */
    release(): void
    /**
     * Removes file descriptor from the set of file descriptors to be
     * polled for a particular context.
     * @param fd a #GPollFD descriptor previously added with g_main_context_add_poll()
     */
    removePoll(fd: PollFD): void
    /**
     * Decreases the reference count on a #GMainContext object by one. If
     * the result is zero, free the context and free all associated memory.
     */
    unref(): void
    /**
     * Tries to become the owner of the specified context,
     * as with g_main_context_acquire(). But if another thread
     * is the owner, atomically drop `mutex` and wait on `cond` until
     * that owner releases ownership or until `cond` is signaled, then
     * try again (once) to become the owner.
     * @param cond a condition variable
     * @param mutex a mutex, currently held
     * @returns %TRUE if the operation succeeded, and   this thread is now the owner of @context.
     */
    wait(cond: Cond, mutex: Mutex): boolean
    /**
     * If `context` is currently blocking in g_main_context_iteration()
     * waiting for a source to become ready, cause it to stop blocking
     * and return.  Otherwise, cause the next invocation of
     * g_main_context_iteration() to return without blocking.
     *
     * This API is useful for low-level control over #GMainContext; for
     * example, integrating it with main loop implementations such as
     * #GMainLoop.
     *
     * Another related use for this function is when implementing a main
     * loop with a termination condition, computed from multiple threads:
     *
     *
     * ```c
     *   #define NUM_TASKS 10
     *   static gint tasks_remaining = NUM_TASKS;  // (atomic)
     *   ...
     *
     *   while (g_atomic_int_get (&tasks_remaining) != 0)
     *     g_main_context_iteration (NULL, TRUE);
     * ```
     *
     *
     * Then in a thread:
     *
     * ```c
     *   perform_work();
     *
     *   if (g_atomic_int_dec_and_test (&tasks_remaining))
     *     g_main_context_wakeup (NULL);
     * ```
     *
     */
    wakeup(): void
  }

  /**
   * The `GMainContext` struct is an opaque data
   * type representing a set of sources to be handled in a main loop.
   * @record
   */
  class MainContext {
    // Own properties of GLib-2.0.GLib.MainContext

    static name: string

    // Constructors of GLib-2.0.GLib.MainContext

    /**
     * Creates a new #GMainContext structure.
     * @constructor
     * @returns the new #GMainContext
     */
    constructor()
    /**
     * Creates a new #GMainContext structure.
     * @constructor
     * @returns the new #GMainContext
     */
    static new(): MainContext
    /**
     * Creates a new #GMainContext structure.
     * @constructor
     * @param flags a bitwise-OR combination of #GMainContextFlags flags that can only be         set at creation time.
     * @returns the new #GMainContext
     */
    static newWithFlags(flags: MainContextFlags): MainContext
    /**
     * Returns the global-default main context. This is the main context
     * used for main loop functions when a main loop is not explicitly
     * specified, and corresponds to the "main" main loop. See also
     * g_main_context_get_thread_default().
     * @returns the global-default main context.
     */
    static default(): MainContext
    /**
     * Gets the thread-default #GMainContext for this thread. Asynchronous
     * operations that want to be able to be run in contexts other than
     * the default one should call this method or
     * g_main_context_ref_thread_default() to get a #GMainContext to add
     * their #GSources to. (Note that even in single-threaded
     * programs applications may sometimes want to temporarily push a
     * non-default context, so it is not safe to assume that this will
     * always return %NULL if you are running in the default thread.)
     *
     * If you need to hold a reference on the context, use
     * g_main_context_ref_thread_default() instead.
     * @returns the thread-default #GMainContext, or %NULL if the thread-default context is the global-default main context.
     */
    static getThreadDefault(): MainContext | null
    /**
     * Gets the thread-default #GMainContext for this thread, as with
     * g_main_context_get_thread_default(), but also adds a reference to
     * it with g_main_context_ref(). In addition, unlike
     * g_main_context_get_thread_default(), if the thread-default context
     * is the global-default context, this will return that #GMainContext
     * (with a ref added to it) rather than returning %NULL.
     * @returns the thread-default #GMainContext. Unref     with g_main_context_unref() when you are done with it.
     */
    static refThreadDefault(): MainContext
  }

  interface MainLoop {
    // Owm methods of GLib-2.0.GLib.MainLoop

    /**
     * Returns the #GMainContext of `loop`.
     * @returns the #GMainContext of @loop
     */
    getContext(): MainContext
    /**
     * Checks to see if the main loop is currently being run via g_main_loop_run().
     * @returns %TRUE if the mainloop is currently being run.
     */
    isRunning(): boolean
    /**
     * Stops a #GMainLoop from running. Any calls to g_main_loop_run()
     * for the loop will return.
     *
     * Note that sources that have already been dispatched when
     * g_main_loop_quit() is called will still be executed.
     */
    quit(): void
    /**
     * Increases the reference count on a #GMainLoop object by one.
     * @returns @loop
     */
    ref(): MainLoop
    /**
     * Runs a main loop until g_main_loop_quit() is called on the loop.
     * If this is called for the thread of the loop's #GMainContext,
     * it will process events from the loop, otherwise it will
     * simply wait.
     */
    run(): void
    /**
     * Decreases the reference count on a #GMainLoop object by one. If
     * the result is zero, free the loop and free all associated memory.
     */
    unref(): void
    run(): void
    quit(): void
  }

  /**
   * The `GMainLoop` struct is an opaque data type
   * representing the main event loop of a GLib or GTK application.
   * @record
   */
  class MainLoop {
    // Own properties of GLib-2.0.GLib.MainLoop

    static name: string

    // Constructors of GLib-2.0.GLib.MainLoop

    /**
     * Creates a new #GMainLoop structure.
     * @constructor
     * @param context a #GMainContext  (if %NULL, the global-default   main context will be used).
     * @param isRunning set to %TRUE to indicate that the loop is running. This is not very important since calling g_main_loop_run() will set this to %TRUE anyway.
     * @returns a new #GMainLoop.
     */
    constructor(context: MainContext | null, isRunning: boolean)
    /**
     * Creates a new #GMainLoop structure.
     * @constructor
     * @param context a #GMainContext  (if %NULL, the global-default   main context will be used).
     * @param isRunning set to %TRUE to indicate that the loop is running. This is not very important since calling g_main_loop_run() will set this to %TRUE anyway.
     * @returns a new #GMainLoop.
     */
    static new(context: MainContext | null, isRunning: boolean): MainLoop
  }

  interface MappedFile {
    // Owm methods of GLib-2.0.GLib.MappedFile

    /**
     * This call existed before #GMappedFile had refcounting and is currently
     * exactly the same as g_mapped_file_unref().
     */
    free(): void
    /**
     * Creates a new #GBytes which references the data mapped from `file`.
     * The mapped contents of the file must not be modified after creating this
     * bytes object, because a #GBytes should be immutable.
     * @returns A newly allocated #GBytes referencing data     from @file
     */
    getBytes(): any
    /**
     * Returns the contents of a #GMappedFile.
     *
     * Note that the contents may not be zero-terminated,
     * even if the #GMappedFile is backed by a text file.
     *
     * If the file is empty then %NULL is returned.
     * @returns the contents of @file, or %NULL.
     */
    getContents(): string | null
    /**
     * Returns the length of the contents of a #GMappedFile.
     * @returns the length of the contents of @file.
     */
    getLength(): number
    /**
     * Increments the reference count of `file` by one.  It is safe to call
     * this function from any thread.
     * @returns the passed in #GMappedFile.
     */
    ref(): MappedFile
    /**
     * Decrements the reference count of `file` by one.  If the reference count
     * drops to 0, unmaps the buffer of `file` and frees it.
     *
     * It is safe to call this function from any thread.
     *
     * Since 2.22
     */
    unref(): void
  }

  /**
   * The #GMappedFile represents a file mapping created with
   * g_mapped_file_new(). It has only private members and should
   * not be accessed directly.
   * @record
   */
  class MappedFile {
    // Own properties of GLib-2.0.GLib.MappedFile

    static name: string

    // Constructors of GLib-2.0.GLib.MappedFile

    /**
     * Maps a file into memory. On UNIX, this is using the mmap() function.
     *
     * If `writable` is %TRUE, the mapped buffer may be modified, otherwise
     * it is an error to modify the mapped buffer. Modifications to the buffer
     * are not visible to other processes mapping the same file, and are not
     * written back to the file.
     *
     * Note that modifications of the underlying file might affect the contents
     * of the #GMappedFile. Therefore, mapping should only be used if the file
     * will not be modified, or if all modifications of the file are done
     * atomically (e.g. using g_file_set_contents()).
     *
     * If `filename` is the name of an empty, regular file, the function
     * will successfully return an empty #GMappedFile. In other cases of
     * size 0 (e.g. device files such as /dev/null), `error` will be set
     * to the #GFileError value %G_FILE_ERROR_INVAL.
     * @constructor
     * @param filename The path of the file to load, in the GLib     filename encoding
     * @param writable whether the mapping should be writable
     * @returns a newly allocated #GMappedFile which must be unref'd    with g_mapped_file_unref(), or %NULL if the mapping failed.
     */
    constructor(filename: string, writable: boolean)
    /**
     * Maps a file into memory. On UNIX, this is using the mmap() function.
     *
     * If `writable` is %TRUE, the mapped buffer may be modified, otherwise
     * it is an error to modify the mapped buffer. Modifications to the buffer
     * are not visible to other processes mapping the same file, and are not
     * written back to the file.
     *
     * Note that modifications of the underlying file might affect the contents
     * of the #GMappedFile. Therefore, mapping should only be used if the file
     * will not be modified, or if all modifications of the file are done
     * atomically (e.g. using g_file_set_contents()).
     *
     * If `filename` is the name of an empty, regular file, the function
     * will successfully return an empty #GMappedFile. In other cases of
     * size 0 (e.g. device files such as /dev/null), `error` will be set
     * to the #GFileError value %G_FILE_ERROR_INVAL.
     * @constructor
     * @param filename The path of the file to load, in the GLib     filename encoding
     * @param writable whether the mapping should be writable
     * @returns a newly allocated #GMappedFile which must be unref'd    with g_mapped_file_unref(), or %NULL if the mapping failed.
     */
    static new(filename: string, writable: boolean): MappedFile
    /**
     * Maps a file into memory. On UNIX, this is using the mmap() function.
     *
     * If `writable` is %TRUE, the mapped buffer may be modified, otherwise
     * it is an error to modify the mapped buffer. Modifications to the buffer
     * are not visible to other processes mapping the same file, and are not
     * written back to the file.
     *
     * Note that modifications of the underlying file might affect the contents
     * of the #GMappedFile. Therefore, mapping should only be used if the file
     * will not be modified, or if all modifications of the file are done
     * atomically (e.g. using g_file_set_contents()).
     * @constructor
     * @param fd The file descriptor of the file to load
     * @param writable whether the mapping should be writable
     * @returns a newly allocated #GMappedFile which must be unref'd    with g_mapped_file_unref(), or %NULL if the mapping failed.
     */
    static newFromFd(fd: number, writable: boolean): MappedFile
  }

  interface MarkupParseContext {
    // Owm methods of GLib-2.0.GLib.MarkupParseContext

    /**
     * Signals to the #GMarkupParseContext that all data has been
     * fed into the parse context with g_markup_parse_context_parse().
     *
     * This function reports an error if the document isn't complete,
     * for example if elements are still open.
     * @returns %TRUE on success, %FALSE if an error was set
     */
    endParse(): boolean
    /**
     * Frees a #GMarkupParseContext.
     *
     * This function can't be called from inside one of the
     * #GMarkupParser functions or while a subparser is pushed.
     */
    free(): void
    /**
     * Retrieves the name of the currently open element.
     *
     * If called from the start_element or end_element handlers this will
     * give the element_name as passed to those functions. For the parent
     * elements, see g_markup_parse_context_get_element_stack().
     * @returns the name of the currently open element, or %NULL
     */
    getElement(): string
    /**
     * Retrieves the element stack from the internal state of the parser.
     *
     * The returned #GSList is a list of strings where the first item is
     * the currently open tag (as would be returned by
     * g_markup_parse_context_get_element()) and the next item is its
     * immediate parent.
     *
     * This function is intended to be used in the start_element and
     * end_element handlers where g_markup_parse_context_get_element()
     * would merely return the name of the element that is being
     * processed.
     * @returns the element stack, which must not be modified
     */
    getElementStack(): string[]
    /**
     * Retrieves the current line number and the number of the character on
     * that line. Intended for use in error messages; there are no strict
     * semantics for what constitutes the "current" line number other than
     * "the best number we could come up with for error messages."
     */
    getPosition(): [/* lineNumber */ number, /* charNumber */ number]
    /**
     * Returns the user_data associated with `context`.
     *
     * This will either be the user_data that was provided to
     * g_markup_parse_context_new() or to the most recent call
     * of g_markup_parse_context_push().
     * @returns the provided user_data. The returned data belongs to     the markup context and will be freed when     g_markup_parse_context_free() is called.
     */
    getUserData(): any | null
    /**
     * Feed some data to the #GMarkupParseContext.
     *
     * The data need not be valid UTF-8; an error will be signaled if
     * it's invalid. The data need not be an entire document; you can
     * feed a document into the parser incrementally, via multiple calls
     * to this function. Typically, as you receive data from a network
     * connection or file, you feed each received chunk of data into this
     * function, aborting the process if an error occurs. Once an error
     * is reported, no further data may be fed to the #GMarkupParseContext;
     * all errors are fatal.
     * @param text chunk of text to parse
     * @param textLen length of `text` in bytes
     * @returns %FALSE if an error occurred, %TRUE on success
     */
    parse(text: string, textLen: number): boolean
    /**
     * Completes the process of a temporary sub-parser redirection.
     *
     * This function exists to collect the user_data allocated by a
     * matching call to g_markup_parse_context_push(). It must be called
     * in the end_element handler corresponding to the start_element
     * handler during which g_markup_parse_context_push() was called.
     * You must not call this function from the error callback -- the
     * `user_data` is provided directly to the callback in that case.
     *
     * This function is not intended to be directly called by users
     * interested in invoking subparsers. Instead, it is intended to
     * be used by the subparsers themselves to implement a higher-level
     * interface.
     * @returns the user data passed to g_markup_parse_context_push()
     */
    pop(): any | null
    /**
     * Temporarily redirects markup data to a sub-parser.
     *
     * This function may only be called from the start_element handler of
     * a #GMarkupParser. It must be matched with a corresponding call to
     * g_markup_parse_context_pop() in the matching end_element handler
     * (except in the case that the parser aborts due to an error).
     *
     * All tags, text and other data between the matching tags is
     * redirected to the subparser given by `parser`. `user_data` is used
     * as the user_data for that parser. `user_data` is also passed to the
     * error callback in the event that an error occurs. This includes
     * errors that occur in subparsers of the subparser.
     *
     * The end tag matching the start tag for which this call was made is
     * handled by the previous parser (which is given its own user_data)
     * which is why g_markup_parse_context_pop() is provided to allow "one
     * last access" to the `user_data` provided to this function. In the
     * case of error, the `user_data` provided here is passed directly to
     * the error callback of the subparser and g_markup_parse_context_pop()
     * should not be called. In either case, if `user_data` was allocated
     * then it ought to be freed from both of these locations.
     *
     * This function is not intended to be directly called by users
     * interested in invoking subparsers. Instead, it is intended to be
     * used by the subparsers themselves to implement a higher-level
     * interface.
     *
     * As an example, see the following implementation of a simple
     * parser that counts the number of tags encountered.
     *
     *
     * ```c
     * typedef struct
     * {
     *   gint tag_count;
     * } CounterData;
     *
     * static void
     * counter_start_element (GMarkupParseContext  *context,
     *                        const gchar          *element_name,
     *                        const gchar         **attribute_names,
     *                        const gchar         **attribute_values,
     *                        gpointer              user_data,
     *                        GError              **error)
     * {
     *   CounterData *data = user_data;
     *
     *   data->tag_count++;
     * }
     *
     * static void
     * counter_error (GMarkupParseContext *context,
     *                GError              *error,
     *                gpointer             user_data)
     * {
     *   CounterData *data = user_data;
     *
     *   g_slice_free (CounterData, data);
     * }
     *
     * static GMarkupParser counter_subparser =
     * {
     *   counter_start_element,
     *   NULL,
     *   NULL,
     *   NULL,
     *   counter_error
     * };
     * ```
     *
     *
     * In order to allow this parser to be easily used as a subparser, the
     * following interface is provided:
     *
     *
     * ```c
     * void
     * start_counting (GMarkupParseContext *context)
     * {
     *   CounterData *data = g_slice_new (CounterData);
     *
     *   data->tag_count = 0;
     *   g_markup_parse_context_push (context, &counter_subparser, data);
     * }
     *
     * gint
     * end_counting (GMarkupParseContext *context)
     * {
     *   CounterData *data = g_markup_parse_context_pop (context);
     *   int result;
     *
     *   result = data->tag_count;
     *   g_slice_free (CounterData, data);
     *
     *   return result;
     * }
     * ```
     *
     *
     * The subparser would then be used as follows:
     *
     *
     * ```c
     * static void start_element (context, element_name, ...)
     * {
     *   if (strcmp (element_name, "count-these") == 0)
     *     start_counting (context);
     *
     *   // else, handle other tags...
     * }
     *
     * static void end_element (context, element_name, ...)
     * {
     *   if (strcmp (element_name, "count-these") == 0)
     *     g_print ("Counted %d tags\n", end_counting (context));
     *
     *   // else, handle other tags...
     * }
     * ```
     *
     * @param parser a #GMarkupParser
     * @param userData user data to pass to #GMarkupParser functions
     */
    push(parser: MarkupParser, userData: any | null): void
    /**
     * Increases the reference count of `context`.
     * @returns the same @context
     */
    ref(): MarkupParseContext
    /**
     * Decreases the reference count of `context`.  When its reference count
     * drops to 0, it is freed.
     */
    unref(): void
  }

  /**
   * A parse context is used to parse a stream of bytes that
   * you expect to contain marked-up text.
   *
   * See g_markup_parse_context_new(), #GMarkupParser, and so
   * on for more details.
   * @record
   */
  class MarkupParseContext {
    // Own properties of GLib-2.0.GLib.MarkupParseContext

    static name: string

    // Constructors of GLib-2.0.GLib.MarkupParseContext

    /**
     * Creates a new parse context. A parse context is used to parse
     * marked-up documents. You can feed any number of documents into
     * a context, as long as no errors occur; once an error occurs,
     * the parse context can't continue to parse text (you have to
     * free it and create a new parse context).
     * @constructor
     * @param parser a #GMarkupParser
     * @param flags one or more #GMarkupParseFlags
     * @param userData user data to pass to #GMarkupParser functions
     * @param userDataDnotify user data destroy notifier called when     the parse context is freed
     * @returns a new #GMarkupParseContext
     */
    constructor(
      parser: MarkupParser,
      flags: MarkupParseFlags,
      userData: any | null,
      userDataDnotify: DestroyNotify
    )
    /**
     * Creates a new parse context. A parse context is used to parse
     * marked-up documents. You can feed any number of documents into
     * a context, as long as no errors occur; once an error occurs,
     * the parse context can't continue to parse text (you have to
     * free it and create a new parse context).
     * @constructor
     * @param parser a #GMarkupParser
     * @param flags one or more #GMarkupParseFlags
     * @param userData user data to pass to #GMarkupParser functions
     * @param userDataDnotify user data destroy notifier called when     the parse context is freed
     * @returns a new #GMarkupParseContext
     */
    static new(
      parser: MarkupParser,
      flags: MarkupParseFlags,
      userData: any | null,
      userDataDnotify: DestroyNotify
    ): MarkupParseContext
  }

  interface MarkupParser {
    // Own fields of GLib-2.0.GLib.MarkupParser

    /**
     * Callback to invoke when the opening tag of an element
     *     is seen. The callback's `attribute_names` and `attribute_values` parameters
     *     are %NULL-terminated.
     * @field
     */
    startElement: (
      context: MarkupParseContext,
      elementName: string,
      attributeNames: string,
      attributeValues: string
    ) => void
    /**
     * Callback to invoke when the closing tag of an element
     *     is seen. Note that this is also called for empty tags like
     *     `<empty/>`.
     * @field
     */
    endElement: (context: MarkupParseContext, elementName: string) => void
    /**
     * Callback to invoke when some text is seen (text is always
     *     inside an element). Note that the text of an element may be spread
     *     over multiple calls of this function. If the
     *     %G_MARKUP_TREAT_CDATA_AS_TEXT flag is set, this function is also
     *     called for the content of CDATA marked sections.
     * @field
     */
    text: (context: MarkupParseContext, text: string, textLen: number) => void
    /**
     * Callback to invoke for comments, processing instructions
     *     and doctype declarations; if you're re-writing the parsed document,
     *     write the passthrough text back out in the same position. If the
     *     %G_MARKUP_TREAT_CDATA_AS_TEXT flag is not set, this function is also
     *     called for CDATA marked sections.
     * @field
     */
    passthrough: (
      context: MarkupParseContext,
      passthroughText: string,
      textLen: number
    ) => void
    /**
     * Callback to invoke when an error occurs.
     * @field
     */
    error: (context: MarkupParseContext, error: Error) => void
  }

  /**
   * Any of the fields in #GMarkupParser can be %NULL, in which case they
   * will be ignored. Except for the `error` function, any of these callbacks
   * can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT,
   * %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT
   * errors are intended to be set from these callbacks. If you set an error
   * from a callback, g_markup_parse_context_parse() will report that error
   * back to its caller.
   * @record
   */
  class MarkupParser {
    // Own properties of GLib-2.0.GLib.MarkupParser

    static name: string
  }

  interface MatchInfo {
    // Owm methods of GLib-2.0.GLib.MatchInfo

    /**
     * Returns a new string containing the text in `string_to_expand` with
     * references and escape sequences expanded. References refer to the last
     * match done with `string` against `regex` and have the same syntax used by
     * g_regex_replace().
     *
     * The `string_to_expand` must be UTF-8 encoded even if %G_REGEX_RAW was
     * passed to g_regex_new().
     *
     * The backreferences are extracted from the string passed to the match
     * function, so you cannot call this function after freeing the string.
     *
     * `match_info` may be %NULL in which case `string_to_expand` must not
     * contain references. For instance "foo\n" does not refer to an actual
     * pattern and '\n' merely will be replaced with \n character,
     * while to expand "\0" (whole match) one needs the result of a match.
     * Use g_regex_check_replacement() to find out whether `string_to_expand`
     * contains references.
     * @param stringToExpand the string to expand
     * @returns the expanded string, or %NULL if an error occurred
     */
    expandReferences(stringToExpand: string): string | null
    /**
     * Retrieves the text matching the `match_num'`th capturing
     * parentheses. 0 is the full text of the match, 1 is the first paren
     * set, 2 the second, and so on.
     *
     * If `match_num` is a valid sub pattern but it didn't match anything
     * (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty
     * string is returned.
     *
     * If the match was obtained using the DFA algorithm, that is using
     * g_regex_match_all() or g_regex_match_all_full(), the retrieved
     * string is not that of a set of parentheses but that of a matched
     * substring. Substrings are matched in reverse order of length, so
     * 0 is the longest match.
     *
     * The string is fetched from the string passed to the match function,
     * so you cannot call this function after freeing the string.
     * @param matchNum number of the sub expression
     * @returns The matched substring, or %NULL if an error     occurred. You have to free the string yourself
     */
    fetch(matchNum: number): string | null
    /**
     * Bundles up pointers to each of the matching substrings from a match
     * and stores them in an array of gchar pointers. The first element in
     * the returned array is the match number 0, i.e. the entire matched
     * text.
     *
     * If a sub pattern didn't match anything (e.g. sub pattern 1, matching
     * "b" against "(a)?b") then an empty string is inserted.
     *
     * If the last match was obtained using the DFA algorithm, that is using
     * g_regex_match_all() or g_regex_match_all_full(), the retrieved
     * strings are not that matched by sets of parentheses but that of the
     * matched substring. Substrings are matched in reverse order of length,
     * so the first one is the longest match.
     *
     * The strings are fetched from the string passed to the match function,
     * so you cannot call this function after freeing the string.
     * @returns a %NULL-terminated array of gchar *     pointers.  It must be freed using g_strfreev(). If the previous     match failed %NULL is returned
     */
    fetchAll(): string[]
    /**
     * Retrieves the text matching the capturing parentheses named `name`.
     *
     * If `name` is a valid sub pattern name but it didn't match anything
     * (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b")
     * then an empty string is returned.
     *
     * The string is fetched from the string passed to the match function,
     * so you cannot call this function after freeing the string.
     * @param name name of the subexpression
     * @returns The matched substring, or %NULL if an error     occurred. You have to free the string yourself
     */
    fetchNamed(name: string): string | null
    /**
     * Retrieves the position in bytes of the capturing parentheses named `name`.
     *
     * If `name` is a valid sub pattern name but it didn't match anything
     * (e.g. sub pattern "X", matching "b" against "(?P<X>a)?b")
     * then `start_pos` and `end_pos` are set to -1 and %TRUE is returned.
     * @param name name of the subexpression
     * @returns %TRUE if the position was fetched, %FALSE otherwise.     If the position cannot be fetched, @start_pos and @end_pos     are left unchanged.
     */
    fetchNamedPos(
      name: string
    ): [/* returnType */ boolean, /* startPos */ number, /* endPos */ number]
    /**
     * Retrieves the position in bytes of the `match_num'`th capturing
     * parentheses. 0 is the full text of the match, 1 is the first
     * paren set, 2 the second, and so on.
     *
     * If `match_num` is a valid sub pattern but it didn't match anything
     * (e.g. sub pattern 1, matching "b" against "(a)?b") then `start_pos`
     * and `end_pos` are set to -1 and %TRUE is returned.
     *
     * If the match was obtained using the DFA algorithm, that is using
     * g_regex_match_all() or g_regex_match_all_full(), the retrieved
     * position is not that of a set of parentheses but that of a matched
     * substring. Substrings are matched in reverse order of length, so
     * 0 is the longest match.
     * @param matchNum number of the sub expression
     * @returns %TRUE if the position was fetched, %FALSE otherwise. If   the position cannot be fetched, @start_pos and @end_pos are left   unchanged
     */
    fetchPos(
      matchNum: number
    ): [/* returnType */ boolean, /* startPos */ number, /* endPos */ number]
    /**
     * If `match_info` is not %NULL, calls g_match_info_unref(); otherwise does
     * nothing.
     */
    free(): void
    /**
     * Retrieves the number of matched substrings (including substring 0,
     * that is the whole matched text), so 1 is returned if the pattern
     * has no substrings in it and 0 is returned if the match failed.
     *
     * If the last match was obtained using the DFA algorithm, that is
     * using g_regex_match_all() or g_regex_match_all_full(), the retrieved
     * count is not that of the number of capturing parentheses but that of
     * the number of matched substrings.
     * @returns Number of matched substrings, or -1 if an error occurred
     */
    getMatchCount(): number
    /**
     * Returns #GRegex object used in `match_info`. It belongs to Glib
     * and must not be freed. Use g_regex_ref() if you need to keep it
     * after you free `match_info` object.
     * @returns #GRegex object used in @match_info
     */
    getRegex(): Regex
    /**
     * Returns the string searched with `match_info`. This is the
     * string passed to g_regex_match() or g_regex_replace() so
     * you may not free it before calling this function.
     * @returns the string searched with @match_info
     */
    getString(): string
    /**
     * Usually if the string passed to g_regex_match*() matches as far as
     * it goes, but is too short to match the entire pattern, %FALSE is
     * returned. There are circumstances where it might be helpful to
     * distinguish this case from other cases in which there is no match.
     *
     * Consider, for example, an application where a human is required to
     * type in data for a field with specific formatting requirements. An
     * example might be a date in the form ddmmmyy, defined by the pattern
     * "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$".
     * If the application sees the user’s keystrokes one by one, and can
     * check that what has been typed so far is potentially valid, it is
     * able to raise an error as soon as a mistake is made.
     *
     * GRegex supports the concept of partial matching by means of the
     * %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD flags.
     * When they are used, the return code for
     * g_regex_match() or g_regex_match_full() is, as usual, %TRUE
     * for a complete match, %FALSE otherwise. But, when these functions
     * return %FALSE, you can check if the match was partial calling
     * g_match_info_is_partial_match().
     *
     * The difference between %G_REGEX_MATCH_PARTIAL_SOFT and
     * %G_REGEX_MATCH_PARTIAL_HARD is that when a partial match is encountered
     * with %G_REGEX_MATCH_PARTIAL_SOFT, matching continues to search for a
     * possible complete match, while with %G_REGEX_MATCH_PARTIAL_HARD matching
     * stops at the partial match.
     * When both %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD
     * are set, the latter takes precedence.
     *
     * There were formerly some restrictions on the pattern for partial matching.
     * The restrictions no longer apply.
     *
     * See pcrepartial(3) for more information on partial matching.
     * @returns %TRUE if the match was partial, %FALSE otherwise
     */
    isPartialMatch(): boolean
    /**
     * Returns whether the previous match operation succeeded.
     * @returns %TRUE if the previous match operation succeeded,   %FALSE otherwise
     */
    matches(): boolean
    /**
     * Scans for the next match using the same parameters of the previous
     * call to g_regex_match_full() or g_regex_match() that returned
     * `match_info`.
     *
     * The match is done on the string passed to the match function, so you
     * cannot free it before calling this function.
     * @returns %TRUE is the string matched, %FALSE otherwise
     */
    next(): boolean
    /**
     * Increases reference count of `match_info` by 1.
     * @returns @match_info
     */
    ref(): MatchInfo
    /**
     * Decreases reference count of `match_info` by 1. When reference count drops
     * to zero, it frees all the memory associated with the match_info structure.
     */
    unref(): void
  }

  /**
   * A GMatchInfo is an opaque struct used to return information about
   * matches.
   * @record
   */
  class MatchInfo {
    // Own properties of GLib-2.0.GLib.MatchInfo

    static name: string
  }

  interface MemChunk {
    // Owm methods of GLib-2.0.GLib.MemChunk

    alloc(): any | null
    alloc0(): any | null
    clean(): void
    destroy(): void
    free(mem: any | null): void
    print(): void
    reset(): void
  }

  class MemChunk {
    // Own properties of GLib-2.0.GLib.MemChunk

    static name: string

    // Constructors of GLib-2.0.GLib.MemChunk

    static info(): void
  }

  interface MemVTable {
    // Own fields of GLib-2.0.GLib.MemVTable

    /**
     * function to use for allocating memory.
     * @field
     */
    malloc: (nBytes: number) => any
    /**
     * function to use for reallocating memory.
     * @field
     */
    realloc: (mem: any, nBytes: number) => any
    /**
     * function to use to free memory.
     * @field
     */
    free: (mem: any) => void
    /**
     * function to use for allocating zero-filled memory.
     * @field
     */
    calloc: (nBlocks: number, nBlockBytes: number) => any
    /**
     * function to use for allocating memory without a default error handler.
     * @field
     */
    tryMalloc: (nBytes: number) => any
    /**
     * function to use for reallocating memory without a default error handler.
     * @field
     */
    tryRealloc: (mem: any, nBytes: number) => any
  }

  /**
   * A set of functions used to perform memory allocation. The same #GMemVTable must
   * be used for all allocations in the same program; a call to g_mem_set_vtable(),
   * if it exists, should be prior to any use of GLib.
   *
   * This functions related to this has been deprecated in 2.46, and no longer work.
   * @record
   */
  class MemVTable {
    // Own properties of GLib-2.0.GLib.MemVTable

    static name: string
  }

  interface Node {
    // Own fields of GLib-2.0.GLib.Node

    /**
     * contains the actual data of the node.
     * @field
     */
    data: any
    /**
     * points to the node's next sibling (a sibling is another
     *        #GNode with the same parent).
     * @field
     */
    next: Node
    /**
     * points to the node's previous sibling.
     * @field
     */
    prev: Node
    /**
     * points to the parent of the #GNode, or is %NULL if the
     *          #GNode is the root of the tree.
     * @field
     */
    parent: Node
    /**
     * points to the first child of the #GNode.  The other
     *            children are accessed by using the `next` pointer of each
     *            child.
     * @field
     */
    children: Node

    // Owm methods of GLib-2.0.GLib.Node

    /**
     * Gets the position of the first child of a #GNode
     * which contains the given data.
     * @param data the data to find
     * @returns the index of the child of @node which contains     @data, or -1 if the data is not found
     */
    childIndex(data: any | null): number
    /**
     * Gets the position of a #GNode with respect to its siblings.
     * `child` must be a child of `node`. The first child is numbered 0,
     * the second 1, and so on.
     * @param child a child of `node`
     * @returns the position of @child with respect to its siblings
     */
    childPosition(child: Node): number
    /**
     * Calls a function for each of the children of a #GNode. Note that it
     * doesn't descend beneath the child nodes. `func` must not do anything
     * that would modify the structure of the tree.
     * @param flags which types of children are to be visited, one of     %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
     * @param func the function to call for each visited node
     */
    childrenForeach(flags: TraverseFlags, func: NodeForeachFunc): void
    /**
     * Gets the depth of a #GNode.
     *
     * If `node` is %NULL the depth is 0. The root node has a depth of 1.
     * For the children of the root node the depth is 2. And so on.
     * @returns the depth of the #GNode
     */
    depth(): number
    /**
     * Removes `root` and its children from the tree, freeing any memory
     * allocated.
     */
    destroy(): void
    /**
     * Returns %TRUE if `node` is an ancestor of `descendant`.
     * This is true if node is the parent of `descendant,`
     * or if node is the grandparent of `descendant` etc.
     * @param descendant a #GNode
     * @returns %TRUE if @node is an ancestor of @descendant
     */
    isAncestor(descendant: Node): boolean
    /**
     * Gets the maximum height of all branches beneath a #GNode.
     * This is the maximum distance from the #GNode to all leaf nodes.
     *
     * If `root` is %NULL, 0 is returned. If `root` has no children,
     * 1 is returned. If `root` has children, 2 is returned. And so on.
     * @returns the maximum height of the tree beneath @root
     */
    maxHeight(): number
    /**
     * Gets the number of children of a #GNode.
     * @returns the number of children of @node
     */
    nChildren(): number
    /**
     * Gets the number of nodes in a tree.
     * @param flags which types of children are to be counted, one of     %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
     * @returns the number of nodes in the tree
     */
    nNodes(flags: TraverseFlags): number
    /**
     * Reverses the order of the children of a #GNode.
     * (It doesn't change the order of the grandchildren.)
     */
    reverseChildren(): void
    /**
     * Traverses a tree starting at the given root #GNode.
     * It calls the given function for each node visited.
     * The traversal can be halted at any point by returning %TRUE from `func`.
     * `func` must not do anything that would modify the structure of the tree.
     * @param order the order in which nodes are visited - %G_IN_ORDER,     %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER.
     * @param flags which types of children are to be visited, one of     %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
     * @param maxDepth the maximum depth of the traversal. Nodes below this     depth will not be visited. If max_depth is -1 all nodes in     the tree are visited. If depth is 1, only the root is visited.     If depth is 2, the root and its children are visited. And so on.
     * @param func the function to call for each visited #GNode
     */
    traverse(
      order: TraverseType,
      flags: TraverseFlags,
      maxDepth: number,
      func: NodeTraverseFunc
    ): void
    /**
     * Unlinks a #GNode from a tree, resulting in two separate trees.
     */
    unlink(): void
  }

  /**
   * The #GNode struct represents one node in a [n-ary tree][glib-N-ary-Trees].
   * @record
   */
  class Node {
    // Own properties of GLib-2.0.GLib.Node

    static name: string

    // Constructors of GLib-2.0.GLib.Node

    static popAllocator(): void
    static pushAllocator(allocator: Allocator): void
  }

  interface Once {
    // Own fields of GLib-2.0.GLib.Once

    /**
     * the status of the #GOnce
     * @field
     */
    status: OnceStatus
    /**
     * the value returned by the call to the function, if `status`
     *          is %G_ONCE_STATUS_READY
     * @field
     */
    retval: any
  }

  /**
   * A #GOnce struct controls a one-time initialization function. Any
   * one-time initialization function must have its own unique #GOnce
   * struct.
   * @record
   */
  class Once {
    // Own properties of GLib-2.0.GLib.Once

    static name: string

    // Constructors of GLib-2.0.GLib.Once

    /**
     * Function to be called when starting a critical initialization
     * section. The argument `location` must point to a static
     * 0-initialized variable that will be set to a value other than 0 at
     * the end of the initialization section. In combination with
     * g_once_init_leave() and the unique address `value_location,` it can
     * be ensured that an initialization section will be executed only once
     * during a program's life time, and that concurrent threads are
     * blocked until initialization completed. To be used in constructs
     * like this:
     *
     *
     * ```c
     *   static gsize initialization_value = 0;
     *
     *   if (g_once_init_enter (&initialization_value))
     *     {
     *       gsize setup_value = 42; // initialization code here
     *
     *       g_once_init_leave (&initialization_value, setup_value);
     *     }
     *
     *   // use initialization_value here
     * ```
     *
     *
     * While `location` has a `volatile` qualifier, this is a historical artifact and
     * the pointer passed to it should not be `volatile`.
     * @param location location of a static initializable variable    containing 0
     * @returns %TRUE if the initialization section should be entered,     %FALSE and blocks otherwise
     */
    static initEnter(
      location: any
    ): [/* returnType */ boolean, /* location */ any]
    static initEnterImpl(location: number): boolean
    /**
     * This functions behaves in the same way as g_once_init_enter(), but can
     * can be used to initialize pointers (or #guintptr) instead of #gsize.
     *
     *
     * ```c
     *   static MyStruct *interesting_struct = NULL;
     *
     *   if (g_once_init_enter_pointer (&interesting_struct))
     *     {
     *       MyStruct *setup_value = allocate_my_struct (); // initialization code here
     *
     *       g_once_init_leave_pointer (&interesting_struct, g_steal_pointer (&setup_value));
     *     }
     *
     *   // use interesting_struct here
     * ```
     *
     * @param location location of a static initializable variable    containing `NULL`
     * @returns %TRUE if the initialization section should be entered,     %FALSE and blocks otherwise
     */
    static initEnterPointer(location: any): boolean
    /**
     * Counterpart to g_once_init_enter(). Expects a location of a static
     * 0-initialized initialization variable, and an initialization value
     * other than 0. Sets the variable to the initialization value, and
     * releases concurrent threads blocking in g_once_init_enter() on this
     * initialization variable.
     *
     * While `location` has a `volatile` qualifier, this is a historical artifact and
     * the pointer passed to it should not be `volatile`.
     * @param location location of a static initializable variable    containing 0
     * @param result new non-0 value for *`value_location`
     */
    static initLeave(location: any, result: number): /* location */ any
    /**
     * Counterpart to g_once_init_enter_pointer(). Expects a location of a static
     * `NULL`-initialized initialization variable, and an initialization value
     * other than `NULL`. Sets the variable to the initialization value, and
     * releases concurrent threads blocking in g_once_init_enter_pointer() on this
     * initialization variable.
     *
     * This functions behaves in the same way as g_once_init_leave(), but
     * can be used to initialize pointers (or #guintptr) instead of #gsize.
     * @param location location of a static initializable variable    containing `NULL`
     * @param result new non-`NULL` value for `*location`
     */
    static initLeavePointer(location: any, result: any | null): void
  }

  interface OptionContext {
    // Owm methods of GLib-2.0.GLib.OptionContext

    /**
     * Adds a #GOptionGroup to the `context,` so that parsing with `context`
     * will recognize the options in the group. Note that this will take
     * ownership of the `group` and thus the `group` should not be freed.
     * @param group the group to add
     */
    addGroup(group: OptionGroup): void
    /**
     * A convenience function which creates a main group if it doesn't
     * exist, adds the `entries` to it and sets the translation domain.
     * @param entries a %NULL-terminated array of #GOptionEntrys
     * @param translationDomain a translation domain to use for translating    the `--help` output for the options in `entries`    with gettext(), or %NULL
     */
    addMainEntries(
      entries: OptionEntry[],
      translationDomain: string | null
    ): void
    /**
     * Frees context and all the groups which have been
     * added to it.
     *
     * Please note that parsed arguments need to be freed separately (see
     * #GOptionEntry).
     */
    free(): void
    /**
     * Returns the description. See g_option_context_set_description().
     * @returns the description
     */
    getDescription(): string
    /**
     * Returns a formatted, translated help text for the given context.
     * To obtain the text produced by `--help`, call
     * `g_option_context_get_help (context, TRUE, NULL)`.
     * To obtain the text produced by `--help-all`, call
     * `g_option_context_get_help (context, FALSE, NULL)`.
     * To obtain the help text for an option group, call
     * `g_option_context_get_help (context, FALSE, group)`.
     * @param mainHelp if %TRUE, only include the main group
     * @param group the #GOptionGroup to create help for, or %NULL
     * @returns A newly allocated string containing the help text
     */
    getHelp(mainHelp: boolean, group: OptionGroup | null): string | null
    /**
     * Returns whether automatic `--help` generation
     * is turned on for `context`. See g_option_context_set_help_enabled().
     * @returns %TRUE if automatic help generation is turned on.
     */
    getHelpEnabled(): boolean
    /**
     * Returns whether unknown options are ignored or not. See
     * g_option_context_set_ignore_unknown_options().
     * @returns %TRUE if unknown options are ignored.
     */
    getIgnoreUnknownOptions(): boolean
    /**
     * Returns a pointer to the main group of `context`.
     * @returns the main group of @context, or %NULL if  @context doesn't have a main group. Note that group belongs to  @context and should not be modified or freed.
     */
    getMainGroup(): OptionGroup
    /**
     * Returns whether strict POSIX code is enabled.
     *
     * See g_option_context_set_strict_posix() for more information.
     * @returns %TRUE if strict POSIX is enabled, %FALSE otherwise.
     */
    getStrictPosix(): boolean
    /**
     * Returns the summary. See g_option_context_set_summary().
     * @returns the summary
     */
    getSummary(): string
    /**
     * Parses the command line arguments, recognizing options
     * which have been added to `context`. A side-effect of
     * calling this function is that g_set_prgname() will be
     * called.
     *
     * If the parsing is successful, any parsed arguments are
     * removed from the array and `argc` and `argv` are updated
     * accordingly. A '--' option is stripped from `argv`
     * unless there are unparsed options before and after it,
     * or some of the options after it start with '-'. In case
     * of an error, `argc` and `argv` are left unmodified.
     *
     * If automatic `--help` support is enabled
     * (see g_option_context_set_help_enabled()), and the
     * `argv` array contains one of the recognized help options,
     * this function will produce help output to stdout and
     * call `exit (0)`.
     *
     * Note that function depends on the [current locale][setlocale] for
     * automatic character set conversion of string and filename
     * arguments.
     * @param argv a pointer to the array of command line arguments
     * @returns %TRUE if the parsing was successful,               %FALSE if an error occurred
     */
    parse(argv?: string[]): [/* returnType */ boolean, /* argv */ string[]]
    /**
     * Parses the command line arguments.
     *
     * This function is similar to g_option_context_parse() except that it
     * respects the normal memory rules when dealing with a strv instead of
     * assuming that the passed-in array is the argv of the main function.
     *
     * In particular, strings that are removed from the arguments list will
     * be freed using g_free().
     *
     * On Windows, the strings are expected to be in UTF-8.  This is in
     * contrast to g_option_context_parse() which expects them to be in the
     * system codepage, which is how they are passed as `argv` to main().
     * See g_win32_get_command_line() for a solution.
     *
     * This function is useful if you are trying to use #GOptionContext with
     * #GApplication.
     * @param arguments_ a pointer    to the command line arguments (which must be in UTF-8 on Windows).    Starting with GLib 2.62, `arguments` can be %NULL, which matches    g_option_context_parse().
     * @returns %TRUE if the parsing was successful,          %FALSE if an error occurred
     */
    parseStrv(
      arguments_?: string[]
    ): [/* returnType */ boolean, /* arguments_ */ string[]]
    /**
     * Adds a string to be displayed in `--help` output after the list
     * of options. This text often includes a bug reporting address.
     *
     * Note that the summary is translated (see
     * g_option_context_set_translate_func()).
     * @param description a string to be shown in `--help` output   after the list of options, or %NULL
     */
    setDescription(description: string | null): void
    /**
     * Enables or disables automatic generation of `--help` output.
     * By default, g_option_context_parse() recognizes `--help`, `-h`,
     * `-?`, `--help-all` and `--help-groupname` and creates suitable
     * output to stdout.
     * @param helpEnabled %TRUE to enable `--help`, %FALSE to disable it
     */
    setHelpEnabled(helpEnabled: boolean): void
    /**
     * Sets whether to ignore unknown options or not. If an argument is
     * ignored, it is left in the `argv` array after parsing. By default,
     * g_option_context_parse() treats unknown options as error.
     *
     * This setting does not affect non-option arguments (i.e. arguments
     * which don't start with a dash). But note that GOption cannot reliably
     * determine whether a non-option belongs to a preceding unknown option.
     * @param ignoreUnknown %TRUE to ignore unknown options, %FALSE to produce    an error when unknown options are met
     */
    setIgnoreUnknownOptions(ignoreUnknown: boolean): void
    /**
     * Sets a #GOptionGroup as main group of the `context`.
     * This has the same effect as calling g_option_context_add_group(),
     * the only difference is that the options in the main group are
     * treated differently when generating `--help` output.
     * @param group the group to set as main group
     */
    setMainGroup(group: OptionGroup): void
    /**
     * Sets strict POSIX mode.
     *
     * By default, this mode is disabled.
     *
     * In strict POSIX mode, the first non-argument parameter encountered
     * (eg: filename) terminates argument processing.  Remaining arguments
     * are treated as non-options and are not attempted to be parsed.
     *
     * If strict POSIX mode is disabled then parsing is done in the GNU way
     * where option arguments can be freely mixed with non-options.
     *
     * As an example, consider "ls foo -l".  With GNU style parsing, this
     * will list "foo" in long mode.  In strict POSIX style, this will list
     * the files named "foo" and "-l".
     *
     * It may be useful to force strict POSIX mode when creating "verb
     * style" command line tools.  For example, the "gsettings" command line
     * tool supports the global option "--schemadir" as well as many
     * subcommands ("get", "set", etc.) which each have their own set of
     * arguments.  Using strict POSIX mode will allow parsing the global
     * options up to the verb name while leaving the remaining options to be
     * parsed by the relevant subcommand (which can be determined by
     * examining the verb name, which should be present in argv[1] after
     * parsing).
     * @param strictPosix the new value
     */
    setStrictPosix(strictPosix: boolean): void
    /**
     * Adds a string to be displayed in `--help` output before the list
     * of options. This is typically a summary of the program functionality.
     *
     * Note that the summary is translated (see
     * g_option_context_set_translate_func() and
     * g_option_context_set_translation_domain()).
     * @param summary a string to be shown in `--help` output  before the list of options, or %NULL
     */
    setSummary(summary: string | null): void
    /**
     * Sets the function which is used to translate the contexts
     * user-visible strings, for `--help` output. If `func` is %NULL,
     * strings are not translated.
     *
     * Note that option groups have their own translation functions,
     * this function only affects the `parameter_string` (see g_option_context_new()),
     * the summary (see g_option_context_set_summary()) and the description
     * (see g_option_context_set_description()).
     *
     * If you are using gettext(), you only need to set the translation
     * domain, see g_option_context_set_translation_domain().
     * @param func the #GTranslateFunc, or %NULL
     */
    setTranslateFunc(func: TranslateFunc | null): void
    /**
     * A convenience function to use gettext() for translating
     * user-visible strings.
     * @param domain the domain to use
     */
    setTranslationDomain(domain: string): void
  }

  /**
   * A `GOptionContext` struct defines which options
   * are accepted by the commandline option parser. The struct has only private
   * fields and should not be directly accessed.
   * @record
   */
  class OptionContext {
    // Own properties of GLib-2.0.GLib.OptionContext

    static name: string
  }

  interface OptionEntry {
    // Own fields of GLib-2.0.GLib.OptionEntry

    /**
     * The long name of an option can be used to specify it
     *     in a commandline as `--long_name`. Every option must have a
     *     long name. To resolve conflicts if multiple option groups contain
     *     the same long name, it is also possible to specify the option as
     *     `--groupname-long_name`.
     * @field
     */
    longName: string
    /**
     * If an option has a short name, it can be specified
     *     `-short_name` in a commandline. `short_name` must be  a printable
     *     ASCII character different from '-', or zero if the option has no
     *     short name.
     * @field
     */
    shortName: number
    /**
     * Flags from #GOptionFlags
     * @field
     */
    flags: number
    /**
     * The type of the option, as a #GOptionArg
     * @field
     */
    arg: OptionArg
    /**
     * If the `arg` type is %G_OPTION_ARG_CALLBACK, then `arg_data`
     *     must point to a #GOptionArgFunc callback function, which will be
     *     called to handle the extra argument. Otherwise, `arg_data` is a
     *     pointer to a location to store the value, the required type of
     *     the location depends on the `arg` type:
     *      - %G_OPTION_ARG_NONE: %gboolean
     *      - %G_OPTION_ARG_STRING: %gchar*
     *      - %G_OPTION_ARG_INT: %gint
     *      - %G_OPTION_ARG_FILENAME: %gchar*
     *      - %G_OPTION_ARG_STRING_ARRAY: %gchar**
     *      - %G_OPTION_ARG_FILENAME_ARRAY: %gchar**
     *      - %G_OPTION_ARG_DOUBLE: %gdouble
     *     If `arg` type is %G_OPTION_ARG_STRING or %G_OPTION_ARG_FILENAME,
     *     the location will contain a newly allocated string if the option
     *     was given. That string needs to be freed by the callee using g_free().
     *     Likewise if `arg` type is %G_OPTION_ARG_STRING_ARRAY or
     *     %G_OPTION_ARG_FILENAME_ARRAY, the data should be freed using g_strfreev().
     * @field
     */
    argData: any
    /**
     * the description for the option in `--help`
     *     output. The `description` is translated using the `translate_func`
     *     of the group, see g_option_group_set_translation_domain().
     * @field
     */
    description: string
    /**
     * The placeholder to use for the extra argument parsed
     *     by the option in `--help` output. The `arg_description` is translated
     *     using the `translate_func` of the group, see
     *     g_option_group_set_translation_domain().
     * @field
     */
    argDescription: string
  }

  /**
   * A GOptionEntry struct defines a single option. To have an effect, they
   * must be added to a #GOptionGroup with g_option_context_add_main_entries()
   * or g_option_group_add_entries().
   * @record
   */
  class OptionEntry {
    // Own properties of GLib-2.0.GLib.OptionEntry

    static name: string
  }

  interface OptionGroup {
    // Owm methods of GLib-2.0.GLib.OptionGroup

    /**
     * Adds the options specified in `entries` to `group`.
     * @param entries a %NULL-terminated array of #GOptionEntrys
     */
    addEntries(entries: OptionEntry[]): void
    /**
     * Frees a #GOptionGroup. Note that you must not free groups
     * which have been added to a #GOptionContext.
     */
    free(): void
    /**
     * Increments the reference count of `group` by one.
     * @returns a #GOptionGroup
     */
    ref(): OptionGroup
    /**
     * Sets the function which is used to translate user-visible strings,
     * for `--help` output. Different groups can use different
     * #GTranslateFuncs. If `func` is %NULL, strings are not translated.
     *
     * If you are using gettext(), you only need to set the translation
     * domain, see g_option_group_set_translation_domain().
     * @param func the #GTranslateFunc, or %NULL
     */
    setTranslateFunc(func: TranslateFunc | null): void
    /**
     * A convenience function to use gettext() for translating
     * user-visible strings.
     * @param domain the domain to use
     */
    setTranslationDomain(domain: string): void
    /**
     * Decrements the reference count of `group` by one.
     * If the reference count drops to 0, the `group` will be freed.
     * and all memory allocated by the `group` is released.
     */
    unref(): void
  }

  /**
   * A `GOptionGroup` struct defines the options in a single
   * group. The struct has only private fields and should not be directly accessed.
   *
   * All options in a group share the same translation function. Libraries which
   * need to parse commandline options are expected to provide a function for
   * getting a `GOptionGroup` holding their options, which
   * the application can then add to its #GOptionContext.
   * @record
   */
  class OptionGroup {
    // Own properties of GLib-2.0.GLib.OptionGroup

    static name: string

    // Constructors of GLib-2.0.GLib.OptionGroup

    /**
     * Creates a new #GOptionGroup.
     *
     * `description` is typically used to provide a title for the group. If so, it
     * is recommended that it’s written in title case, and has a trailing colon so
     * that it matches the style of built-in GLib group titles such as
     * ‘Application Options:’.
     * @constructor
     * @param name the name for the option group, this is used to provide   help for the options in this group with `--help-``name`
     * @param description a description for this group to be shown in   `--help`. This string is translated using the translation   domain or translation function of the group
     * @param helpDescription a description for the `--help-``name` option.   This string is translated using the translation domain or translation function   of the group
     * @param userData user data that will be passed to the pre- and post-parse hooks,   the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL
     * @param destroy a function that will be called to free `user_data,` or %NULL
     * @returns a newly created option group. It should be added   to a #GOptionContext or freed with g_option_group_unref().
     */
    constructor(
      name: string,
      description: string,
      helpDescription: string,
      userData: any | null,
      destroy: DestroyNotify | null
    )
    /**
     * Creates a new #GOptionGroup.
     *
     * `description` is typically used to provide a title for the group. If so, it
     * is recommended that it’s written in title case, and has a trailing colon so
     * that it matches the style of built-in GLib group titles such as
     * ‘Application Options:’.
     * @constructor
     * @param name the name for the option group, this is used to provide   help for the options in this group with `--help-``name`
     * @param description a description for this group to be shown in   `--help`. This string is translated using the translation   domain or translation function of the group
     * @param helpDescription a description for the `--help-``name` option.   This string is translated using the translation domain or translation function   of the group
     * @param userData user data that will be passed to the pre- and post-parse hooks,   the error hook and to callbacks of %G_OPTION_ARG_CALLBACK options, or %NULL
     * @param destroy a function that will be called to free `user_data,` or %NULL
     * @returns a newly created option group. It should be added   to a #GOptionContext or freed with g_option_group_unref().
     */
    static new(
      name: string,
      description: string,
      helpDescription: string,
      userData: any | null,
      destroy: DestroyNotify | null
    ): OptionGroup
  }

  interface PathBuf {
    // Owm methods of GLib-2.0.GLib.PathBuf

    /**
     * Clears the contents of the path buffer.
     *
     * This function should be use to free the resources in a stack-allocated
     * `GPathBuf` initialized using g_path_buf_init() or
     * g_path_buf_init_from_path().
     */
    clear(): void
    /**
     * Clears the contents of the path buffer and returns the built path.
     *
     * This function returns `NULL` if the `GPathBuf` is empty.
     *
     * See also: g_path_buf_to_path()
     * @returns the built path
     */
    clearToPath(): string | null
    /**
     * Frees a `GPathBuf` allocated by g_path_buf_new().
     */
    free(): void
    /**
     * Frees a `GPathBuf` allocated by g_path_buf_new(), and
     * returns the path inside the buffer.
     *
     * This function returns `NULL` if the `GPathBuf` is empty.
     *
     * See also: g_path_buf_to_path()
     * @returns the path
     */
    freeToPath(): string | null
    /**
     * Initializes a `GPathBuf` instance.
     * @returns the initialized path builder
     */
    init(): PathBuf
    /**
     * Initializes a `GPathBuf` instance with the given path.
     * @param path a file system path
     * @returns the initialized path builder
     */
    initFromPath(path: string | null): PathBuf
    /**
     * Removes the last element of the path buffer.
     *
     * If there is only one element in the path buffer (for example, `/` on
     * Unix-like operating systems or the drive on Windows systems), it will
     * not be removed and %FALSE will be returned instead.
     *
     *
     * ```c
     * GPathBuf buf, cmp;
     *
     * g_path_buf_init_from_path (&buf, "/bin/sh");
     *
     * g_path_buf_pop (&buf);
     * g_path_buf_init_from_path (&cmp, "/bin");
     * g_assert_true (g_path_buf_equal (&buf, &cmp));
     * g_path_buf_clear (&cmp);
     *
     * g_path_buf_pop (&buf);
     * g_path_buf_init_from_path (&cmp, "/");
     * g_assert_true (g_path_buf_equal (&buf, &cmp));
     * g_path_buf_clear (&cmp);
     *
     * g_path_buf_clear (&buf);
     * ```
     *
     * @returns `TRUE` if the buffer was modified and `FALSE` otherwise
     */
    pop(): boolean
    /**
     * Extends the given path buffer with `path`.
     *
     * If `path` is absolute, it replaces the current path.
     *
     * If `path` contains a directory separator, the buffer is extended by
     * as many elements the path provides.
     *
     * On Windows, both forward slashes and backslashes are treated as
     * directory separators. On other platforms, %G_DIR_SEPARATOR_S is the
     * only directory separator.
     *
     *
     * ```c
     * GPathBuf buf, cmp;
     *
     * g_path_buf_init_from_path (&buf, "/tmp");
     * g_path_buf_push (&buf, ".X11-unix/X0");
     * g_path_buf_init_from_path (&cmp, "/tmp/.X11-unix/X0");
     * g_assert_true (g_path_buf_equal (&buf, &cmp));
     * g_path_buf_clear (&cmp);
     *
     * g_path_buf_push (&buf, "/etc/locale.conf");
     * g_path_buf_init_from_path (&cmp, "/etc/locale.conf");
     * g_assert_true (g_path_buf_equal (&buf, &cmp));
     * g_path_buf_clear (&cmp);
     *
     * g_path_buf_clear (&buf);
     * ```
     *
     * @param path a path
     * @returns the same pointer to @buf, for convenience
     */
    push(path: string): PathBuf
    /**
     * Adds an extension to the file name in the path buffer.
     *
     * If `extension` is `NULL`, the extension will be unset.
     *
     * If the path buffer does not have a file name set, this function returns
     * `FALSE` and leaves the path buffer unmodified.
     * @param extension the file extension
     * @returns `TRUE` if the extension was replaced, and `FALSE` otherwise
     */
    setExtension(extension: string | null): boolean
    /**
     * Sets the file name of the path.
     *
     * If the path buffer is empty, the filename is left unset and this
     * function returns `FALSE`.
     *
     * If the path buffer only contains the root element (on Unix-like operating
     * systems) or the drive (on Windows), this is the equivalent of pushing
     * the new `file_name`.
     *
     * If the path buffer contains a path, this is the equivalent of
     * popping the path buffer and pushing `file_name,` creating a
     * sibling of the original path.
     *
     *
     * ```c
     * GPathBuf buf, cmp;
     *
     * g_path_buf_init_from_path (&buf, "/");
     *
     * g_path_buf_set_filename (&buf, "bar");
     * g_path_buf_init_from_path (&cmp, "/bar");
     * g_assert_true (g_path_buf_equal (&buf, &cmp));
     * g_path_buf_clear (&cmp);
     *
     * g_path_buf_set_filename (&buf, "baz.txt");
     * g_path_buf_init_from_path (&cmp, "/baz.txt");
     * g_assert_true (g_path_buf_equal (&buf, &cmp);
     * g_path_buf_clear (&cmp);
     *
     * g_path_buf_clear (&buf);
     * ```
     *
     * @param fileName the file name in the path
     * @returns `TRUE` if the file name was replaced, and `FALSE` otherwise
     */
    setFilename(fileName: string): boolean
    /**
     * Retrieves the built path from the path buffer.
     *
     * On Windows, the result contains backslashes as directory separators,
     * even if forward slashes were used in input.
     *
     * If the path buffer is empty, this function returns `NULL`.
     * @returns the path
     */
    toPath(): string | null
  }

  /**
   * `GPathBuf` is a helper type that allows you to easily build paths from
   * individual elements, using the platform specific conventions for path
   * separators.
   *
   * ```c
   * g_auto (GPathBuf) path;
   *
   * g_path_buf_init (&path);
   *
   * g_path_buf_push (&path, "usr");
   * g_path_buf_push (&path, "bin");
   * g_path_buf_push (&path, "echo");
   *
   * g_autofree char *echo = g_path_buf_to_path (&path);
   * g_assert_cmpstr (echo, ==, "/usr/bin/echo");
   * ```
   *
   * You can also load a full path and then operate on its components:
   *
   * ```c
   * g_auto (GPathBuf) path;
   *
   * g_path_buf_init_from_path (&path, "/usr/bin/echo");
   *
   * g_path_buf_pop (&path);
   * g_path_buf_push (&path, "sh");
   *
   * g_autofree char *sh = g_path_buf_to_path (&path);
   * g_assert_cmpstr (sh, ==, "/usr/bin/sh");
   * ```
   * @record
   */
  class PathBuf {
    // Own properties of GLib-2.0.GLib.PathBuf

    static name: string

    // Constructors of GLib-2.0.GLib.PathBuf

    /**
     * Compares two path buffers for equality and returns `TRUE`
     * if they are equal.
     *
     * The path inside the paths buffers are not going to be normalized,
     * so `X/Y/Z/A/..`, `X/./Y/Z` and `X/Y/Z` are not going to be considered
     * equal.
     *
     * This function can be passed to g_hash_table_new() as the
     * `key_equal_func` parameter.
     * @param v1 a path buffer to compare
     * @param v2 a path buffer to compare
     * @returns `TRUE` if the two path buffers are equal,   and `FALSE` otherwise
     */
    static equal(v1: any, v2: any): boolean
  }

  interface PatternSpec {
    // Owm methods of GLib-2.0.GLib.PatternSpec

    /**
     * Copies `pspec` in a new #GPatternSpec.
     * @returns a copy of @pspec.
     */
    copy(): PatternSpec
    /**
     * Compares two compiled pattern specs and returns whether they will
     * match the same set of strings.
     * @param pspec2 another #GPatternSpec
     * @returns Whether the compiled patterns are equal
     */
    equal(pspec2: PatternSpec): boolean
    /**
     * Frees the memory allocated for the #GPatternSpec.
     */
    free(): void
    /**
     * Matches a string against a compiled pattern. Passing the correct
     * length of the string given is mandatory. The reversed string can be
     * omitted by passing %NULL, this is more efficient if the reversed
     * version of the string to be matched is not at hand, as
     * g_pattern_match() will only construct it if the compiled pattern
     * requires reverse matches.
     *
     * Note that, if the user code will (possibly) match a string against a
     * multitude of patterns containing wildcards, chances are high that
     * some patterns will require a reversed string. In this case, it's
     * more efficient to provide the reversed string to avoid multiple
     * constructions thereof in the various calls to g_pattern_match().
     *
     * Note also that the reverse of a UTF-8 encoded string can in general
     * not be obtained by g_strreverse(). This works only if the string
     * does not contain any multibyte characters. GLib offers the
     * g_utf8_strreverse() function to reverse UTF-8 encoded strings.
     * @param stringLength the length of `string` (in bytes, i.e. strlen(),     not g_utf8_strlen())
     * @param string the UTF-8 encoded string to match
     * @param stringReversed the reverse of `string` or %NULL
     * @returns %TRUE if @string matches @pspec
     */
    match(
      stringLength: number,
      string: string,
      stringReversed: string | null
    ): boolean
    /**
     * Matches a string against a compiled pattern. If the string is to be
     * matched against more than one pattern, consider using
     * g_pattern_match() instead while supplying the reversed string.
     * @param string the UTF-8 encoded string to match
     * @returns %TRUE if @string matches @pspec
     */
    matchString(string: string): boolean
  }

  /**
   * A `GPatternSpec` struct is the 'compiled' form of a glob-style pattern.
   *
   * The [func`GLib`.pattern_match_simple] and [method`GLib`.PatternSpec.match] functions
   * match a string against a pattern containing '*' and '?' wildcards with similar
   * semantics as the standard `glob()` function: '*' matches an arbitrary,
   * possibly empty, string, '?' matches an arbitrary character.
   *
   * Note that in contrast to `glob()`, the '/' character can be matched by
   * the wildcards, there are no '[...]' character ranges and '*' and '?'
   * can not be escaped to include them literally in a pattern.
   *
   * When multiple strings must be matched against the same pattern, it is better
   * to compile the pattern to a [struct`GLib`.PatternSpec] using
   * [ctor`GLib`.PatternSpec.new] and use [method`GLib`.PatternSpec.match_string]
   * instead of [func`GLib`.pattern_match_simple]. This avoids the overhead of repeated
   * pattern compilation.
   * @record
   */
  class PatternSpec {
    // Own properties of GLib-2.0.GLib.PatternSpec

    static name: string

    // Constructors of GLib-2.0.GLib.PatternSpec

    /**
     * Compiles a pattern to a #GPatternSpec.
     * @constructor
     * @param pattern a zero-terminated UTF-8 encoded string
     * @returns a newly-allocated #GPatternSpec
     */
    constructor(pattern: string)
    /**
     * Compiles a pattern to a #GPatternSpec.
     * @constructor
     * @param pattern a zero-terminated UTF-8 encoded string
     * @returns a newly-allocated #GPatternSpec
     */
    static new(pattern: string): PatternSpec
  }

  interface PollFD {
    // Own fields of GLib-2.0.GLib.PollFD

    /**
     * the file descriptor to poll (or a HANDLE on Win32)
     * @field
     */
    fd: number
    /**
     * a bitwise combination from #GIOCondition, specifying which
     *     events should be polled for. Typically for reading from a file
     *     descriptor you would use %G_IO_IN | %G_IO_HUP | %G_IO_ERR, and
     *     for writing you would use %G_IO_OUT | %G_IO_ERR.
     * @field
     */
    events: number
    /**
     * a bitwise combination of flags from #GIOCondition, returned
     *     from the poll() function to indicate which events occurred.
     * @field
     */
    revents: number
  }

  /**
   * Represents a file descriptor, which events to poll for, and which events
   * occurred.
   * @record
   */
  class PollFD {
    // Own properties of GLib-2.0.GLib.PollFD

    static name: string
  }

  interface Private {
    // Owm methods of GLib-2.0.GLib.Private

    /**
     * Returns the current value of the thread local variable `key`.
     *
     * If the value has not yet been set in this thread, %NULL is returned.
     * Values are never copied between threads (when a new thread is
     * created, for example).
     * @returns the thread-local value
     */
    get(): any | null
    /**
     * Sets the thread local variable `key` to have the value `value` in the
     * current thread.
     *
     * This function differs from g_private_set() in the following way: if
     * the previous value was non-%NULL then the #GDestroyNotify handler for
     * `key` is run on it.
     * @param value the new value
     */
    replace(value: any | null): void
    /**
     * Sets the thread local variable `key` to have the value `value` in the
     * current thread.
     *
     * This function differs from g_private_replace() in the following way:
     * the #GDestroyNotify for `key` is not called on the old value.
     * @param value the new value
     */
    set(value: any | null): void
  }

  /**
   * The #GPrivate struct is an opaque data structure to represent a
   * thread-local data key. It is approximately equivalent to the
   * pthread_setspecific()/pthread_getspecific() APIs on POSIX and to
   * TlsSetValue()/TlsGetValue() on Windows.
   *
   * If you don't already know why you might want this functionality,
   * then you probably don't need it.
   *
   * #GPrivate is a very limited resource (as far as 128 per program,
   * shared between all libraries). It is also not possible to destroy a
   * #GPrivate after it has been used. As such, it is only ever acceptable
   * to use #GPrivate in static scope, and even then sparingly so.
   *
   * See G_PRIVATE_INIT() for a couple of examples.
   *
   * The #GPrivate structure should be considered opaque.  It should only
   * be accessed via the g_private_ functions.
   * @record
   */
  class Private {
    // Own properties of GLib-2.0.GLib.Private

    static name: string
  }

  interface PtrArray {
    // Own fields of GLib-2.0.GLib.PtrArray

    /**
     * points to the array of pointers, which may be moved when the
     *     array grows
     * @field
     */
    pdata: any
    /**
     * number of pointers in the array
     * @field
     */
    len: number
  }

  /**
   * Contains the public fields of a pointer array.
   * @record
   */
  class PtrArray {
    // Own properties of GLib-2.0.GLib.PtrArray

    static name: string
  }

  interface Queue {
    // Own fields of GLib-2.0.GLib.Queue

    /**
     * a pointer to the first element of the queue
     * @field
     */
    head: any[]
    /**
     * a pointer to the last element of the queue
     * @field
     */
    tail: any[]
    /**
     * the number of elements in the queue
     * @field
     */
    length: number

    // Owm methods of GLib-2.0.GLib.Queue

    /**
     * Removes all the elements in `queue`. If queue elements contain
     * dynamically-allocated memory, they should be freed first.
     */
    clear(): void
    /**
     * Convenience method, which frees all the memory used by a #GQueue,
     * and calls the provided `free_func` on each item in the #GQueue.
     * @param freeFunc the function to be called to free memory allocated
     */
    clearFull(freeFunc: DestroyNotify | null): void
    /**
     * Calls `func` for each element in the queue passing `user_data` to the
     * function.
     *
     * It is safe for `func` to remove the element from `queue,` but it must
     * not modify any part of the queue after that element.
     * @param func the function to call for each element's data
     */
    foreach(func: Func): void
    /**
     * Frees the memory allocated for the #GQueue. Only call this function
     * if `queue` was created with g_queue_new(). If queue elements contain
     * dynamically-allocated memory, they should be freed first.
     *
     * If queue elements contain dynamically-allocated memory, you should
     * either use g_queue_free_full() or free them manually first.
     */
    free(): void
    /**
     * Convenience method, which frees all the memory used by a #GQueue,
     * and calls the specified destroy function on every element's data.
     *
     * `free_func` should not modify the queue (eg, by removing the freed
     * element from it).
     * @param freeFunc the function to be called to free each element's data
     */
    freeFull(freeFunc: DestroyNotify): void
    /**
     * Returns the number of items in `queue`.
     * @returns the number of items in @queue
     */
    getLength(): number
    /**
     * Returns the position of the first element in `queue` which contains `data`.
     * @param data the data to find
     * @returns the position of the first element in @queue which     contains @data, or -1 if no element in @queue contains @data
     */
    index(data: any | null): number
    /**
     * A statically-allocated #GQueue must be initialized with this function
     * before it can be used. Alternatively you can initialize it with
     * %G_QUEUE_INIT. It is not necessary to initialize queues created with
     * g_queue_new().
     */
    init(): void
    /**
     * Inserts `data` into `queue` using `func` to determine the new position.
     * @param data the data to insert
     * @param func the #GCompareDataFunc used to compare elements in the queue. It is     called with two elements of the `queue` and `user_data`. It should     return 0 if the elements are equal, a negative value if the first     element comes before the second, and a positive value if the second     element comes before the first.
     */
    insertSorted(data: any | null, func: CompareDataFunc): void
    /**
     * Returns %TRUE if the queue is empty.
     * @returns %TRUE if the queue is empty
     */
    isEmpty(): boolean
    /**
     * Returns the first element of the queue.
     * @returns the data of the first element in the queue, or %NULL     if the queue is empty
     */
    peekHead(): any | null
    /**
     * Returns the `n'`th element of `queue`.
     * @param n the position of the element
     * @returns the data for the @n'th element of @queue,     or %NULL if @n is off the end of @queue
     */
    peekNth(n: number): any | null
    /**
     * Returns the last element of the queue.
     * @returns the data of the last element in the queue, or %NULL     if the queue is empty
     */
    peekTail(): any | null
    /**
     * Removes the first element of the queue and returns its data.
     * @returns the data of the first element in the queue, or %NULL     if the queue is empty
     */
    popHead(): any | null
    /**
     * Removes the `n'`th element of `queue` and returns its data.
     * @param n the position of the element
     * @returns the element's data, or %NULL if @n is off the end of @queue
     */
    popNth(n: number): any | null
    /**
     * Removes the last element of the queue and returns its data.
     * @returns the data of the last element in the queue, or %NULL     if the queue is empty
     */
    popTail(): any | null
    /**
     * Adds a new element at the head of the queue.
     * @param data the data for the new element.
     */
    pushHead(data: any | null): void
    /**
     * Inserts a new element into `queue` at the given position.
     * @param data the data for the new element
     * @param n the position to insert the new element. If `n` is negative or     larger than the number of elements in the `queue,` the element is     added to the end of the queue.
     */
    pushNth(data: any | null, n: number): void
    /**
     * Adds a new element at the tail of the queue.
     * @param data the data for the new element
     */
    pushTail(data: any | null): void
    /**
     * Removes the first element in `queue` that contains `data`.
     * @param data the data to remove
     * @returns %TRUE if @data was found and removed from @queue
     */
    remove(data: any | null): boolean
    /**
     * Remove all elements whose data equals `data` from `queue`.
     * @param data the data to remove
     * @returns the number of elements removed from @queue
     */
    removeAll(data: any | null): number
    /**
     * Reverses the order of the items in `queue`.
     */
    reverse(): void
    /**
     * Sorts `queue` using `compare_func`.
     * @param compareFunc the #GCompareDataFunc used to sort `queue`. This function     is passed two elements of the queue and should return 0 if they are     equal, a negative value if the first comes before the second, and     a positive value if the second comes before the first.
     */
    sort(compareFunc: CompareDataFunc): void
  }

  /**
   * Contains the public fields of a
   * [Queue][glib-Double-ended-Queues].
   * @record
   */
  class Queue {
    // Own properties of GLib-2.0.GLib.Queue

    static name: string
  }

  interface RWLock {
    // Owm methods of GLib-2.0.GLib.RWLock

    /**
     * Frees the resources allocated to a lock with g_rw_lock_init().
     *
     * This function should not be used with a #GRWLock that has been
     * statically allocated.
     *
     * Calling g_rw_lock_clear() when any thread holds the lock
     * leads to undefined behaviour.
     */
    clear(): void
    /**
     * Initializes a #GRWLock so that it can be used.
     *
     * This function is useful to initialize a lock that has been
     * allocated on the stack, or as part of a larger structure.  It is not
     * necessary to initialise a reader-writer lock that has been statically
     * allocated.
     *
     *
     * ```c
     *   typedef struct {
     *     GRWLock l;
     *     ...
     *   } Blob;
     *
     * Blob *b;
     *
     * b = g_new (Blob, 1);
     * g_rw_lock_init (&b->l);
     * ```
     *
     *
     * To undo the effect of g_rw_lock_init() when a lock is no longer
     * needed, use g_rw_lock_clear().
     *
     * Calling g_rw_lock_init() on an already initialized #GRWLock leads
     * to undefined behaviour.
     */
    init(): void
    /**
     * Obtain a read lock on `rw_lock`. If another thread currently holds
     * the write lock on `rw_lock,` the current thread will block until the
     * write lock was (held and) released. If another thread does not hold
     * the write lock, but is waiting for it, it is implementation defined
     * whether the reader or writer will block. Read locks can be taken
     * recursively.
     *
     * Calling g_rw_lock_reader_lock() while the current thread already
     * owns a write lock leads to undefined behaviour. Read locks however
     * can be taken recursively, in which case you need to make sure to
     * call g_rw_lock_reader_unlock() the same amount of times.
     *
     * It is implementation-defined how many read locks are allowed to be
     * held on the same lock simultaneously. If the limit is hit,
     * or if a deadlock is detected, a critical warning will be emitted.
     */
    readerLock(): void
    /**
     * Tries to obtain a read lock on `rw_lock` and returns %TRUE if
     * the read lock was successfully obtained. Otherwise it
     * returns %FALSE.
     * @returns %TRUE if @rw_lock could be locked
     */
    readerTrylock(): boolean
    /**
     * Release a read lock on `rw_lock`.
     *
     * Calling g_rw_lock_reader_unlock() on a lock that is not held
     * by the current thread leads to undefined behaviour.
     */
    readerUnlock(): void
    /**
     * Obtain a write lock on `rw_lock`. If another thread currently holds
     * a read or write lock on `rw_lock,` the current thread will block
     * until all other threads have dropped their locks on `rw_lock`.
     *
     * Calling g_rw_lock_writer_lock() while the current thread already
     * owns a read or write lock on `rw_lock` leads to undefined behaviour.
     */
    writerLock(): void
    /**
     * Tries to obtain a write lock on `rw_lock`. If another thread
     * currently holds a read or write lock on `rw_lock,` it immediately
     * returns %FALSE.
     * Otherwise it locks `rw_lock` and returns %TRUE.
     * @returns %TRUE if @rw_lock could be locked
     */
    writerTrylock(): boolean
    /**
     * Release a write lock on `rw_lock`.
     *
     * Calling g_rw_lock_writer_unlock() on a lock that is not held
     * by the current thread leads to undefined behaviour.
     */
    writerUnlock(): void
  }

  /**
   * The GRWLock struct is an opaque data structure to represent a
   * reader-writer lock. It is similar to a #GMutex in that it allows
   * multiple threads to coordinate access to a shared resource.
   *
   * The difference to a mutex is that a reader-writer lock discriminates
   * between read-only ('reader') and full ('writer') access. While only
   * one thread at a time is allowed write access (by holding the 'writer'
   * lock via g_rw_lock_writer_lock()), multiple threads can gain
   * simultaneous read-only access (by holding the 'reader' lock via
   * g_rw_lock_reader_lock()).
   *
   * It is unspecified whether readers or writers have priority in acquiring the
   * lock when a reader already holds the lock and a writer is queued to acquire
   * it.
   *
   * Here is an example for an array with access functions:
   *
   * ```c
   *   GRWLock lock;
   *   GPtrArray *array;
   *
   *   gpointer
   *   my_array_get (guint index)
   *   {
   *     gpointer retval = NULL;
   *
   *     if (!array)
   *       return NULL;
   *
   *     g_rw_lock_reader_lock (&lock);
   *     if (index < array->len)
   *       retval = g_ptr_array_index (array, index);
   *     g_rw_lock_reader_unlock (&lock);
   *
   *     return retval;
   *   }
   *
   *   void
   *   my_array_set (guint index, gpointer data)
   *   {
   *     g_rw_lock_writer_lock (&lock);
   *
   *     if (!array)
   *       array = g_ptr_array_new ();
   *
   *     if (index >= array->len)
   *       g_ptr_array_set_size (array, index+1);
   *     g_ptr_array_index (array, index) = data;
   *
   *     g_rw_lock_writer_unlock (&lock);
   *   }
   *  ```
   *
   * This example shows an array which can be accessed by many readers
   * (the my_array_get() function) simultaneously, whereas the writers
   * (the my_array_set() function) will only be allowed one at a time
   * and only if no readers currently access the array. This is because
   * of the potentially dangerous resizing of the array. Using these
   * functions is fully multi-thread safe now.
   *
   * If a #GRWLock is allocated in static storage then it can be used
   * without initialisation.  Otherwise, you should call
   * g_rw_lock_init() on it and g_rw_lock_clear() when done.
   *
   * A GRWLock should only be accessed with the g_rw_lock_ functions.
   * @record
   */
  class RWLock {
    // Own properties of GLib-2.0.GLib.RWLock

    static name: string
  }

  interface Rand {
    // Owm methods of GLib-2.0.GLib.Rand

    /**
     * Copies a #GRand into a new one with the same exact state as before.
     * This way you can take a snapshot of the random number generator for
     * replaying later.
     * @returns the new #GRand
     */
    copy(): Rand
    /**
     * Returns the next random #gdouble from `rand_` equally distributed over
     * the range [0..1).
     * @returns a random number
     */
    double(): number
    /**
     * Returns the next random #gdouble from `rand_` equally distributed over
     * the range [`begin`..`end)`.
     * @param begin lower closed bound of the interval
     * @param end upper open bound of the interval
     * @returns a random number
     */
    doubleRange(begin: number, end: number): number
    /**
     * Frees the memory allocated for the #GRand.
     */
    free(): void
    /**
     * Returns the next random #guint32 from `rand_` equally distributed over
     * the range [0..2^32-1].
     * @returns a random number
     */
    int(): number
    /**
     * Returns the next random #gint32 from `rand_` equally distributed over
     * the range [`begin`..`end-1`].
     * @param begin lower closed bound of the interval
     * @param end upper open bound of the interval
     * @returns a random number
     */
    intRange(begin: number, end: number): number
    /**
     * Sets the seed for the random number generator #GRand to `seed`.
     * @param seed a value to reinitialize the random number generator
     */
    setSeed(seed: number): void
    /**
     * Initializes the random number generator by an array of longs.
     * Array can be of arbitrary size, though only the first 624 values
     * are taken.  This function is useful if you have many low entropy
     * seeds, or if you require more then 32 bits of actual entropy for
     * your application.
     * @param seed array to initialize with
     * @param seedLength length of array
     */
    setSeedArray(seed: number, seedLength: number): void
  }

  /**
   * The GRand struct is an opaque data structure. It should only be
   * accessed through the g_rand_* functions.
   * @record
   */
  class Rand {
    // Own properties of GLib-2.0.GLib.Rand

    static name: string

    // Constructors of GLib-2.0.GLib.Rand

    /**
     * Creates a new random number generator initialized with a seed taken
     * either from `/dev/urandom` (if existing) or from the current time
     * (as a fallback).
     *
     * On Windows, the seed is taken from rand_s().
     * @constructor
     * @returns the new #GRand
     */
    constructor()
    /**
     * Creates a new random number generator initialized with a seed taken
     * either from `/dev/urandom` (if existing) or from the current time
     * (as a fallback).
     *
     * On Windows, the seed is taken from rand_s().
     * @constructor
     * @returns the new #GRand
     */
    static new(): Rand
    /**
     * Creates a new random number generator initialized with `seed`.
     * @constructor
     * @param seed a value to initialize the random number generator
     * @returns the new #GRand
     */
    static newWithSeed(seed: number): Rand
    /**
     * Creates a new random number generator initialized with `seed`.
     * @constructor
     * @param seed an array of seeds to initialize the random number generator
     * @param seedLength an array of seeds to initialize the random number     generator
     * @returns the new #GRand
     */
    static newWithSeedArray(seed: number, seedLength: number): Rand
  }

  interface RecMutex {
    // Owm methods of GLib-2.0.GLib.RecMutex

    /**
     * Frees the resources allocated to a recursive mutex with
     * g_rec_mutex_init().
     *
     * This function should not be used with a #GRecMutex that has been
     * statically allocated.
     *
     * Calling g_rec_mutex_clear() on a locked recursive mutex leads
     * to undefined behaviour.
     */
    clear(): void
    /**
     * Initializes a #GRecMutex so that it can be used.
     *
     * This function is useful to initialize a recursive mutex
     * that has been allocated on the stack, or as part of a larger
     * structure.
     *
     * It is not necessary to initialise a recursive mutex that has been
     * statically allocated.
     *
     *
     * ```c
     *   typedef struct {
     *     GRecMutex m;
     *     ...
     *   } Blob;
     *
     * Blob *b;
     *
     * b = g_new (Blob, 1);
     * g_rec_mutex_init (&b->m);
     * ```
     *
     *
     * Calling g_rec_mutex_init() on an already initialized #GRecMutex
     * leads to undefined behaviour.
     *
     * To undo the effect of g_rec_mutex_init() when a recursive mutex
     * is no longer needed, use g_rec_mutex_clear().
     */
    init(): void
    /**
     * Locks `rec_mutex`. If `rec_mutex` is already locked by another
     * thread, the current thread will block until `rec_mutex` is
     * unlocked by the other thread. If `rec_mutex` is already locked
     * by the current thread, the 'lock count' of `rec_mutex` is increased.
     * The mutex will only become available again when it is unlocked
     * as many times as it has been locked.
     */
    lock(): void
    /**
     * Tries to lock `rec_mutex`. If `rec_mutex` is already locked
     * by another thread, it immediately returns %FALSE. Otherwise
     * it locks `rec_mutex` and returns %TRUE.
     * @returns %TRUE if @rec_mutex could be locked
     */
    trylock(): boolean
    /**
     * Unlocks `rec_mutex`. If another thread is blocked in a
     * g_rec_mutex_lock() call for `rec_mutex,` it will become unblocked
     * and can lock `rec_mutex` itself.
     *
     * Calling g_rec_mutex_unlock() on a recursive mutex that is not
     * locked by the current thread leads to undefined behaviour.
     */
    unlock(): void
  }

  /**
   * The GRecMutex struct is an opaque data structure to represent a
   * recursive mutex. It is similar to a #GMutex with the difference
   * that it is possible to lock a GRecMutex multiple times in the same
   * thread without deadlock. When doing so, care has to be taken to
   * unlock the recursive mutex as often as it has been locked.
   *
   * If a #GRecMutex is allocated in static storage then it can be used
   * without initialisation.  Otherwise, you should call
   * g_rec_mutex_init() on it and g_rec_mutex_clear() when done.
   *
   * A GRecMutex should only be accessed with the
   * g_rec_mutex_ functions.
   * @record
   */
  class RecMutex {
    // Own properties of GLib-2.0.GLib.RecMutex

    static name: string
  }

  interface Regex {
    // Owm methods of GLib-2.0.GLib.Regex

    /**
     * Returns the number of capturing subpatterns in the pattern.
     * @returns the number of capturing subpatterns
     */
    getCaptureCount(): number
    /**
     * Returns the compile options that `regex` was created with.
     *
     * Depending on the version of PCRE that is used, this may or may not
     * include flags set by option expressions such as `(?i)` found at the
     * top-level within the compiled pattern.
     * @returns flags from #GRegexCompileFlags
     */
    getCompileFlags(): RegexCompileFlags
    /**
     * Checks whether the pattern contains explicit CR or LF references.
     * @returns %TRUE if the pattern contains explicit CR or LF references
     */
    getHasCrOrLf(): boolean
    /**
     * Returns the match options that `regex` was created with.
     * @returns flags from #GRegexMatchFlags
     */
    getMatchFlags(): RegexMatchFlags
    /**
     * Returns the number of the highest back reference
     * in the pattern, or 0 if the pattern does not contain
     * back references.
     * @returns the number of the highest back reference
     */
    getMaxBackref(): number
    /**
     * Gets the number of characters in the longest lookbehind assertion in the
     * pattern. This information is useful when doing multi-segment matching using
     * the partial matching facilities.
     * @returns the number of characters in the longest lookbehind assertion.
     */
    getMaxLookbehind(): number
    /**
     * Gets the pattern string associated with `regex,` i.e. a copy of
     * the string passed to g_regex_new().
     * @returns the pattern of @regex
     */
    getPattern(): string
    /**
     * Retrieves the number of the subexpression named `name`.
     * @param name name of the subexpression
     * @returns The number of the subexpression or -1 if @name   does not exists
     */
    getStringNumber(name: string): number
    /**
     * Scans for a match in `string` for the pattern in `regex`.
     * The `match_options` are combined with the match options specified
     * when the `regex` structure was created, letting you have more
     * flexibility in reusing #GRegex structures.
     *
     * Unless %G_REGEX_RAW is specified in the options, `string` must be valid UTF-8.
     *
     * A #GMatchInfo structure, used to get information on the match,
     * is stored in `match_info` if not %NULL. Note that if `match_info`
     * is not %NULL then it is created even if the function returns %FALSE,
     * i.e. you must free it regardless if regular expression actually matched.
     *
     * To retrieve all the non-overlapping matches of the pattern in
     * string you can use g_match_info_next().
     *
     *
     * ```c
     * static void
     * print_uppercase_words (const gchar *string)
     * {
     *   // Print all uppercase-only words.
     *   GRegex *regex;
     *   GMatchInfo *match_info;
     *
     *   regex = g_regex_new ("[A-Z]+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL);
     *   g_regex_match (regex, string, 0, &match_info);
     *   while (g_match_info_matches (match_info))
     *     {
     *       gchar *word = g_match_info_fetch (match_info, 0);
     *       g_print ("Found: %s\n", word);
     *       g_free (word);
     *       g_match_info_next (match_info, NULL);
     *     }
     *   g_match_info_free (match_info);
     *   g_regex_unref (regex);
     * }
     * ```
     *
     *
     * `string` is not copied and is used in #GMatchInfo internally. If
     * you use any #GMatchInfo method (except g_match_info_free()) after
     * freeing or modifying `string` then the behaviour is undefined.
     * @param string the string to scan for matches
     * @param matchOptions match options
     * @returns %TRUE is the string matched, %FALSE otherwise
     */
    match(
      string: string,
      matchOptions: RegexMatchFlags
    ): [/* returnType */ boolean, /* matchInfo */ MatchInfo]
    /**
     * Using the standard algorithm for regular expression matching only
     * the longest match in the string is retrieved. This function uses
     * a different algorithm so it can retrieve all the possible matches.
     * For more documentation see g_regex_match_all_full().
     *
     * A #GMatchInfo structure, used to get information on the match, is
     * stored in `match_info` if not %NULL. Note that if `match_info` is
     * not %NULL then it is created even if the function returns %FALSE,
     * i.e. you must free it regardless if regular expression actually
     * matched.
     *
     * `string` is not copied and is used in #GMatchInfo internally. If
     * you use any #GMatchInfo method (except g_match_info_free()) after
     * freeing or modifying `string` then the behaviour is undefined.
     * @param string the string to scan for matches
     * @param matchOptions match options
     * @returns %TRUE is the string matched, %FALSE otherwise
     */
    matchAll(
      string: string,
      matchOptions: RegexMatchFlags
    ): [/* returnType */ boolean, /* matchInfo */ MatchInfo]
    /**
     * Using the standard algorithm for regular expression matching only
     * the longest match in the `string` is retrieved, it is not possible
     * to obtain all the available matches. For instance matching
     * "<a> <b> <c>" against the pattern "<.*>"
     * you get "<a> <b> <c>".
     *
     * This function uses a different algorithm (called DFA, i.e. deterministic
     * finite automaton), so it can retrieve all the possible matches, all
     * starting at the same point in the string. For instance matching
     * "<a> <b> <c>" against the pattern "<.*>;"
     * you would obtain three matches: "<a> <b> <c>",
     * "<a> <b>" and "<a>".
     *
     * The number of matched strings is retrieved using
     * g_match_info_get_match_count(). To obtain the matched strings and
     * their position you can use, respectively, g_match_info_fetch() and
     * g_match_info_fetch_pos(). Note that the strings are returned in
     * reverse order of length; that is, the longest matching string is
     * given first.
     *
     * Note that the DFA algorithm is slower than the standard one and it
     * is not able to capture substrings, so backreferences do not work.
     *
     * Setting `start_position` differs from just passing over a shortened
     * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern
     * that begins with any kind of lookbehind assertion, such as "\b".
     *
     * Unless %G_REGEX_RAW is specified in the options, `string` must be valid UTF-8.
     *
     * A #GMatchInfo structure, used to get information on the match, is
     * stored in `match_info` if not %NULL. Note that if `match_info` is
     * not %NULL then it is created even if the function returns %FALSE,
     * i.e. you must free it regardless if regular expression actually
     * matched.
     *
     * `string` is not copied and is used in #GMatchInfo internally. If
     * you use any #GMatchInfo method (except g_match_info_free()) after
     * freeing or modifying `string` then the behaviour is undefined.
     * @param string the string to scan for matches
     * @param startPosition starting index of the string to match, in bytes
     * @param matchOptions match options
     * @returns %TRUE is the string matched, %FALSE otherwise
     */
    matchAllFull(
      string: string[],
      startPosition: number,
      matchOptions: RegexMatchFlags
    ): [/* returnType */ boolean, /* matchInfo */ MatchInfo]
    /**
     * Scans for a match in `string` for the pattern in `regex`.
     * The `match_options` are combined with the match options specified
     * when the `regex` structure was created, letting you have more
     * flexibility in reusing #GRegex structures.
     *
     * Setting `start_position` differs from just passing over a shortened
     * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern
     * that begins with any kind of lookbehind assertion, such as "\b".
     *
     * Unless %G_REGEX_RAW is specified in the options, `string` must be valid UTF-8.
     *
     * A #GMatchInfo structure, used to get information on the match, is
     * stored in `match_info` if not %NULL. Note that if `match_info` is
     * not %NULL then it is created even if the function returns %FALSE,
     * i.e. you must free it regardless if regular expression actually
     * matched.
     *
     * `string` is not copied and is used in #GMatchInfo internally. If
     * you use any #GMatchInfo method (except g_match_info_free()) after
     * freeing or modifying `string` then the behaviour is undefined.
     *
     * To retrieve all the non-overlapping matches of the pattern in
     * string you can use g_match_info_next().
     *
     *
     * ```c
     * static void
     * print_uppercase_words (const gchar *string)
     * {
     *   // Print all uppercase-only words.
     *   GRegex *regex;
     *   GMatchInfo *match_info;
     *   GError *error = NULL;
     *
     *   regex = g_regex_new ("[A-Z]+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL);
     *   g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error);
     *   while (g_match_info_matches (match_info))
     *     {
     *       gchar *word = g_match_info_fetch (match_info, 0);
     *       g_print ("Found: %s\n", word);
     *       g_free (word);
     *       g_match_info_next (match_info, &error);
     *     }
     *   g_match_info_free (match_info);
     *   g_regex_unref (regex);
     *   if (error != NULL)
     *     {
     *       g_printerr ("Error while matching: %s\n", error->message);
     *       g_error_free (error);
     *     }
     * }
     * ```
     *
     * @param string the string to scan for matches
     * @param startPosition starting index of the string to match, in bytes
     * @param matchOptions match options
     * @returns %TRUE is the string matched, %FALSE otherwise
     */
    matchFull(
      string: string[],
      startPosition: number,
      matchOptions: RegexMatchFlags
    ): [/* returnType */ boolean, /* matchInfo */ MatchInfo]
    /**
     * Increases reference count of `regex` by 1.
     * @returns @regex
     */
    ref(): Regex
    /**
     * Replaces all occurrences of the pattern in `regex` with the
     * replacement text. Backreferences of the form '\number' or
     * '\g<number>' in the replacement text are interpolated by the
     * number-th captured subexpression of the match, '\g<name>' refers
     * to the captured subexpression with the given name. '\0' refers
     * to the complete match, but '\0' followed by a number is the octal
     * representation of a character. To include a literal '\' in the
     * replacement, write '\\\\'.
     *
     * There are also escapes that changes the case of the following text:
     *
     * - \l: Convert to lower case the next character
     * - \u: Convert to upper case the next character
     * - \L: Convert to lower case till \E
     * - \U: Convert to upper case till \E
     * - \E: End case modification
     *
     * If you do not need to use backreferences use g_regex_replace_literal().
     *
     * The `replacement` string must be UTF-8 encoded even if %G_REGEX_RAW was
     * passed to g_regex_new(). If you want to use not UTF-8 encoded strings
     * you can use g_regex_replace_literal().
     *
     * Setting `start_position` differs from just passing over a shortened
     * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that
     * begins with any kind of lookbehind assertion, such as "\b".
     * @param string the string to perform matches against
     * @param startPosition starting index of the string to match, in bytes
     * @param replacement text to replace each match with
     * @param matchOptions options for the match
     * @returns a newly allocated string containing the replacements
     */
    replace(
      string: string[],
      startPosition: number,
      replacement: string,
      matchOptions: RegexMatchFlags
    ): string | null
    /**
     * Replaces occurrences of the pattern in regex with the output of
     * `eval` for that occurrence.
     *
     * Setting `start_position` differs from just passing over a shortened
     * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern
     * that begins with any kind of lookbehind assertion, such as "\b".
     *
     * The following example uses g_regex_replace_eval() to replace multiple
     * strings at once:
     *
     * ```c
     * static gboolean
     * eval_cb (const GMatchInfo *info,
     *          GString          *res,
     *          gpointer          data)
     * {
     *   gchar *match;
     *   gchar *r;
     *
     *    match = g_match_info_fetch (info, 0);
     *    r = g_hash_table_lookup ((GHashTable *)data, match);
     *    g_string_append (res, r);
     *    g_free (match);
     *
     *    return FALSE;
     * }
     *
     * ...
     *
     * GRegex *reg;
     * GHashTable *h;
     * gchar *res;
     *
     * h = g_hash_table_new (g_str_hash, g_str_equal);
     *
     * g_hash_table_insert (h, "1", "ONE");
     * g_hash_table_insert (h, "2", "TWO");
     * g_hash_table_insert (h, "3", "THREE");
     * g_hash_table_insert (h, "4", "FOUR");
     *
     * reg = g_regex_new ("1|2|3|4", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL);
     * res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL);
     * g_hash_table_destroy (h);
     *
     * ...
     * ```
     *
     * @param string string to perform matches against
     * @param startPosition starting index of the string to match, in bytes
     * @param matchOptions options for the match
     * @param eval_ a function to call for each match
     * @returns a newly allocated string containing the replacements
     */
    replaceEval(
      string: string[],
      startPosition: number,
      matchOptions: RegexMatchFlags,
      eval_: RegexEvalCallback
    ): string | null
    /**
     * Replaces all occurrences of the pattern in `regex` with the
     * replacement text. `replacement` is replaced literally, to
     * include backreferences use g_regex_replace().
     *
     * Setting `start_position` differs from just passing over a
     * shortened string and setting %G_REGEX_MATCH_NOTBOL in the
     * case of a pattern that begins with any kind of lookbehind
     * assertion, such as "\b".
     * @param string the string to perform matches against
     * @param startPosition starting index of the string to match, in bytes
     * @param replacement text to replace each match with
     * @param matchOptions options for the match
     * @returns a newly allocated string containing the replacements
     */
    replaceLiteral(
      string: string[],
      startPosition: number,
      replacement: string,
      matchOptions: RegexMatchFlags
    ): string | null
    /**
     * Breaks the string on the pattern, and returns an array of the tokens.
     * If the pattern contains capturing parentheses, then the text for each
     * of the substrings will also be returned. If the pattern does not match
     * anywhere in the string, then the whole string is returned as the first
     * token.
     *
     * As a special case, the result of splitting the empty string "" is an
     * empty vector, not a vector containing a single string. The reason for
     * this special case is that being able to represent an empty vector is
     * typically more useful than consistent handling of empty elements. If
     * you do need to represent empty elements, you'll need to check for the
     * empty string before calling this function.
     *
     * A pattern that can match empty strings splits `string` into separate
     * characters wherever it matches the empty string between characters.
     * For example splitting "ab c" using as a separator "\s*", you will get
     * "a", "b" and "c".
     * @param string the string to split with the pattern
     * @param matchOptions match time option flags
     * @returns a %NULL-terminated gchar ** array. Free it using g_strfreev()
     */
    split(string: string, matchOptions: RegexMatchFlags): string[]
    /**
     * Breaks the string on the pattern, and returns an array of the tokens.
     * If the pattern contains capturing parentheses, then the text for each
     * of the substrings will also be returned. If the pattern does not match
     * anywhere in the string, then the whole string is returned as the first
     * token.
     *
     * As a special case, the result of splitting the empty string "" is an
     * empty vector, not a vector containing a single string. The reason for
     * this special case is that being able to represent an empty vector is
     * typically more useful than consistent handling of empty elements. If
     * you do need to represent empty elements, you'll need to check for the
     * empty string before calling this function.
     *
     * A pattern that can match empty strings splits `string` into separate
     * characters wherever it matches the empty string between characters.
     * For example splitting "ab c" using as a separator "\s*", you will get
     * "a", "b" and "c".
     *
     * Setting `start_position` differs from just passing over a shortened
     * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern
     * that begins with any kind of lookbehind assertion, such as "\b".
     * @param string the string to split with the pattern
     * @param startPosition starting index of the string to match, in bytes
     * @param matchOptions match time option flags
     * @param maxTokens the maximum number of tokens to split `string` into.   If this is less than 1, the string is split completely
     * @returns a %NULL-terminated gchar ** array. Free it using g_strfreev()
     */
    splitFull(
      string: string[],
      startPosition: number,
      matchOptions: RegexMatchFlags,
      maxTokens: number
    ): string[]
    /**
     * Decreases reference count of `regex` by 1. When reference count drops
     * to zero, it frees all the memory associated with the regex structure.
     */
    unref(): void
  }

  /**
   * A `GRegex` is the "compiled" form of a regular expression pattern.
   *
   * `GRegex` implements regular expression pattern matching using syntax and
   * semantics similar to Perl regular expression. See the
   * [PCRE documentation](man:pcrepattern(3)) for the syntax definition.
   *
   * Some functions accept a `start_position` argument, setting it differs
   * from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL
   * in the case of a pattern that begins with any kind of lookbehind assertion.
   * For example, consider the pattern "\Biss\B" which finds occurrences of "iss"
   * in the middle of words. ("\B" matches only if the current position in the
   * subject is not a word boundary.) When applied to the string "Mississipi"
   * from the fourth byte, namely "issipi", it does not match, because "\B" is
   * always false at the start of the subject, which is deemed to be a word
   * boundary. However, if the entire string is passed , but with
   * `start_position` set to 4, it finds the second occurrence of "iss" because
   * it is able to look behind the starting point to discover that it is
   * preceded by a letter.
   *
   * Note that, unless you set the %G_REGEX_RAW flag, all the strings passed
   * to these functions must be encoded in UTF-8. The lengths and the positions
   * inside the strings are in bytes and not in characters, so, for instance,
   * "\xc3\xa0" (i.e. "à") is two bytes long but it is treated as a
   * single character. If you set %G_REGEX_RAW the strings can be non-valid
   * UTF-8 strings and a byte is treated as a character, so "\xc3\xa0" is two
   * bytes and two characters long.
   *
   * When matching a pattern, "\n" matches only against a "\n" character in
   * the string, and "\r" matches only a "\r" character. To match any newline
   * sequence use "\R". This particular group matches either the two-character
   * sequence CR + LF ("\r\n"), or one of the single characters LF (linefeed,
   * U+000A, "\n"), VT vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"),
   * CR (carriage return, U+000D, "\r"), NEL (next line, U+0085), LS (line
   * separator, U+2028), or PS (paragraph separator, U+2029).
   *
   * The behaviour of the dot, circumflex, and dollar metacharacters are
   * affected by newline characters, the default is to recognize any newline
   * character (the same characters recognized by "\R"). This can be changed
   * with `G_REGEX_NEWLINE_CR`, `G_REGEX_NEWLINE_LF` and `G_REGEX_NEWLINE_CRLF`
   * compile options, and with `G_REGEX_MATCH_NEWLINE_ANY`,
   * `G_REGEX_MATCH_NEWLINE_CR`, `G_REGEX_MATCH_NEWLINE_LF` and
   * `G_REGEX_MATCH_NEWLINE_CRLF` match options. These settings are also
   * relevant when compiling a pattern if `G_REGEX_EXTENDED` is set, and an
   * unescaped "#" outside a character class is encountered. This indicates
   * a comment that lasts until after the next newline.
   *
   * Creating and manipulating the same `GRegex` structure from different
   * threads is not a problem as `GRegex` does not modify its internal
   * state between creation and destruction, on the other hand `GMatchInfo`
   * is not threadsafe.
   *
   * The regular expressions low-level functionalities are obtained through
   * the excellent [PCRE](http://www.pcre.org/) library written by Philip Hazel.
   * @record
   */
  class Regex {
    // Own properties of GLib-2.0.GLib.Regex

    static name: string

    // Constructors of GLib-2.0.GLib.Regex

    /**
     * Compiles the regular expression to an internal form, and does
     * the initial setup of the #GRegex structure.
     * @constructor
     * @param pattern the regular expression
     * @param compileOptions compile options for the regular expression, or 0
     * @param matchOptions match options for the regular expression, or 0
     * @returns a #GRegex structure or %NULL if an error occurred. Call   g_regex_unref() when you are done with it
     */
    constructor(
      pattern: string,
      compileOptions: RegexCompileFlags,
      matchOptions: RegexMatchFlags
    )
    /**
     * Compiles the regular expression to an internal form, and does
     * the initial setup of the #GRegex structure.
     * @constructor
     * @param pattern the regular expression
     * @param compileOptions compile options for the regular expression, or 0
     * @param matchOptions match options for the regular expression, or 0
     * @returns a #GRegex structure or %NULL if an error occurred. Call   g_regex_unref() when you are done with it
     */
    static new(
      pattern: string,
      compileOptions: RegexCompileFlags,
      matchOptions: RegexMatchFlags
    ): Regex
    /**
     * Checks whether `replacement` is a valid replacement string
     * (see g_regex_replace()), i.e. that all escape sequences in
     * it are valid.
     *
     * If `has_references` is not %NULL then `replacement` is checked
     * for pattern references. For instance, replacement text 'foo\n'
     * does not contain references and may be evaluated without information
     * about actual match, but '\0\1' (whole match followed by first
     * subpattern) requires valid #GMatchInfo object.
     * @param replacement the replacement string
     * @returns whether @replacement is a valid replacement string
     */
    static checkReplacement(
      replacement: string
    ): [/* returnType */ boolean, /* hasReferences */ boolean]
    static errorQuark(): Quark
    /**
     * Escapes the nul characters in `string` to "\x00".  It can be used
     * to compile a regex with embedded nul characters.
     *
     * For completeness, `length` can be -1 for a nul-terminated string.
     * In this case the output string will be of course equal to `string`.
     * @param string the string to escape
     * @param length the length of `string`
     * @returns a newly-allocated escaped string
     */
    static escapeNul(string: string, length: number): string | null
    /**
     * Escapes the special characters used for regular expressions
     * in `string,` for instance "a.b*c" becomes "a\.b\*c". This
     * function is useful to dynamically generate regular expressions.
     *
     * `string` can contain nul characters that are replaced with "\0",
     * in this case remember to specify the correct length of `string`
     * in `length`.
     * @param string the string to escape
     * @param length the length of `string,` in bytes, or -1 if `string` is nul-terminated
     * @returns a newly-allocated escaped string
     */
    static escapeString(string: string, length: number): string | null
    /**
     * Scans for a match in `string` for `pattern`.
     *
     * This function is equivalent to g_regex_match() but it does not
     * require to compile the pattern with g_regex_new(), avoiding some
     * lines of code when you need just to do a match without extracting
     * substrings, capture counts, and so on.
     *
     * If this function is to be called on the same `pattern` more than
     * once, it's more efficient to compile the pattern once with
     * g_regex_new() and then use g_regex_match().
     * @param pattern the regular expression
     * @param string the string to scan for matches
     * @param compileOptions compile options for the regular expression, or 0
     * @param matchOptions match options, or 0
     * @returns %TRUE if the string matched, %FALSE otherwise
     */
    static matchSimple(
      pattern: string,
      string: string,
      compileOptions: RegexCompileFlags,
      matchOptions: RegexMatchFlags
    ): boolean
    /**
     * Breaks the string on the pattern, and returns an array of
     * the tokens. If the pattern contains capturing parentheses,
     * then the text for each of the substrings will also be returned.
     * If the pattern does not match anywhere in the string, then the
     * whole string is returned as the first token.
     *
     * This function is equivalent to g_regex_split() but it does
     * not require to compile the pattern with g_regex_new(), avoiding
     * some lines of code when you need just to do a split without
     * extracting substrings, capture counts, and so on.
     *
     * If this function is to be called on the same `pattern` more than
     * once, it's more efficient to compile the pattern once with
     * g_regex_new() and then use g_regex_split().
     *
     * As a special case, the result of splitting the empty string ""
     * is an empty vector, not a vector containing a single string.
     * The reason for this special case is that being able to represent
     * an empty vector is typically more useful than consistent handling
     * of empty elements. If you do need to represent empty elements,
     * you'll need to check for the empty string before calling this
     * function.
     *
     * A pattern that can match empty strings splits `string` into
     * separate characters wherever it matches the empty string between
     * characters. For example splitting "ab c" using as a separator
     * "\s*", you will get "a", "b" and "c".
     * @param pattern the regular expression
     * @param string the string to scan for matches
     * @param compileOptions compile options for the regular expression, or 0
     * @param matchOptions match options, or 0
     * @returns a %NULL-terminated array of strings. Free it using g_strfreev()
     */
    static splitSimple(
      pattern: string,
      string: string,
      compileOptions: RegexCompileFlags,
      matchOptions: RegexMatchFlags
    ): string[]
  }

  interface Relation {
    // Owm methods of GLib-2.0.GLib.Relation

    /**
     * Returns the number of tuples in a #GRelation that have the given
     * value in the given field.
     * @param key the value to compare with.
     * @param field the field of each record to match.
     * @returns the number of matches.
     */
    count(key: any | null, field: number): number
    /**
     * Deletes any records from a #GRelation that have the given key value
     * in the given field.
     * @param key the value to compare with.
     * @param field the field of each record to match.
     * @returns the number of records deleted.
     */
    delete(key: any | null, field: number): number
    /**
     * Destroys the #GRelation, freeing all memory allocated. However, it
     * does not free memory allocated for the tuple data, so you should
     * free that first if appropriate.
     */
    destroy(): void
    /**
     * Outputs information about all records in a #GRelation, as well as
     * the indexes. It is for debugging.
     */
    print(): void
  }

  /**
   * A `GRelation` is a table of data which can be indexed on any number
   * of fields, rather like simple database tables. A `GRelation` contains
   * a number of records, called tuples. Each record contains a number of
   * fields. Records are not ordered, so it is not possible to find the
   * record at a particular index.
   *
   * Note that `GRelation` tables are currently limited to 2 fields.
   *
   * To create a `GRelation`, use [func`GLib`.Relation.new].
   *
   * To specify which fields should be indexed, use [method`GLib`.Relation.index].
   * Note that this must be called before any tuples are added to the
   * `GRelation`.
   *
   * To add records to a `GRelation` use [method`GLib`.Relation.insert].
   *
   * To determine if a given record appears in a `GRelation`, use
   * [method`GLib`.Relation.exists]. Note that fields are compared directly, so
   * pointers must point to the exact same position (i.e. different
   * copies of the same string will not match.)
   *
   * To count the number of records which have a particular value in a
   * given field, use [method`GLib`.Relation.count].
   *
   * To get all the records which have a particular value in a given
   * field, use [method`GLib`.Relation.select]. To access fields of the resulting
   * records, use [method`GLib`.Tuples.index]. To free the resulting records use
   * [method`GLib`.Tuples.destroy].
   *
   * To delete all records which have a particular value in a given
   * field, use [method`GLib`.Relation.delete].
   *
   * To destroy the `GRelation`, use [method`GLib`.Relation.destroy].
   *
   * To help debug `GRelation` objects, use [method`GLib`.Relation.print].
   *
   * `GRelation` has been marked as deprecated, since this API has never
   * been fully implemented, is not very actively maintained and rarely
   * used.
   * @record
   */
  class Relation {
    // Own properties of GLib-2.0.GLib.Relation

    static name: string
  }

  interface SList {
    // Own fields of GLib-2.0.GLib.SList

    /**
     * holds the element's data, which can be a pointer to any kind
     *        of data, or any integer value using the
     *        [Type Conversion Macros][glib-Type-Conversion-Macros]
     * @field
     */
    data: any
    /**
     * contains the link to the next element in the list.
     * @field
     */
    next: any[]
  }

  /**
   * The #GSList struct is used for each element in the singly-linked
   * list.
   * @record
   */
  class SList {
    // Own properties of GLib-2.0.GLib.SList

    static name: string

    // Constructors of GLib-2.0.GLib.SList

    static popAllocator(): void
    static pushAllocator(allocator: Allocator): void
  }

  interface Scanner {
    // Own fields of GLib-2.0.GLib.Scanner

    /**
     * unused
     * @field
     */
    userData: any
    /**
     * unused
     * @field
     */
    maxParseErrors: number
    /**
     * g_scanner_error() increments this field
     * @field
     */
    parseErrors: number
    /**
     * name of input stream, featured by the default message handler
     * @field
     */
    inputName: string
    /**
     * quarked data
     * @field
     */
    qdata: Data
    /**
     * link into the scanner configuration
     * @field
     */
    config: ScannerConfig
    /**
     * token parsed by the last g_scanner_get_next_token()
     * @field
     */
    token: TokenType
    /**
     * value of the last token from g_scanner_get_next_token()
     * @field
     */
    value: TokenValue
    /**
     * line number of the last token from g_scanner_get_next_token()
     * @field
     */
    line: number
    /**
     * char number of the last token from g_scanner_get_next_token()
     * @field
     */
    position: number
    /**
     * token parsed by the last g_scanner_peek_next_token()
     * @field
     */
    nextToken: TokenType
    /**
     * value of the last token from g_scanner_peek_next_token()
     * @field
     */
    nextValue: TokenValue
    /**
     * line number of the last token from g_scanner_peek_next_token()
     * @field
     */
    nextLine: number
    /**
     * char number of the last token from g_scanner_peek_next_token()
     * @field
     */
    nextPosition: number
    /**
     * handler function for _warn and _error
     * @field
     */
    msgHandler: ScannerMsgFunc

    // Owm methods of GLib-2.0.GLib.Scanner

    /**
     * Returns the current line in the input stream (counting
     * from 1). This is the line of the last token parsed via
     * g_scanner_get_next_token().
     * @returns the current line
     */
    curLine(): number
    /**
     * Returns the current position in the current line (counting
     * from 0). This is the position of the last token parsed via
     * g_scanner_get_next_token().
     * @returns the current position on the line
     */
    curPosition(): number
    /**
     * Gets the current token type. This is simply the `token`
     * field in the #GScanner structure.
     * @returns the current token type
     */
    curToken(): TokenType
    /**
     * Frees all memory used by the #GScanner.
     */
    destroy(): void
    /**
     * Returns %TRUE if the scanner has reached the end of
     * the file or text buffer.
     * @returns %TRUE if the scanner has reached the end of     the file or text buffer
     */
    eof(): boolean
    /**
     * Parses the next token just like g_scanner_peek_next_token()
     * and also removes it from the input stream. The token data is
     * placed in the `token,` `value,` `line,` and `position` fields of
     * the #GScanner structure.
     * @returns the type of the token
     */
    getNextToken(): TokenType
    /**
     * Prepares to scan a file.
     * @param inputFd a file descriptor
     */
    inputFile(inputFd: number): void
    /**
     * Prepares to scan a text buffer.
     * @param text the text buffer to scan
     * @param textLen the length of the text buffer
     */
    inputText(text: string, textLen: number): void
    /**
     * Looks up a symbol in the current scope and return its value.
     * If the symbol is not bound in the current scope, %NULL is
     * returned.
     * @param symbol the symbol to look up
     * @returns the value of @symbol in the current scope, or %NULL     if @symbol is not bound in the current scope
     */
    lookupSymbol(symbol: string): any | null
    /**
     * Parses the next token, without removing it from the input stream.
     * The token data is placed in the `next_token,` `next_value,` `next_line,`
     * and `next_position` fields of the #GScanner structure.
     *
     * Note that, while the token is not removed from the input stream
     * (i.e. the next call to g_scanner_get_next_token() will return the
     * same token), it will not be reevaluated. This can lead to surprising
     * results when changing scope or the scanner configuration after peeking
     * the next token. Getting the next token after switching the scope or
     * configuration will return whatever was peeked before, regardless of
     * any symbols that may have been added or removed in the new scope.
     * @returns the type of the token
     */
    peekNextToken(): TokenType
    /**
     * Adds a symbol to the given scope.
     * @param scopeId the scope id
     * @param symbol the symbol to add
     * @param value the value of the symbol
     */
    scopeAddSymbol(scopeId: number, symbol: string, value: any | null): void
    /**
     * Calls the given function for each of the symbol/value pairs
     * in the given scope of the #GScanner. The function is passed
     * the symbol and value of each pair, and the given `user_data`
     * parameter.
     * @param scopeId the scope id
     * @param func the function to call for each symbol/value pair
     */
    scopeForeachSymbol(scopeId: number, func: HFunc): void
    /**
     * Looks up a symbol in a scope and return its value. If the
     * symbol is not bound in the scope, %NULL is returned.
     * @param scopeId the scope id
     * @param symbol the symbol to look up
     * @returns the value of @symbol in the given scope, or %NULL     if @symbol is not bound in the given scope.
     */
    scopeLookupSymbol(scopeId: number, symbol: string): any | null
    /**
     * Removes a symbol from a scope.
     * @param scopeId the scope id
     * @param symbol the symbol to remove
     */
    scopeRemoveSymbol(scopeId: number, symbol: string): void
    /**
     * Sets the current scope.
     * @param scopeId the new scope id
     * @returns the old scope id
     */
    setScope(scopeId: number): number
    /**
     * Rewinds the filedescriptor to the current buffer position
     * and blows the file read ahead buffer. This is useful for
     * third party uses of the scanners filedescriptor, which hooks
     * onto the current scanning position.
     */
    syncFileOffset(): void
    /**
     * Outputs a message through the scanner's msg_handler,
     * resulting from an unexpected token in the input stream.
     * Note that you should not call g_scanner_peek_next_token()
     * followed by g_scanner_unexp_token() without an intermediate
     * call to g_scanner_get_next_token(), as g_scanner_unexp_token()
     * evaluates the scanner's current token (not the peeked token)
     * to construct part of the message.
     * @param expectedToken the expected token
     * @param identifierSpec a string describing how the scanner's user     refers to identifiers (%NULL defaults to "identifier").     This is used if `expected_token` is %G_TOKEN_IDENTIFIER or     %G_TOKEN_IDENTIFIER_NULL.
     * @param symbolSpec a string describing how the scanner's user refers     to symbols (%NULL defaults to "symbol"). This is used if     `expected_token` is %G_TOKEN_SYMBOL or any token value greater     than %G_TOKEN_LAST.
     * @param symbolName the name of the symbol, if the scanner's current     token is a symbol.
     * @param message a message string to output at the end of the     warning/error, or %NULL.
     * @param isError if %TRUE it is output as an error. If %FALSE it is     output as a warning.
     */
    unexpToken(
      expectedToken: TokenType,
      identifierSpec: string,
      symbolSpec: string,
      symbolName: string,
      message: string,
      isError: number
    ): void
  }

  /**
   * `GScanner` provides a general-purpose lexical scanner.
   *
   * You should set `input_name` after creating the scanner, since
   * it is used by the default message handler when displaying
   * warnings and errors. If you are scanning a file, the filename
   * would be a good choice.
   *
   * The `user_data` and `max_parse_errors` fields are not used.
   * If you need to associate extra data with the scanner you
   * can place them here.
   *
   * If you want to use your own message handler you can set the
   * `msg_handler` field. The type of the message handler function
   * is declared by #GScannerMsgFunc.
   * @record
   */
  class Scanner {
    // Own properties of GLib-2.0.GLib.Scanner

    static name: string
  }

  interface ScannerConfig {
    // Own fields of GLib-2.0.GLib.ScannerConfig

    /**
     * specifies which characters should be skipped
     *     by the scanner (the default is the whitespace characters: space,
     *     tab, carriage-return and line-feed).
     * @field
     */
    csetSkipCharacters: string | null
    /**
     * specifies the characters which can start
     *     identifiers (the default is %G_CSET_a_2_z, "_", and %G_CSET_A_2_Z).
     * @field
     */
    csetIdentifierFirst: string | null
    /**
     * specifies the characters which can be used
     *     in identifiers, after the first character (the default is
     *     %G_CSET_a_2_z, "_0123456789", %G_CSET_A_2_Z, %G_CSET_LATINS,
     *     %G_CSET_LATINC).
     * @field
     */
    csetIdentifierNth: string | null
    /**
     * specifies the characters at the start and
     *     end of single-line comments. The default is "#\n" which means
     *     that single-line comments start with a '#' and continue until
     *     a '\n' (end of line).
     * @field
     */
    cpairCommentSingle: string | null
    /**
     * specifies if symbols are case sensitive (the
     *     default is %FALSE).
     * @field
     */
    caseSensitive: number
    /**
     * specifies if multi-line comments are skipped
     *     and not returned as tokens (the default is %TRUE).
     * @field
     */
    skipCommentMulti: number
    /**
     * specifies if single-line comments are skipped
     *     and not returned as tokens (the default is %TRUE).
     * @field
     */
    skipCommentSingle: number
    /**
     * specifies if multi-line comments are recognized
     *     (the default is %TRUE).
     * @field
     */
    scanCommentMulti: number
    /**
     * specifies if identifiers are recognized (the
     *     default is %TRUE).
     * @field
     */
    scanIdentifier: number
    /**
     * specifies if single-character
     *     identifiers are recognized (the default is %FALSE).
     * @field
     */
    scanIdentifier1char: number
    /**
     * specifies if %NULL is reported as
     *     %G_TOKEN_IDENTIFIER_NULL (the default is %FALSE).
     * @field
     */
    scanIdentifierNULL: number
    /**
     * specifies if symbols are recognized (the default
     *     is %TRUE).
     * @field
     */
    scanSymbols: number
    /**
     * specifies if binary numbers are recognized (the
     *     default is %FALSE).
     * @field
     */
    scanBinary: number
    /**
     * specifies if octal numbers are recognized (the
     *     default is %TRUE).
     * @field
     */
    scanOctal: number
    /**
     * specifies if floating point numbers are recognized
     *     (the default is %TRUE).
     * @field
     */
    scanFloat: number
    /**
     * specifies if hexadecimal numbers are recognized (the
     *     default is %TRUE).
     * @field
     */
    scanHex: number
    /**
     * specifies if '$' is recognized as a prefix for
     *     hexadecimal numbers (the default is %FALSE).
     * @field
     */
    scanHexDollar: number
    /**
     * specifies if strings can be enclosed in single
     *     quotes (the default is %TRUE).
     * @field
     */
    scanStringSq: number
    /**
     * specifies if strings can be enclosed in double
     *     quotes (the default is %TRUE).
     * @field
     */
    scanStringDq: number
    /**
     * specifies if binary, octal and hexadecimal numbers
     *     are reported as %G_TOKEN_INT (the default is %TRUE).
     * @field
     */
    numbers2Int: number
    /**
     * specifies if all numbers are reported as %G_TOKEN_FLOAT
     *     (the default is %FALSE).
     * @field
     */
    int2Float: number
    /**
     * specifies if identifiers are reported as strings
     *     (the default is %FALSE).
     * @field
     */
    identifier2String: number
    /**
     * specifies if characters are reported by setting
     *     `token = ch` or as %G_TOKEN_CHAR (the default is %TRUE).
     * @field
     */
    char2Token: number
    /**
     * specifies if symbols are reported by setting
     *     `token = v_symbol` or as %G_TOKEN_SYMBOL (the default is %FALSE).
     * @field
     */
    symbol2Token: number
    /**
     * specifies if a symbol is searched for in the
     *     default scope in addition to the current scope (the default is %FALSE).
     * @field
     */
    scope0Fallback: number
    /**
     * use value.v_int64 rather than v_int
     * @field
     */
    storeInt64: number
  }

  /**
   * Specifies the #GScanner parser configuration. Most settings can
   * be changed during the parsing phase and will affect the lexical
   * parsing of the next unpeeked token.
   * @record
   */
  class ScannerConfig {
    // Own properties of GLib-2.0.GLib.ScannerConfig

    static name: string
  }

  interface Sequence {
    // Owm methods of GLib-2.0.GLib.Sequence

    /**
     * Adds a new item to the end of `seq`.
     * @param data the data for the new item
     * @returns an iterator pointing to the new item
     */
    append(data: any | null): SequenceIter
    /**
     * Calls `func` for each item in the sequence passing `user_data`
     * to the function. `func` must not modify the sequence itself.
     * @param func the function to call for each item in `seq`
     */
    foreach(func: Func): void
    /**
     * Frees the memory allocated for `seq`. If `seq` has a data destroy
     * function associated with it, that function is called on all items
     * in `seq`.
     */
    free(): void
    /**
     * Returns the begin iterator for `seq`.
     * @returns the begin iterator for @seq.
     */
    getBeginIter(): SequenceIter
    /**
     * Returns the end iterator for `seg`
     * @returns the end iterator for @seq
     */
    getEndIter(): SequenceIter
    /**
     * Returns the iterator at position `pos`. If `pos` is negative or larger
     * than the number of items in `seq,` the end iterator is returned.
     * @param pos a position in `seq,` or -1 for the end
     * @returns The #GSequenceIter at position @pos
     */
    getIterAtPos(pos: number): SequenceIter
    /**
     * Returns the positive length (>= 0) of `seq`. Note that this method is
     * O(h) where `h' is the height of the tree. It is thus more efficient
     * to use g_sequence_is_empty() when comparing the length to zero.
     * @returns the length of @seq
     */
    getLength(): number
    /**
     * Inserts `data` into `seq` using `cmp_func` to determine the new
     * position. The sequence must already be sorted according to `cmp_func;`
     * otherwise the new position of `data` is undefined.
     *
     * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
     * It should return 0 if the items are equal, a negative value
     * if the first item comes before the second, and a positive value
     * if the second item comes before the first.
     *
     * Note that when adding a large amount of data to a #GSequence,
     * it is more efficient to do unsorted insertions and then call
     * g_sequence_sort() or g_sequence_sort_iter().
     * @param data the data to insert
     * @param cmpFunc the function used to compare items in the sequence
     * @returns a #GSequenceIter pointing to the new item.
     */
    insertSorted(data: any | null, cmpFunc: CompareDataFunc): SequenceIter
    /**
     * Like g_sequence_insert_sorted(), but uses
     * a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
     * the compare function.
     *
     * `iter_cmp` is called with two iterators pointing into `seq`.
     * It should return 0 if the iterators are equal, a negative
     * value if the first iterator comes before the second, and a
     * positive value if the second iterator comes before the first.
     *
     * Note that when adding a large amount of data to a #GSequence,
     * it is more efficient to do unsorted insertions and then call
     * g_sequence_sort() or g_sequence_sort_iter().
     * @param data data for the new item
     * @param iterCmp the function used to compare iterators in the sequence
     * @returns a #GSequenceIter pointing to the new item
     */
    insertSortedIter(
      data: any | null,
      iterCmp: SequenceIterCompareFunc
    ): SequenceIter
    /**
     * Returns %TRUE if the sequence contains zero items.
     *
     * This function is functionally identical to checking the result of
     * g_sequence_get_length() being equal to zero. However this function is
     * implemented in O(1) running time.
     * @returns %TRUE if the sequence is empty, otherwise %FALSE.
     */
    isEmpty(): boolean
    /**
     * Returns an iterator pointing to the position of the first item found
     * equal to `data` according to `cmp_func` and `cmp_data`. If more than one
     * item is equal, it is not guaranteed that it is the first which is
     * returned. In that case, you can use g_sequence_iter_next() and
     * g_sequence_iter_prev() to get others.
     *
     * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
     * It should return 0 if the items are equal, a negative value if
     * the first item comes before the second, and a positive value if
     * the second item comes before the first.
     *
     * This function will fail if the data contained in the sequence is
     * unsorted.
     * @param data data to look up
     * @param cmpFunc the function used to compare items in the sequence
     * @returns an #GSequenceIter pointing to the position of the     first item found equal to @data according to @cmp_func and     @cmp_data, or %NULL if no such item exists
     */
    lookup(data: any | null, cmpFunc: CompareDataFunc): SequenceIter | null
    /**
     * Like g_sequence_lookup(), but uses a #GSequenceIterCompareFunc
     * instead of a #GCompareDataFunc as the compare function.
     *
     * `iter_cmp` is called with two iterators pointing into `seq`.
     * It should return 0 if the iterators are equal, a negative value
     * if the first iterator comes before the second, and a positive
     * value if the second iterator comes before the first.
     *
     * This function will fail if the data contained in the sequence is
     * unsorted.
     * @param data data to look up
     * @param iterCmp the function used to compare iterators in the sequence
     * @returns an #GSequenceIter pointing to the position of     the first item found equal to @data according to @iter_cmp     and @cmp_data, or %NULL if no such item exists
     */
    lookupIter(
      data: any | null,
      iterCmp: SequenceIterCompareFunc
    ): SequenceIter | null
    /**
     * Adds a new item to the front of `seq`
     * @param data the data for the new item
     * @returns an iterator pointing to the new item
     */
    prepend(data: any | null): SequenceIter
    /**
     * Returns an iterator pointing to the position where `data` would
     * be inserted according to `cmp_func` and `cmp_data`.
     *
     * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
     * It should return 0 if the items are equal, a negative value if
     * the first item comes before the second, and a positive value if
     * the second item comes before the first.
     *
     * If you are simply searching for an existing element of the sequence,
     * consider using g_sequence_lookup().
     *
     * This function will fail if the data contained in the sequence is
     * unsorted.
     * @param data data for the new item
     * @param cmpFunc the function used to compare items in the sequence
     * @returns an #GSequenceIter pointing to the position where @data     would have been inserted according to @cmp_func and @cmp_data
     */
    search(data: any | null, cmpFunc: CompareDataFunc): SequenceIter
    /**
     * Like g_sequence_search(), but uses a #GSequenceIterCompareFunc
     * instead of a #GCompareDataFunc as the compare function.
     *
     * `iter_cmp` is called with two iterators pointing into `seq`.
     * It should return 0 if the iterators are equal, a negative value
     * if the first iterator comes before the second, and a positive
     * value if the second iterator comes before the first.
     *
     * If you are simply searching for an existing element of the sequence,
     * consider using g_sequence_lookup_iter().
     *
     * This function will fail if the data contained in the sequence is
     * unsorted.
     * @param data data for the new item
     * @param iterCmp the function used to compare iterators in the sequence
     * @returns a #GSequenceIter pointing to the position in @seq     where @data would have been inserted according to @iter_cmp     and @cmp_data
     */
    searchIter(data: any | null, iterCmp: SequenceIterCompareFunc): SequenceIter
    /**
     * Sorts `seq` using `cmp_func`.
     *
     * `cmp_func` is passed two items of `seq` and should
     * return 0 if they are equal, a negative value if the
     * first comes before the second, and a positive value
     * if the second comes before the first.
     * @param cmpFunc the function used to sort the sequence
     */
    sort(cmpFunc: CompareDataFunc): void
    /**
     * Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead
     * of a #GCompareDataFunc as the compare function
     *
     * `cmp_func` is called with two iterators pointing into `seq`. It should
     * return 0 if the iterators are equal, a negative value if the first
     * iterator comes before the second, and a positive value if the second
     * iterator comes before the first.
     * @param cmpFunc the function used to compare iterators in the sequence
     */
    sortIter(cmpFunc: SequenceIterCompareFunc): void
  }

  /**
   * The #GSequence struct is an opaque data type representing a
   * [sequence][glib-Sequences] data type.
   * @record
   */
  class Sequence {
    // Own properties of GLib-2.0.GLib.Sequence

    static name: string

    // Constructors of GLib-2.0.GLib.Sequence

    /**
     * Calls `func` for each item in the range (`begin,` `end)` passing
     * `user_data` to the function. `func` must not modify the sequence
     * itself.
     * @param begin a #GSequenceIter
     * @param end a #GSequenceIter
     * @param func a #GFunc
     */
    static foreachRange(
      begin: SequenceIter,
      end: SequenceIter,
      func: Func
    ): void
    /**
     * Returns the data that `iter` points to.
     * @param iter a #GSequenceIter
     * @returns the data that @iter points to
     */
    static get(iter: SequenceIter): any | null
    /**
     * Inserts a new item just before the item pointed to by `iter`.
     * @param iter a #GSequenceIter
     * @param data the data for the new item
     * @returns an iterator pointing to the new item
     */
    static insertBefore(iter: SequenceIter, data: any | null): SequenceIter
    /**
     * Moves the item pointed to by `src` to the position indicated by `dest`.
     * After calling this function `dest` will point to the position immediately
     * after `src`. It is allowed for `src` and `dest` to point into different
     * sequences.
     * @param src a #GSequenceIter pointing to the item to move
     * @param dest a #GSequenceIter pointing to the position to which     the item is moved
     */
    static move(src: SequenceIter, dest: SequenceIter): void
    /**
     * Inserts the (`begin,` `end)` range at the destination pointed to by `dest`.
     * The `begin` and `end` iters must point into the same sequence. It is
     * allowed for `dest` to point to a different sequence than the one pointed
     * into by `begin` and `end`.
     *
     * If `dest` is %NULL, the range indicated by `begin` and `end` is
     * removed from the sequence. If `dest` points to a place within
     * the (`begin,` `end)` range, the range does not move.
     * @param dest a #GSequenceIter
     * @param begin a #GSequenceIter
     * @param end a #GSequenceIter
     */
    static moveRange(
      dest: SequenceIter,
      begin: SequenceIter,
      end: SequenceIter
    ): void
    /**
     * Finds an iterator somewhere in the range (`begin,` `end)`. This
     * iterator will be close to the middle of the range, but is not
     * guaranteed to be exactly in the middle.
     *
     * The `begin` and `end` iterators must both point to the same sequence
     * and `begin` must come before or be equal to `end` in the sequence.
     * @param begin a #GSequenceIter
     * @param end a #GSequenceIter
     * @returns a #GSequenceIter pointing somewhere in the    (@begin, @end) range
     */
    static rangeGetMidpoint(
      begin: SequenceIter,
      end: SequenceIter
    ): SequenceIter
    /**
     * Removes the item pointed to by `iter`. It is an error to pass the
     * end iterator to this function.
     *
     * If the sequence has a data destroy function associated with it, this
     * function is called on the data for the removed item.
     * @param iter a #GSequenceIter
     */
    static remove(iter: SequenceIter): void
    /**
     * Removes all items in the (`begin,` `end)` range.
     *
     * If the sequence has a data destroy function associated with it, this
     * function is called on the data for the removed items.
     * @param begin a #GSequenceIter
     * @param end a #GSequenceIter
     */
    static removeRange(begin: SequenceIter, end: SequenceIter): void
    /**
     * Changes the data for the item pointed to by `iter` to be `data`. If
     * the sequence has a data destroy function associated with it, that
     * function is called on the existing data that `iter` pointed to.
     * @param iter a #GSequenceIter
     * @param data new data for the item
     */
    static set(iter: SequenceIter, data: any | null): void
    /**
     * Moves the data pointed to by `iter` to a new position as indicated by
     * `cmp_func`. This
     * function should be called for items in a sequence already sorted according
     * to `cmp_func` whenever some aspect of an item changes so that `cmp_func`
     * may return different values for that item.
     *
     * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
     * It should return 0 if the items are equal, a negative value if
     * the first item comes before the second, and a positive value if
     * the second item comes before the first.
     * @param iter A #GSequenceIter
     * @param cmpFunc the function used to compare items in the sequence
     */
    static sortChanged(iter: SequenceIter, cmpFunc: CompareDataFunc): void
    /**
     * Like g_sequence_sort_changed(), but uses
     * a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
     * the compare function.
     *
     * `iter_cmp` is called with two iterators pointing into the #GSequence that
     * `iter` points into. It should
     * return 0 if the iterators are equal, a negative value if the first
     * iterator comes before the second, and a positive value if the second
     * iterator comes before the first.
     * @param iter a #GSequenceIter
     * @param iterCmp the function used to compare iterators in the sequence
     */
    static sortChangedIter(
      iter: SequenceIter,
      iterCmp: SequenceIterCompareFunc
    ): void
    /**
     * Swaps the items pointed to by `a` and `b`. It is allowed for `a` and `b`
     * to point into difference sequences.
     * @param a a #GSequenceIter
     * @param b a #GSequenceIter
     */
    static swap(a: SequenceIter, b: SequenceIter): void
  }

  interface SequenceIter {
    // Owm methods of GLib-2.0.GLib.SequenceIter

    /**
     * Returns a negative number if `a` comes before `b,` 0 if they are equal,
     * and a positive number if `a` comes after `b`.
     *
     * The `a` and `b` iterators must point into the same sequence.
     * @param b a #GSequenceIter
     * @returns a negative number if @a comes before @b, 0 if they are     equal, and a positive number if @a comes after @b
     */
    compare(b: SequenceIter): number
    /**
     * Returns the position of `iter`
     * @returns the position of @iter
     */
    getPosition(): number
    /**
     * Returns the #GSequence that `iter` points into.
     * @returns the #GSequence that @iter points into
     */
    getSequence(): Sequence
    /**
     * Returns whether `iter` is the begin iterator
     * @returns whether @iter is the begin iterator
     */
    isBegin(): boolean
    /**
     * Returns whether `iter` is the end iterator
     * @returns Whether @iter is the end iterator
     */
    isEnd(): boolean
    /**
     * Returns the #GSequenceIter which is `delta` positions away from `iter`.
     * If `iter` is closer than -`delta` positions to the beginning of the sequence,
     * the begin iterator is returned. If `iter` is closer than `delta` positions
     * to the end of the sequence, the end iterator is returned.
     * @param delta A positive or negative number indicating how many positions away    from `iter` the returned #GSequenceIter will be
     * @returns a #GSequenceIter which is @delta positions away from @iter
     */
    move(delta: number): SequenceIter
    /**
     * Returns an iterator pointing to the next position after `iter`.
     * If `iter` is the end iterator, the end iterator is returned.
     * @returns a #GSequenceIter pointing to the next position after @iter
     */
    next(): SequenceIter
    /**
     * Returns an iterator pointing to the previous position before `iter`.
     * If `iter` is the begin iterator, the begin iterator is returned.
     * @returns a #GSequenceIter pointing to the previous position     before @iter
     */
    prev(): SequenceIter
  }

  /**
   * The #GSequenceIter struct is an opaque data type representing an
   * iterator pointing into a #GSequence.
   * @record
   */
  class SequenceIter {
    // Own properties of GLib-2.0.GLib.SequenceIter

    static name: string
  }

  interface Source {
    // Owm methods of GLib-2.0.GLib.Source

    /**
     * Adds `child_source` to `source` as a "polled" source; when `source` is
     * added to a #GMainContext, `child_source` will be automatically added
     * with the same priority, when `child_source` is triggered, it will
     * cause `source` to dispatch (in addition to calling its own
     * callback), and when `source` is destroyed, it will destroy
     * `child_source` as well. (`source` will also still be dispatched if
     * its own prepare/check functions indicate that it is ready.)
     *
     * If you don't need `child_source` to do anything on its own when it
     * triggers, you can call g_source_set_dummy_callback() on it to set a
     * callback that does nothing (except return %TRUE if appropriate).
     *
     * `source` will hold a reference on `child_source` while `child_source`
     * is attached to it.
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     * @param childSource a second #GSource that `source` should "poll"
     */
    addChildSource(childSource: Source): void
    /**
     * Adds a file descriptor to the set of file descriptors polled for
     * this source. This is usually combined with g_source_new() to add an
     * event source. The event source's check function will typically test
     * the `revents` field in the #GPollFD struct and return %TRUE if events need
     * to be processed.
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     *
     * Using this API forces the linear scanning of event sources on each
     * main loop iteration.  Newly-written event sources should try to use
     * g_source_add_unix_fd() instead of this API.
     * @param fd a #GPollFD structure holding information about a file      descriptor to watch.
     */
    addPoll(fd: PollFD): void
    /**
     * Monitors `fd` for the IO events in `events`.
     *
     * The tag returned by this function can be used to remove or modify the
     * monitoring of the fd using g_source_remove_unix_fd() or
     * g_source_modify_unix_fd().
     *
     * It is not necessary to remove the fd before destroying the source; it
     * will be cleaned up automatically.
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     *
     * As the name suggests, this function is not available on Windows.
     * @param fd the fd to monitor
     * @param events an event mask
     * @returns an opaque tag
     */
    addUnixFd(fd: number, events: IOCondition): any
    /**
     * Adds a #GSource to a `context` so that it will be executed within
     * that context. Remove it by calling g_source_destroy().
     *
     * This function is safe to call from any thread, regardless of which thread
     * the `context` is running in.
     * @param context a #GMainContext (if %NULL, the global-default   main context will be used)
     * @returns the ID (greater than 0) for the source within the   #GMainContext.
     */
    attach(context: MainContext | null): number
    /**
     * Removes a source from its #GMainContext, if any, and mark it as
     * destroyed.  The source cannot be subsequently added to another
     * context. It is safe to call this on sources which have already been
     * removed from their context.
     *
     * This does not unref the #GSource: if you still hold a reference, use
     * g_source_unref() to drop it.
     *
     * This function is safe to call from any thread, regardless of which thread
     * the #GMainContext is running in.
     *
     * If the source is currently attached to a #GMainContext, destroying it
     * will effectively unset the callback similar to calling g_source_set_callback().
     * This can mean, that the data's #GDestroyNotify gets called right away.
     */
    destroy(): void
    /**
     * Checks whether a source is allowed to be called recursively.
     * see g_source_set_can_recurse().
     * @returns whether recursion is allowed.
     */
    getCanRecurse(): boolean
    /**
     * Gets the #GMainContext with which the source is associated.
     *
     * You can call this on a source that has been destroyed, provided
     * that the #GMainContext it was attached to still exists (in which
     * case it will return that #GMainContext). In particular, you can
     * always call this function on the source returned from
     * g_main_current_source(). But calling this function on a source
     * whose #GMainContext has been destroyed is an error.
     * @returns the #GMainContext with which the               source is associated, or %NULL if the context has not               yet been added to a source.
     */
    getContext(): MainContext | null
    /**
     * This function ignores `source` and is otherwise the same as
     * g_get_current_time().
     * @param timeval #GTimeVal structure in which to store current time.
     */
    getCurrentTime(timeval: TimeVal): void
    /**
     * Returns the numeric ID for a particular source. The ID of a source
     * is a positive integer which is unique within a particular main loop
     * context. The reverse
     * mapping from ID to source is done by g_main_context_find_source_by_id().
     *
     * You can only call this function while the source is associated to a
     * #GMainContext instance; calling this function before g_source_attach()
     * or after g_source_destroy() yields undefined behavior. The ID returned
     * is unique within the #GMainContext instance passed to g_source_attach().
     * @returns the ID (greater than 0) for the source
     */
    getId(): number
    /**
     * Gets a name for the source, used in debugging and profiling.  The
     * name may be #NULL if it has never been set with g_source_set_name().
     * @returns the name of the source
     */
    getName(): string | null
    /**
     * Gets the priority of a source.
     * @returns the priority of the source
     */
    getPriority(): number
    /**
     * Gets the "ready time" of `source,` as set by
     * g_source_set_ready_time().
     *
     * Any time before or equal to the current monotonic time (including 0)
     * is an indication that the source will fire immediately.
     * @returns the monotonic ready time, -1 for "never"
     */
    getReadyTime(): number
    /**
     * Gets the time to be used when checking this source. The advantage of
     * calling this function over calling g_get_monotonic_time() directly is
     * that when checking multiple sources, GLib can cache a single value
     * instead of having to repeatedly get the system monotonic time.
     *
     * The time here is the system monotonic time, if available, or some
     * other reasonable alternative otherwise.  See g_get_monotonic_time().
     * @returns the monotonic time in microseconds
     */
    getTime(): number
    /**
     * Returns whether `source` has been destroyed.
     *
     * This is important when you operate upon your objects
     * from within idle handlers, but may have freed the object
     * before the dispatch of your idle handler.
     *
     *
     * ```c
     * static gboolean
     * idle_callback (gpointer data)
     * {
     *   SomeWidget *self = data;
     *
     *   g_mutex_lock (&self->idle_id_mutex);
     *   // do stuff with self
     *   self->idle_id = 0;
     *   g_mutex_unlock (&self->idle_id_mutex);
     *
     *   return G_SOURCE_REMOVE;
     * }
     *
     * static void
     * some_widget_do_stuff_later (SomeWidget *self)
     * {
     *   g_mutex_lock (&self->idle_id_mutex);
     *   self->idle_id = g_idle_add (idle_callback, self);
     *   g_mutex_unlock (&self->idle_id_mutex);
     * }
     *
     * static void
     * some_widget_init (SomeWidget *self)
     * {
     *   g_mutex_init (&self->idle_id_mutex);
     *
     *   // ...
     * }
     *
     * static void
     * some_widget_finalize (GObject *object)
     * {
     *   SomeWidget *self = SOME_WIDGET (object);
     *
     *   if (self->idle_id)
     *     g_source_remove (self->idle_id);
     *
     *   g_mutex_clear (&self->idle_id_mutex);
     *
     *   G_OBJECT_CLASS (parent_class)->finalize (object);
     * }
     * ```
     *
     *
     * This will fail in a multi-threaded application if the
     * widget is destroyed before the idle handler fires due
     * to the use after free in the callback. A solution, to
     * this particular problem, is to check to if the source
     * has already been destroy within the callback.
     *
     *
     * ```c
     * static gboolean
     * idle_callback (gpointer data)
     * {
     *   SomeWidget *self = data;
     *
     *   g_mutex_lock (&self->idle_id_mutex);
     *   if (!g_source_is_destroyed (g_main_current_source ()))
     *     {
     *       // do stuff with self
     *     }
     *   g_mutex_unlock (&self->idle_id_mutex);
     *
     *   return FALSE;
     * }
     * ```
     *
     *
     * Calls to this function from a thread other than the one acquired by the
     * #GMainContext the #GSource is attached to are typically redundant, as the
     * source could be destroyed immediately after this function returns. However,
     * once a source is destroyed it cannot be un-destroyed, so this function can be
     * used for opportunistic checks from any thread.
     * @returns %TRUE if the source has been destroyed
     */
    isDestroyed(): boolean
    /**
     * Updates the event mask to watch for the fd identified by `tag`.
     *
     * `tag` is the tag returned from g_source_add_unix_fd().
     *
     * If you want to remove a fd, don't set its event mask to zero.
     * Instead, call g_source_remove_unix_fd().
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     *
     * As the name suggests, this function is not available on Windows.
     * @param tag the tag from g_source_add_unix_fd()
     * @param newEvents the new event mask to watch
     */
    modifyUnixFd(tag: any, newEvents: IOCondition): void
    /**
     * Queries the events reported for the fd corresponding to `tag` on
     * `source` during the last poll.
     *
     * The return value of this function is only defined when the function
     * is called from the check or dispatch functions for `source`.
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     *
     * As the name suggests, this function is not available on Windows.
     * @param tag the tag from g_source_add_unix_fd()
     * @returns the conditions reported on the fd
     */
    queryUnixFd(tag: any): IOCondition
    /**
     * Increases the reference count on a source by one.
     * @returns @source
     */
    ref(): Source
    /**
     * Detaches `child_source` from `source` and destroys it.
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     * @param childSource a #GSource previously passed to     g_source_add_child_source().
     */
    removeChildSource(childSource: Source): void
    /**
     * Removes a file descriptor from the set of file descriptors polled for
     * this source.
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     * @param fd a #GPollFD structure previously passed to g_source_add_poll().
     */
    removePoll(fd: PollFD): void
    /**
     * Reverses the effect of a previous call to g_source_add_unix_fd().
     *
     * You only need to call this if you want to remove an fd from being
     * watched while keeping the same source around.  In the normal case you
     * will just want to destroy the source.
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     *
     * As the name suggests, this function is not available on Windows.
     * @param tag the tag from g_source_add_unix_fd()
     */
    removeUnixFd(tag: any): void
    /**
     * Sets the callback function for a source. The callback for a source is
     * called from the source's dispatch function.
     *
     * The exact type of `func` depends on the type of source; ie. you
     * should not count on `func` being called with `data` as its first
     * parameter. Cast `func` with G_SOURCE_FUNC() to avoid warnings about
     * incompatible function types.
     *
     * See [memory management of sources][mainloop-memory-management] for details
     * on how to handle memory management of `data`.
     *
     * Typically, you won't use this function. Instead use functions specific
     * to the type of source you are using, such as g_idle_add() or g_timeout_add().
     *
     * It is safe to call this function multiple times on a source which has already
     * been attached to a context. The changes will take effect for the next time
     * the source is dispatched after this call returns.
     *
     * Note that g_source_destroy() for a currently attached source has the effect
     * of also unsetting the callback.
     * @param func a callback function
     */
    setCallback(func: SourceFunc): void
    /**
     * Sets the callback function storing the data as a refcounted callback
     * "object". This is used internally. Note that calling
     * g_source_set_callback_indirect() assumes
     * an initial reference count on `callback_data,` and thus
     * `callback_funcs->`unref will eventually be called once more
     * than `callback_funcs->`ref.
     *
     * It is safe to call this function multiple times on a source which has already
     * been attached to a context. The changes will take effect for the next time
     * the source is dispatched after this call returns.
     * @param callbackData pointer to callback data "object"
     * @param callbackFuncs functions for reference counting `callback_data`                  and getting the callback and data
     */
    setCallbackIndirect(
      callbackData: any | null,
      callbackFuncs: SourceCallbackFuncs
    ): void
    /**
     * Sets whether a source can be called recursively. If `can_recurse` is
     * %TRUE, then while the source is being dispatched then this source
     * will be processed normally. Otherwise, all processing of this
     * source is blocked until the dispatch function returns.
     * @param canRecurse whether recursion is allowed for this source
     */
    setCanRecurse(canRecurse: boolean): void
    /**
     * Sets the source functions (can be used to override
     * default implementations) of an unattached source.
     * @param funcs the new #GSourceFuncs
     */
    setFuncs(funcs: SourceFuncs): void
    /**
     * Sets a name for the source, used in debugging and profiling.
     * The name defaults to #NULL.
     *
     * The source name should describe in a human-readable way
     * what the source does. For example, "X11 event queue"
     * or "GTK repaint idle handler" or whatever it is.
     *
     * It is permitted to call this function multiple times, but is not
     * recommended due to the potential performance impact.  For example,
     * one could change the name in the "check" function of a #GSourceFuncs
     * to include details like the event type in the source name.
     *
     * Use caution if changing the name while another thread may be
     * accessing it with g_source_get_name(); that function does not copy
     * the value, and changing the value will free it while the other thread
     * may be attempting to use it.
     *
     * Also see g_source_set_static_name().
     * @param name debug name for the source
     */
    setName(name: string): void
    /**
     * Sets the priority of a source. While the main loop is being run, a
     * source will be dispatched if it is ready to be dispatched and no
     * sources at a higher (numerically smaller) priority are ready to be
     * dispatched.
     *
     * A child source always has the same priority as its parent.  It is not
     * permitted to change the priority of a source once it has been added
     * as a child of another source.
     * @param priority the new priority.
     */
    setPriority(priority: number): void
    /**
     * Sets a #GSource to be dispatched when the given monotonic time is
     * reached (or passed).  If the monotonic time is in the past (as it
     * always will be if `ready_time` is 0) then the source will be
     * dispatched immediately.
     *
     * If `ready_time` is -1 then the source is never woken up on the basis
     * of the passage of time.
     *
     * Dispatching the source does not reset the ready time.  You should do
     * so yourself, from the source dispatch function.
     *
     * Note that if you have a pair of sources where the ready time of one
     * suggests that it will be delivered first but the priority for the
     * other suggests that it would be delivered first, and the ready time
     * for both sources is reached during the same main context iteration,
     * then the order of dispatch is undefined.
     *
     * It is a no-op to call this function on a #GSource which has already been
     * destroyed with g_source_destroy().
     *
     * This API is only intended to be used by implementations of #GSource.
     * Do not call this API on a #GSource that you did not create.
     * @param readyTime the monotonic time at which the source will be ready,              0 for "immediately", -1 for "never"
     */
    setReadyTime(readyTime: number): void
    /**
     * A variant of g_source_set_name() that does not
     * duplicate the `name,` and can only be used with
     * string literals.
     * @param name debug name for the source
     */
    setStaticName(name: string): void
    /**
     * Decreases the reference count of a source by one. If the
     * resulting reference count is zero the source and associated
     * memory will be destroyed.
     */
    unref(): void
  }

  /**
   * The `GSource` struct is an opaque data type
   * representing an event source.
   * @record
   */
  class Source {
    // Own properties of GLib-2.0.GLib.Source

    static name: string

    // Constructors of GLib-2.0.GLib.Source

    /**
     * Creates a new #GSource structure. The size is specified to
     * allow creating structures derived from #GSource that contain
     * additional data. The size passed in must be at least
     * `sizeof (GSource)`.
     *
     * The source will not initially be associated with any #GMainContext
     * and must be added to one with g_source_attach() before it will be
     * executed.
     * @constructor
     * @param sourceFuncs structure containing functions that implement                the sources behavior.
     * @param structSize size of the #GSource structure to create.
     * @returns the newly-created #GSource.
     */
    constructor(sourceFuncs: SourceFuncs, structSize: number)
    /**
     * Creates a new #GSource structure. The size is specified to
     * allow creating structures derived from #GSource that contain
     * additional data. The size passed in must be at least
     * `sizeof (GSource)`.
     *
     * The source will not initially be associated with any #GMainContext
     * and must be added to one with g_source_attach() before it will be
     * executed.
     * @constructor
     * @param sourceFuncs structure containing functions that implement                the sources behavior.
     * @param structSize size of the #GSource structure to create.
     * @returns the newly-created #GSource.
     */
    static new(sourceFuncs: SourceFuncs, structSize: number): Source
    /**
     * Removes the source with the given ID from the default main context. You must
     * use g_source_destroy() for sources added to a non-default main context.
     *
     * The ID of a #GSource is given by g_source_get_id(), or will be
     * returned by the functions g_source_attach(), g_idle_add(),
     * g_idle_add_full(), g_timeout_add(), g_timeout_add_full(),
     * g_child_watch_add(), g_child_watch_add_full(), g_io_add_watch(), and
     * g_io_add_watch_full().
     *
     * It is a programmer error to attempt to remove a non-existent source.
     *
     * More specifically: source IDs can be reissued after a source has been
     * destroyed and therefore it is never valid to use this function with a
     * source ID which may have already been removed.  An example is when
     * scheduling an idle to run in another thread with g_idle_add(): the
     * idle may already have run and been removed by the time this function
     * is called on its (now invalid) source ID.  This source ID may have
     * been reissued, leading to the operation being performed against the
     * wrong source.
     * @param tag the ID of the source to remove.
     * @returns %TRUE if the source was found and removed.
     */
    static remove(tag: number): boolean
    /**
     * Removes a source from the default main loop context given the
     * source functions and user data. If multiple sources exist with the
     * same source functions and user data, only one will be destroyed.
     * @param funcs The `source_funcs` passed to g_source_new()
     * @param userData the user data for the callback
     * @returns %TRUE if a source was found and removed.
     */
    static removeByFuncsUserData(
      funcs: SourceFuncs,
      userData: any | null
    ): boolean
    /**
     * Removes a source from the default main loop context given the user
     * data for the callback. If multiple sources exist with the same user
     * data, only one will be destroyed.
     * @param userData the user_data for the callback.
     * @returns %TRUE if a source was found and removed.
     */
    static removeByUserData(userData: any | null): boolean
    /**
     * Sets the name of a source using its ID.
     *
     * This is a convenience utility to set source names from the return
     * value of g_idle_add(), g_timeout_add(), etc.
     *
     * It is a programmer error to attempt to set the name of a non-existent
     * source.
     *
     * More specifically: source IDs can be reissued after a source has been
     * destroyed and therefore it is never valid to use this function with a
     * source ID which may have already been removed.  An example is when
     * scheduling an idle to run in another thread with g_idle_add(): the
     * idle may already have run and been removed by the time this function
     * is called on its (now invalid) source ID.  This source ID may have
     * been reissued, leading to the operation being performed against the
     * wrong source.
     * @param tag a #GSource ID
     * @param name debug name for the source
     */
    static setNameById(tag: number, name: string): void
  }

  interface SourceCallbackFuncs {
    // Own fields of GLib-2.0.GLib.SourceCallbackFuncs

    /**
     * Called when a reference is added to the callback object
     * @field
     */
    ref: (cbData: any) => void
    /**
     * Called when a reference to the callback object is dropped
     * @field
     */
    unref: (cbData: any) => void
  }

  /**
   * The `GSourceCallbackFuncs` struct contains
   * functions for managing callback objects.
   * @record
   */
  class SourceCallbackFuncs {
    // Own properties of GLib-2.0.GLib.SourceCallbackFuncs

    static name: string
  }

  interface SourceFuncs {
    // Own fields of GLib-2.0.GLib.SourceFuncs

    /**
     * Called before all the file descriptors are polled. If the
     *     source can determine that it is ready here (without waiting for the
     *     results of the poll() call) it should return %TRUE. It can also return
     *     a `timeout_` value which should be the maximum timeout (in milliseconds)
     *     which should be passed to the poll() call. The actual timeout used will
     *     be -1 if all sources returned -1, or it will be the minimum of all
     *     the `timeout_` values returned which were >= 0.  Since 2.36 this may
     *     be %NULL, in which case the effect is as if the function always returns
     *     %FALSE with a timeout of -1.  If `prepare` returns a
     *     timeout and the source also has a ready time set, then the
     *     lower of the two will be used.
     * @field
     */
    prepare: (source: Source, timeout: number) => boolean
    /**
     * Called after all the file descriptors are polled. The source
     *     should return %TRUE if it is ready to be dispatched. Note that some
     *     time may have passed since the previous prepare function was called,
     *     so the source should be checked again here.  Since 2.36 this may
     *     be %NULL, in which case the effect is as if the function always returns
     *     %FALSE.
     * @field
     */
    check: (source: Source) => boolean
    /**
     * Called when the source is finalized. At this point, the source
     *     will have been destroyed, had its callback cleared, and have been removed
     *     from its #GMainContext, but it will still have its final reference count,
     *     so methods can be called on it from within this function.
     * @field
     */
    finalize: (source: Source) => void
  }

  /**
   * The `GSourceFuncs` struct contains a table of
   * functions used to handle event sources in a generic manner.
   *
   * For idle sources, the prepare and check functions always return %TRUE
   * to indicate that the source is always ready to be processed. The prepare
   * function also returns a timeout value of 0 to ensure that the poll() call
   * doesn't block (since that would be time wasted which could have been spent
   * running the idle function).
   *
   * For timeout sources, the prepare and check functions both return %TRUE
   * if the timeout interval has expired. The prepare function also returns
   * a timeout value to ensure that the poll() call doesn't block too long
   * and miss the next timeout.
   *
   * For file descriptor sources, the prepare function typically returns %FALSE,
   * since it must wait until poll() has been called before it knows whether
   * any events need to be processed. It sets the returned timeout to -1 to
   * indicate that it doesn't mind how long the poll() call blocks. In the
   * check function, it tests the results of the poll() call to see if the
   * required condition has been met, and returns %TRUE if so.
   * @record
   */
  class SourceFuncs {
    // Own properties of GLib-2.0.GLib.SourceFuncs

    static name: string
  }

  interface SourcePrivate {}

  class SourcePrivate {
    // Own properties of GLib-2.0.GLib.SourcePrivate

    static name: string
  }

  interface StatBuf {}

  /**
   * A type corresponding to the appropriate struct type for the stat()
   * system call, depending on the platform and/or compiler being used.
   *
   * See g_stat() for more information.
   * @record
   */
  class StatBuf {
    // Own properties of GLib-2.0.GLib.StatBuf

    static name: string
  }

  interface StaticMutex {
    // Own fields of GLib-2.0.GLib.StaticMutex

    mutex: Mutex

    // Owm methods of GLib-2.0.GLib.StaticMutex

    getMutexImpl(): Mutex
  }

  /**
   * A #GStaticMutex works like a #GMutex.
   *
   * Prior to GLib 2.32, GStaticMutex had the significant advantage
   * that it doesn't need to be created at run-time, but can be defined
   * at compile-time. Since 2.32, #GMutex can be statically allocated
   * as well, and GStaticMutex has been deprecated.
   *
   * Here is a version of our give_me_next_number() example using
   * a GStaticMutex:
   *
   * ```
   *   int
   *   give_me_next_number (void)
   *   {
   *     static int current_number = 0;
   *     int ret_val;
   *     static GStaticMutex mutex = G_STATIC_MUTEX_INIT;
   *
   *     g_static_mutex_lock (&mutex);
   *     ret_val = current_number = calc_next_number (current_number);
   *     g_static_mutex_unlock (&mutex);
   *
   *     return ret_val;
   *   }
   * ```
   *
   *
   * Sometimes you would like to dynamically create a mutex. If you don't
   * want to require prior calling to g_thread_init(), because your code
   * should also be usable in non-threaded programs, you are not able to
   * use g_mutex_new() and thus #GMutex, as that requires a prior call to
   * g_thread_init(). In these cases you can also use a #GStaticMutex.
   * It must be initialized with g_static_mutex_init() before using it
   * and freed with with g_static_mutex_free() when not needed anymore to
   * free up any allocated resources.
   *
   * Even though #GStaticMutex is not opaque, it should only be used with
   * the following functions, as it is defined differently on different
   * platforms.
   *
   * All of the g_static_mutex_* functions apart from
   * g_static_mutex_get_mutex() can also be used even if g_thread_init()
   * has not yet been called. Then they do nothing, apart from
   * g_static_mutex_trylock() which does nothing but returning %TRUE.
   *
   * All of the g_static_mutex_* functions are actually macros. Apart from
   * taking their addresses, you can however use them as if they were
   * functions.
   * @record
   */
  class StaticMutex {
    // Own properties of GLib-2.0.GLib.StaticMutex

    static name: string
  }

  interface StaticPrivate {}

  /**
   * A #GStaticPrivate works almost like a #GPrivate, but it has one
   * significant advantage. It doesn't need to be created at run-time
   * like a #GPrivate, but can be defined at compile-time. This is
   * similar to the difference between #GMutex and #GStaticMutex.
   *
   * Now look at our give_me_next_number() example with #GStaticPrivate:
   *
   * ```
   *   int
   *   give_me_next_number ()
   *   {
   *     static GStaticPrivate current_number_key = G_STATIC_PRIVATE_INIT;
   *     int *current_number = g_static_private_get (&current_number_key);
   *
   *     if (!current_number)
   *       {
   *         current_number = g_new (int, 1);
   *         *current_number = 0;
   *         g_static_private_set (&current_number_key, current_number, g_free);
   *       }
   *
   *     *current_number = calc_next_number (*current_number);
   *
   *     return *current_number;
   *   }
   * ```
   *
   * @record
   */
  class StaticPrivate {
    // Own properties of GLib-2.0.GLib.StaticPrivate

    static name: string
  }

  interface StaticRWLock {}

  /**
   * The #GStaticRWLock struct represents a read-write lock. A read-write
   * lock can be used for protecting data that some portions of code only
   * read from, while others also write. In such situations it is
   * desirable that several readers can read at once, whereas of course
   * only one writer may write at a time.
   *
   * Take a look at the following example:
   *
   * ```
   *   GStaticRWLock rwlock = G_STATIC_RW_LOCK_INIT;
   *   GPtrArray *array;
   *
   *   gpointer
   *   my_array_get (guint index)
   *   {
   *     gpointer retval = NULL;
   *
   *     if (!array)
   *       return NULL;
   *
   *     g_static_rw_lock_reader_lock (&rwlock);
   *     if (index < array->len)
   *       retval = g_ptr_array_index (array, index);
   *     g_static_rw_lock_reader_unlock (&rwlock);
   *
   *     return retval;
   *   }
   *
   *   void
   *   my_array_set (guint index, gpointer data)
   *   {
   *     g_static_rw_lock_writer_lock (&rwlock);
   *
   *     if (!array)
   *       array = g_ptr_array_new ();
   *
   *     if (index >= array->len)
   *       g_ptr_array_set_size (array, index + 1);
   *     g_ptr_array_index (array, index) = data;
   *
   *     g_static_rw_lock_writer_unlock (&rwlock);
   *   }
   * ```
   *
   *
   * This example shows an array which can be accessed by many readers
   * (the my_array_get() function) simultaneously, whereas the writers
   * (the my_array_set() function) will only be allowed once at a time
   * and only if no readers currently access the array. This is because
   * of the potentially dangerous resizing of the array. Using these
   * functions is fully multi-thread safe now.
   *
   * Most of the time, writers should have precedence over readers. That
   * means, for this implementation, that as soon as a writer wants to
   * lock the data, no other reader is allowed to lock the data, whereas,
   * of course, the readers that already have locked the data are allowed
   * to finish their operation. As soon as the last reader unlocks the
   * data, the writer will lock it.
   *
   * Even though #GStaticRWLock is not opaque, it should only be used
   * with the following functions.
   *
   * All of the g_static_rw_lock_* functions can be used even if
   * g_thread_init() has not been called. Then they do nothing, apart
   * from g_static_rw_lock_*_trylock, which does nothing but returning %TRUE.
   *
   * A read-write lock has a higher overhead than a mutex. For example, both
   * g_static_rw_lock_reader_lock() and g_static_rw_lock_reader_unlock() have
   * to lock and unlock a #GStaticMutex, so it takes at least twice the time
   * to lock and unlock a #GStaticRWLock that it does to lock and unlock a
   * #GStaticMutex. So only data structures that are accessed by multiple
   * readers, and which keep the lock for a considerable time justify a
   * #GStaticRWLock. The above example most probably would fare better with a
   * #GStaticMutex.
   * @record
   */
  class StaticRWLock {
    // Own properties of GLib-2.0.GLib.StaticRWLock

    static name: string
  }

  interface StaticRecMutex {}

  /**
   * A #GStaticRecMutex works like a #GStaticMutex, but it can be locked
   * multiple times by one thread. If you enter it n times, you have to
   * unlock it n times again to let other threads lock it. An exception
   * is the function g_static_rec_mutex_unlock_full(): that allows you to
   * unlock a #GStaticRecMutex completely returning the depth, (i.e. the
   * number of times this mutex was locked). The depth can later be used
   * to restore the state of the #GStaticRecMutex by calling
   * g_static_rec_mutex_lock_full(). In GLib 2.32, #GStaticRecMutex has
   * been deprecated in favor of #GRecMutex.
   *
   * Even though #GStaticRecMutex is not opaque, it should only be used
   * with the following functions.
   *
   * All of the g_static_rec_mutex_* functions can be used even if
   * g_thread_init() has not been called. Then they do nothing, apart
   * from g_static_rec_mutex_trylock(), which does nothing but returning
   * %TRUE.
   * @record
   */
  class StaticRecMutex {
    // Own properties of GLib-2.0.GLib.StaticRecMutex

    static name: string
  }

  interface String {
    // Own fields of GLib-2.0.GLib.String

    /**
     * points to the character data. It may move as text is added.
     *   The `str` field is null-terminated and so
     *   can be used as an ordinary C string.
     * @field
     */
    str: string | null
    /**
     * contains the length of the string, not including the
     *   terminating nul byte.
     * @field
     */
    len: number
    /**
     * the number of bytes that can be stored in the
     *   string before it needs to be reallocated. May be larger than `len`.
     * @field
     */
    allocatedLen: number

    // Owm methods of GLib-2.0.GLib.String

    /**
     * Adds a string onto the end of a #GString, expanding
     * it if necessary.
     * @param val the string to append onto the end of `string`
     * @returns @string
     */
    append(val: string): String
    /**
     * Adds a byte onto the end of a #GString, expanding
     * it if necessary.
     * @param c the byte to append onto the end of `string`
     * @returns @string
     */
    appendC(c: number): String
    /**
     * Appends `len` bytes of `val` to `string`.
     *
     * If `len` is positive, `val` may contain embedded nuls and need
     * not be nul-terminated. It is the caller's responsibility to
     * ensure that `val` has at least `len` addressable bytes.
     *
     * If `len` is negative, `val` must be nul-terminated and `len`
     * is considered to request the entire string length. This
     * makes g_string_append_len() equivalent to g_string_append().
     * @param val bytes to append
     * @param len number of bytes of `val` to use, or -1 for all of `val`
     * @returns @string
     */
    appendLen(val: string, len: number): String
    /**
     * Converts a Unicode character into UTF-8, and appends it
     * to the string.
     * @param wc a Unicode character
     * @returns @string
     */
    appendUnichar(wc: string): String
    /**
     * Appends `unescaped` to `string,` escaping any characters that
     * are reserved in URIs using URI-style escape sequences.
     * @param unescaped a string
     * @param reservedCharsAllowed a string of reserved characters allowed     to be used, or %NULL
     * @param allowUtf8 set %TRUE if the escaped string may include UTF8 characters
     * @returns @string
     */
    appendUriEscaped(
      unescaped: string,
      reservedCharsAllowed: string,
      allowUtf8: boolean
    ): String
    /**
     * Converts all uppercase ASCII letters to lowercase ASCII letters.
     * @returns passed-in @string pointer, with all the     uppercase characters converted to lowercase in place,     with semantics that exactly match g_ascii_tolower().
     */
    asciiDown(): String
    /**
     * Converts all lowercase ASCII letters to uppercase ASCII letters.
     * @returns passed-in @string pointer, with all the     lowercase characters converted to uppercase in place,     with semantics that exactly match g_ascii_toupper().
     */
    asciiUp(): String
    /**
     * Copies the bytes from a string into a #GString,
     * destroying any previous contents. It is rather like
     * the standard strcpy() function, except that you do not
     * have to worry about having enough space to copy the string.
     * @param rval the string to copy into `string`
     * @returns @string
     */
    assign(rval: string): String
    /**
     * Converts a #GString to lowercase.
     * @returns the #GString
     */
    down(): String
    /**
     * Compares two strings for equality, returning %TRUE if they are equal.
     * For use with #GHashTable.
     * @param v2 another #GString
     * @returns %TRUE if the strings are the same length and contain the     same bytes
     */
    equal(v2: String): boolean
    /**
     * Removes `len` bytes from a #GString, starting at position `pos`.
     * The rest of the #GString is shifted down to fill the gap.
     * @param pos the position of the content to remove
     * @param len the number of bytes to remove, or -1 to remove all       following bytes
     * @returns @string
     */
    erase(pos: number, len: number): String
    /**
     * Frees the memory allocated for the #GString.
     * If `free_segment` is %TRUE it also frees the character data.  If
     * it's %FALSE, the caller gains ownership of the buffer and must
     * free it after use with g_free().
     *
     * Instead of passing %FALSE to this function, consider using
     * g_string_free_and_steal().
     * @param freeSegment if %TRUE, the actual character data is freed as well
     * @returns the character data of @string          (i.e. %NULL if @free_segment is %TRUE)
     */
    free(freeSegment: boolean): string | null
    /**
     * Frees the memory allocated for the #GString.
     *
     * The caller gains ownership of the buffer and
     * must free it after use with g_free().
     * @returns the character data of @string
     */
    freeAndSteal(): string | null
    /**
     * Transfers ownership of the contents of `string` to a newly allocated
     * #GBytes.  The #GString structure itself is deallocated, and it is
     * therefore invalid to use `string` after invoking this function.
     *
     * Note that while #GString ensures that its buffer always has a
     * trailing nul character (not reflected in its "len"), the returned
     * #GBytes does not include this extra nul; i.e. it has length exactly
     * equal to the "len" member.
     * @returns A newly allocated #GBytes containing contents of @string; @string itself is freed
     */
    freeToBytes(): any
    /**
     * Creates a hash code for `str;` for use with #GHashTable.
     * @returns hash code for @str
     */
    hash(): number
    /**
     * Inserts a copy of a string into a #GString,
     * expanding it if necessary.
     * @param pos the position to insert the copy of the string
     * @param val the string to insert
     * @returns @string
     */
    insert(pos: number, val: string): String
    /**
     * Inserts a byte into a #GString, expanding it if necessary.
     * @param pos the position to insert the byte
     * @param c the byte to insert
     * @returns @string
     */
    insertC(pos: number, c: number): String
    /**
     * Inserts `len` bytes of `val` into `string` at `pos`.
     *
     * If `len` is positive, `val` may contain embedded nuls and need
     * not be nul-terminated. It is the caller's responsibility to
     * ensure that `val` has at least `len` addressable bytes.
     *
     * If `len` is negative, `val` must be nul-terminated and `len`
     * is considered to request the entire string length.
     *
     * If `pos` is -1, bytes are inserted at the end of the string.
     * @param pos position in `string` where insertion should       happen, or -1 for at the end
     * @param val bytes to insert
     * @param len number of bytes of `val` to insert, or -1 for all of `val`
     * @returns @string
     */
    insertLen(pos: number, val: string, len: number): String
    /**
     * Converts a Unicode character into UTF-8, and insert it
     * into the string at the given position.
     * @param pos the position at which to insert character, or -1     to append at the end of the string
     * @param wc a Unicode character
     * @returns @string
     */
    insertUnichar(pos: number, wc: string): String
    /**
     * Overwrites part of a string, lengthening it if necessary.
     * @param pos the position at which to start overwriting
     * @param val the string that will overwrite the `string` starting at `pos`
     * @returns @string
     */
    overwrite(pos: number, val: string): String
    /**
     * Overwrites part of a string, lengthening it if necessary.
     * This function will work with embedded nuls.
     * @param pos the position at which to start overwriting
     * @param val the string that will overwrite the `string` starting at `pos`
     * @param len the number of bytes to write from `val`
     * @returns @string
     */
    overwriteLen(pos: number, val: string, len: number): String
    /**
     * Adds a string on to the start of a #GString,
     * expanding it if necessary.
     * @param val the string to prepend on the start of `string`
     * @returns @string
     */
    prepend(val: string): String
    /**
     * Adds a byte onto the start of a #GString,
     * expanding it if necessary.
     * @param c the byte to prepend on the start of the #GString
     * @returns @string
     */
    prependC(c: number): String
    /**
     * Prepends `len` bytes of `val` to `string`.
     *
     * If `len` is positive, `val` may contain embedded nuls and need
     * not be nul-terminated. It is the caller's responsibility to
     * ensure that `val` has at least `len` addressable bytes.
     *
     * If `len` is negative, `val` must be nul-terminated and `len`
     * is considered to request the entire string length. This
     * makes g_string_prepend_len() equivalent to g_string_prepend().
     * @param val bytes to prepend
     * @param len number of bytes in `val` to prepend, or -1 for all of `val`
     * @returns @string
     */
    prependLen(val: string, len: number): String
    /**
     * Converts a Unicode character into UTF-8, and prepends it
     * to the string.
     * @param wc a Unicode character
     * @returns @string
     */
    prependUnichar(wc: string): String
    /**
     * Replaces the string `find` with the string `replace` in a #GString up to
     * `limit` times. If the number of instances of `find` in the #GString is
     * less than `limit,` all instances are replaced. If `limit` is `0`,
     * all instances of `find` are replaced.
     *
     * If `find` is the empty string, since versions 2.69.1 and 2.68.4 the
     * replacement will be inserted no more than once per possible position
     * (beginning of string, end of string and between characters). This did
     * not work correctly in earlier versions.
     * @param find the string to find in `string`
     * @param replace the string to insert in place of `find`
     * @param limit the maximum instances of `find` to replace with `replace,` or `0` for no limit
     * @returns the number of find and replace operations performed.
     */
    replace(find: string, replace: string, limit: number): number
    /**
     * Sets the length of a #GString. If the length is less than
     * the current length, the string will be truncated. If the
     * length is greater than the current length, the contents
     * of the newly added area are undefined. (However, as
     * always, string->str[string->len] will be a nul byte.)
     * @param len the new length
     * @returns @string
     */
    setSize(len: number): String
    /**
     * Cuts off the end of the GString, leaving the first `len` bytes.
     * @param len the new size of `string`
     * @returns @string
     */
    truncate(len: number): String
    /**
     * Converts a #GString to uppercase.
     * @returns @string
     */
    up(): String
  }

  /**
   * A `GString` is an object that handles the memory management of a C string.
   *
   * The emphasis of `GString` is on text, typically UTF-8. Crucially, the "str" member
   * of a `GString` is guaranteed to have a trailing nul character, and it is therefore
   * always safe to call functions such as `strchr()` or `strdup()` on it.
   *
   * However, a `GString` can also hold arbitrary binary data, because it has a "len" member,
   * which includes any possible embedded nul characters in the data. Conceptually then,
   * `GString` is like a `GByteArray` with the addition of many convenience methods for
   * text, and a guaranteed nul terminator.
   * @record
   */
  class String {
    // Own properties of GLib-2.0.GLib.String

    static name: string

    // Constructors of GLib-2.0.GLib.String

    /**
     * Creates a new #GString, initialized with the given string.
     * @constructor
     * @param init the initial text to copy into the string, or %NULL to   start with an empty string
     * @returns the new #GString
     */
    constructor(init: string | null)
    /**
     * Creates a new #GString, initialized with the given string.
     * @constructor
     * @param init the initial text to copy into the string, or %NULL to   start with an empty string
     * @returns the new #GString
     */
    static new(init: string | null): String
    /**
     * Creates a new #GString with `len` bytes of the `init` buffer.
     * Because a length is provided, `init` need not be nul-terminated,
     * and can contain embedded nul bytes.
     *
     * Since this function does not stop at nul bytes, it is the caller's
     * responsibility to ensure that `init` has at least `len` addressable
     * bytes.
     * @constructor
     * @param init initial contents of the string
     * @param len length of `init` to use
     * @returns a new #GString
     */
    static newLen(init: string, len: number): String
    /**
     * Creates a new #GString, initialized with the given string.
     *
     * After this call, `init` belongs to the #GString and may no longer be
     * modified by the caller. The memory of `data` has to be dynamically
     * allocated and will eventually be freed with g_free().
     * @constructor
     * @param init initial text used as the string.     Ownership of the string is transferred to the #GString.     Passing %NULL creates an empty string.
     * @returns the new #GString
     */
    static newTake(init: string | null): String
    /**
     * Creates a new #GString, with enough space for `dfl_size`
     * bytes. This is useful if you are going to add a lot of
     * text to the string and don't want it to be reallocated
     * too often.
     * @constructor
     * @param dflSize the default size of the space allocated to hold the string
     * @returns the new #GString
     */
    static sizedNew(dflSize: number): String
  }

  interface StringChunk {
    // Owm methods of GLib-2.0.GLib.StringChunk

    /**
     * Frees all strings contained within the #GStringChunk.
     * After calling g_string_chunk_clear() it is not safe to
     * access any of the strings which were contained within it.
     */
    clear(): void
    /**
     * Frees all memory allocated by the #GStringChunk.
     * After calling g_string_chunk_free() it is not safe to
     * access any of the strings which were contained within it.
     */
    free(): void
    /**
     * Adds a copy of `string` to the #GStringChunk.
     * It returns a pointer to the new copy of the string
     * in the #GStringChunk. The characters in the string
     * can be changed, if necessary, though you should not
     * change anything after the end of the string.
     *
     * Unlike g_string_chunk_insert_const(), this function
     * does not check for duplicates. Also strings added
     * with g_string_chunk_insert() will not be searched
     * by g_string_chunk_insert_const() when looking for
     * duplicates.
     * @param string the string to add
     * @returns a pointer to the copy of @string within     the #GStringChunk
     */
    insert(string: string): string | null
    /**
     * Adds a copy of `string` to the #GStringChunk, unless the same
     * string has already been added to the #GStringChunk with
     * g_string_chunk_insert_const().
     *
     * This function is useful if you need to copy a large number
     * of strings but do not want to waste space storing duplicates.
     * But you must remember that there may be several pointers to
     * the same string, and so any changes made to the strings
     * should be done very carefully.
     *
     * Note that g_string_chunk_insert_const() will not return a
     * pointer to a string added with g_string_chunk_insert(), even
     * if they do match.
     * @param string the string to add
     * @returns a pointer to the new or existing copy of @string     within the #GStringChunk
     */
    insertConst(string: string): string | null
    /**
     * Adds a copy of the first `len` bytes of `string` to the #GStringChunk.
     * The copy is nul-terminated.
     *
     * Since this function does not stop at nul bytes, it is the caller's
     * responsibility to ensure that `string` has at least `len` addressable
     * bytes.
     *
     * The characters in the returned string can be changed, if necessary,
     * though you should not change anything after the end of the string.
     * @param string bytes to insert
     * @param len number of bytes of `string` to insert, or -1 to insert a     nul-terminated string
     * @returns a pointer to the copy of @string within the #GStringChunk
     */
    insertLen(string: string, len: number): string | null
  }

  /**
   * `GStringChunk` provides efficient storage of groups of strings
   *
   * String chunks are used to store groups of strings. Memory is
   * allocated in blocks, and as strings are added to the `GStringChunk`
   * they are copied into the next free position in a block. When a block
   * is full a new block is allocated.
   *
   * When storing a large number of strings, string chunks are more
   * efficient than using [func`GLib`.strdup] since fewer calls to `malloc()`
   * are needed, and less memory is wasted in memory allocation overheads.
   *
   * By adding strings with [method`GLib`.StringChunk.insert_const] it is also
   * possible to remove duplicates.
   *
   * To create a new `GStringChunk` use [func`GLib`.StringChunk.new].
   *
   * To add strings to a `GStringChunk` use [method`GLib`.StringChunk.insert].
   *
   * To add strings to a `GStringChunk`, but without duplicating strings
   * which are already in the `GStringChunk`, use [method`GLib`.StringChunk.insert_const].
   *
   * To free the entire `GStringChunk` use [method`GLib`.StringChunk.free].
   * It is not possible to free individual strings.
   * @record
   */
  class StringChunk {
    // Own properties of GLib-2.0.GLib.StringChunk

    static name: string
  }

  interface StrvBuilder {
    // Owm methods of GLib-2.0.GLib.StrvBuilder

    /**
     * Add a string to the end of the array.
     *
     * Since 2.68
     * @param value a string.
     */
    add(value: string): void
    /**
     * Appends all the strings in the given vector to the builder.
     *
     * Since 2.70
     * @param value the vector of strings to add
     */
    addv(value: string[]): void
    /**
     * Ends the builder process and returns the constructed NULL-terminated string
     * array. The returned value should be freed with g_strfreev() when no longer
     * needed.
     * @returns the constructed string array. Since 2.68
     */
    end(): string[]
    /**
     * Atomically increments the reference count of `builder` by one.
     * This function is thread-safe and may be called from any thread.
     * @returns The passed in #GStrvBuilder
     */
    ref(): StrvBuilder
    /**
     * Add a string to the end of the array. After `value` belongs to the
     * #GStrvBuilder and may no longer be modified by the caller.
     *
     * Since 2.80
     * @param value a string.     Ownership of the string is transferred to the #GStrvBuilder
     */
    take(value: string | null): void
    /**
     * Decreases the reference count on `builder`.
     *
     * In the event that there are no more references, releases all memory
     * associated with the #GStrvBuilder.
     */
    unref(): void
  }

  /**
   * `GStrvBuilder` is a helper object to build a %NULL-terminated string arrays.
   *
   * The following example shows how to build a two element array:
   *
   * ```c
   *   g_autoptr(GStrvBuilder) builder = g_strv_builder_new ();
   *   g_strv_builder_add (builder, "hello");
   *   g_strv_builder_add (builder, "world");
   *   g_auto(GStrv) array = g_strv_builder_end (builder);
   * ```
   * @record
   */
  class StrvBuilder {
    // Own properties of GLib-2.0.GLib.StrvBuilder

    static name: string

    // Constructors of GLib-2.0.GLib.StrvBuilder

    /**
     * Creates a new #GStrvBuilder with a reference count of 1.
     * Use g_strv_builder_unref() on the returned value when no longer needed.
     * @constructor
     * @returns the new #GStrvBuilder
     */
    constructor()
    /**
     * Creates a new #GStrvBuilder with a reference count of 1.
     * Use g_strv_builder_unref() on the returned value when no longer needed.
     * @constructor
     * @returns the new #GStrvBuilder
     */
    static new(): StrvBuilder
  }

  interface TestCase {
    // Owm methods of GLib-2.0.GLib.TestCase

    /**
     * Free the `test_case`.
     */
    free(): void
  }

  /**
   * An opaque structure representing a test case.
   * @record
   */
  class TestCase {
    // Own properties of GLib-2.0.GLib.TestCase

    static name: string
  }

  interface TestConfig {
    // Own fields of GLib-2.0.GLib.TestConfig

    testInitialized: boolean
    testQuick: boolean
    testPerf: boolean
    testVerbose: boolean
    testQuiet: boolean
    testUndefined: boolean
  }

  class TestConfig {
    // Own properties of GLib-2.0.GLib.TestConfig

    static name: string
  }

  interface TestLogBuffer {
    // Owm methods of GLib-2.0.GLib.TestLogBuffer

    /**
     * Internal function for gtester to free test log messages, no ABI guarantees provided.
     */
    free(): void
    /**
     * Internal function for gtester to decode test log messages, no ABI guarantees provided.
     * @param nBytes
     * @param bytes
     */
    push(nBytes: number, bytes: number): void
  }

  class TestLogBuffer {
    // Own properties of GLib-2.0.GLib.TestLogBuffer

    static name: string
  }

  interface TestLogMsg {
    // Own fields of GLib-2.0.GLib.TestLogMsg

    logType: TestLogType
    nStrings: number
    strings: string | null
    nNums: number

    // Owm methods of GLib-2.0.GLib.TestLogMsg

    /**
     * Internal function for gtester to free test log messages, no ABI guarantees provided.
     */
    free(): void
  }

  class TestLogMsg {
    // Own properties of GLib-2.0.GLib.TestLogMsg

    static name: string
  }

  interface TestSuite {
    // Owm methods of GLib-2.0.GLib.TestSuite

    /**
     * Adds `test_case` to `suite`.
     * @param testCase a #GTestCase
     */
    add(testCase: TestCase): void
    /**
     * Adds `nestedsuite` to `suite`.
     * @param nestedsuite another #GTestSuite
     */
    addSuite(nestedsuite: TestSuite): void
    /**
     * Free the `suite` and all nested #GTestSuites.
     */
    free(): void
  }

  /**
   * An opaque structure representing a test suite.
   * @record
   */
  class TestSuite {
    // Own properties of GLib-2.0.GLib.TestSuite

    static name: string
  }

  interface Thread {
    // Owm methods of GLib-2.0.GLib.Thread

    /**
     * Waits until `thread` finishes, i.e. the function `func,` as
     * given to g_thread_new(), returns or g_thread_exit() is called.
     * If `thread` has already terminated, then g_thread_join()
     * returns immediately.
     *
     * Any thread can wait for any other thread by calling g_thread_join(),
     * not just its 'creator'. Calling g_thread_join() from multiple threads
     * for the same `thread` leads to undefined behaviour.
     *
     * The value returned by `func` or given to g_thread_exit() is
     * returned by this function.
     *
     * g_thread_join() consumes the reference to the passed-in `thread`.
     * This will usually cause the #GThread struct and associated resources
     * to be freed. Use g_thread_ref() to obtain an extra reference if you
     * want to keep the GThread alive beyond the g_thread_join() call.
     * @returns the return value of the thread
     */
    join(): any | null
    /**
     * Increase the reference count on `thread`.
     * @returns a new reference to @thread
     */
    ref(): Thread
    /**
     * Decrease the reference count on `thread,` possibly freeing all
     * resources associated with it.
     *
     * Note that each thread holds a reference to its #GThread while
     * it is running, so it is safe to drop your own reference to it
     * if you don't need it anymore.
     */
    unref(): void
  }

  /**
   * The #GThread struct represents a running thread. This struct
   * is returned by g_thread_new() or g_thread_try_new(). You can
   * obtain the #GThread struct representing the current thread by
   * calling g_thread_self().
   *
   * GThread is refcounted, see g_thread_ref() and g_thread_unref().
   * The thread represented by it holds a reference while it is running,
   * and g_thread_join() consumes the reference that it is given, so
   * it is normally not necessary to manage GThread references
   * explicitly.
   *
   * The structure is opaque -- none of its fields may be directly
   * accessed.
   * @record
   */
  class Thread {
    // Own properties of GLib-2.0.GLib.Thread

    static name: string

    // Constructors of GLib-2.0.GLib.Thread

    /**
     * This function creates a new thread. The new thread starts by invoking
     * `func` with the argument data. The thread will run until `func` returns
     * or until g_thread_exit() is called from the new thread. The return value
     * of `func` becomes the return value of the thread, which can be obtained
     * with g_thread_join().
     *
     * The `name` can be useful for discriminating threads in a debugger.
     * It is not used for other purposes and does not have to be unique.
     * Some systems restrict the length of `name` to 16 bytes.
     *
     * If the thread can not be created the program aborts. See
     * g_thread_try_new() if you want to attempt to deal with failures.
     *
     * If you are using threads to offload (potentially many) short-lived tasks,
     * #GThreadPool may be more appropriate than manually spawning and tracking
     * multiple #GThreads.
     *
     * To free the struct returned by this function, use g_thread_unref().
     * Note that g_thread_join() implicitly unrefs the #GThread as well.
     *
     * New threads by default inherit their scheduler policy (POSIX) or thread
     * priority (Windows) of the thread creating the new thread.
     *
     * This behaviour changed in GLib 2.64: before threads on Windows were not
     * inheriting the thread priority but were spawned with the default priority.
     * Starting with GLib 2.64 the behaviour is now consistent between Windows and
     * POSIX and all threads inherit their parent thread's priority.
     * @constructor
     * @param name an (optional) name for the new thread
     * @param func a function to execute in the new thread
     * @returns the new #GThread
     */
    constructor(name: string | null, func: ThreadFunc)
    /**
     * This function creates a new thread. The new thread starts by invoking
     * `func` with the argument data. The thread will run until `func` returns
     * or until g_thread_exit() is called from the new thread. The return value
     * of `func` becomes the return value of the thread, which can be obtained
     * with g_thread_join().
     *
     * The `name` can be useful for discriminating threads in a debugger.
     * It is not used for other purposes and does not have to be unique.
     * Some systems restrict the length of `name` to 16 bytes.
     *
     * If the thread can not be created the program aborts. See
     * g_thread_try_new() if you want to attempt to deal with failures.
     *
     * If you are using threads to offload (potentially many) short-lived tasks,
     * #GThreadPool may be more appropriate than manually spawning and tracking
     * multiple #GThreads.
     *
     * To free the struct returned by this function, use g_thread_unref().
     * Note that g_thread_join() implicitly unrefs the #GThread as well.
     *
     * New threads by default inherit their scheduler policy (POSIX) or thread
     * priority (Windows) of the thread creating the new thread.
     *
     * This behaviour changed in GLib 2.64: before threads on Windows were not
     * inheriting the thread priority but were spawned with the default priority.
     * Starting with GLib 2.64 the behaviour is now consistent between Windows and
     * POSIX and all threads inherit their parent thread's priority.
     * @constructor
     * @param name an (optional) name for the new thread
     * @param func a function to execute in the new thread
     * @returns the new #GThread
     */
    static new(name: string | null, func: ThreadFunc): Thread
    /**
     * This function is the same as g_thread_new() except that
     * it allows for the possibility of failure.
     *
     * If a thread can not be created (due to resource limits),
     * `error` is set and %NULL is returned.
     * @constructor
     * @param name an (optional) name for the new thread
     * @param func a function to execute in the new thread
     * @returns the new #GThread, or %NULL if an error occurred
     */
    static tryNew(name: string | null, func: ThreadFunc): Thread
    static errorQuark(): Quark
    /**
     * Terminates the current thread.
     *
     * If another thread is waiting for us using g_thread_join() then the
     * waiting thread will be woken up and get `retval` as the return value
     * of g_thread_join().
     *
     * Calling g_thread_exit() with a parameter `retval` is equivalent to
     * returning `retval` from the function `func,` as given to g_thread_new().
     *
     * You must only call g_thread_exit() from a thread that you created
     * yourself with g_thread_new() or related APIs. You must not call
     * this function from a thread created with another threading library
     * or or from within a #GThreadPool.
     * @param retval the return value of this thread
     */
    static exit(retval: any | null): void
    /**
     * This function returns the #GThread corresponding to the
     * current thread. Note that this function does not increase
     * the reference count of the returned struct.
     *
     * This function will return a #GThread even for threads that
     * were not created by GLib (i.e. those created by other threading
     * APIs). This may be useful for thread identification purposes
     * (i.e. comparisons) but you must not use GLib functions (such
     * as g_thread_join()) on these threads.
     * @returns the #GThread representing the current thread
     */
    static self(): Thread
    /**
     * Causes the calling thread to voluntarily relinquish the CPU, so
     * that other threads can run.
     *
     * This function is often used as a method to make busy wait less evil.
     */
    static yield(): void
  }

  interface ThreadFunctions {
    // Own fields of GLib-2.0.GLib.ThreadFunctions

    /**
     * virtual function pointer for g_mutex_new()
     * @field
     */
    mutexNew: () => Mutex
    /**
     * virtual function pointer for g_mutex_lock()
     * @field
     */
    mutexLock: (mutex: Mutex) => void
    /**
     * virtual function pointer for g_mutex_trylock()
     * @field
     */
    mutexTrylock: (mutex: Mutex) => boolean
    /**
     * virtual function pointer for g_mutex_unlock()
     * @field
     */
    mutexUnlock: (mutex: Mutex) => void
    /**
     * virtual function pointer for g_mutex_free()
     * @field
     */
    mutexFree: (mutex: Mutex) => void
    /**
     * virtual function pointer for g_cond_new()
     * @field
     */
    condNew: () => Cond
    /**
     * virtual function pointer for g_cond_signal()
     * @field
     */
    condSignal: (cond: Cond) => void
    /**
     * virtual function pointer for g_cond_broadcast()
     * @field
     */
    condBroadcast: (cond: Cond) => void
    /**
     * virtual function pointer for g_cond_wait()
     * @field
     */
    condWait: (cond: Cond, mutex: Mutex) => void
    /**
     * virtual function pointer for g_cond_timed_wait()
     * @field
     */
    condTimedWait: (cond: Cond, mutex: Mutex, endTime: TimeVal) => boolean
    /**
     * virtual function pointer for g_cond_free()
     * @field
     */
    condFree: (cond: Cond) => void
    /**
     * virtual function pointer for g_private_new()
     * @field
     */
    privateNew: (destructor: DestroyNotify) => Private
    /**
     * virtual function pointer for g_private_get()
     * @field
     */
    privateGet: (privateKey: Private) => any
    /**
     * virtual function pointer for g_private_set()
     * @field
     */
    privateSet: (privateKey: Private, data: any) => void
    /**
     * virtual function pointer for g_thread_create()
     * @field
     */
    threadCreate: any
    /**
     * virtual function pointer for g_thread_yield()
     * @field
     */
    threadYield: () => void
    /**
     * virtual function pointer for g_thread_join()
     * @field
     */
    threadJoin: (thread: any) => void
    /**
     * virtual function pointer for g_thread_exit()
     * @field
     */
    threadExit: () => void
    /**
     * virtual function pointer for
     *                       g_thread_set_priority()
     * @field
     */
    threadSetPriority: any
    /**
     * virtual function pointer for g_thread_self()
     * @field
     */
    threadSelf: (thread: any) => void
    /**
     * used internally by recursive mutex locks and by some
     *                assertion checks
     * @field
     */
    threadEqual: (thread1: any, thread2: any) => boolean
  }

  /**
   * This function table is no longer used by g_thread_init()
   * to initialize the thread system.
   * @record
   */
  class ThreadFunctions {
    // Own properties of GLib-2.0.GLib.ThreadFunctions

    static name: string
  }

  interface ThreadPool {
    // Own fields of GLib-2.0.GLib.ThreadPool

    /**
     * the function to execute in the threads of this pool
     * @field
     */
    func: Func
    /**
     * the user data for the threads of this pool
     * @field
     */
    userData: any
    /**
     * are all threads exclusive to this pool
     * @field
     */
    exclusive: boolean

    // Owm methods of GLib-2.0.GLib.ThreadPool

    /**
     * Frees all resources allocated for `pool`.
     *
     * If `immediate` is %TRUE, no new task is processed for `pool`.
     * Otherwise `pool` is not freed before the last task is processed.
     * Note however, that no thread of this pool is interrupted while
     * processing a task. Instead at least all still running threads
     * can finish their tasks before the `pool` is freed.
     *
     * If `wait_` is %TRUE, this function does not return before all
     * tasks to be processed (dependent on `immediate,` whether all
     * or only the currently running) are ready.
     * Otherwise this function returns immediately.
     *
     * After calling this function `pool` must not be used anymore.
     * @param immediate should `pool` shut down immediately?
     * @param wait should the function wait for all tasks to be finished?
     */
    free(immediate: boolean, wait: boolean): void
    /**
     * Returns the maximal number of threads for `pool`.
     * @returns the maximal number of threads
     */
    getMaxThreads(): number
    /**
     * Returns the number of threads currently running in `pool`.
     * @returns the number of threads currently running
     */
    getNumThreads(): number
    /**
     * Moves the item to the front of the queue of unprocessed
     * items, so that it will be processed next.
     * @param data an unprocessed item in the pool
     * @returns %TRUE if the item was found and moved
     */
    moveToFront(data: any | null): boolean
    /**
     * Inserts `data` into the list of tasks to be executed by `pool`.
     *
     * When the number of currently running threads is lower than the
     * maximal allowed number of threads, a new thread is started (or
     * reused) with the properties given to g_thread_pool_new().
     * Otherwise, `data` stays in the queue until a thread in this pool
     * finishes its previous task and processes `data`.
     *
     * `error` can be %NULL to ignore errors, or non-%NULL to report
     * errors. An error can only occur when a new thread couldn't be
     * created. In that case `data` is simply appended to the queue of
     * work to do.
     *
     * Before version 2.32, this function did not return a success status.
     * @param data a new task for `pool`
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    push(data: any | null): boolean
    /**
     * Sets the maximal allowed number of threads for `pool`.
     * A value of -1 means that the maximal number of threads
     * is unlimited. If `pool` is an exclusive thread pool, setting
     * the maximal number of threads to -1 is not allowed.
     *
     * Setting `max_threads` to 0 means stopping all work for `pool`.
     * It is effectively frozen until `max_threads` is set to a non-zero
     * value again.
     *
     * A thread is never terminated while calling `func,` as supplied by
     * g_thread_pool_new(). Instead the maximal number of threads only
     * has effect for the allocation of new threads in g_thread_pool_push().
     * A new thread is allocated, whenever the number of currently
     * running threads in `pool` is smaller than the maximal number.
     *
     * `error` can be %NULL to ignore errors, or non-%NULL to report
     * errors. An error can only occur when a new thread couldn't be
     * created.
     *
     * Before version 2.32, this function did not return a success status.
     * @param maxThreads a new maximal number of threads for `pool,`     or -1 for unlimited
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    setMaxThreads(maxThreads: number): boolean
    /**
     * Returns the number of tasks still unprocessed in `pool`.
     * @returns the number of unprocessed tasks
     */
    unprocessed(): number
  }

  /**
   * The `GThreadPool` struct represents a thread pool.
   *
   * A thread pool is useful when you wish to asynchronously fork out the execution of work
   * and continue working in your own thread. If that will happen often, the overhead of starting
   * and destroying a thread each time might be too high. In such cases reusing already started
   * threads seems like a good idea. And it indeed is, but implementing this can be tedious
   * and error-prone.
   *
   * Therefore GLib provides thread pools for your convenience. An added advantage is, that the
   * threads can be shared between the different subsystems of your program, when they are using GLib.
   *
   * To create a new thread pool, you use [func`GLib`.ThreadPool.new].
   * It is destroyed by [method`GLib`.ThreadPool.free].
   *
   * If you want to execute a certain task within a thread pool, use [method`GLib`.ThreadPool.push].
   *
   * To get the current number of running threads you call [method`GLib`.ThreadPool.get_num_threads].
   * To get the number of still unprocessed tasks you call [method`GLib`.ThreadPool.unprocessed].
   * To control the maximum number of threads for a thread pool, you use
   * [method`GLib`.ThreadPool.get_max_threads]. and [method`GLib`.ThreadPool.set_max_threads].
   *
   * Finally you can control the number of unused threads, that are kept alive by GLib for future use.
   * The current number can be fetched with [func`GLib`.ThreadPool.get_num_unused_threads].
   * The maximum number can be controlled by [func`GLib`.ThreadPool.get_max_unused_threads] and
   * [func`GLib`.ThreadPool.set_max_unused_threads]. All currently unused threads
   * can be stopped by calling [func`GLib`.ThreadPool.stop_unused_threads].
   * @record
   */
  class ThreadPool {
    // Own properties of GLib-2.0.GLib.ThreadPool

    static name: string

    // Constructors of GLib-2.0.GLib.ThreadPool

    /**
     * This function will return the maximum `interval` that a
     * thread will wait in the thread pool for new tasks before
     * being stopped.
     *
     * If this function returns 0, threads waiting in the thread
     * pool for new work are not stopped.
     * @returns the maximum @interval (milliseconds) to wait     for new tasks in the thread pool before stopping the     thread
     */
    static getMaxIdleTime(): number
    /**
     * Returns the maximal allowed number of unused threads.
     * @returns the maximal number of unused threads
     */
    static getMaxUnusedThreads(): number
    /**
     * Returns the number of currently unused threads.
     * @returns the number of currently unused threads
     */
    static getNumUnusedThreads(): number
    /**
     * This function will set the maximum `interval` that a thread
     * waiting in the pool for new tasks can be idle for before
     * being stopped. This function is similar to calling
     * g_thread_pool_stop_unused_threads() on a regular timeout,
     * except this is done on a per thread basis.
     *
     * By setting `interval` to 0, idle threads will not be stopped.
     *
     * The default value is 15000 (15 seconds).
     * @param interval the maximum `interval` (in milliseconds)     a thread can be idle
     */
    static setMaxIdleTime(interval: number): void
    /**
     * Sets the maximal number of unused threads to `max_threads`.
     * If `max_threads` is -1, no limit is imposed on the number
     * of unused threads.
     *
     * The default value is 2.
     * @param maxThreads maximal number of unused threads
     */
    static setMaxUnusedThreads(maxThreads: number): void
    /**
     * Stops all currently unused threads. This does not change the
     * maximal number of unused threads. This function can be used to
     * regularly stop all unused threads e.g. from g_timeout_add().
     */
    static stopUnusedThreads(): void
  }

  interface TimeVal {
    // Own fields of GLib-2.0.GLib.TimeVal

    /**
     * seconds
     * @field
     */
    tvSec: number
    /**
     * microseconds
     * @field
     */
    tvUsec: number

    // Owm methods of GLib-2.0.GLib.TimeVal

    /**
     * Adds the given number of microseconds to `time_`. `microseconds` can
     * also be negative to decrease the value of `time_`.
     * @param microseconds number of microseconds to add to `time`
     */
    add(microseconds: number): void
    /**
     * Converts `time_` into an RFC 3339 encoded string, relative to the
     * Coordinated Universal Time (UTC). This is one of the many formats
     * allowed by ISO 8601.
     *
     * ISO 8601 allows a large number of date/time formats, with or without
     * punctuation and optional elements. The format returned by this function
     * is a complete date and time, with optional punctuation included, the
     * UTC time zone represented as "Z", and the `tv_usec` part included if
     * and only if it is nonzero, i.e. either
     * "YYYY-MM-DDTHH:MM:SSZ" or "YYYY-MM-DDTHH:MM:SS.fffffZ".
     *
     * This corresponds to the Internet date/time format defined by
     * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt),
     * and to either of the two most-precise formats defined by
     * the W3C Note
     * [Date and Time Formats](http://www.w3.org/TR/NOTE-datetime-19980827).
     * Both of these documents are profiles of ISO 8601.
     *
     * Use g_date_time_format() or g_strdup_printf() if a different
     * variation of ISO 8601 format is required.
     *
     * If `time_` represents a date which is too large to fit into a `struct tm`,
     * %NULL will be returned. This is platform dependent. Note also that since
     * `GTimeVal` stores the number of seconds as a `glong`, on 32-bit systems it
     * is subject to the year 2038 problem. Accordingly, since GLib 2.62, this
     * function has been deprecated. Equivalent functionality is available using:
     *
     * ```
     * GDateTime *dt = g_date_time_new_from_unix_utc (time_val);
     * iso8601_string = g_date_time_format_iso8601 (dt);
     * g_date_time_unref (dt);
     * ```
     *
     *
     * The return value of g_time_val_to_iso8601() has been nullable since GLib
     * 2.54; before then, GLib would crash under the same conditions.
     * @returns a newly allocated string containing an ISO 8601 date,    or %NULL if @time_ was too large
     */
    toIso8601(): string | null
  }

  /**
   * Represents a precise time, with seconds and microseconds.
   *
   * Similar to the struct timeval returned by the `gettimeofday()`
   * UNIX system call.
   *
   * GLib is attempting to unify around the use of 64-bit integers to
   * represent microsecond-precision time. As such, this type will be
   * removed from a future version of GLib. A consequence of using `glong` for
   * `tv_sec` is that on 32-bit systems `GTimeVal` is subject to the year 2038
   * problem.
   * @record
   */
  class TimeVal {
    // Own properties of GLib-2.0.GLib.TimeVal

    static name: string

    // Constructors of GLib-2.0.GLib.TimeVal

    /**
     * Converts a string containing an ISO 8601 encoded date and time
     * to a #GTimeVal and puts it into `time_`.
     *
     * `iso_date` must include year, month, day, hours, minutes, and
     * seconds. It can optionally include fractions of a second and a time
     * zone indicator. (In the absence of any time zone indication, the
     * timestamp is assumed to be in local time.)
     *
     * Any leading or trailing space in `iso_date` is ignored.
     *
     * This function was deprecated, along with #GTimeVal itself, in GLib 2.62.
     * Equivalent functionality is available using code like:
     *
     * ```
     * GDateTime *dt = g_date_time_new_from_iso8601 (iso8601_string, NULL);
     * gint64 time_val = g_date_time_to_unix (dt);
     * g_date_time_unref (dt);
     * ```
     *
     * @param isoDate an ISO 8601 encoded date string
     * @returns %TRUE if the conversion was successful.
     */
    static fromIso8601(
      isoDate: string
    ): [/* returnType */ boolean, /* time */ TimeVal]
  }

  interface TimeZone {
    // Owm methods of GLib-2.0.GLib.TimeZone

    /**
     * Finds an interval within `tz` that corresponds to the given `time_,`
     * possibly adjusting `time_` if required to fit into an interval.
     * The meaning of `time_` depends on `type`.
     *
     * This function is similar to g_time_zone_find_interval(), with the
     * difference that it always succeeds (by making the adjustments
     * described below).
     *
     * In any of the cases where g_time_zone_find_interval() succeeds then
     * this function returns the same value, without modifying `time_`.
     *
     * This function may, however, modify `time_` in order to deal with
     * non-existent times.  If the non-existent local `time_` of 02:30 were
     * requested on March 14th 2010 in Toronto then this function would
     * adjust `time_` to be 03:00 and return the interval containing the
     * adjusted time.
     * @param type the #GTimeType of `time_`
     * @param time a pointer to a number of seconds since January 1, 1970
     * @returns the interval containing @time_, never -1
     */
    adjustTime(
      type: TimeType,
      time: number
    ): [/* returnType */ number, /* time */ number]
    /**
     * Finds an interval within `tz` that corresponds to the given `time_`.
     * The meaning of `time_` depends on `type`.
     *
     * If `type` is %G_TIME_TYPE_UNIVERSAL then this function will always
     * succeed (since universal time is monotonic and continuous).
     *
     * Otherwise `time_` is treated as local time.  The distinction between
     * %G_TIME_TYPE_STANDARD and %G_TIME_TYPE_DAYLIGHT is ignored except in
     * the case that the given `time_` is ambiguous.  In Toronto, for example,
     * 01:30 on November 7th 2010 occurred twice (once inside of daylight
     * savings time and the next, an hour later, outside of daylight savings
     * time).  In this case, the different value of `type` would result in a
     * different interval being returned.
     *
     * It is still possible for this function to fail.  In Toronto, for
     * example, 02:00 on March 14th 2010 does not exist (due to the leap
     * forward to begin daylight savings time).  -1 is returned in that
     * case.
     * @param type the #GTimeType of `time_`
     * @param time a number of seconds since January 1, 1970
     * @returns the interval containing @time_, or -1 in case of failure
     */
    findInterval(type: TimeType, time: number): number
    /**
     * Determines the time zone abbreviation to be used during a particular
     * `interval` of time in the time zone `tz`.
     *
     * For example, in Toronto this is currently "EST" during the winter
     * months and "EDT" during the summer months when daylight savings time
     * is in effect.
     * @param interval an interval within the timezone
     * @returns the time zone abbreviation, which belongs to @tz
     */
    getAbbreviation(interval: number): string
    /**
     * Get the identifier of this #GTimeZone, as passed to g_time_zone_new().
     * If the identifier passed at construction time was not recognised, `UTC` will
     * be returned. If it was %NULL, the identifier of the local timezone at
     * construction time will be returned.
     *
     * The identifier will be returned in the same format as provided at
     * construction time: if provided as a time offset, that will be returned by
     * this function.
     * @returns identifier for this timezone
     */
    getIdentifier(): string
    /**
     * Determines the offset to UTC in effect during a particular `interval`
     * of time in the time zone `tz`.
     *
     * The offset is the number of seconds that you add to UTC time to
     * arrive at local time for `tz` (ie: negative numbers for time zones
     * west of GMT, positive numbers for east).
     * @param interval an interval within the timezone
     * @returns the number of seconds that should be added to UTC to get the          local time in @tz
     */
    getOffset(interval: number): number
    /**
     * Determines if daylight savings time is in effect during a particular
     * `interval` of time in the time zone `tz`.
     * @param interval an interval within the timezone
     * @returns %TRUE if daylight savings time is in effect
     */
    isDst(interval: number): boolean
    /**
     * Increases the reference count on `tz`.
     * @returns a new reference to @tz.
     */
    ref(): TimeZone
    /**
     * Decreases the reference count on `tz`.
     */
    unref(): void
  }

  /**
   * A `GTimeZone` represents a time zone, at no particular point in time.
   *
   * The `GTimeZone` struct is refcounted and immutable.
   *
   * Each time zone has an identifier (for example, ‘Europe/London’) which is
   * platform dependent. See [ctor`GLib`.TimeZone.new] for information on the
   * identifier formats. The identifier of a time zone can be retrieved using
   * [method`GLib`.TimeZone.get_identifier].
   *
   * A time zone contains a number of intervals. Each interval has an abbreviation
   * to describe it (for example, ‘PDT’), an offset to UTC and a flag indicating
   * if the daylight savings time is in effect during that interval. A time zone
   * always has at least one interval — interval 0. Note that interval abbreviations
   * are not the same as time zone identifiers (apart from ‘UTC’), and cannot be
   * passed to [ctor`GLib`.TimeZone.new].
   *
   * Every UTC time is contained within exactly one interval, but a given
   * local time may be contained within zero, one or two intervals (due to
   * incontinuities associated with daylight savings time).
   *
   * An interval may refer to a specific period of time (eg: the duration
   * of daylight savings time during 2010) or it may refer to many periods
   * of time that share the same properties (eg: all periods of daylight
   * savings time).  It is also possible (usually for political reasons)
   * that some properties (like the abbreviation) change between intervals
   * without other properties changing.
   * @record
   */
  class TimeZone {
    // Own properties of GLib-2.0.GLib.TimeZone

    static name: string

    // Constructors of GLib-2.0.GLib.TimeZone

    /**
     * A version of g_time_zone_new_identifier() which returns the UTC time zone
     * if `identifier` could not be parsed or loaded.
     *
     * If you need to check whether `identifier` was loaded successfully, use
     * g_time_zone_new_identifier().
     * @constructor
     * @param identifier a timezone identifier
     * @returns the requested timezone
     */
    constructor(identifier: string | null)
    /**
     * A version of g_time_zone_new_identifier() which returns the UTC time zone
     * if `identifier` could not be parsed or loaded.
     *
     * If you need to check whether `identifier` was loaded successfully, use
     * g_time_zone_new_identifier().
     * @constructor
     * @param identifier a timezone identifier
     * @returns the requested timezone
     */
    static new(identifier: string | null): TimeZone
    /**
     * Creates a #GTimeZone corresponding to `identifier`. If `identifier` cannot be
     * parsed or loaded, %NULL is returned.
     *
     * `identifier` can either be an RFC3339/ISO 8601 time offset or
     * something that would pass as a valid value for the `TZ` environment
     * variable (including %NULL).
     *
     * In Windows, `identifier` can also be the unlocalized name of a time
     * zone for standard time, for example "Pacific Standard Time".
     *
     * Valid RFC3339 time offsets are `"Z"` (for UTC) or
     * `"±hh:mm"`.  ISO 8601 additionally specifies
     * `"±hhmm"` and `"±hh"`.  Offsets are
     * time values to be added to Coordinated Universal Time (UTC) to get
     * the local time.
     *
     * In UNIX, the `TZ` environment variable typically corresponds
     * to the name of a file in the zoneinfo database, an absolute path to a file
     * somewhere else, or a string in
     * "std offset [dst [offset],start[/time],end[/time]]" (POSIX) format.
     * There  are  no spaces in the specification. The name of standard
     * and daylight savings time zone must be three or more alphabetic
     * characters. Offsets are time values to be added to local time to
     * get Coordinated Universal Time (UTC) and should be
     * `"[±]hh[[:]mm[:ss]]"`.  Dates are either
     * `"Jn"` (Julian day with n between 1 and 365, leap
     * years not counted), `"n"` (zero-based Julian day
     * with n between 0 and 365) or `"Mm.w.d"` (day d
     * (0 <= d <= 6) of week w (1 <= w <= 5) of month m (1 <= m <= 12), day
     * 0 is a Sunday).  Times are in local wall clock time, the default is
     * 02:00:00.
     *
     * In Windows, the "tzn[+|–]hh[:mm[:ss]][dzn]" format is used, but also
     * accepts POSIX format.  The Windows format uses US rules for all time
     * zones; daylight savings time is 60 minutes behind the standard time
     * with date and time of change taken from Pacific Standard Time.
     * Offsets are time values to be added to the local time to get
     * Coordinated Universal Time (UTC).
     *
     * g_time_zone_new_local() calls this function with the value of the
     * `TZ` environment variable. This function itself is independent of
     * the value of `TZ`, but if `identifier` is %NULL then `/etc/localtime`
     * will be consulted to discover the correct time zone on UNIX and the
     * registry will be consulted or GetTimeZoneInformation() will be used
     * to get the local time zone on Windows.
     *
     * If intervals are not available, only time zone rules from `TZ`
     * environment variable or other means, then they will be computed
     * from year 1900 to 2037.  If the maximum year for the rules is
     * available and it is greater than 2037, then it will followed
     * instead.
     *
     * See
     * [RFC3339 §5.6](http://tools.ietf.org/html/rfc3339#section-5.6)
     * for a precise definition of valid RFC3339 time offsets
     * (the `time-offset` expansion) and ISO 8601 for the
     * full list of valid time offsets.  See
     * [The GNU C Library manual](http://www.gnu.org/s/libc/manual/html_node/TZ-Variable.html)
     * for an explanation of the possible
     * values of the `TZ` environment variable. See
     * [Microsoft Time Zone Index Values](http://msdn.microsoft.com/en-us/library/ms912391%28v=winembedded.11%29.aspx)
     * for the list of time zones on Windows.
     *
     * You should release the return value by calling g_time_zone_unref()
     * when you are done with it.
     * @constructor
     * @param identifier a timezone identifier
     * @returns the requested timezone, or %NULL on     failure
     */
    static newIdentifier(identifier: string | null): TimeZone
    /**
     * Creates a #GTimeZone corresponding to local time.  The local time
     * zone may change between invocations to this function; for example,
     * if the system administrator changes it.
     *
     * This is equivalent to calling g_time_zone_new() with the value of
     * the `TZ` environment variable (including the possibility of %NULL).
     *
     * You should release the return value by calling g_time_zone_unref()
     * when you are done with it.
     * @constructor
     * @returns the local timezone
     */
    static newLocal(): TimeZone
    /**
     * Creates a #GTimeZone corresponding to the given constant offset from UTC,
     * in seconds.
     *
     * This is equivalent to calling g_time_zone_new() with a string in the form
     * `[+|-]hh[:mm[:ss]]`.
     *
     * It is possible for this function to fail if `seconds` is too big (greater than
     * 24 hours), in which case this function will return the UTC timezone for
     * backwards compatibility. To detect failures like this, use
     * g_time_zone_new_identifier() directly.
     * @constructor
     * @param seconds offset to UTC, in seconds
     * @returns a timezone at the given offset from UTC, or UTC on   failure
     */
    static newOffset(seconds: number): TimeZone
    /**
     * Creates a #GTimeZone corresponding to UTC.
     *
     * This is equivalent to calling g_time_zone_new() with a value like
     * "Z", "UTC", "+00", etc.
     *
     * You should release the return value by calling g_time_zone_unref()
     * when you are done with it.
     * @constructor
     * @returns the universal timezone
     */
    static newUtc(): TimeZone
  }

  interface Timer {
    // Owm methods of GLib-2.0.GLib.Timer

    /**
     * Resumes a timer that has previously been stopped with
     * g_timer_stop(). g_timer_stop() must be called before using this
     * function.
     */
    continue(): void
    /**
     * Destroys a timer, freeing associated resources.
     */
    destroy(): void
    /**
     * If `timer` has been started but not stopped, obtains the time since
     * the timer was started. If `timer` has been stopped, obtains the
     * elapsed time between the time it was started and the time it was
     * stopped. The return value is the number of seconds elapsed,
     * including any fractional part. The `microseconds` out parameter is
     * essentially useless.
     * @param microseconds return location for the fractional part of seconds                elapsed, in microseconds (that is, the total number                of microseconds elapsed, modulo 1000000), or %NULL
     * @returns seconds elapsed as a floating point value, including any          fractional part.
     */
    elapsed(microseconds: number): number
    /**
     * Exposes whether the timer is currently active.
     * @returns %TRUE if the timer is running, %FALSE otherwise
     */
    isActive(): boolean
    /**
     * This function is useless; it's fine to call g_timer_start() on an
     * already-started timer to reset the start time, so g_timer_reset()
     * serves no purpose.
     */
    reset(): void
    /**
     * Marks a start time, so that future calls to g_timer_elapsed() will
     * report the time since g_timer_start() was called. g_timer_new()
     * automatically marks the start time, so no need to call
     * g_timer_start() immediately after creating the timer.
     */
    start(): void
    /**
     * Marks an end time, so calls to g_timer_elapsed() will return the
     * difference between this end time and the start time.
     */
    stop(): void
  }

  /**
   * `GTimer` records a start time, and counts microseconds elapsed since
   * that time.
   *
   * This is done somewhat differently on different platforms, and can be
   * tricky to get exactly right, so `GTimer` provides a portable/convenient interface.
   * @record
   */
  class Timer {
    // Own properties of GLib-2.0.GLib.Timer

    static name: string
  }

  interface TrashStack {
    // Own fields of GLib-2.0.GLib.TrashStack

    /**
     * pointer to the previous element of the stack,
     *     gets stored in the first `sizeof (gpointer)`
     *     bytes of the element
     * @field
     */
    next: TrashStack
  }

  /**
   * A `GTrashStack` is an efficient way to keep a stack of unused allocated
   * memory chunks. Each memory chunk is required to be large enough to hold
   * a `gpointer`. This allows the stack to be maintained without any space
   * overhead, since the stack pointers can be stored inside the memory chunks.
   *
   * There is no function to create a `GTrashStack`. A `NULL` `GTrashStack*`
   * is a perfectly valid empty stack.
   *
   * Each piece of memory that is pushed onto the stack is cast to a
   * `GTrashStack*`.
   *
   * There is no longer any good reason to use `GTrashStack`.  If you have
   * extra pieces of memory, `free()` them and allocate them again later.
   * @record
   */
  class TrashStack {
    // Own properties of GLib-2.0.GLib.TrashStack

    static name: string

    // Constructors of GLib-2.0.GLib.TrashStack

    /**
     * Returns the height of a #GTrashStack.
     *
     * Note that execution of this function is of O(N) complexity
     * where N denotes the number of items on the stack.
     * @param stackP a #GTrashStack
     * @returns the height of the stack
     */
    static height(stackP: TrashStack): number
    /**
     * Returns the element at the top of a #GTrashStack
     * which may be %NULL.
     * @param stackP a #GTrashStack
     * @returns the element at the top of the stack
     */
    static peek(stackP: TrashStack): any | null
    /**
     * Pops a piece of memory off a #GTrashStack.
     * @param stackP a #GTrashStack
     * @returns the element at the top of the stack
     */
    static pop(stackP: TrashStack): any | null
    /**
     * Pushes a piece of memory onto a #GTrashStack.
     * @param stackP a #GTrashStack
     * @param dataP the piece of memory to push on the stack
     */
    static push(stackP: TrashStack, dataP: any): void
  }

  interface Tree {
    // Owm methods of GLib-2.0.GLib.Tree

    /**
     * Removes all keys and values from the #GTree and decreases its
     * reference count by one. If keys and/or values are dynamically
     * allocated, you should either free them first or create the #GTree
     * using g_tree_new_full(). In the latter case the destroy functions
     * you supplied will be called on all keys and values before destroying
     * the #GTree.
     */
    destroy(): void
    /**
     * Calls the given function for each of the key/value pairs in the #GTree.
     * The function is passed the key and value of each pair, and the given
     * `data` parameter. The tree is traversed in sorted order.
     *
     * The tree may not be modified while iterating over it (you can't
     * add/remove items). To remove all items matching a predicate, you need
     * to add each item to a list in your #GTraverseFunc as you walk over
     * the tree, then walk the list and remove each item.
     * @param func the function to call for each node visited.     If this function returns %TRUE, the traversal is stopped.
     */
    foreach(func: TraverseFunc): void
    /**
     * Calls the given function for each of the nodes in the #GTree.
     * The function is passed the pointer to the particular node, and the given
     * `data` parameter. The tree traversal happens in-order.
     *
     * The tree may not be modified while iterating over it (you can't
     * add/remove items). To remove all items matching a predicate, you need
     * to add each item to a list in your #GTraverseFunc as you walk over
     * the tree, then walk the list and remove each item.
     * @param func the function to call for each node visited.     If this function returns %TRUE, the traversal is stopped.
     */
    foreachNode(func: TraverseNodeFunc): void
    /**
     * Gets the height of a #GTree.
     *
     * If the #GTree contains no nodes, the height is 0.
     * If the #GTree contains only one root node the height is 1.
     * If the root node has children the height is 2, etc.
     * @returns the height of @tree
     */
    height(): number
    /**
     * Inserts a key/value pair into a #GTree.
     *
     * Inserts a new key and value into a #GTree as g_tree_insert_node() does,
     * only this function does not return the inserted or set node.
     * @param key the key to insert
     * @param value the value corresponding to the key
     */
    insert(key: any | null, value: any | null): void
    /**
     * Inserts a key/value pair into a #GTree.
     *
     * If the given key already exists in the #GTree its corresponding value
     * is set to the new value. If you supplied a `value_destroy_func` when
     * creating the #GTree, the old value is freed using that function. If
     * you supplied a `key_destroy_func` when creating the #GTree, the passed
     * key is freed using that function.
     *
     * The tree is automatically 'balanced' as new key/value pairs are added,
     * so that the distance from the root to every leaf is as small as possible.
     * The cost of maintaining a balanced tree while inserting new key/value
     * result in a O(n log(n)) operation where most of the other operations
     * are O(log(n)).
     * @param key the key to insert
     * @param value the value corresponding to the key
     * @returns the inserted (or set) node or %NULL if insertion would overflow the tree node counter.
     */
    insertNode(key: any | null, value: any | null): TreeNode | null
    /**
     * Gets the value corresponding to the given key. Since a #GTree is
     * automatically balanced as key/value pairs are added, key lookup
     * is O(log n) (where n is the number of key/value pairs in the tree).
     * @param key the key to look up
     * @returns the value corresponding to the key, or %NULL     if the key was not found
     */
    lookup(key: any | null): any | null
    /**
     * Looks up a key in the #GTree, returning the original key and the
     * associated value. This is useful if you need to free the memory
     * allocated for the original key, for example before calling
     * g_tree_remove().
     * @param lookupKey the key to look up
     * @returns %TRUE if the key was found in the #GTree
     */
    lookupExtended(
      lookupKey: any | null
    ): [
      /* returnType */ boolean,
      /* origKey */ any | null,
      /* value */ any | null,
    ]
    /**
     * Gets the tree node corresponding to the given key. Since a #GTree is
     * automatically balanced as key/value pairs are added, key lookup
     * is O(log n) (where n is the number of key/value pairs in the tree).
     * @param key the key to look up
     * @returns the tree node corresponding to          the key, or %NULL if the key was not found
     */
    lookupNode(key: any | null): TreeNode | null
    /**
     * Gets the lower bound node corresponding to the given key,
     * or %NULL if the tree is empty or all the nodes in the tree
     * have keys that are strictly lower than the searched key.
     *
     * The lower bound is the first node that has its key greater
     * than or equal to the searched key.
     * @param key the key to calculate the lower bound for
     * @returns the tree node corresponding to          the lower bound, or %NULL if the tree is empty or has only          keys strictly lower than the searched key.
     */
    lowerBound(key: any | null): TreeNode | null
    /**
     * Gets the number of nodes in a #GTree.
     * @returns the number of nodes in @tree The node counter value type is really a #guint, but it is returned as a #gint due to backward compatibility issues (can be cast back to #guint to support its full range of values).
     */
    nnodes(): number
    /**
     * Returns the first in-order node of the tree, or %NULL
     * for an empty tree.
     * @returns the first node in the tree
     */
    nodeFirst(): TreeNode | null
    /**
     * Returns the last in-order node of the tree, or %NULL
     * for an empty tree.
     * @returns the last node in the tree
     */
    nodeLast(): TreeNode | null
    /**
     * Increments the reference count of `tree` by one.
     *
     * It is safe to call this function from any thread.
     * @returns the passed in #GTree
     */
    ref(): Tree
    /**
     * Removes a key/value pair from a #GTree.
     *
     * If the #GTree was created using g_tree_new_full(), the key and value
     * are freed using the supplied destroy functions, otherwise you have to
     * make sure that any dynamically allocated values are freed yourself.
     * If the key does not exist in the #GTree, the function does nothing.
     *
     * The cost of maintaining a balanced tree while removing a key/value
     * result in a O(n log(n)) operation where most of the other operations
     * are O(log(n)).
     * @param key the key to remove
     * @returns %TRUE if the key was found (prior to 2.8, this function     returned nothing)
     */
    remove(key: any | null): boolean
    /**
     * Removes all nodes from a #GTree and destroys their keys and values,
     * then resets the #GTree’s root to %NULL.
     */
    removeAll(): void
    /**
     * Inserts a new key and value into a #GTree as g_tree_replace_node() does,
     * only this function does not return the inserted or set node.
     * @param key the key to insert
     * @param value the value corresponding to the key
     */
    replace(key: any | null, value: any | null): void
    /**
     * Inserts a new key and value into a #GTree similar to g_tree_insert_node().
     * The difference is that if the key already exists in the #GTree, it gets
     * replaced by the new key. If you supplied a `value_destroy_func` when
     * creating the #GTree, the old value is freed using that function. If you
     * supplied a `key_destroy_func` when creating the #GTree, the old key is
     * freed using that function.
     *
     * The tree is automatically 'balanced' as new key/value pairs are added,
     * so that the distance from the root to every leaf is as small as possible.
     * @param key the key to insert
     * @param value the value corresponding to the key
     * @returns the inserted (or set) node or %NULL if insertion would overflow the tree node counter.
     */
    replaceNode(key: any | null, value: any | null): TreeNode | null
    /**
     * Searches a #GTree using `search_func`.
     *
     * The `search_func` is called with a pointer to the key of a key/value
     * pair in the tree, and the passed in `user_data`. If `search_func` returns
     * 0 for a key/value pair, then the corresponding value is returned as
     * the result of g_tree_search(). If `search_func` returns -1, searching
     * will proceed among the key/value pairs that have a smaller key; if
     * `search_func` returns 1, searching will proceed among the key/value
     * pairs that have a larger key.
     * @param searchFunc a function used to search the #GTree
     * @returns the value corresponding to the found key, or %NULL     if the key was not found
     */
    search(searchFunc: CompareFunc): any | null
    /**
     * Searches a #GTree using `search_func`.
     *
     * The `search_func` is called with a pointer to the key of a key/value
     * pair in the tree, and the passed in `user_data`. If `search_func` returns
     * 0 for a key/value pair, then the corresponding node is returned as
     * the result of g_tree_search(). If `search_func` returns -1, searching
     * will proceed among the key/value pairs that have a smaller key; if
     * `search_func` returns 1, searching will proceed among the key/value
     * pairs that have a larger key.
     * @param searchFunc a function used to search the #GTree
     * @returns the node corresponding to the          found key, or %NULL if the key was not found
     */
    searchNode(searchFunc: CompareFunc): TreeNode | null
    /**
     * Removes a key and its associated value from a #GTree without calling
     * the key and value destroy functions.
     *
     * If the key does not exist in the #GTree, the function does nothing.
     * @param key the key to remove
     * @returns %TRUE if the key was found (prior to 2.8, this function     returned nothing)
     */
    steal(key: any | null): boolean
    /**
     * Calls the given function for each node in the #GTree.
     * @param traverseFunc the function to call for each node visited. If this   function returns %TRUE, the traversal is stopped.
     * @param traverseType the order in which nodes are visited, one of %G_IN_ORDER,   %G_PRE_ORDER and %G_POST_ORDER
     */
    traverse(traverseFunc: TraverseFunc, traverseType: TraverseType): void
    /**
     * Decrements the reference count of `tree` by one.
     * If the reference count drops to 0, all keys and values will
     * be destroyed (if destroy functions were specified) and all
     * memory allocated by `tree` will be released.
     *
     * It is safe to call this function from any thread.
     */
    unref(): void
    /**
     * Gets the upper bound node corresponding to the given key,
     * or %NULL if the tree is empty or all the nodes in the tree
     * have keys that are lower than or equal to the searched key.
     *
     * The upper bound is the first node that has its key strictly greater
     * than the searched key.
     * @param key the key to calculate the upper bound for
     * @returns the tree node corresponding to the          upper bound, or %NULL if the tree is empty or has only keys          lower than or equal to the searched key.
     */
    upperBound(key: any | null): TreeNode | null
  }

  /**
   * The GTree struct is an opaque data structure representing a
   * [balanced binary tree][glib-Balanced-Binary-Trees]. It should be
   * accessed only by using the following functions.
   * @record
   */
  class Tree {
    // Own properties of GLib-2.0.GLib.Tree

    static name: string

    // Constructors of GLib-2.0.GLib.Tree

    /**
     * Creates a new #GTree like g_tree_new() and allows to specify functions
     * to free the memory allocated for the key and value that get called when
     * removing the entry from the #GTree.
     * @constructor
     * @param keyCompareFunc qsort()-style comparison function
     * @param keyDestroyFunc a function to free the memory allocated for the key   used when removing the entry from the #GTree or %NULL if you don't   want to supply such a function
     * @returns a newly allocated #GTree
     */
    static newFull(
      keyCompareFunc: CompareDataFunc,
      keyDestroyFunc: DestroyNotify
    ): Tree
  }

  interface TreeNode {
    // Owm methods of GLib-2.0.GLib.TreeNode

    /**
     * Gets the key stored at a particular tree node.
     * @returns the key at the node.
     */
    key(): any | null
    /**
     * Returns the next in-order node of the tree, or %NULL
     * if the passed node was already the last one.
     * @returns the next node in the tree
     */
    next(): TreeNode | null
    /**
     * Returns the previous in-order node of the tree, or %NULL
     * if the passed node was already the first one.
     * @returns the previous node in the tree
     */
    previous(): TreeNode | null
    /**
     * Gets the value stored at a particular tree node.
     * @returns the value at the node.
     */
    value(): any | null
  }

  /**
   * An opaque type which identifies a specific node in a #GTree.
   * @record
   */
  class TreeNode {
    // Own properties of GLib-2.0.GLib.TreeNode

    static name: string
  }

  interface Tuples {
    // Own fields of GLib-2.0.GLib.Tuples

    /**
     * the number of records that matched.
     * @field
     */
    len: number

    // Owm methods of GLib-2.0.GLib.Tuples

    /**
     * Frees the records which were returned by g_relation_select(). This
     * should always be called after g_relation_select() when you are
     * finished with the records. The records are not removed from the
     * #GRelation.
     */
    destroy(): void
    /**
     * Gets a field from the records returned by g_relation_select(). It
     * returns the given field of the record at the given index. The
     * returned value should not be changed.
     * @param index the index of the record.
     * @param field the field to return.
     * @returns the field of the record.
     */
    index(index: number, field: number): any | null
  }

  /**
   * The #GTuples struct is used to return records (or tuples) from the
   * #GRelation by g_relation_select(). It only contains one public
   * member - the number of records that matched. To access the matched
   * records, you must use g_tuples_index().
   * @record
   */
  class Tuples {
    // Own properties of GLib-2.0.GLib.Tuples

    static name: string
  }

  interface UnixPipe {
    // Own fields of GLib-2.0.GLib.UnixPipe

    /**
     * A pair of file descriptors, each negative if closed or not yet opened.
     *  The file descriptor with index %G_UNIX_PIPE_END_READ is readable.
     *  The file descriptor with index %G_UNIX_PIPE_END_WRITE is writable.
     * @field
     */
    fds: number[]
  }

  /**
   * A Unix pipe. The advantage of this type over `int[2]` is that it can
   * be closed automatically when it goes out of scope, using `g_auto(GUnixPipe)`,
   * on compilers that support that feature.
   * @record
   */
  class UnixPipe {
    // Own properties of GLib-2.0.GLib.UnixPipe

    static name: string
  }

  interface Uri {
    // Owm methods of GLib-2.0.GLib.Uri

    /**
     * Gets `uri'`s authentication parameters, which may contain
     * `%`-encoding, depending on the flags with which `uri` was created.
     * (If `uri` was not created with %G_URI_FLAGS_HAS_AUTH_PARAMS then this will
     * be %NULL.)
     *
     * Depending on the URI scheme, g_uri_parse_params() may be useful for
     * further parsing this information.
     * @returns @uri's authentication parameters.
     */
    getAuthParams(): string | null
    /**
     * Gets `uri'`s flags set upon construction.
     * @returns @uri's flags.
     */
    getFlags(): UriFlags
    /**
     * Gets `uri'`s fragment, which may contain `%`-encoding, depending on
     * the flags with which `uri` was created.
     * @returns @uri's fragment.
     */
    getFragment(): string | null
    /**
     * Gets `uri'`s host. This will never have `%`-encoded characters,
     * unless it is non-UTF-8 (which can only be the case if `uri` was
     * created with %G_URI_FLAGS_NON_DNS).
     *
     * If `uri` contained an IPv6 address literal, this value will be just
     * that address, without the brackets around it that are necessary in
     * the string form of the URI. Note that in this case there may also
     * be a scope ID attached to the address. Eg, `fe80::1234%``em1` (or
     * `fe80::1234%``25em1` if the string is still encoded).
     * @returns @uri's host.
     */
    getHost(): string | null
    /**
     * Gets `uri'`s password, which may contain `%`-encoding, depending on
     * the flags with which `uri` was created. (If `uri` was not created
     * with %G_URI_FLAGS_HAS_PASSWORD then this will be %NULL.)
     * @returns @uri's password.
     */
    getPassword(): string | null
    /**
     * Gets `uri'`s path, which may contain `%`-encoding, depending on the
     * flags with which `uri` was created.
     * @returns @uri's path.
     */
    getPath(): string
    /**
     * Gets `uri'`s port.
     * @returns @uri's port, or `-1` if no port was specified.
     */
    getPort(): number
    /**
     * Gets `uri'`s query, which may contain `%`-encoding, depending on the
     * flags with which `uri` was created.
     *
     * For queries consisting of a series of `name=value` parameters,
     * #GUriParamsIter or g_uri_parse_params() may be useful.
     * @returns @uri's query.
     */
    getQuery(): string | null
    /**
     * Gets `uri'`s scheme. Note that this will always be all-lowercase,
     * regardless of the string or strings that `uri` was created from.
     * @returns @uri's scheme.
     */
    getScheme(): string
    /**
     * Gets the ‘username’ component of `uri'`s userinfo, which may contain
     * `%`-encoding, depending on the flags with which `uri` was created.
     * If `uri` was not created with %G_URI_FLAGS_HAS_PASSWORD or
     * %G_URI_FLAGS_HAS_AUTH_PARAMS, this is the same as g_uri_get_userinfo().
     * @returns @uri's user.
     */
    getUser(): string | null
    /**
     * Gets `uri'`s userinfo, which may contain `%`-encoding, depending on
     * the flags with which `uri` was created.
     * @returns @uri's userinfo.
     */
    getUserinfo(): string | null
    /**
     * Parses `uri_ref` according to `flags` and, if it is a
     * [relative URI](#relative-and-absolute-uris), resolves it relative to `base_uri`.
     * If the result is not a valid absolute URI, it will be discarded, and an error
     * returned.
     * @param uriRef a string representing a relative or absolute URI
     * @param flags flags describing how to parse `uri_ref`
     * @returns a new #GUri, or NULL on error.
     */
    parseRelative(uriRef: string, flags: UriFlags): Uri
    /**
     * Returns a string representing `uri`.
     *
     * This is not guaranteed to return a string which is identical to the
     * string that `uri` was parsed from. However, if the source URI was
     * syntactically correct (according to RFC 3986), and it was parsed
     * with %G_URI_FLAGS_ENCODED, then g_uri_to_string() is guaranteed to return
     * a string which is at least semantically equivalent to the source
     * URI (according to RFC 3986).
     *
     * If `uri` might contain sensitive details, such as authentication parameters,
     * or private data in its query string, and the returned string is going to be
     * logged, then consider using g_uri_to_string_partial() to redact parts.
     * @returns a string representing @uri,     which the caller must free.
     */
    toString(): string | null
    /**
     * Returns a string representing `uri,` subject to the options in
     * `flags`. See g_uri_to_string() and #GUriHideFlags for more details.
     * @param flags flags describing what parts of `uri` to hide
     * @returns a string representing     @uri, which the caller must free.
     */
    toStringPartial(flags: UriHideFlags): string | null
  }

  /**
   * The `GUri` type and related functions can be used to parse URIs into
   * their components, and build valid URIs from individual components.
   *
   * Since `GUri` only represents absolute URIs, all `GUri`s will have a
   * URI scheme, so [method`GLib`.Uri.get_scheme] will always return a non-`NULL`
   * answer. Likewise, by definition, all URIs have a path component, so
   * [method`GLib`.Uri.get_path] will always return a non-`NULL` string (which may
   * be empty).
   *
   * If the URI string has an
   * [‘authority’ component](https://tools.ietf.org/html/rfc3986#section-3) (that
   * is, if the scheme is followed by `://` rather than just `:`), then the
   * `GUri` will contain a hostname, and possibly a port and ‘userinfo’.
   * Additionally, depending on how the `GUri` was constructed/parsed (for example,
   * using the `G_URI_FLAGS_HAS_PASSWORD` and `G_URI_FLAGS_HAS_AUTH_PARAMS` flags),
   * the userinfo may be split out into a username, password, and
   * additional authorization-related parameters.
   *
   * Normally, the components of a `GUri` will have all `%`-encoded
   * characters decoded. However, if you construct/parse a `GUri` with
   * `G_URI_FLAGS_ENCODED`, then the `%`-encoding will be preserved instead in
   * the userinfo, path, and query fields (and in the host field if also
   * created with `G_URI_FLAGS_NON_DNS`). In particular, this is necessary if
   * the URI may contain binary data or non-UTF-8 text, or if decoding
   * the components might change the interpretation of the URI.
   *
   * For example, with the encoded flag:
   *
   * ```c
   * g_autoptr(GUri) uri = g_uri_parse ("http://host/path?query=http%3A%2F%2Fhost%2Fpath%3Fparam%3Dvalue", G_URI_FLAGS_ENCODED, &err);
   * g_assert_cmpstr (g_uri_get_query (uri), ==, "query=http%3A%2F%2Fhost%2Fpath%3Fparam%3Dvalue");
   * ```
   *
   * While the default `%`-decoding behaviour would give:
   *
   * ```c
   * g_autoptr(GUri) uri = g_uri_parse ("http://host/path?query=http%3A%2F%2Fhost%2Fpath%3Fparam%3Dvalue", G_URI_FLAGS_NONE, &err);
   * g_assert_cmpstr (g_uri_get_query (uri), ==, "query=http://host/path?param=value");
   * ```
   *
   * During decoding, if an invalid UTF-8 string is encountered, parsing will fail
   * with an error indicating the bad string location:
   *
   * ```c
   * g_autoptr(GUri) uri = g_uri_parse ("http://host/path?query=http%3A%2F%2Fhost%2Fpath%3Fbad%3D%00alue", G_URI_FLAGS_NONE, &err);
   * g_assert_error (err, G_URI_ERROR, G_URI_ERROR_BAD_QUERY);
   * ```
   *
   * You should pass `G_URI_FLAGS_ENCODED` or `G_URI_FLAGS_ENCODED_QUERY` if you
   * need to handle that case manually. In particular, if the query string
   * contains `=` characters that are `%`-encoded, you should let
   * [func`GLib`.Uri.parse_params] do the decoding once of the query.
   *
   * `GUri` is immutable once constructed, and can safely be accessed from
   * multiple threads. Its reference counting is atomic.
   *
   * Note that the scope of `GUri` is to help manipulate URIs in various applications,
   * following [RFC 3986](https://tools.ietf.org/html/rfc3986). In particular,
   * it doesn't intend to cover web browser needs, and doesn’t implement the
   * [WHATWG URL](https://url.spec.whatwg.org/) standard. No APIs are provided to
   * help prevent
   * [homograph attacks](https://en.wikipedia.org/wiki/IDN_homograph_attack), so
   * `GUri` is not suitable for formatting URIs for display to the user for making
   * security-sensitive decisions.
   *
   * ## Relative and absolute URIs
   *
   * As defined in [RFC 3986](https://tools.ietf.org/html/rfc3986#section-4), the
   * hierarchical nature of URIs means that they can either be ‘relative
   * references’ (sometimes referred to as ‘relative URIs’) or ‘URIs’ (for
   * clarity, ‘URIs’ are referred to in this documentation as
   * ‘absolute URIs’ — although
   * [in constrast to RFC 3986](https://tools.ietf.org/html/rfc3986#section-4.3),
   * fragment identifiers are always allowed).
   *
   * Relative references have one or more components of the URI missing. In
   * particular, they have no scheme. Any other component, such as hostname,
   * query, etc. may be missing, apart from a path, which has to be specified (but
   * may be empty). The path may be relative, starting with `./` rather than `/`.
   *
   * For example, a valid relative reference is `./path?query`,
   * `/?query#fragment` or `//example.com`.
   *
   * Absolute URIs have a scheme specified. Any other components of the URI which
   * are missing are specified as explicitly unset in the URI, rather than being
   * resolved relative to a base URI using [method`GLib`.Uri.parse_relative].
   *
   * For example, a valid absolute URI is `file:///home/bob` or
   * `https://search.com?query=string`.
   *
   * A `GUri` instance is always an absolute URI. A string may be an absolute URI
   * or a relative reference; see the documentation for individual functions as to
   * what forms they accept.
   *
   * ## Parsing URIs
   *
   * The most minimalist APIs for parsing URIs are [func`GLib`.Uri.split] and
   * [func`GLib`.Uri.split_with_user]. These split a URI into its component
   * parts, and return the parts; the difference between the two is that
   * [func`GLib`.Uri.split] treats the ‘userinfo’ component of the URI as a
   * single element, while [func`GLib`.Uri.split_with_user] can (depending on the
   * [flags`GLib`.UriFlags] you pass) treat it as containing a username, password,
   * and authentication parameters. Alternatively, [func`GLib`.Uri.split_network]
   * can be used when you are only interested in the components that are
   * needed to initiate a network connection to the service (scheme,
   * host, and port).
   *
   * [func`GLib`.Uri.parse] is similar to [func`GLib`.Uri.split], but instead of
   * returning individual strings, it returns a `GUri` structure (and it requires
   * that the URI be an absolute URI).
   *
   * [func`GLib`.Uri.resolve_relative] and [method`GLib`.Uri.parse_relative] allow
   * you to resolve a relative URI relative to a base URI.
   * [func`GLib`.Uri.resolve_relative] takes two strings and returns a string,
   * and [method`GLib`.Uri.parse_relative] takes a `GUri` and a string and returns a
   * `GUri`.
   *
   * All of the parsing functions take a [flags`GLib`.UriFlags] argument describing
   * exactly how to parse the URI; see the documentation for that type
   * for more details on the specific flags that you can pass. If you
   * need to choose different flags based on the type of URI, you can
   * use [func`GLib`.Uri.peek_scheme] on the URI string to check the scheme
   * first, and use that to decide what flags to parse it with.
   *
   * For example, you might want to use `G_URI_PARAMS_WWW_FORM` when parsing the
   * params for a web URI, so compare the result of [func`GLib`.Uri.peek_scheme]
   * against `http` and `https`.
   *
   * ## Building URIs
   *
   * [func`GLib`.Uri.join] and [func`GLib`.Uri.join_with_user] can be used to construct
   * valid URI strings from a set of component strings. They are the
   * inverse of [func`GLib`.Uri.split] and [func`GLib`.Uri.split_with_user].
   *
   * Similarly, [func`GLib`.Uri.build] and [func`GLib`.Uri.build_with_user] can be
   * used to construct a `GUri` from a set of component strings.
   *
   * As with the parsing functions, the building functions take a
   * [flags`GLib`.UriFlags] argument. In particular, it is important to keep in mind
   * whether the URI components you are using are already `%`-encoded. If so,
   * you must pass the `G_URI_FLAGS_ENCODED` flag.
   *
   * ## `file://` URIs
   *
   * Note that Windows and Unix both define special rules for parsing
   * `file://` URIs (involving non-UTF-8 character sets on Unix, and the
   * interpretation of path separators on Windows). `GUri` does not
   * implement these rules. Use [func`GLib`.filename_from_uri] and
   * [func`GLib`.filename_to_uri] if you want to properly convert between
   * `file://` URIs and local filenames.
   *
   * ## URI Equality
   *
   * Note that there is no `g_uri_equal ()` function, because comparing
   * URIs usefully requires scheme-specific knowledge that `GUri` does
   * not have. `GUri` can help with normalization if you use the various
   * encoded [flags`GLib`.UriFlags] as well as `G_URI_FLAGS_SCHEME_NORMALIZE`
   * however it is not comprehensive.
   * For example, `data:,foo` and `data:;base64,Zm9v` resolve to the same
   * thing according to the `data:` URI specification which GLib does not
   * handle.
   * @record
   */
  class Uri {
    // Own properties of GLib-2.0.GLib.Uri

    static name: string

    // Constructors of GLib-2.0.GLib.Uri

    /**
     * Creates a new #GUri from the given components according to `flags`.
     *
     * See also g_uri_build_with_user(), which allows specifying the
     * components of the "userinfo" separately.
     * @param flags flags describing how to build the #GUri
     * @param scheme the URI scheme
     * @param userinfo the userinfo component, or %NULL
     * @param host the host component, or %NULL
     * @param port the port, or `-1`
     * @param path the path component
     * @param query the query component, or %NULL
     * @param fragment the fragment, or %NULL
     * @returns a new #GUri
     */
    static build(
      flags: UriFlags,
      scheme: string,
      userinfo: string | null,
      host: string | null,
      port: number,
      path: string,
      query: string | null,
      fragment: string | null
    ): Uri
    /**
     * Creates a new #GUri from the given components according to `flags`
     * (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The `flags` must be
     * coherent with the passed values, in particular use `%`-encoded values with
     * %G_URI_FLAGS_ENCODED.
     *
     * In contrast to g_uri_build(), this allows specifying the components
     * of the ‘userinfo’ field separately. Note that `user` must be non-%NULL
     * if either `password` or `auth_params` is non-%NULL.
     * @param flags flags describing how to build the #GUri
     * @param scheme the URI scheme
     * @param user the user component of the userinfo, or %NULL
     * @param password the password component of the userinfo, or %NULL
     * @param authParams the auth params of the userinfo, or %NULL
     * @param host the host component, or %NULL
     * @param port the port, or `-1`
     * @param path the path component
     * @param query the query component, or %NULL
     * @param fragment the fragment, or %NULL
     * @returns a new #GUri
     */
    static buildWithUser(
      flags: UriFlags,
      scheme: string,
      user: string | null,
      password: string | null,
      authParams: string | null,
      host: string | null,
      port: number,
      path: string,
      query: string | null,
      fragment: string | null
    ): Uri
    static errorQuark(): Quark
    /**
     * Escapes arbitrary data for use in a URI.
     *
     * Normally all characters that are not ‘unreserved’ (i.e. ASCII
     * alphanumerical characters plus dash, dot, underscore and tilde) are
     * escaped. But if you specify characters in `reserved_chars_allowed`
     * they are not escaped. This is useful for the ‘reserved’ characters
     * in the URI specification, since those are allowed unescaped in some
     * portions of a URI.
     *
     * Though technically incorrect, this will also allow escaping nul
     * bytes as `%``00`.
     * @param unescaped the unescaped input data.
     * @param reservedCharsAllowed a string of reserved   characters that are allowed to be used, or %NULL.
     * @returns an escaped version of @unescaped.     The returned string should be freed when no longer needed.
     */
    static escapeBytes(
      unescaped: number[],
      reservedCharsAllowed: string | null
    ): string | null
    /**
     * Escapes a string for use in a URI.
     *
     * Normally all characters that are not "unreserved" (i.e. ASCII
     * alphanumerical characters plus dash, dot, underscore and tilde) are
     * escaped. But if you specify characters in `reserved_chars_allowed`
     * they are not escaped. This is useful for the "reserved" characters
     * in the URI specification, since those are allowed unescaped in some
     * portions of a URI.
     * @param unescaped the unescaped input string.
     * @param reservedCharsAllowed a string of reserved   characters that are allowed to be used, or %NULL.
     * @param allowUtf8 %TRUE if the result can include UTF-8 characters.
     * @returns an escaped version of @unescaped. The returned string should be freed when no longer needed.
     */
    static escapeString(
      unescaped: string,
      reservedCharsAllowed: string | null,
      allowUtf8: boolean
    ): string | null
    /**
     * Parses `uri_string` according to `flags,` to determine whether it is a valid
     * [absolute URI](#relative-and-absolute-uris), i.e. it does not need to be resolved
     * relative to another URI using g_uri_parse_relative().
     *
     * If it’s not a valid URI, an error is returned explaining how it’s invalid.
     *
     * See g_uri_split(), and the definition of #GUriFlags, for more
     * information on the effect of `flags`.
     * @param uriString a string containing an absolute URI
     * @param flags flags for parsing `uri_string`
     * @returns %TRUE if @uri_string is a valid absolute URI, %FALSE on error.
     */
    static isValid(uriString: string, flags: UriFlags): boolean
    /**
     * Joins the given components together according to `flags` to create
     * an absolute URI string. `path` may not be %NULL (though it may be the empty
     * string).
     *
     * When `host` is present, `path` must either be empty or begin with a slash (`/`)
     * character. When `host` is not present, `path` cannot begin with two slash
     * characters (`//`). See
     * [RFC 3986, section 3](https://tools.ietf.org/html/rfc3986#section-3).
     *
     * See also g_uri_join_with_user(), which allows specifying the
     * components of the ‘userinfo’ separately.
     *
     * %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
     * in `flags`.
     * @param flags flags describing how to build the URI string
     * @param scheme the URI scheme, or %NULL
     * @param userinfo the userinfo component, or %NULL
     * @param host the host component, or %NULL
     * @param port the port, or `-1`
     * @param path the path component
     * @param query the query component, or %NULL
     * @param fragment the fragment, or %NULL
     * @returns an absolute URI string
     */
    static join(
      flags: UriFlags,
      scheme: string | null,
      userinfo: string | null,
      host: string | null,
      port: number,
      path: string,
      query: string | null,
      fragment: string | null
    ): string | null
    /**
     * Joins the given components together according to `flags` to create
     * an absolute URI string. `path` may not be %NULL (though it may be the empty
     * string).
     *
     * In contrast to g_uri_join(), this allows specifying the components
     * of the ‘userinfo’ separately. It otherwise behaves the same.
     *
     * %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
     * in `flags`.
     * @param flags flags describing how to build the URI string
     * @param scheme the URI scheme, or %NULL
     * @param user the user component of the userinfo, or %NULL
     * @param password the password component of the userinfo, or   %NULL
     * @param authParams the auth params of the userinfo, or   %NULL
     * @param host the host component, or %NULL
     * @param port the port, or `-1`
     * @param path the path component
     * @param query the query component, or %NULL
     * @param fragment the fragment, or %NULL
     * @returns an absolute URI string
     */
    static joinWithUser(
      flags: UriFlags,
      scheme: string | null,
      user: string | null,
      password: string | null,
      authParams: string | null,
      host: string | null,
      port: number,
      path: string,
      query: string | null,
      fragment: string | null
    ): string | null
    /**
     * Splits an URI list conforming to the text/uri-list
     * mime type defined in RFC 2483 into individual URIs,
     * discarding any comments. The URIs are not validated.
     * @param uriList an URI list
     * @returns a newly allocated %NULL-terminated list   of strings holding the individual URIs. The array should be freed   with g_strfreev().
     */
    static listExtractUris(uriList: string): string[]
    /**
     * Parses `uri_string` according to `flags`. If the result is not a
     * valid [absolute URI](#relative-and-absolute-uris), it will be discarded, and an
     * error returned.
     * @param uriString a string representing an absolute URI
     * @param flags flags describing how to parse `uri_string`
     * @returns a new #GUri, or NULL on error.
     */
    static parse(uriString: string, flags: UriFlags): Uri
    /**
     * Many URI schemes include one or more attribute/value pairs as part of the URI
     * value. This method can be used to parse them into a hash table. When an
     * attribute has multiple occurrences, the last value is the final returned
     * value. If you need to handle repeated attributes differently, use
     * #GUriParamsIter.
     *
     * The `params` string is assumed to still be `%`-encoded, but the returned
     * values will be fully decoded. (Thus it is possible that the returned values
     * may contain `=` or `separators,` if the value was encoded in the input.)
     * Invalid `%`-encoding is treated as with the %G_URI_FLAGS_PARSE_RELAXED
     * rules for g_uri_parse(). (However, if `params` is the path or query string
     * from a #GUri that was parsed without %G_URI_FLAGS_PARSE_RELAXED and
     * %G_URI_FLAGS_ENCODED, then you already know that it does not contain any
     * invalid encoding.)
     *
     * %G_URI_PARAMS_WWW_FORM is handled as documented for g_uri_params_iter_init().
     *
     * If %G_URI_PARAMS_CASE_INSENSITIVE is passed to `flags,` attributes will be
     * compared case-insensitively, so a params string `attr=123&Attr=456` will only
     * return a single attribute–value pair, `Attr=456`. Case will be preserved in
     * the returned attributes.
     *
     * If `params` cannot be parsed (for example, it contains two `separators`
     * characters in a row), then `error` is set and %NULL is returned.
     * @param params a `%`-encoded string containing `attribute=value`   parameters
     * @param length the length of `params,` or `-1` if it is nul-terminated
     * @param separators the separator byte character set between parameters. (usually   `&`, but sometimes `;` or both `&;`). Note that this function works on   bytes not characters, so it can't be used to delimit UTF-8 strings for   anything but ASCII characters. You may pass an empty set, in which case   no splitting will occur.
     * @param flags flags to modify the way the parameters are handled.
     * @returns A hash table of attribute/value pairs, with both names and values     fully-decoded; or %NULL on error.
     */
    static parseParams(
      params: string,
      length: number,
      separators: string,
      flags: UriParamsFlags
    ): HashTable
    /**
     * Gets the scheme portion of a URI string.
     * [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
     * as:
     *
     * ```
     * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
     * ```
     *
     * Common schemes include `file`, `https`, `svn+ssh`, etc.
     * @param uri a valid URI.
     * @returns The ‘scheme’ component of the URI, or     %NULL on error. The returned string should be freed when no longer needed.
     */
    static parseScheme(uri: string): string | null
    /**
     * Gets the scheme portion of a URI string.
     * [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
     * as:
     *
     * ```
     * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
     * ```
     *
     * Common schemes include `file`, `https`, `svn+ssh`, etc.
     *
     * Unlike g_uri_parse_scheme(), the returned scheme is normalized to
     * all-lowercase and does not need to be freed.
     * @param uri a valid URI.
     * @returns The ‘scheme’ component of the URI, or     %NULL on error. The returned string is normalized to all-lowercase, and     interned via g_intern_string(), so it does not need to be freed.
     */
    static peekScheme(uri: string): string | null
    /**
     * Parses `uri_ref` according to `flags` and, if it is a
     * [relative URI](#relative-and-absolute-uris), resolves it relative to
     * `base_uri_string`. If the result is not a valid absolute URI, it will be
     * discarded, and an error returned.
     *
     * (If `base_uri_string` is %NULL, this just returns `uri_ref,` or
     * %NULL if `uri_ref` is invalid or not absolute.)
     * @param baseUriString a string representing a base URI
     * @param uriRef a string representing a relative or absolute URI
     * @param flags flags describing how to parse `uri_ref`
     * @returns the resolved URI string, or NULL on error.
     */
    static resolveRelative(
      baseUriString: string | null,
      uriRef: string,
      flags: UriFlags
    ): string | null
    /**
     * Parses `uri_ref` (which can be an
     * [absolute or relative URI](#relative-and-absolute-uris)) according to `flags,` and
     * returns the pieces. Any component that doesn't appear in `uri_ref` will be
     * returned as %NULL (but note that all URIs always have a path component,
     * though it may be the empty string).
     *
     * If `flags` contains %G_URI_FLAGS_ENCODED, then `%`-encoded characters in
     * `uri_ref` will remain encoded in the output strings. (If not,
     * then all such characters will be decoded.) Note that decoding will
     * only work if the URI components are ASCII or UTF-8, so you will
     * need to use %G_URI_FLAGS_ENCODED if they are not.
     *
     * Note that the %G_URI_FLAGS_HAS_PASSWORD and
     * %G_URI_FLAGS_HAS_AUTH_PARAMS `flags` are ignored by g_uri_split(),
     * since it always returns only the full userinfo; use
     * g_uri_split_with_user() if you want it split up.
     * @param uriRef a string containing a relative or absolute URI
     * @param flags flags for parsing `uri_ref`
     * @returns %TRUE if @uri_ref parsed successfully, %FALSE   on error.
     */
    static split(
      uriRef: string,
      flags: UriFlags
    ): [
      /* returnType */ boolean,
      /* scheme */ string | null,
      /* userinfo */ string | null,
      /* host */ string | null,
      /* port */ number,
      /* path */ string,
      /* query */ string | null,
      /* fragment */ string | null,
    ]
    /**
     * Parses `uri_string` (which must be an [absolute URI](#relative-and-absolute-uris))
     * according to `flags,` and returns the pieces relevant to connecting to a host.
     * See the documentation for g_uri_split() for more details; this is
     * mostly a wrapper around that function with simpler arguments.
     * However, it will return an error if `uri_string` is a relative URI,
     * or does not contain a hostname component.
     * @param uriString a string containing an absolute URI
     * @param flags flags for parsing `uri_string`
     * @returns %TRUE if @uri_string parsed successfully,   %FALSE on error.
     */
    static splitNetwork(
      uriString: string,
      flags: UriFlags
    ): [
      /* returnType */ boolean,
      /* scheme */ string | null,
      /* host */ string | null,
      /* port */ number,
    ]
    /**
     * Parses `uri_ref` (which can be an
     * [absolute or relative URI](#relative-and-absolute-uris)) according to `flags,` and
     * returns the pieces. Any component that doesn't appear in `uri_ref` will be
     * returned as %NULL (but note that all URIs always have a path component,
     * though it may be the empty string).
     *
     * See g_uri_split(), and the definition of #GUriFlags, for more
     * information on the effect of `flags`. Note that `password` will only
     * be parsed out if `flags` contains %G_URI_FLAGS_HAS_PASSWORD, and
     * `auth_params` will only be parsed out if `flags` contains
     * %G_URI_FLAGS_HAS_AUTH_PARAMS.
     * @param uriRef a string containing a relative or absolute URI
     * @param flags flags for parsing `uri_ref`
     * @returns %TRUE if @uri_ref parsed successfully, %FALSE   on error.
     */
    static splitWithUser(
      uriRef: string,
      flags: UriFlags
    ): [
      /* returnType */ boolean,
      /* scheme */ string | null,
      /* user */ string | null,
      /* password */ string | null,
      /* authParams */ string | null,
      /* host */ string | null,
      /* port */ number,
      /* path */ string,
      /* query */ string | null,
      /* fragment */ string | null,
    ]
    /**
     * Unescapes a segment of an escaped string as binary data.
     *
     * Note that in contrast to g_uri_unescape_string(), this does allow
     * nul bytes to appear in the output.
     *
     * If any of the characters in `illegal_characters` appears as an escaped
     * character in `escaped_string,` then that is an error and %NULL will be
     * returned. This is useful if you want to avoid for instance having a slash
     * being expanded in an escaped path element, which might confuse pathname
     * handling.
     * @param escapedString A URI-escaped string
     * @param length the length (in bytes) of `escaped_string` to escape, or `-1` if it   is nul-terminated.
     * @param illegalCharacters a string of illegal characters   not to be allowed, or %NULL.
     * @returns an unescaped version of @escaped_string     or %NULL on error (if decoding failed, using %G_URI_ERROR_FAILED error     code). The returned #GBytes should be unreffed when no longer needed.
     */
    static unescapeBytes(
      escapedString: string,
      length: number,
      illegalCharacters: string | null
    ): any
    /**
     * Unescapes a segment of an escaped string.
     *
     * If any of the characters in `illegal_characters` or the NUL
     * character appears as an escaped character in `escaped_string,` then
     * that is an error and %NULL will be returned. This is useful if you
     * want to avoid for instance having a slash being expanded in an
     * escaped path element, which might confuse pathname handling.
     *
     * Note: `NUL` byte is not accepted in the output, in contrast to
     * g_uri_unescape_bytes().
     * @param escapedString A string, may be %NULL
     * @param escapedStringEnd Pointer to end of `escaped_string,`   may be %NULL
     * @param illegalCharacters An optional string of illegal   characters not to be allowed, may be %NULL
     * @returns an unescaped version of @escaped_string, or %NULL on error. The returned string should be freed when no longer needed.  As a special case if %NULL is given for @escaped_string, this function will return %NULL.
     */
    static unescapeSegment(
      escapedString: string | null,
      escapedStringEnd: string | null,
      illegalCharacters: string | null
    ): string | null
    /**
     * Unescapes a whole escaped string.
     *
     * If any of the characters in `illegal_characters` or the NUL
     * character appears as an escaped character in `escaped_string,` then
     * that is an error and %NULL will be returned. This is useful if you
     * want to avoid for instance having a slash being expanded in an
     * escaped path element, which might confuse pathname handling.
     * @param escapedString an escaped string to be unescaped.
     * @param illegalCharacters a string of illegal characters   not to be allowed, or %NULL.
     * @returns an unescaped version of @escaped_string. The returned string should be freed when no longer needed.
     */
    static unescapeString(
      escapedString: string,
      illegalCharacters: string | null
    ): string | null
  }

  interface UriParamsIter {
    // Owm methods of GLib-2.0.GLib.UriParamsIter

    /**
     * Initializes an attribute/value pair iterator.
     *
     * The iterator keeps pointers to the `params` and `separators` arguments, those
     * variables must thus outlive the iterator and not be modified during the
     * iteration.
     *
     * If %G_URI_PARAMS_WWW_FORM is passed in `flags,` `+` characters in the param
     * string will be replaced with spaces in the output. For example, `foo=bar+baz`
     * will give attribute `foo` with value `bar baz`. This is commonly used on the
     * web (the `https` and `http` schemes only), but is deprecated in favour of
     * the equivalent of encoding spaces as `%20`.
     *
     * Unlike with g_uri_parse_params(), %G_URI_PARAMS_CASE_INSENSITIVE has no
     * effect if passed to `flags` for g_uri_params_iter_init(). The caller is
     * responsible for doing their own case-insensitive comparisons.
     *
     *
     * ```c
     * GUriParamsIter iter;
     * GError *error = NULL;
     * gchar *unowned_attr, *unowned_value;
     *
     * g_uri_params_iter_init (&iter, "foo=bar&baz=bar&Foo=frob&baz=bar2", -1, "&", G_URI_PARAMS_NONE);
     * while (g_uri_params_iter_next (&iter, &unowned_attr, &unowned_value, &error))
     *   {
     *     g_autofree gchar *attr = g_steal_pointer (&unowned_attr);
     *     g_autofree gchar *value = g_steal_pointer (&unowned_value);
     *     // do something with attr and value; this code will be called 4 times
     *     // for the params string in this example: once with attr=foo and value=bar,
     *     // then with baz/bar, then Foo/frob, then baz/bar2.
     *   }
     * if (error)
     *   // handle parsing error
     * ```
     *
     * @param params a `%`-encoded string containing `attribute=value`   parameters
     * @param length the length of `params,` or `-1` if it is nul-terminated
     * @param separators the separator byte character set between parameters. (usually   `&`, but sometimes `;` or both `&;`). Note that this function works on   bytes not characters, so it can't be used to delimit UTF-8 strings for   anything but ASCII characters. You may pass an empty set, in which case   no splitting will occur.
     * @param flags flags to modify the way the parameters are handled.
     */
    init(
      params: string,
      length: number,
      separators: string,
      flags: UriParamsFlags
    ): void
    /**
     * Advances `iter` and retrieves the next attribute/value. %FALSE is returned if
     * an error has occurred (in which case `error` is set), or if the end of the
     * iteration is reached (in which case `attribute` and `value` are set to %NULL
     * and the iterator becomes invalid). If %TRUE is returned,
     * g_uri_params_iter_next() may be called again to receive another
     * attribute/value pair.
     *
     * Note that the same `attribute` may be returned multiple times, since URIs
     * allow repeated attributes.
     * @returns %FALSE if the end of the parameters has been reached or an error was     encountered. %TRUE otherwise.
     */
    next(): [
      /* returnType */ boolean,
      /* attribute */ string | null,
      /* value */ string | null,
    ]
  }

  /**
   * Many URI schemes include one or more attribute/value pairs as part of the URI
   * value. For example `scheme://server/path?query=string&is=there` has two
   * attributes – `query=string` and `is=there` – in its query part.
   *
   * A #GUriParamsIter structure represents an iterator that can be used to
   * iterate over the attribute/value pairs of a URI query string. #GUriParamsIter
   * structures are typically allocated on the stack and then initialized with
   * g_uri_params_iter_init(). See the documentation for g_uri_params_iter_init()
   * for a usage example.
   * @record
   */
  class UriParamsIter {
    // Own properties of GLib-2.0.GLib.UriParamsIter

    static name: string
  }

  interface Variant {
    // Owm methods of GLib-2.0.GLib.Variant

    /**
     * Performs a byteswapping operation on the contents of `value`.  The
     * result is that all multi-byte numeric data contained in `value` is
     * byteswapped.  That includes 16, 32, and 64bit signed and unsigned
     * integers as well as file handles and double precision floating point
     * values.
     *
     * This function is an identity mapping on any value that does not
     * contain multi-byte numeric data.  That include strings, booleans,
     * bytes and containers containing only these things (recursively).
     *
     * While this function can safely handle untrusted, non-normal data, it is
     * recommended to check whether the input is in normal form beforehand, using
     * g_variant_is_normal_form(), and to reject non-normal inputs if your
     * application can be strict about what inputs it rejects.
     *
     * The returned value is always in normal form and is marked as trusted.
     * A full, not floating, reference is returned.
     * @returns the byteswapped form of @value
     */
    byteswap(): Variant
    /**
     * Checks if calling g_variant_get() with `format_string` on `value` would
     * be valid from a type-compatibility standpoint.  `format_string` is
     * assumed to be a valid format string (from a syntactic standpoint).
     *
     * If `copy_only` is %TRUE then this function additionally checks that it
     * would be safe to call g_variant_unref() on `value` immediately after
     * the call to g_variant_get() without invalidating the result.  This is
     * only possible if deep copies are made (ie: there are no pointers to
     * the data inside of the soon-to-be-freed #GVariant instance).  If this
     * check fails then a g_critical() is printed and %FALSE is returned.
     *
     * This function is meant to be used by functions that wish to provide
     * varargs accessors to #GVariant values of uncertain values (eg:
     * g_variant_lookup() or g_menu_model_get_item_attribute()).
     * @param formatString a valid #GVariant format string
     * @param copyOnly %TRUE to ensure the format string makes deep copies
     * @returns %TRUE if @format_string is safe to use
     */
    checkFormatString(formatString: string, copyOnly: boolean): boolean
    /**
     * Classifies `value` according to its top-level type.
     * @returns the #GVariantClass of @value
     */
    classify(): VariantClass
    /**
     * Compares `one` and `two`.
     *
     * The types of `one` and `two` are #gconstpointer only to allow use of
     * this function with #GTree, #GPtrArray, etc.  They must each be a
     * #GVariant.
     *
     * Comparison is only defined for basic types (ie: booleans, numbers,
     * strings).  For booleans, %FALSE is less than %TRUE.  Numbers are
     * ordered in the usual way.  Strings are in ASCII lexographical order.
     *
     * It is a programmer error to attempt to compare container values or
     * two values that have types that are not exactly equal.  For example,
     * you cannot compare a 32-bit signed integer with a 32-bit unsigned
     * integer.  Also note that this function is not particularly
     * well-behaved when it comes to comparison of doubles; in particular,
     * the handling of incomparable values (ie: NaN) is undefined.
     *
     * If you only require an equality comparison, g_variant_equal() is more
     * general.
     * @param two a #GVariant instance of the same type
     * @returns negative value if a < b;          zero if a = b;          positive value if a > b.
     */
    compare(two: Variant): number
    /**
     * Similar to g_variant_get_bytestring() except that instead of
     * returning a constant string, the string is duplicated.
     *
     * The return value must be freed using g_free().
     * @returns a newly allocated string
     */
    dupBytestring(): number[]
    /**
     * Gets the contents of an array of array of bytes #GVariant.  This call
     * makes a deep copy; the return result should be released with
     * g_strfreev().
     *
     * If `length` is non-%NULL then the number of elements in the result is
     * stored there.  In any case, the resulting array will be
     * %NULL-terminated.
     *
     * For an empty array, `length` will be set to 0 and a pointer to a
     * %NULL pointer will be returned.
     * @returns an array of strings
     */
    dupBytestringArray(): string[]
    /**
     * Gets the contents of an array of object paths #GVariant.  This call
     * makes a deep copy; the return result should be released with
     * g_strfreev().
     *
     * If `length` is non-%NULL then the number of elements in the result
     * is stored there.  In any case, the resulting array will be
     * %NULL-terminated.
     *
     * For an empty array, `length` will be set to 0 and a pointer to a
     * %NULL pointer will be returned.
     * @returns an array of strings
     */
    dupObjv(): string[]
    /**
     * Similar to g_variant_get_string() except that instead of returning
     * a constant string, the string is duplicated.
     *
     * The string will always be UTF-8 encoded.
     *
     * The return value must be freed using g_free().
     * @returns a newly allocated string, UTF-8 encoded
     */
    dupString(): [/* returnType */ string | null, /* length */ number]
    /**
     * Gets the contents of an array of strings #GVariant.  This call
     * makes a deep copy; the return result should be released with
     * g_strfreev().
     *
     * If `length` is non-%NULL then the number of elements in the result
     * is stored there.  In any case, the resulting array will be
     * %NULL-terminated.
     *
     * For an empty array, `length` will be set to 0 and a pointer to a
     * %NULL pointer will be returned.
     * @returns an array of strings
     */
    dupStrv(): string[]
    /**
     * Checks if `one` and `two` have the same type and value.
     *
     * The types of `one` and `two` are #gconstpointer only to allow use of
     * this function with #GHashTable.  They must each be a #GVariant.
     * @param two a #GVariant instance
     * @returns %TRUE if @one and @two are equal
     */
    equal(two: Variant): boolean
    /**
     * Returns the boolean value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_BOOLEAN.
     * @returns %TRUE or %FALSE
     */
    getBoolean(): boolean
    /**
     * Returns the byte value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_BYTE.
     * @returns a #guint8
     */
    getByte(): number
    /**
     * Returns the string value of a #GVariant instance with an
     * array-of-bytes type.  The string has no particular encoding.
     *
     * If the array does not end with a nul terminator character, the empty
     * string is returned.  For this reason, you can always trust that a
     * non-%NULL nul-terminated string will be returned by this function.
     *
     * If the array contains a nul terminator character somewhere other than
     * the last byte then the returned string is the string, up to the first
     * such nul character.
     *
     * g_variant_get_fixed_array() should be used instead if the array contains
     * arbitrary data that could not be nul-terminated or could contain nul bytes.
     *
     * It is an error to call this function with a `value` that is not an
     * array of bytes.
     *
     * The return value remains valid as long as `value` exists.
     * @returns the constant string
     */
    getBytestring(): number[]
    /**
     * Gets the contents of an array of array of bytes #GVariant.  This call
     * makes a shallow copy; the return result should be released with
     * g_free(), but the individual strings must not be modified.
     *
     * If `length` is non-%NULL then the number of elements in the result is
     * stored there.  In any case, the resulting array will be
     * %NULL-terminated.
     *
     * For an empty array, `length` will be set to 0 and a pointer to a
     * %NULL pointer will be returned.
     * @returns an array of constant strings
     */
    getBytestringArray(): string[]
    /**
     * Reads a child item out of a container #GVariant instance.  This
     * includes variants, maybes, arrays, tuples and dictionary
     * entries.  It is an error to call this function on any other type of
     * #GVariant.
     *
     * It is an error if `index_` is greater than the number of child items
     * in the container.  See g_variant_n_children().
     *
     * The returned value is never floating.  You should free it with
     * g_variant_unref() when you're done with it.
     *
     * Note that values borrowed from the returned child are not guaranteed to
     * still be valid after the child is freed even if you still hold a reference
     * to `value,` if `value` has not been serialized at the time this function is
     * called. To avoid this, you can serialize `value` by calling
     * g_variant_get_data() and optionally ignoring the return value.
     *
     * There may be implementation specific restrictions on deeply nested values,
     * which would result in the unit tuple being returned as the child value,
     * instead of further nested children. #GVariant is guaranteed to handle
     * nesting up to at least 64 levels.
     *
     * This function is O(1).
     * @param index the index of the child to fetch
     * @returns the child at the specified index
     */
    getChildValue(index: number): Variant
    /**
     * Returns a pointer to the serialized form of a #GVariant instance.
     * The returned data may not be in fully-normalised form if read from an
     * untrusted source.  The returned data must not be freed; it remains
     * valid for as long as `value` exists.
     *
     * If `value` is a fixed-sized value that was deserialized from a
     * corrupted serialized container then %NULL may be returned.  In this
     * case, the proper thing to do is typically to use the appropriate
     * number of nul bytes in place of `value`.  If `value` is not fixed-sized
     * then %NULL is never returned.
     *
     * In the case that `value` is already in serialized form, this function
     * is O(1).  If the value is not already in serialized form,
     * serialization occurs implicitly and is approximately O(n) in the size
     * of the result.
     *
     * To deserialize the data returned by this function, in addition to the
     * serialized data, you must know the type of the #GVariant, and (if the
     * machine might be different) the endianness of the machine that stored
     * it. As a result, file formats or network messages that incorporate
     * serialized #GVariants must include this information either
     * implicitly (for instance "the file always contains a
     * %G_VARIANT_TYPE_VARIANT and it is always in little-endian order") or
     * explicitly (by storing the type and/or endianness in addition to the
     * serialized data).
     * @returns the serialized form of @value, or %NULL
     */
    getData(): any | null
    /**
     * Returns a pointer to the serialized form of a #GVariant instance.
     * The semantics of this function are exactly the same as
     * g_variant_get_data(), except that the returned #GBytes holds
     * a reference to the variant data.
     * @returns A new #GBytes representing the variant data
     */
    getDataAsBytes(): any
    /**
     * Returns the double precision floating point value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_DOUBLE.
     * @returns a #gdouble
     */
    getDouble(): number
    /**
     * Returns the 32-bit signed integer value of `value`.
     *
     * It is an error to call this function with a `value` of any type other
     * than %G_VARIANT_TYPE_HANDLE.
     *
     * By convention, handles are indexes into an array of file descriptors
     * that are sent alongside a D-Bus message.  If you're not interacting
     * with D-Bus, you probably don't need them.
     * @returns a #gint32
     */
    getHandle(): number
    /**
     * Returns the 16-bit signed integer value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_INT16.
     * @returns a #gint16
     */
    getInt16(): number
    /**
     * Returns the 32-bit signed integer value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_INT32.
     * @returns a #gint32
     */
    getInt32(): number
    /**
     * Returns the 64-bit signed integer value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_INT64.
     * @returns a #gint64
     */
    getInt64(): number
    /**
     * Given a maybe-typed #GVariant instance, extract its value.  If the
     * value is Nothing, then this function returns %NULL.
     * @returns the contents of @value, or %NULL
     */
    getMaybe(): Variant | null
    /**
     * Gets a #GVariant instance that has the same value as `value` and is
     * trusted to be in normal form.
     *
     * If `value` is already trusted to be in normal form then a new
     * reference to `value` is returned.
     *
     * If `value` is not already trusted, then it is scanned to check if it
     * is in normal form.  If it is found to be in normal form then it is
     * marked as trusted and a new reference to it is returned.
     *
     * If `value` is found not to be in normal form then a new trusted
     * #GVariant is created with the same value as `value`. The non-normal parts of
     * `value` will be replaced with default values which are guaranteed to be in
     * normal form.
     *
     * It makes sense to call this function if you've received #GVariant
     * data from untrusted sources and you want to ensure your serialized
     * output is definitely in normal form.
     *
     * If `value` is already in normal form, a new reference will be returned
     * (which will be floating if `value` is floating). If it is not in normal form,
     * the newly created #GVariant will be returned with a single non-floating
     * reference. Typically, g_variant_take_ref() should be called on the return
     * value from this function to guarantee ownership of a single non-floating
     * reference to it.
     * @returns a trusted #GVariant
     */
    getNormalForm(): Variant
    /**
     * Gets the contents of an array of object paths #GVariant.  This call
     * makes a shallow copy; the return result should be released with
     * g_free(), but the individual strings must not be modified.
     *
     * If `length` is non-%NULL then the number of elements in the result
     * is stored there.  In any case, the resulting array will be
     * %NULL-terminated.
     *
     * For an empty array, `length` will be set to 0 and a pointer to a
     * %NULL pointer will be returned.
     * @returns an array of constant strings
     */
    getObjv(): string[]
    /**
     * Determines the number of bytes that would be required to store `value`
     * with g_variant_store().
     *
     * If `value` has a fixed-sized type then this function always returned
     * that fixed size.
     *
     * In the case that `value` is already in serialized form or the size has
     * already been calculated (ie: this function has been called before)
     * then this function is O(1).  Otherwise, the size is calculated, an
     * operation which is approximately O(n) in the number of values
     * involved.
     * @returns the serialized size of @value
     */
    getSize(): number
    /**
     * Returns the string value of a #GVariant instance with a string
     * type.  This includes the types %G_VARIANT_TYPE_STRING,
     * %G_VARIANT_TYPE_OBJECT_PATH and %G_VARIANT_TYPE_SIGNATURE.
     *
     * The string will always be UTF-8 encoded, will never be %NULL, and will never
     * contain nul bytes.
     *
     * If `length` is non-%NULL then the length of the string (in bytes) is
     * returned there.  For trusted values, this information is already
     * known.  Untrusted values will be validated and, if valid, a strlen() will be
     * performed. If invalid, a default value will be returned — for
     * %G_VARIANT_TYPE_OBJECT_PATH, this is `"/"`, and for other types it is the
     * empty string.
     *
     * It is an error to call this function with a `value` of any type
     * other than those three.
     *
     * The return value remains valid as long as `value` exists.
     * @returns the constant string, UTF-8 encoded
     */
    getString(): [/* returnType */ string, /* length */ number]
    /**
     * Gets the contents of an array of strings #GVariant.  This call
     * makes a shallow copy; the return result should be released with
     * g_free(), but the individual strings must not be modified.
     *
     * If `length` is non-%NULL then the number of elements in the result
     * is stored there.  In any case, the resulting array will be
     * %NULL-terminated.
     *
     * For an empty array, `length` will be set to 0 and a pointer to a
     * %NULL pointer will be returned.
     * @returns an array of constant strings
     */
    getStrv(): string[]
    /**
     * Determines the type of `value`.
     *
     * The return value is valid for the lifetime of `value` and must not
     * be freed.
     * @returns a #GVariantType
     */
    getType(): VariantType
    /**
     * Returns the type string of `value`.  Unlike the result of calling
     * g_variant_type_peek_string(), this string is nul-terminated.  This
     * string belongs to #GVariant and must not be freed.
     * @returns the type string for the type of @value
     */
    getTypeString(): string
    /**
     * Returns the 16-bit unsigned integer value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_UINT16.
     * @returns a #guint16
     */
    getUint16(): number
    /**
     * Returns the 32-bit unsigned integer value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_UINT32.
     * @returns a #guint32
     */
    getUint32(): number
    /**
     * Returns the 64-bit unsigned integer value of `value`.
     *
     * It is an error to call this function with a `value` of any type
     * other than %G_VARIANT_TYPE_UINT64.
     * @returns a #guint64
     */
    getUint64(): number
    /**
     * Unboxes `value`.  The result is the #GVariant instance that was
     * contained in `value`.
     * @returns the item contained in the variant
     */
    getVariant(): Variant
    /**
     * Generates a hash value for a #GVariant instance.
     *
     * The output of this function is guaranteed to be the same for a given
     * value only per-process.  It may change between different processor
     * architectures or even different versions of GLib.  Do not use this
     * function as a basis for building protocols or file formats.
     *
     * The type of `value` is #gconstpointer only to allow use of this
     * function with #GHashTable.  `value` must be a #GVariant.
     * @returns a hash value corresponding to @value
     */
    hash(): number
    /**
     * Checks if `value` is a container.
     * @returns %TRUE if @value is a container
     */
    isContainer(): boolean
    /**
     * Checks whether `value` has a floating reference count.
     *
     * This function should only ever be used to assert that a given variant
     * is or is not floating, or for debug purposes. To acquire a reference
     * to a variant that might be floating, always use g_variant_ref_sink()
     * or g_variant_take_ref().
     *
     * See g_variant_ref_sink() for more information about floating reference
     * counts.
     * @returns whether @value is floating
     */
    isFloating(): boolean
    /**
     * Checks if `value` is in normal form.
     *
     * The main reason to do this is to detect if a given chunk of
     * serialized data is in normal form: load the data into a #GVariant
     * using g_variant_new_from_data() and then use this function to
     * check.
     *
     * If `value` is found to be in normal form then it will be marked as
     * being trusted.  If the value was already marked as being trusted then
     * this function will immediately return %TRUE.
     *
     * There may be implementation specific restrictions on deeply nested values.
     * GVariant is guaranteed to handle nesting up to at least 64 levels.
     * @returns %TRUE if @value is in normal form
     */
    isNormalForm(): boolean
    /**
     * Checks if a value has a type matching the provided type.
     * @param type a #GVariantType
     * @returns %TRUE if the type of @value matches @type
     */
    isOfType(type: VariantType): boolean
    /**
     * Looks up a value in a dictionary #GVariant.
     *
     * This function works with dictionaries of the type a{s*} (and equally
     * well with type a{o*}, but we only further discuss the string case
     * for sake of clarity).
     *
     * In the event that `dictionary` has the type a{sv}, the `expected_type`
     * string specifies what type of value is expected to be inside of the
     * variant. If the value inside the variant has a different type then
     * %NULL is returned. In the event that `dictionary` has a value type other
     * than v then `expected_type` must directly match the value type and it is
     * used to unpack the value directly or an error occurs.
     *
     * In either case, if `key` is not found in `dictionary,` %NULL is returned.
     *
     * If the key is found and the value has the correct type, it is
     * returned.  If `expected_type` was specified then any non-%NULL return
     * value will have this type.
     *
     * This function is currently implemented with a linear scan.  If you
     * plan to do many lookups then #GVariantDict may be more efficient.
     * @param key the key to look up in the dictionary
     * @param expectedType a #GVariantType, or %NULL
     * @returns the value of the dictionary key, or %NULL
     */
    lookupValue(key: string, expectedType: VariantType | null): Variant
    /**
     * Determines the number of children in a container #GVariant instance.
     * This includes variants, maybes, arrays, tuples and dictionary
     * entries.  It is an error to call this function on any other type of
     * #GVariant.
     *
     * For variants, the return value is always 1.  For values with maybe
     * types, it is always zero or one.  For arrays, it is the length of the
     * array.  For tuples it is the number of tuple items (which depends
     * only on the type).  For dictionary entries, it is always 2
     *
     * This function is O(1).
     * @returns the number of children in the container
     */
    nChildren(): number
    /**
     * Pretty-prints `value` in the format understood by g_variant_parse().
     *
     * The format is described [here][gvariant-text].
     *
     * If `type_annotate` is %TRUE, then type information is included in
     * the output.
     * @param typeAnnotate %TRUE if type information should be included in                 the output
     * @returns a newly-allocated string holding the result.
     */
    print(typeAnnotate: boolean): string | null
    /**
     * Increases the reference count of `value`.
     * @returns the same @value
     */
    ref(): Variant
    /**
     * #GVariant uses a floating reference count system.  All functions with
     * names starting with `g_variant_new_` return floating
     * references.
     *
     * Calling g_variant_ref_sink() on a #GVariant with a floating reference
     * will convert the floating reference into a full reference.  Calling
     * g_variant_ref_sink() on a non-floating #GVariant results in an
     * additional normal reference being added.
     *
     * In other words, if the `value` is floating, then this call "assumes
     * ownership" of the floating reference, converting it to a normal
     * reference.  If the `value` is not floating, then this call adds a
     * new normal reference increasing the reference count by one.
     *
     * All calls that result in a #GVariant instance being inserted into a
     * container will call g_variant_ref_sink() on the instance.  This means
     * that if the value was just created (and has only its floating
     * reference) then the container will assume sole ownership of the value
     * at that point and the caller will not need to unreference it.  This
     * makes certain common styles of programming much easier while still
     * maintaining normal refcounting semantics in situations where values
     * are not floating.
     * @returns the same @value
     */
    refSink(): Variant
    /**
     * Stores the serialized form of `value` at `data`.  `data` should be
     * large enough.  See g_variant_get_size().
     *
     * The stored data is in machine native byte order but may not be in
     * fully-normalised form if read from an untrusted source.  See
     * g_variant_get_normal_form() for a solution.
     *
     * As with g_variant_get_data(), to be able to deserialize the
     * serialized variant successfully, its type and (if the destination
     * machine might be different) its endianness must also be available.
     *
     * This function is approximately O(n) in the size of `data`.
     * @param data the location to store the serialized data at
     */
    store(data: any): void
    /**
     * If `value` is floating, sink it.  Otherwise, do nothing.
     *
     * Typically you want to use g_variant_ref_sink() in order to
     * automatically do the correct thing with respect to floating or
     * non-floating references, but there is one specific scenario where
     * this function is helpful.
     *
     * The situation where this function is helpful is when creating an API
     * that allows the user to provide a callback function that returns a
     * #GVariant.  We certainly want to allow the user the flexibility to
     * return a non-floating reference from this callback (for the case
     * where the value that is being returned already exists).
     *
     * At the same time, the style of the #GVariant API makes it likely that
     * for newly-created #GVariant instances, the user can be saved some
     * typing if they are allowed to return a #GVariant with a floating
     * reference.
     *
     * Using this function on the return value of the user's callback allows
     * the user to do whichever is more convenient for them.  The caller
     * will always receives exactly one full reference to the value: either
     * the one that was returned in the first place, or a floating reference
     * that has been converted to a full reference.
     *
     * This function has an odd interaction when combined with
     * g_variant_ref_sink() running at the same time in another thread on
     * the same #GVariant instance.  If g_variant_ref_sink() runs first then
     * the result will be that the floating reference is converted to a hard
     * reference.  If g_variant_take_ref() runs first then the result will
     * be that the floating reference is converted to a hard reference and
     * an additional reference on top of that one is added.  It is best to
     * avoid this situation.
     * @returns the same @value
     */
    takeRef(): Variant
    /**
     * Decreases the reference count of `value`.  When its reference count
     * drops to 0, the memory used by the variant is freed.
     */
    unref(): void
  }

  /**
   * `GVariant` is a variant datatype; it can contain one or more values
   * along with information about the type of the values.
   *
   * A `GVariant` may contain simple types, like an integer, or a boolean value;
   * or complex types, like an array of two strings, or a dictionary of key
   * value pairs. A `GVariant` is also immutable: once it’s been created neither
   * its type nor its content can be modified further.
   *
   * `GVariant` is useful whenever data needs to be serialized, for example when
   * sending method parameters in D-Bus, or when saving settings using
   * [`GSettings`](../gio/class.Settings.html).
   *
   * When creating a new `GVariant`, you pass the data you want to store in it
   * along with a string representing the type of data you wish to pass to it.
   *
   * For instance, if you want to create a `GVariant` holding an integer value you
   * can use:
   *
   * ```c
   * GVariant *v = g_variant_new ("u", 40);
   * ```
   *
   * The string `u` in the first argument tells `GVariant` that the data passed to
   * the constructor (`40`) is going to be an unsigned integer.
   *
   * More advanced examples of `GVariant` in use can be found in documentation for
   * [`GVariant` format strings](gvariant-format-strings.html#pointers).
   *
   * The range of possible values is determined by the type.
   *
   * The type system used by `GVariant` is [type`GLib`.VariantType].
   *
   * `GVariant` instances always have a type and a value (which are given
   * at construction time).  The type and value of a `GVariant` instance
   * can never change other than by the `GVariant` itself being
   * destroyed.  A `GVariant` cannot contain a pointer.
   *
   * `GVariant` is reference counted using [method`GLib`.Variant.ref] and
   * [method`GLib`.Variant.unref].  `GVariant` also has floating reference counts —
   * see [method`GLib`.Variant.ref_sink].
   *
   * `GVariant` is completely threadsafe.  A `GVariant` instance can be
   * concurrently accessed in any way from any number of threads without
   * problems.
   *
   * `GVariant` is heavily optimised for dealing with data in serialized
   * form.  It works particularly well with data located in memory-mapped
   * files.  It can perform nearly all deserialization operations in a
   * small constant time, usually touching only a single memory page.
   * Serialized `GVariant` data can also be sent over the network.
   *
   * `GVariant` is largely compatible with D-Bus.  Almost all types of
   * `GVariant` instances can be sent over D-Bus.  See [type`GLib`.VariantType] for
   * exceptions.  (However, `GVariant`’s serialization format is not the same
   * as the serialization format of a D-Bus message body: use
   * [GDBusMessage](../gio/class.DBusMessage.html), in the GIO library, for those.)
   *
   * For space-efficiency, the `GVariant` serialization format does not
   * automatically include the variant’s length, type or endianness,
   * which must either be implied from context (such as knowledge that a
   * particular file format always contains a little-endian
   * `G_VARIANT_TYPE_VARIANT` which occupies the whole length of the file)
   * or supplied out-of-band (for instance, a length, type and/or endianness
   * indicator could be placed at the beginning of a file, network message
   * or network stream).
   *
   * A `GVariant`’s size is limited mainly by any lower level operating
   * system constraints, such as the number of bits in `gsize`.  For
   * example, it is reasonable to have a 2GB file mapped into memory
   * with [struct`GLib`.MappedFile], and call [ctor`GLib`.Variant.new_from_data] on
   * it.
   *
   * For convenience to C programmers, `GVariant` features powerful
   * varargs-based value construction and destruction.  This feature is
   * designed to be embedded in other libraries.
   *
   * There is a Python-inspired text language for describing `GVariant`
   * values.  `GVariant` includes a printer for this language and a parser
   * with type inferencing.
   *
   * ## Memory Use
   *
   * `GVariant` tries to be quite efficient with respect to memory use.
   * This section gives a rough idea of how much memory is used by the
   * current implementation.  The information here is subject to change
   * in the future.
   *
   * The memory allocated by `GVariant` can be grouped into 4 broad
   * purposes: memory for serialized data, memory for the type
   * information cache, buffer management memory and memory for the
   * `GVariant` structure itself.
   *
   * ## Serialized Data Memory
   *
   * This is the memory that is used for storing `GVariant` data in
   * serialized form.  This is what would be sent over the network or
   * what would end up on disk, not counting any indicator of the
   * endianness, or of the length or type of the top-level variant.
   *
   * The amount of memory required to store a boolean is 1 byte. 16,
   * 32 and 64 bit integers and double precision floating point numbers
   * use their ‘natural’ size.  Strings (including object path and
   * signature strings) are stored with a nul terminator, and as such
   * use the length of the string plus 1 byte.
   *
   * ‘Maybe’ types use no space at all to represent the null value and
   * use the same amount of space (sometimes plus one byte) as the
   * equivalent non-maybe-typed value to represent the non-null case.
   *
   * Arrays use the amount of space required to store each of their
   * members, concatenated.  Additionally, if the items stored in an
   * array are not of a fixed-size (ie: strings, other arrays, etc)
   * then an additional framing offset is stored for each item.  The
   * size of this offset is either 1, 2 or 4 bytes depending on the
   * overall size of the container.  Additionally, extra padding bytes
   * are added as required for alignment of child values.
   *
   * Tuples (including dictionary entries) use the amount of space
   * required to store each of their members, concatenated, plus one
   * framing offset (as per arrays) for each non-fixed-sized item in
   * the tuple, except for the last one.  Additionally, extra padding
   * bytes are added as required for alignment of child values.
   *
   * Variants use the same amount of space as the item inside of the
   * variant, plus 1 byte, plus the length of the type string for the
   * item inside the variant.
   *
   * As an example, consider a dictionary mapping strings to variants.
   * In the case that the dictionary is empty, 0 bytes are required for
   * the serialization.
   *
   * If we add an item ‘width’ that maps to the int32 value of 500 then
   * we will use 4 bytes to store the int32 (so 6 for the variant
   * containing it) and 6 bytes for the string.  The variant must be
   * aligned to 8 after the 6 bytes of the string, so that’s 2 extra
   * bytes.  6 (string) + 2 (padding) + 6 (variant) is 14 bytes used
   * for the dictionary entry.  An additional 1 byte is added to the
   * array as a framing offset making a total of 15 bytes.
   *
   * If we add another entry, ‘title’ that maps to a nullable string
   * that happens to have a value of null, then we use 0 bytes for the
   * null value (and 3 bytes for the variant to contain it along with
   * its type string) plus 6 bytes for the string.  Again, we need 2
   * padding bytes.  That makes a total of 6 + 2 + 3 = 11 bytes.
   *
   * We now require extra padding between the two items in the array.
   * After the 14 bytes of the first item, that’s 2 bytes required.
   * We now require 2 framing offsets for an extra two
   * bytes. 14 + 2 + 11 + 2 = 29 bytes to encode the entire two-item
   * dictionary.
   *
   * ## Type Information Cache
   *
   * For each `GVariant` type that currently exists in the program a type
   * information structure is kept in the type information cache.  The
   * type information structure is required for rapid deserialization.
   *
   * Continuing with the above example, if a `GVariant` exists with the
   * type `a{sv}` then a type information struct will exist for
   * `a{sv}`, `{sv}`, `s`, and `v`.  Multiple uses of the same type
   * will share the same type information.  Additionally, all
   * single-digit types are stored in read-only static memory and do
   * not contribute to the writable memory footprint of a program using
   * `GVariant`.
   *
   * Aside from the type information structures stored in read-only
   * memory, there are two forms of type information.  One is used for
   * container types where there is a single element type: arrays and
   * maybe types.  The other is used for container types where there
   * are multiple element types: tuples and dictionary entries.
   *
   * Array type info structures are `6 * sizeof (void *)`, plus the
   * memory required to store the type string itself.  This means that
   * on 32-bit systems, the cache entry for `a{sv}` would require 30
   * bytes of memory (plus allocation overhead).
   *
   * Tuple type info structures are `6 * sizeof (void *)`, plus `4 *
   * sizeof (void *)` for each item in the tuple, plus the memory
   * required to store the type string itself.  A 2-item tuple, for
   * example, would have a type information structure that consumed
   * writable memory in the size of `14 * sizeof (void *)` (plus type
   * string)  This means that on 32-bit systems, the cache entry for
   * `{sv}` would require 61 bytes of memory (plus allocation overhead).
   *
   * This means that in total, for our `a{sv}` example, 91 bytes of
   * type information would be allocated.
   *
   * The type information cache, additionally, uses a [struct`GLib`.HashTable] to
   * store and look up the cached items and stores a pointer to this
   * hash table in static storage.  The hash table is freed when there
   * are zero items in the type cache.
   *
   * Although these sizes may seem large it is important to remember
   * that a program will probably only have a very small number of
   * different types of values in it and that only one type information
   * structure is required for many different values of the same type.
   *
   * ## Buffer Management Memory
   *
   * `GVariant` uses an internal buffer management structure to deal
   * with the various different possible sources of serialized data
   * that it uses.  The buffer is responsible for ensuring that the
   * correct call is made when the data is no longer in use by
   * `GVariant`.  This may involve a [func`GLib`.free] or
   * even [method`GLib`.MappedFile.unref].
   *
   * One buffer management structure is used for each chunk of
   * serialized data.  The size of the buffer management structure
   * is `4 * (void *)`.  On 32-bit systems, that’s 16 bytes.
   *
   * ## GVariant structure
   *
   * The size of a `GVariant` structure is `6 * (void *)`.  On 32-bit
   * systems, that’s 24 bytes.
   *
   * `GVariant` structures only exist if they are explicitly created
   * with API calls.  For example, if a `GVariant` is constructed out of
   * serialized data for the example given above (with the dictionary)
   * then although there are 9 individual values that comprise the
   * entire dictionary (two keys, two values, two variants containing
   * the values, two dictionary entries, plus the dictionary itself),
   * only 1 `GVariant` instance exists — the one referring to the
   * dictionary.
   *
   * If calls are made to start accessing the other values then
   * `GVariant` instances will exist for those values only for as long
   * as they are in use (ie: until you call [method`GLib`.Variant.unref]).  The
   * type information is shared.  The serialized data and the buffer
   * management structure for that serialized data is shared by the
   * child.
   *
   * ## Summary
   *
   * To put the entire example together, for our dictionary mapping
   * strings to variants (with two entries, as given above), we are
   * using 91 bytes of memory for type information, 29 bytes of memory
   * for the serialized data, 16 bytes for buffer management and 24
   * bytes for the `GVariant` instance, or a total of 160 bytes, plus
   * allocation overhead.  If we were to use [method`GLib`.Variant.get_child_value]
   * to access the two dictionary entries, we would use an additional 48
   * bytes.  If we were to have other dictionaries of the same type, we
   * would use more memory for the serialized data and buffer
   * management for those dictionaries, but the type information would
   * be shared.
   * @record
   */
  class Variant {
    // Own properties of GLib-2.0.GLib.Variant

    static name: string

    // Constructors of GLib-2.0.GLib.Variant

    /**
     * Creates a new #GVariant array from `children`.
     *
     * `child_type` must be non-%NULL if `n_children` is zero.  Otherwise, the
     * child type is determined by inspecting the first element of the
     * `children` array.  If `child_type` is non-%NULL then it must be a
     * definite type.
     *
     * The items of the array are taken from the `children` array.  No entry
     * in the `children` array may be %NULL.
     *
     * All items in the array must have the same type, which must be the
     * same as `child_type,` if given.
     *
     * If the `children` are floating references (see g_variant_ref_sink()), the
     * new instance takes ownership of them as if via g_variant_ref_sink().
     * @constructor
     * @param childType the element type of the new array
     * @param children an array of            #GVariant pointers, the children
     * @returns a floating reference to a new #GVariant array
     */
    static newArray(
      childType: VariantType | null,
      children: Variant[] | null
    ): Variant
    /**
     * Creates a new boolean #GVariant instance -- either %TRUE or %FALSE.
     * @constructor
     * @param value a #gboolean value
     * @returns a floating reference to a new boolean #GVariant instance
     */
    static newBoolean(value: boolean): Variant
    /**
     * Creates a new byte #GVariant instance.
     * @constructor
     * @param value a #guint8 value
     * @returns a floating reference to a new byte #GVariant instance
     */
    static newByte(value: number): Variant
    /**
     * Creates an array-of-bytes #GVariant with the contents of `string`.
     * This function is just like g_variant_new_string() except that the
     * string need not be valid UTF-8.
     *
     * The nul terminator character at the end of the string is stored in
     * the array.
     * @constructor
     * @param string a normal          nul-terminated string in no particular encoding
     * @returns a floating reference to a new bytestring #GVariant instance
     */
    static newBytestring(string: number[]): Variant
    /**
     * Constructs an array of bytestring #GVariant from the given array of
     * strings.
     *
     * If `length` is -1 then `strv` is %NULL-terminated.
     * @constructor
     * @param strv an array of strings
     * @returns a new floating #GVariant instance
     */
    static newBytestringArray(strv: string[]): Variant
    /**
     * Creates a new dictionary entry #GVariant. `key` and `value` must be
     * non-%NULL. `key` must be a value of a basic type (ie: not a container).
     *
     * If the `key` or `value` are floating references (see g_variant_ref_sink()),
     * the new instance takes ownership of them as if via g_variant_ref_sink().
     * @constructor
     * @param key a basic #GVariant, the key
     * @param value a #GVariant, the value
     * @returns a floating reference to a new dictionary entry #GVariant
     */
    static newDictEntry(key: Variant, value: Variant): Variant
    /**
     * Creates a new double #GVariant instance.
     * @constructor
     * @param value a #gdouble floating point value
     * @returns a floating reference to a new double #GVariant instance
     */
    static newDouble(value: number): Variant
    /**
     * Constructs a new array #GVariant instance, where the elements are
     * of `element_type` type.
     *
     * `elements` must be an array with fixed-sized elements.  Numeric types are
     * fixed-size as are tuples containing only other fixed-sized types.
     *
     * `element_size` must be the size of a single element in the array.
     * For example, if calling this function for an array of 32-bit integers,
     * you might say sizeof(gint32). This value isn't used except for the purpose
     * of a double-check that the form of the serialized data matches the caller's
     * expectation.
     *
     * `n_elements` must be the length of the `elements` array.
     * @constructor
     * @param elementType the #GVariantType of each element
     * @param elements a pointer to the fixed array of contiguous elements
     * @param nElements the number of elements
     * @param elementSize the size of each element
     * @returns a floating reference to a new array #GVariant instance
     */
    static newFixedArray(
      elementType: VariantType,
      elements: any | null,
      nElements: number,
      elementSize: number
    ): Variant
    /**
     * Constructs a new serialized-mode #GVariant instance.  This is the
     * inner interface for creation of new serialized values that gets
     * called from various functions in gvariant.c.
     *
     * A reference is taken on `bytes`.
     *
     * The data in `bytes` must be aligned appropriately for the `type` being loaded.
     * Otherwise this function will internally create a copy of the memory (since
     * GLib 2.60) or (in older versions) fail and exit the process.
     * @constructor
     * @param type a #GVariantType
     * @param bytes a #GBytes
     * @param trusted if the contents of `bytes` are trusted
     * @returns a new #GVariant with a floating reference
     */
    static newFromBytes(
      type: VariantType,
      bytes: any,
      trusted: boolean
    ): Variant
    /**
     * Creates a new #GVariant instance from serialized data.
     *
     * `type` is the type of #GVariant instance that will be constructed.
     * The interpretation of `data` depends on knowing the type.
     *
     * `data` is not modified by this function and must remain valid with an
     * unchanging value until such a time as `notify` is called with
     * `user_data`.  If the contents of `data` change before that time then
     * the result is undefined.
     *
     * If `data` is trusted to be serialized data in normal form then
     * `trusted` should be %TRUE.  This applies to serialized data created
     * within this process or read from a trusted location on the disk (such
     * as a file installed in /usr/lib alongside your application).  You
     * should set trusted to %FALSE if `data` is read from the network, a
     * file in the user's home directory, etc.
     *
     * If `data` was not stored in this machine's native endianness, any multi-byte
     * numeric values in the returned variant will also be in non-native
     * endianness. g_variant_byteswap() can be used to recover the original values.
     *
     * `notify` will be called with `user_data` when `data` is no longer
     * needed.  The exact time of this call is unspecified and might even be
     * before this function returns.
     *
     * Note: `data` must be backed by memory that is aligned appropriately for the
     * `type` being loaded. Otherwise this function will internally create a copy of
     * the memory (since GLib 2.60) or (in older versions) fail and exit the
     * process.
     * @constructor
     * @param type a definite #GVariantType
     * @param data the serialized data
     * @param trusted %TRUE if `data` is definitely in normal form
     * @param notify function to call when `data` is no longer needed
     * @param userData data for `notify`
     * @returns a new floating #GVariant of type @type
     */
    static newFromData(
      type: VariantType,
      data: number[],
      trusted: boolean,
      notify: DestroyNotify,
      userData: any | null
    ): Variant
    /**
     * Creates a new handle #GVariant instance.
     *
     * By convention, handles are indexes into an array of file descriptors
     * that are sent alongside a D-Bus message.  If you're not interacting
     * with D-Bus, you probably don't need them.
     * @constructor
     * @param value a #gint32 value
     * @returns a floating reference to a new handle #GVariant instance
     */
    static newHandle(value: number): Variant
    /**
     * Creates a new int16 #GVariant instance.
     * @constructor
     * @param value a #gint16 value
     * @returns a floating reference to a new int16 #GVariant instance
     */
    static newInt16(value: number): Variant
    /**
     * Creates a new int32 #GVariant instance.
     * @constructor
     * @param value a #gint32 value
     * @returns a floating reference to a new int32 #GVariant instance
     */
    static newInt32(value: number): Variant
    /**
     * Creates a new int64 #GVariant instance.
     * @constructor
     * @param value a #gint64 value
     * @returns a floating reference to a new int64 #GVariant instance
     */
    static newInt64(value: number): Variant
    /**
     * Depending on if `child` is %NULL, either wraps `child` inside of a
     * maybe container or creates a Nothing instance for the given `type`.
     *
     * At least one of `child_type` and `child` must be non-%NULL.
     * If `child_type` is non-%NULL then it must be a definite type.
     * If they are both non-%NULL then `child_type` must be the type
     * of `child`.
     *
     * If `child` is a floating reference (see g_variant_ref_sink()), the new
     * instance takes ownership of `child`.
     * @constructor
     * @param childType the #GVariantType of the child, or %NULL
     * @param child the child value, or %NULL
     * @returns a floating reference to a new #GVariant maybe instance
     */
    static newMaybe(
      childType: VariantType | null,
      child: Variant | null
    ): Variant
    /**
     * Creates a D-Bus object path #GVariant with the contents of `object_path`.
     * `object_path` must be a valid D-Bus object path.  Use
     * g_variant_is_object_path() if you're not sure.
     * @constructor
     * @param objectPath a normal C nul-terminated string
     * @returns a floating reference to a new object path #GVariant instance
     */
    static newObjectPath(objectPath: string): Variant
    /**
     * Constructs an array of object paths #GVariant from the given array of
     * strings.
     *
     * Each string must be a valid #GVariant object path; see
     * g_variant_is_object_path().
     *
     * If `length` is -1 then `strv` is %NULL-terminated.
     * @constructor
     * @param strv an array of strings
     * @returns a new floating #GVariant instance
     */
    static newObjv(strv: string[]): Variant
    /**
     * Creates a D-Bus type signature #GVariant with the contents of
     * `string`.  `string` must be a valid D-Bus type signature.  Use
     * g_variant_is_signature() if you're not sure.
     * @constructor
     * @param signature a normal C nul-terminated string
     * @returns a floating reference to a new signature #GVariant instance
     */
    static newSignature(signature: string): Variant
    /**
     * Creates a string #GVariant with the contents of `string`.
     *
     * `string` must be valid UTF-8, and must not be %NULL. To encode
     * potentially-%NULL strings, use g_variant_new() with `ms` as the
     * [format string][gvariant-format-strings-maybe-types].
     * @constructor
     * @param string a normal UTF-8 nul-terminated string
     * @returns a floating reference to a new string #GVariant instance
     */
    static newString(string: string): Variant
    /**
     * Constructs an array of strings #GVariant from the given array of
     * strings.
     *
     * If `length` is -1 then `strv` is %NULL-terminated.
     * @constructor
     * @param strv an array of strings
     * @returns a new floating #GVariant instance
     */
    static newStrv(strv: string[]): Variant
    /**
     * Creates a new tuple #GVariant out of the items in `children`.  The
     * type is determined from the types of `children`.  No entry in the
     * `children` array may be %NULL.
     *
     * If `n_children` is 0 then the unit tuple is constructed.
     *
     * If the `children` are floating references (see g_variant_ref_sink()), the
     * new instance takes ownership of them as if via g_variant_ref_sink().
     * @constructor
     * @param children the items to make the tuple out of
     * @returns a floating reference to a new #GVariant tuple
     */
    static newTuple(children: Variant[]): Variant
    /**
     * Creates a new uint16 #GVariant instance.
     * @constructor
     * @param value a #guint16 value
     * @returns a floating reference to a new uint16 #GVariant instance
     */
    static newUint16(value: number): Variant
    /**
     * Creates a new uint32 #GVariant instance.
     * @constructor
     * @param value a #guint32 value
     * @returns a floating reference to a new uint32 #GVariant instance
     */
    static newUint32(value: number): Variant
    /**
     * Creates a new uint64 #GVariant instance.
     * @constructor
     * @param value a #guint64 value
     * @returns a floating reference to a new uint64 #GVariant instance
     */
    static newUint64(value: number): Variant
    /**
     * Boxes `value`.  The result is a #GVariant instance representing a
     * variant containing the original value.
     *
     * If `child` is a floating reference (see g_variant_ref_sink()), the new
     * instance takes ownership of `child`.
     * @constructor
     * @param value a #GVariant instance
     * @returns a floating reference to a new variant #GVariant instance
     */
    static newVariant(value: Variant): Variant
    /**
     * Determines if a given string is a valid D-Bus object path.  You
     * should ensure that a string is a valid D-Bus object path before
     * passing it to g_variant_new_object_path().
     *
     * A valid object path starts with `/` followed by zero or more
     * sequences of characters separated by `/` characters.  Each sequence
     * must contain only the characters `[A-Z][a-z][0-9]_`.  No sequence
     * (including the one following the final `/` character) may be empty.
     * @param string a normal C nul-terminated string
     * @returns %TRUE if @string is a D-Bus object path
     */
    static isObjectPath(string: string): boolean
    /**
     * Determines if a given string is a valid D-Bus type signature.  You
     * should ensure that a string is a valid D-Bus type signature before
     * passing it to g_variant_new_signature().
     *
     * D-Bus type signatures consist of zero or more definite #GVariantType
     * strings in sequence.
     * @param string a normal C nul-terminated string
     * @returns %TRUE if @string is a D-Bus type signature
     */
    static isSignature(string: string): boolean
    /**
     * Parses a #GVariant from a text representation.
     *
     * A single #GVariant is parsed from the content of `text`.
     *
     * The format is described [here](gvariant-text-format.html).
     *
     * The memory at `limit` will never be accessed and the parser behaves as
     * if the character at `limit` is the nul terminator.  This has the
     * effect of bounding `text`.
     *
     * If `endptr` is non-%NULL then `text` is permitted to contain data
     * following the value that this function parses and `endptr` will be
     * updated to point to the first character past the end of the text
     * parsed by this function.  If `endptr` is %NULL and there is extra data
     * then an error is returned.
     *
     * If `type` is non-%NULL then the value will be parsed to have that
     * type.  This may result in additional parse errors (in the case that
     * the parsed value doesn't fit the type) but may also result in fewer
     * errors (in the case that the type would have been ambiguous, such as
     * with empty arrays).
     *
     * In the event that the parsing is successful, the resulting #GVariant
     * is returned. It is never floating, and must be freed with
     * [method`GLib`.Variant.unref].
     *
     * In case of any error, %NULL will be returned.  If `error` is non-%NULL
     * then it will be set to reflect the error that occurred.
     *
     * Officially, the language understood by the parser is “any string
     * produced by [method`GLib`.Variant.print]”. This explicitly includes
     * `g_variant_print()`’s annotated types like `int64 -1000`.
     *
     * There may be implementation specific restrictions on deeply nested values,
     * which would result in a %G_VARIANT_PARSE_ERROR_RECURSION error. #GVariant is
     * guaranteed to handle nesting up to at least 64 levels.
     * @param type a #GVariantType, or %NULL
     * @param text a string containing a GVariant in text form
     * @param limit a pointer to the end of `text,` or %NULL
     * @param endptr a location to store the end pointer, or %NULL
     * @returns a non-floating reference to a #GVariant, or %NULL
     */
    static parse(
      type: VariantType | null,
      text: string,
      limit: string | null,
      endptr: string | null
    ): Variant
    /**
     * Pretty-prints a message showing the context of a #GVariant parse
     * error within the string for which parsing was attempted.
     *
     * The resulting string is suitable for output to the console or other
     * monospace media where newlines are treated in the usual way.
     *
     * The message will typically look something like one of the following:
     *
     *
     * ```
     * unterminated string constant:
     *   (1, 2, 3, 'abc
     *             ^^^^
     * ```
     *
     *
     * or
     *
     *
     * ```
     * unable to find a common type:
     *   [1, 2, 3, 'str']
     *    ^        ^^^^^
     * ```
     *
     *
     * The format of the message may change in a future version.
     *
     * `error` must have come from a failed attempt to g_variant_parse() and
     * `source_str` must be exactly the same string that caused the error.
     * If `source_str` was not nul-terminated when you passed it to
     * g_variant_parse() then you must add nul termination before using this
     * function.
     * @param error a #GError from the #GVariantParseError domain
     * @param sourceStr the string that was given to the parser
     * @returns the printed message
     */
    static parseErrorPrintContext(
      error: Error,
      sourceStr: string
    ): string | null
    static parseErrorQuark(): Quark
    /**
     * Same as g_variant_error_quark().
     */
    static parserGetErrorQuark(): Quark
  }

  interface VariantBuilder {
    // Owm methods of GLib-2.0.GLib.VariantBuilder

    /**
     * Adds `value` to `builder`.
     *
     * It is an error to call this function in any way that would create an
     * inconsistent value to be constructed.  Some examples of this are
     * putting different types of items into an array, putting the wrong
     * types or number of items in a tuple, putting more than one value into
     * a variant, etc.
     *
     * If `value` is a floating reference (see g_variant_ref_sink()),
     * the `builder` instance takes ownership of `value`.
     * @param value a #GVariant
     */
    addValue(value: Variant): void
    /**
     * Closes the subcontainer inside the given `builder` that was opened by
     * the most recent call to g_variant_builder_open().
     *
     * It is an error to call this function in any way that would create an
     * inconsistent value to be constructed (ie: too few values added to the
     * subcontainer).
     */
    close(): void
    /**
     * Ends the builder process and returns the constructed value.
     *
     * It is not permissible to use `builder` in any way after this call
     * except for reference counting operations (in the case of a
     * heap-allocated #GVariantBuilder) or by reinitialising it with
     * g_variant_builder_init() (in the case of stack-allocated). This
     * means that for the stack-allocated builders there is no need to
     * call g_variant_builder_clear() after the call to
     * g_variant_builder_end().
     *
     * It is an error to call this function in any way that would create an
     * inconsistent value to be constructed (ie: insufficient number of
     * items added to a container with a specific number of children
     * required).  It is also an error to call this function if the builder
     * was created with an indefinite array or maybe type and no children
     * have been added; in this case it is impossible to infer the type of
     * the empty array.
     * @returns a new, floating, #GVariant
     */
    end(): Variant
    /**
     * Opens a subcontainer inside the given `builder`.  When done adding
     * items to the subcontainer, g_variant_builder_close() must be called. `type`
     * is the type of the container: so to build a tuple of several values, `type`
     * must include the tuple itself.
     *
     * It is an error to call this function in any way that would cause an
     * inconsistent value to be constructed (ie: adding too many values or
     * a value of an incorrect type).
     *
     * Example of building a nested variant:
     *
     * ```c
     * GVariantBuilder builder;
     * guint32 some_number = get_number ();
     * g_autoptr (GHashTable) some_dict = get_dict ();
     * GHashTableIter iter;
     * const gchar *key;
     * const GVariant *value;
     * g_autoptr (GVariant) output = NULL;
     *
     * g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ua{sv})"));
     * g_variant_builder_add (&builder, "u", some_number);
     * g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));
     *
     * g_hash_table_iter_init (&iter, some_dict);
     * while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value))
     *   {
     *     g_variant_builder_open (&builder, G_VARIANT_TYPE ("{sv}"));
     *     g_variant_builder_add (&builder, "s", key);
     *     g_variant_builder_add (&builder, "v", value);
     *     g_variant_builder_close (&builder);
     *   }
     *
     * g_variant_builder_close (&builder);
     *
     * output = g_variant_builder_end (&builder);
     * ```
     *
     * @param type the #GVariantType of the container
     */
    open(type: VariantType): void
    /**
     * Increases the reference count on `builder`.
     *
     * Don't call this on stack-allocated #GVariantBuilder instances or bad
     * things will happen.
     * @returns a new reference to @builder
     */
    ref(): VariantBuilder
    /**
     * Decreases the reference count on `builder`.
     *
     * In the event that there are no more references, releases all memory
     * associated with the #GVariantBuilder.
     *
     * Don't call this on stack-allocated #GVariantBuilder instances or bad
     * things will happen.
     */
    unref(): void
  }

  /**
   * A utility type for constructing container-type #GVariant instances.
   *
   * This is an opaque structure and may only be accessed using the
   * following functions.
   *
   * #GVariantBuilder is not threadsafe in any way.  Do not attempt to
   * access it from more than one thread.
   * @record
   */
  class VariantBuilder {
    // Own properties of GLib-2.0.GLib.VariantBuilder

    static name: string

    // Constructors of GLib-2.0.GLib.VariantBuilder

    /**
     * Allocates and initialises a new #GVariantBuilder.
     *
     * You should call g_variant_builder_unref() on the return value when it
     * is no longer needed.  The memory will not be automatically freed by
     * any other call.
     *
     * In most cases it is easier to place a #GVariantBuilder directly on
     * the stack of the calling function and initialise it with
     * g_variant_builder_init().
     * @constructor
     * @param type a container type
     * @returns a #GVariantBuilder
     */
    constructor(type: VariantType)
    /**
     * Allocates and initialises a new #GVariantBuilder.
     *
     * You should call g_variant_builder_unref() on the return value when it
     * is no longer needed.  The memory will not be automatically freed by
     * any other call.
     *
     * In most cases it is easier to place a #GVariantBuilder directly on
     * the stack of the calling function and initialise it with
     * g_variant_builder_init().
     * @constructor
     * @param type a container type
     * @returns a #GVariantBuilder
     */
    static new(type: VariantType): VariantBuilder
  }

  interface VariantDict {
    // Owm methods of GLib-2.0.GLib.VariantDict

    /**
     * Releases all memory associated with a #GVariantDict without freeing
     * the #GVariantDict structure itself.
     *
     * It typically only makes sense to do this on a stack-allocated
     * #GVariantDict if you want to abort building the value part-way
     * through.  This function need not be called if you call
     * g_variant_dict_end() and it also doesn't need to be called on dicts
     * allocated with g_variant_dict_new (see g_variant_dict_unref() for
     * that).
     *
     * It is valid to call this function on either an initialised
     * #GVariantDict or one that was previously cleared by an earlier call
     * to g_variant_dict_clear() but it is not valid to call this function
     * on uninitialised memory.
     */
    clear(): void
    /**
     * Checks if `key` exists in `dict`.
     * @param key the key to look up in the dictionary
     * @returns %TRUE if @key is in @dict
     */
    contains(key: string): boolean
    /**
     * Returns the current value of `dict` as a #GVariant of type
     * %G_VARIANT_TYPE_VARDICT, clearing it in the process.
     *
     * It is not permissible to use `dict` in any way after this call except
     * for reference counting operations (in the case of a heap-allocated
     * #GVariantDict) or by reinitialising it with g_variant_dict_init() (in
     * the case of stack-allocated).
     * @returns a new, floating, #GVariant
     */
    end(): Variant
    /**
     * Inserts (or replaces) a key in a #GVariantDict.
     *
     * `value` is consumed if it is floating.
     * @param key the key to insert a value for
     * @param value the value to insert
     */
    insertValue(key: string, value: Variant): void
    /**
     * Looks up a value in a #GVariantDict.
     *
     * If `key` is not found in `dictionary,` %NULL is returned.
     *
     * The `expected_type` string specifies what type of value is expected.
     * If the value associated with `key` has a different type then %NULL is
     * returned.
     *
     * If the key is found and the value has the correct type, it is
     * returned.  If `expected_type` was specified then any non-%NULL return
     * value will have this type.
     * @param key the key to look up in the dictionary
     * @param expectedType a #GVariantType, or %NULL
     * @returns the value of the dictionary key, or %NULL
     */
    lookupValue(key: string, expectedType: VariantType | null): Variant | null
    /**
     * Increases the reference count on `dict`.
     *
     * Don't call this on stack-allocated #GVariantDict instances or bad
     * things will happen.
     * @returns a new reference to @dict
     */
    ref(): VariantDict
    /**
     * Removes a key and its associated value from a #GVariantDict.
     * @param key the key to remove
     * @returns %TRUE if the key was found and removed
     */
    remove(key: string): boolean
    /**
     * Decreases the reference count on `dict`.
     *
     * In the event that there are no more references, releases all memory
     * associated with the #GVariantDict.
     *
     * Don't call this on stack-allocated #GVariantDict instances or bad
     * things will happen.
     */
    unref(): void
  }

  /**
   * #GVariantDict is a mutable interface to #GVariant dictionaries.
   *
   * It can be used for doing a sequence of dictionary lookups in an
   * efficient way on an existing #GVariant dictionary or it can be used
   * to construct new dictionaries with a hashtable-like interface.  It
   * can also be used for taking existing dictionaries and modifying them
   * in order to create new ones.
   *
   * #GVariantDict can only be used with %G_VARIANT_TYPE_VARDICT
   * dictionaries.
   *
   * It is possible to use #GVariantDict allocated on the stack or on the
   * heap.  When using a stack-allocated #GVariantDict, you begin with a
   * call to g_variant_dict_init() and free the resources with a call to
   * g_variant_dict_clear().
   *
   * Heap-allocated #GVariantDict follows normal refcounting rules: you
   * allocate it with g_variant_dict_new() and use g_variant_dict_ref()
   * and g_variant_dict_unref().
   *
   * g_variant_dict_end() is used to convert the #GVariantDict back into a
   * dictionary-type #GVariant.  When used with stack-allocated instances,
   * this also implicitly frees all associated memory, but for
   * heap-allocated instances, you must still call g_variant_dict_unref()
   * afterwards.
   *
   * You will typically want to use a heap-allocated #GVariantDict when
   * you expose it as part of an API.  For most other uses, the
   * stack-allocated form will be more convenient.
   *
   * Consider the following two examples that do the same thing in each
   * style: take an existing dictionary and look up the "count" uint32
   * key, adding 1 to it if it is found, or returning an error if the
   * key is not found.  Each returns the new dictionary as a floating
   * #GVariant.
   *
   * ## Using a stack-allocated GVariantDict
   *
   *
   * ```c
   *   GVariant *
   *   add_to_count (GVariant  *orig,
   *                 GError   **error)
   *   {
   *     GVariantDict dict;
   *     guint32 count;
   *
   *     g_variant_dict_init (&dict, orig);
   *     if (!g_variant_dict_lookup (&dict, "count", "u", &count))
   *       {
   *         g_set_error (...);
   *         g_variant_dict_clear (&dict);
   *         return NULL;
   *       }
   *
   *     g_variant_dict_insert (&dict, "count", "u", count + 1);
   *
   *     return g_variant_dict_end (&dict);
   *   }
   * ```
   *
   *
   * ## Using heap-allocated GVariantDict
   *
   *
   * ```c
   *   GVariant *
   *   add_to_count (GVariant  *orig,
   *                 GError   **error)
   *   {
   *     GVariantDict *dict;
   *     GVariant *result;
   *     guint32 count;
   *
   *     dict = g_variant_dict_new (orig);
   *
   *     if (g_variant_dict_lookup (dict, "count", "u", &count))
   *       {
   *         g_variant_dict_insert (dict, "count", "u", count + 1);
   *         result = g_variant_dict_end (dict);
   *       }
   *     else
   *       {
   *         g_set_error (...);
   *         result = NULL;
   *       }
   *
   *     g_variant_dict_unref (dict);
   *
   *     return result;
   *   }
   * ```
   *
   * @record
   */
  class VariantDict {
    // Own properties of GLib-2.0.GLib.VariantDict

    static name: string

    // Constructors of GLib-2.0.GLib.VariantDict

    /**
     * Allocates and initialises a new #GVariantDict.
     *
     * You should call g_variant_dict_unref() on the return value when it
     * is no longer needed.  The memory will not be automatically freed by
     * any other call.
     *
     * In some cases it may be easier to place a #GVariantDict directly on
     * the stack of the calling function and initialise it with
     * g_variant_dict_init().  This is particularly useful when you are
     * using #GVariantDict to construct a #GVariant.
     * @constructor
     * @param fromAsv the #GVariant with which to initialise the   dictionary
     * @returns a #GVariantDict
     */
    constructor(fromAsv: Variant | null)
    /**
     * Allocates and initialises a new #GVariantDict.
     *
     * You should call g_variant_dict_unref() on the return value when it
     * is no longer needed.  The memory will not be automatically freed by
     * any other call.
     *
     * In some cases it may be easier to place a #GVariantDict directly on
     * the stack of the calling function and initialise it with
     * g_variant_dict_init().  This is particularly useful when you are
     * using #GVariantDict to construct a #GVariant.
     * @constructor
     * @param fromAsv the #GVariant with which to initialise the   dictionary
     * @returns a #GVariantDict
     */
    static new(fromAsv: Variant | null): VariantDict
  }

  interface VariantIter {
    // Owm methods of GLib-2.0.GLib.VariantIter

    /**
     * Frees a heap-allocated #GVariantIter.  Only call this function on
     * iterators that were returned by g_variant_iter_new() or
     * g_variant_iter_copy().
     */
    free(): void
    /**
     * Queries the number of child items in the container that we are
     * iterating over.  This is the total number of items -- not the number
     * of items remaining.
     *
     * This function might be useful for preallocation of arrays.
     * @returns the number of children in the container
     */
    nChildren(): number
    /**
     * Gets the next item in the container.  If no more items remain then
     * %NULL is returned.
     *
     * Use g_variant_unref() to drop your reference on the return value when
     * you no longer need it.
     *
     * Here is an example for iterating with g_variant_iter_next_value():
     *
     * ```c
     *   // recursively iterate a container
     *   void
     *   iterate_container_recursive (GVariant *container)
     *   {
     *     GVariantIter iter;
     *     GVariant *child;
     *
     *     g_variant_iter_init (&iter, container);
     *     while ((child = g_variant_iter_next_value (&iter)))
     *       {
     *         g_print ("type '%s'\n", g_variant_get_type_string (child));
     *
     *         if (g_variant_is_container (child))
     *           iterate_container_recursive (child);
     *
     *         g_variant_unref (child);
     *       }
     *   }
     * ```
     *
     * @returns a #GVariant, or %NULL
     */
    nextValue(): Variant | null
  }

  /**
   * #GVariantIter is an opaque data structure and can only be accessed
   * using the following functions.
   * @record
   */
  class VariantIter {
    // Own properties of GLib-2.0.GLib.VariantIter

    static name: string
  }

  interface VariantType {
    // Owm methods of GLib-2.0.GLib.VariantType

    /**
     * Makes a copy of a #GVariantType.  It is appropriate to call
     * g_variant_type_free() on the return value.  `type` may not be %NULL.
     * @returns a new #GVariantType Since 2.24
     */
    copy(): VariantType
    /**
     * Returns a newly-allocated copy of the type string corresponding to
     * `type`.  The returned string is nul-terminated.  It is appropriate to
     * call g_free() on the return value.
     * @returns the corresponding type string Since 2.24
     */
    dupString(): string | null
    /**
     * Determines the element type of an array or maybe type.
     *
     * This function may only be used with array or maybe types.
     * @returns the element type of @type Since 2.24
     */
    element(): VariantType
    /**
     * Compares `type1` and `type2` for equality.
     *
     * Only returns %TRUE if the types are exactly equal.  Even if one type
     * is an indefinite type and the other is a subtype of it, %FALSE will
     * be returned if they are not exactly equal.  If you want to check for
     * subtypes, use g_variant_type_is_subtype_of().
     *
     * The argument types of `type1` and `type2` are only #gconstpointer to
     * allow use with #GHashTable without function pointer casting.  For
     * both arguments, a valid #GVariantType must be provided.
     * @param type2 a #GVariantType
     * @returns %TRUE if @type1 and @type2 are exactly equal Since 2.24
     */
    equal(type2: VariantType): boolean
    /**
     * Determines the first item type of a tuple or dictionary entry
     * type.
     *
     * This function may only be used with tuple or dictionary entry types,
     * but must not be used with the generic tuple type
     * %G_VARIANT_TYPE_TUPLE.
     *
     * In the case of a dictionary entry type, this returns the type of
     * the key.
     *
     * %NULL is returned in case of `type` being %G_VARIANT_TYPE_UNIT.
     *
     * This call, together with g_variant_type_next() provides an iterator
     * interface over tuple and dictionary entry types.
     * @returns the first item type of @type, or %NULL Since 2.24
     */
    first(): VariantType
    /**
     * Frees a #GVariantType that was allocated with
     * g_variant_type_copy(), g_variant_type_new() or one of the container
     * type constructor functions.
     *
     * In the case that `type` is %NULL, this function does nothing.
     *
     * Since 2.24
     */
    free(): void
    /**
     * Returns the length of the type string corresponding to the given
     * `type`.  This function must be used to determine the valid extent of
     * the memory region returned by g_variant_type_peek_string().
     * @returns the length of the corresponding type string Since 2.24
     */
    getStringLength(): number
    /**
     * Hashes `type`.
     *
     * The argument type of `type` is only #gconstpointer to allow use with
     * #GHashTable without function pointer casting.  A valid
     * #GVariantType must be provided.
     * @returns the hash value Since 2.24
     */
    hash(): number
    /**
     * Determines if the given `type` is an array type.  This is true if the
     * type string for `type` starts with an 'a'.
     *
     * This function returns %TRUE for any indefinite type for which every
     * definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for
     * example.
     * @returns %TRUE if @type is an array type Since 2.24
     */
    isArray(): boolean
    /**
     * Determines if the given `type` is a basic type.
     *
     * Basic types are booleans, bytes, integers, doubles, strings, object
     * paths and signatures.
     *
     * Only a basic type may be used as the key of a dictionary entry.
     *
     * This function returns %FALSE for all indefinite types except
     * %G_VARIANT_TYPE_BASIC.
     * @returns %TRUE if @type is a basic type Since 2.24
     */
    isBasic(): boolean
    /**
     * Determines if the given `type` is a container type.
     *
     * Container types are any array, maybe, tuple, or dictionary
     * entry types plus the variant type.
     *
     * This function returns %TRUE for any indefinite type for which every
     * definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for
     * example.
     * @returns %TRUE if @type is a container type Since 2.24
     */
    isContainer(): boolean
    /**
     * Determines if the given `type` is definite (ie: not indefinite).
     *
     * A type is definite if its type string does not contain any indefinite
     * type characters ('*', '?', or 'r').
     *
     * A #GVariant instance may not have an indefinite type, so calling
     * this function on the result of g_variant_get_type() will always
     * result in %TRUE being returned.  Calling this function on an
     * indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in
     * %FALSE being returned.
     * @returns %TRUE if @type is definite Since 2.24
     */
    isDefinite(): boolean
    /**
     * Determines if the given `type` is a dictionary entry type.  This is
     * true if the type string for `type` starts with a '{'.
     *
     * This function returns %TRUE for any indefinite type for which every
     * definite subtype is a dictionary entry type --
     * %G_VARIANT_TYPE_DICT_ENTRY, for example.
     * @returns %TRUE if @type is a dictionary entry type Since 2.24
     */
    isDictEntry(): boolean
    /**
     * Determines if the given `type` is a maybe type.  This is true if the
     * type string for `type` starts with an 'm'.
     *
     * This function returns %TRUE for any indefinite type for which every
     * definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for
     * example.
     * @returns %TRUE if @type is a maybe type Since 2.24
     */
    isMaybe(): boolean
    /**
     * Checks if `type` is a subtype of `supertype`.
     *
     * This function returns %TRUE if `type` is a subtype of `supertype`.  All
     * types are considered to be subtypes of themselves.  Aside from that,
     * only indefinite types can have subtypes.
     * @param supertype a #GVariantType
     * @returns %TRUE if @type is a subtype of @supertype Since 2.24
     */
    isSubtypeOf(supertype: VariantType): boolean
    /**
     * Determines if the given `type` is a tuple type.  This is true if the
     * type string for `type` starts with a '(' or if `type` is
     * %G_VARIANT_TYPE_TUPLE.
     *
     * This function returns %TRUE for any indefinite type for which every
     * definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for
     * example.
     * @returns %TRUE if @type is a tuple type Since 2.24
     */
    isTuple(): boolean
    /**
     * Determines if the given `type` is the variant type.
     * @returns %TRUE if @type is the variant type Since 2.24
     */
    isVariant(): boolean
    /**
     * Determines the key type of a dictionary entry type.
     *
     * This function may only be used with a dictionary entry type.  Other
     * than the additional restriction, this call is equivalent to
     * g_variant_type_first().
     * @returns the key type of the dictionary entry Since 2.24
     */
    key(): VariantType
    /**
     * Determines the number of items contained in a tuple or
     * dictionary entry type.
     *
     * This function may only be used with tuple or dictionary entry types,
     * but must not be used with the generic tuple type
     * %G_VARIANT_TYPE_TUPLE.
     *
     * In the case of a dictionary entry type, this function will always
     * return 2.
     * @returns the number of items in @type Since 2.24
     */
    nItems(): number
    /**
     * Determines the next item type of a tuple or dictionary entry
     * type.
     *
     * `type` must be the result of a previous call to
     * g_variant_type_first() or g_variant_type_next().
     *
     * If called on the key type of a dictionary entry then this call
     * returns the value type.  If called on the value type of a dictionary
     * entry then this call returns %NULL.
     *
     * For tuples, %NULL is returned when `type` is the last item in a tuple.
     * @returns the next #GVariantType after @type, or %NULL Since 2.24
     */
    next(): VariantType
    /**
     * Determines the value type of a dictionary entry type.
     *
     * This function may only be used with a dictionary entry type.
     * @returns the value type of the dictionary entry Since 2.24
     */
    value(): VariantType
  }

  /**
   * A type in the [type`GLib`.Variant] type system.
   *
   * This section introduces the [type`GLib`.Variant] type system. It is based, in
   * large part, on the D-Bus type system, with two major changes and
   * some minor lifting of restrictions. The
   * [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html),
   * therefore, provides a significant amount of
   * information that is useful when working with [type`GLib`.Variant].
   *
   * The first major change with respect to the D-Bus type system is the
   * introduction of maybe (or ‘nullable’) types.  Any type in [type`GLib`.Variant]
   * can be converted to a maybe type, in which case, `nothing` (or `null`)
   * becomes a valid value.  Maybe types have been added by introducing the
   * character `m` to type strings.
   *
   * The second major change is that the [type`GLib`.Variant] type system supports
   * the concept of ‘indefinite types’ — types that are less specific than
   * the normal types found in D-Bus.  For example, it is possible to speak
   * of ‘an array of any type’ in [type`GLib`.Variant], where the D-Bus type system
   * would require you to speak of ‘an array of integers’ or ‘an array of
   * strings’.  Indefinite types have been added by introducing the
   * characters `*`, `?` and `r` to type strings.
   *
   * Finally, all arbitrary restrictions relating to the complexity of
   * types are lifted along with the restriction that dictionary entries
   * may only appear nested inside of arrays.
   *
   * Just as in D-Bus, [type`GLib`.Variant] types are described with strings (‘type
   * strings’).  Subject to the differences mentioned above, these strings
   * are of the same form as those found in D-Bus.  Note, however: D-Bus
   * always works in terms of messages and therefore individual type
   * strings appear nowhere in its interface.  Instead, ‘signatures’
   * are a concatenation of the strings of the type of each argument in a
   * message.  [type`GLib`.Variant] deals with single values directly so
   * [type`GLib`.Variant] type strings always describe the type of exactly one
   * value.  This means that a D-Bus signature string is generally not a valid
   * [type`GLib`.Variant] type string — except in the case that it is the signature
   * of a message containing exactly one argument.
   *
   * An indefinite type is similar in spirit to what may be called an
   * abstract type in other type systems.  No value can exist that has an
   * indefinite type as its type, but values can exist that have types
   * that are subtypes of indefinite types.  That is to say,
   * [method`GLib`.Variant.get_type] will never return an indefinite type, but
   * calling [method`GLib`.Variant.is_of_type] with an indefinite type may return
   * true.  For example, you cannot have a value that represents ‘an
   * array of no particular type’, but you can have an ‘array of integers’
   * which certainly matches the type of ‘an array of no particular type’,
   * since ‘array of integers’ is a subtype of ‘array of no particular
   * type’.
   *
   * This is similar to how instances of abstract classes may not
   * directly exist in other type systems, but instances of their
   * non-abstract subtypes may.  For example, in GTK, no object that has
   * the type of [`GtkWidget`](https://docs.gtk.org/gtk4/class.Widget.html) can
   * exist (since `GtkWidget` is an abstract class), but a [`GtkWindow`](https://docs.gtk.org/gtk4/class.Window.html)
   * can certainly be instantiated, and you would say that a `GtkWindow` is a
   * `GtkWidget` (since `GtkWindow` is a subclass of `GtkWidget`).
   *
   * Two types may not be compared by value; use [method`GLib`.VariantType.equal]
   * or [method`GLib`.VariantType.is_subtype_of]  May be copied using
   * [method`GLib`.VariantType.copy] and freed using [method`GLib`.VariantType.free].
   *
   * ## GVariant Type Strings
   *
   * A [type`GLib`.Variant] type string can be any of the following:
   *
   * - any basic type string (listed below)
   * - `v`, `r` or `*`
   * - one of the characters `a` or `m`, followed by another type string
   * - the character `(`, followed by a concatenation of zero or more other
   *   type strings, followed by the character `)`
   * - the character `{`, followed by a basic type string (see below),
   *   followed by another type string, followed by the character `}`
   *
   * A basic type string describes a basic type (as per
   * [method`GLib`.VariantType.is_basic]) and is always a single character in
   * length. The valid basic type strings are `b`, `y`, `n`, `q`, `i`, `u`, `x`,
   * `t`, `h`, `d`, `s`, `o`, `g` and `?`.
   *
   * The above definition is recursive to arbitrary depth. `aaaaai` and
   * `(ui(nq((y)))s)` are both valid type strings, as is
   * `a(aa(ui)(qna{ya(yd)}))`. In order to not hit memory limits,
   * [type`GLib`.Variant] imposes a limit on recursion depth of 65 nested
   * containers. This is the limit in the D-Bus specification (64) plus one to
   * allow a [`GDBusMessage`](../gio/class.DBusMessage.html) to be nested in
   * a top-level tuple.
   *
   * The meaning of each of the characters is as follows:
   *
   * - `b`: the type string of `G_VARIANT_TYPE_BOOLEAN`; a boolean value.
   * - `y`: the type string of `G_VARIANT_TYPE_BYTE`; a byte.
   * - `n`: the type string of `G_VARIANT_TYPE_INT16`; a signed 16 bit integer.
   * - `q`: the type string of `G_VARIANT_TYPE_UINT16`; an unsigned 16 bit integer.
   * - `i`: the type string of `G_VARIANT_TYPE_INT32`; a signed 32 bit integer.
   * - `u`: the type string of `G_VARIANT_TYPE_UINT32`; an unsigned 32 bit integer.
   * - `x`: the type string of `G_VARIANT_TYPE_INT64`; a signed 64 bit integer.
   * - `t`: the type string of `G_VARIANT_TYPE_UINT64`; an unsigned 64 bit integer.
   * - `h`: the type string of `G_VARIANT_TYPE_HANDLE`; a signed 32 bit value
   *   that, by convention, is used as an index into an array of file
   *   descriptors that are sent alongside a D-Bus message.
   * - `d`: the type string of `G_VARIANT_TYPE_DOUBLE`; a double precision
   *   floating point value.
   * - `s`: the type string of `G_VARIANT_TYPE_STRING`; a string.
   * - `o`: the type string of `G_VARIANT_TYPE_OBJECT_PATH`; a string in the form
   *   of a D-Bus object path.
   * - `g`: the type string of `G_VARIANT_TYPE_SIGNATURE`; a string in the form of
   *   a D-Bus type signature.
   * - `?`: the type string of `G_VARIANT_TYPE_BASIC`; an indefinite type that
   *   is a supertype of any of the basic types.
   * - `v`: the type string of `G_VARIANT_TYPE_VARIANT`; a container type that
   *   contain any other type of value.
   * - `a`: used as a prefix on another type string to mean an array of that
   *   type; the type string `ai`, for example, is the type of an array of
   *   signed 32-bit integers.
   * - `m`: used as a prefix on another type string to mean a ‘maybe’, or
   *   ‘nullable’, version of that type; the type string `ms`, for example,
   *   is the type of a value that maybe contains a string, or maybe contains
   *   nothing.
   * - `()`: used to enclose zero or more other concatenated type strings to
   *   create a tuple type; the type string `(is)`, for example, is the type of
   *   a pair of an integer and a string.
   * - `r`: the type string of `G_VARIANT_TYPE_TUPLE`; an indefinite type that is
   *   a supertype of any tuple type, regardless of the number of items.
   * - `{}`: used to enclose a basic type string concatenated with another type
   *   string to create a dictionary entry type, which usually appears inside of
   *   an array to form a dictionary; the type string `a{sd}`, for example, is
   *   the type of a dictionary that maps strings to double precision floating
   *   point values.
   *
   *   The first type (the basic type) is the key type and the second type is
   *   the value type. The reason that the first type is restricted to being a
   *   basic type is so that it can easily be hashed.
   * - `*`: the type string of `G_VARIANT_TYPE_ANY`; the indefinite type that is
   *   a supertype of all types.  Note that, as with all type strings, this
   *   character represents exactly one type. It cannot be used inside of tuples
   *   to mean ‘any number of items’.
   *
   * Any type string of a container that contains an indefinite type is,
   * itself, an indefinite type. For example, the type string `a*`
   * (corresponding to `G_VARIANT_TYPE_ARRAY`) is an indefinite type
   * that is a supertype of every array type. `(*s)` is a supertype
   * of all tuples that contain exactly two items where the second
   * item is a string.
   *
   * `a{?*}` is an indefinite type that is a supertype of all arrays
   * containing dictionary entries where the key is any basic type and
   * the value is any type at all.  This is, by definition, a dictionary,
   * so this type string corresponds to `G_VARIANT_TYPE_DICTIONARY`. Note
   * that, due to the restriction that the key of a dictionary entry must
   * be a basic type, `{**}` is not a valid type string.
   * @record
   */
  class VariantType {
    // Own properties of GLib-2.0.GLib.VariantType

    static name: string

    // Constructors of GLib-2.0.GLib.VariantType

    /**
     * Creates a new #GVariantType corresponding to the type string given
     * by `type_string`.  It is appropriate to call g_variant_type_free() on
     * the return value.
     *
     * It is a programmer error to call this function with an invalid type
     * string.  Use g_variant_type_string_is_valid() if you are unsure.
     * @constructor
     * @param typeString a valid GVariant type string
     * @returns a new #GVariantType
     */
    constructor(typeString: string)
    /**
     * Creates a new #GVariantType corresponding to the type string given
     * by `type_string`.  It is appropriate to call g_variant_type_free() on
     * the return value.
     *
     * It is a programmer error to call this function with an invalid type
     * string.  Use g_variant_type_string_is_valid() if you are unsure.
     * @constructor
     * @param typeString a valid GVariant type string
     * @returns a new #GVariantType
     */
    static new(typeString: string): VariantType
    /**
     * Constructs the type corresponding to an array of elements of the
     * type `type`.
     *
     * It is appropriate to call g_variant_type_free() on the return value.
     * @constructor
     * @param element a #GVariantType
     * @returns a new array #GVariantType Since 2.24
     */
    static newArray(element: VariantType): VariantType
    /**
     * Constructs the type corresponding to a dictionary entry with a key
     * of type `key` and a value of type `value`.
     *
     * It is appropriate to call g_variant_type_free() on the return value.
     * @constructor
     * @param key a basic #GVariantType
     * @param value a #GVariantType
     * @returns a new dictionary entry #GVariantType Since 2.24
     */
    static newDictEntry(key: VariantType, value: VariantType): VariantType
    /**
     * Constructs the type corresponding to a maybe instance containing
     * type `type` or Nothing.
     *
     * It is appropriate to call g_variant_type_free() on the return value.
     * @constructor
     * @param element a #GVariantType
     * @returns a new maybe #GVariantType Since 2.24
     */
    static newMaybe(element: VariantType): VariantType
    /**
     * Constructs a new tuple type, from `items`.
     *
     * `length` is the number of items in `items,` or -1 to indicate that
     * `items` is %NULL-terminated.
     *
     * It is appropriate to call g_variant_type_free() on the return value.
     * @constructor
     * @param items an array of #GVariantTypes, one for each item
     * @returns a new tuple #GVariantType Since 2.24
     */
    static newTuple(items: VariantType[]): VariantType
    static checked(typeString: string): VariantType
    static stringGetDepth(typeString: string): number
    /**
     * Checks if `type_string` is a valid GVariant type string.  This call is
     * equivalent to calling g_variant_type_string_scan() and confirming
     * that the following character is a nul terminator.
     * @param typeString a pointer to any string
     * @returns %TRUE if @type_string is exactly one valid type string Since 2.24
     */
    static stringIsValid(typeString: string): boolean
    /**
     * Scan for a single complete and valid GVariant type string in `string`.
     * The memory pointed to by `limit` (or bytes beyond it) is never
     * accessed.
     *
     * If a valid type string is found, `endptr` is updated to point to the
     * first character past the end of the string that was found and %TRUE
     * is returned.
     *
     * If there is no valid type string starting at `string,` or if the type
     * string does not end before `limit` then %FALSE is returned.
     *
     * For the simple case of checking if a string is a valid type string,
     * see g_variant_type_string_is_valid().
     * @param string a pointer to any string
     * @param limit the end of `string,` or %NULL
     * @returns %TRUE if a valid type string was found
     */
    static stringScan(
      string: string,
      limit: string | null
    ): [/* returnType */ boolean, /* endptr */ string]
  }

  interface DoubleIEEE754 {
    // Own fields of GLib-2.0.GLib.DoubleIEEE754

    vDouble: number
  }

  class DoubleIEEE754 {
    // Own properties of GLib-2.0.GLib.DoubleIEEE754

    static name: string
  }

  interface FloatIEEE754 {
    // Own fields of GLib-2.0.GLib.FloatIEEE754

    vFloat: number
  }

  class FloatIEEE754 {
    // Own properties of GLib-2.0.GLib.FloatIEEE754

    static name: string
  }

  interface Mutex {
    // Owm methods of GLib-2.0.GLib.Mutex

    /**
     * Frees the resources allocated to a mutex with g_mutex_init().
     *
     * This function should not be used with a #GMutex that has been
     * statically allocated.
     *
     * Calling g_mutex_clear() on a locked mutex leads to undefined
     * behaviour.
     */
    clear(): void
    /**
     * Initializes a #GMutex so that it can be used.
     *
     * This function is useful to initialize a mutex that has been
     * allocated on the stack, or as part of a larger structure.
     * It is not necessary to initialize a mutex that has been
     * statically allocated.
     *
     *
     * ```c
     *   typedef struct {
     *     GMutex m;
     *     ...
     *   } Blob;
     *
     * Blob *b;
     *
     * b = g_new (Blob, 1);
     * g_mutex_init (&b->m);
     * ```
     *
     *
     * To undo the effect of g_mutex_init() when a mutex is no longer
     * needed, use g_mutex_clear().
     *
     * Calling g_mutex_init() on an already initialized #GMutex leads
     * to undefined behaviour.
     */
    init(): void
    /**
     * Locks `mutex`. If `mutex` is already locked by another thread, the
     * current thread will block until `mutex` is unlocked by the other
     * thread.
     *
     * #GMutex is neither guaranteed to be recursive nor to be
     * non-recursive.  As such, calling g_mutex_lock() on a #GMutex that has
     * already been locked by the same thread results in undefined behaviour
     * (including but not limited to deadlocks).
     */
    lock(): void
    /**
     * Tries to lock `mutex`. If `mutex` is already locked by another thread,
     * it immediately returns %FALSE. Otherwise it locks `mutex` and returns
     * %TRUE.
     *
     * #GMutex is neither guaranteed to be recursive nor to be
     * non-recursive.  As such, calling g_mutex_lock() on a #GMutex that has
     * already been locked by the same thread results in undefined behaviour
     * (including but not limited to deadlocks or arbitrary return values).
     * @returns %TRUE if @mutex could be locked
     */
    trylock(): boolean
    /**
     * Unlocks `mutex`. If another thread is blocked in a g_mutex_lock()
     * call for `mutex,` it will become unblocked and can lock `mutex` itself.
     *
     * Calling g_mutex_unlock() on a mutex that is not locked by the
     * current thread leads to undefined behaviour.
     */
    unlock(): void
  }

  /**
   * The #GMutex struct is an opaque data structure to represent a mutex
   * (mutual exclusion). It can be used to protect data against shared
   * access.
   *
   * Take for example the following function:
   *
   * ```c
   *   int
   *   give_me_next_number (void)
   *   {
   *     static int current_number = 0;
   *
   *     // now do a very complicated calculation to calculate the new
   *     // number, this might for example be a random number generator
   *     current_number = calc_next_number (current_number);
   *
   *     return current_number;
   *   }
   * ```
   *
   * It is easy to see that this won't work in a multi-threaded
   * application. There current_number must be protected against shared
   * access. A #GMutex can be used as a solution to this problem:
   *
   * ```c
   *   int
   *   give_me_next_number (void)
   *   {
   *     static GMutex mutex;
   *     static int current_number = 0;
   *     int ret_val;
   *
   *     g_mutex_lock (&mutex);
   *     ret_val = current_number = calc_next_number (current_number);
   *     g_mutex_unlock (&mutex);
   *
   *     return ret_val;
   *   }
   * ```
   *
   * Notice that the #GMutex is not initialised to any particular value.
   * Its placement in static storage ensures that it will be initialised
   * to all-zeros, which is appropriate.
   *
   * If a #GMutex is placed in other contexts (eg: embedded in a struct)
   * then it must be explicitly initialised using g_mutex_init().
   *
   * A #GMutex should only be accessed via g_mutex_ functions.
   * @union
   */
  class Mutex {
    // Own properties of GLib-2.0.GLib.Mutex

    static name: string
  }

  interface TokenValue {
    // Own fields of GLib-2.0.GLib.TokenValue

    /**
     * token symbol value
     * @field
     */
    vSymbol: any
    /**
     * token identifier value
     * @field
     */
    vIdentifier: string | null
    /**
     * token binary integer value
     * @field
     */
    vBinary: number
    /**
     * octal integer value
     * @field
     */
    vOctal: number
    /**
     * integer value
     * @field
     */
    vInt: number
    /**
     * 64-bit integer value
     * @field
     */
    vInt64: number
    /**
     * floating point value
     * @field
     */
    vFloat: number
    /**
     * hex integer value
     * @field
     */
    vHex: number
    /**
     * string value
     * @field
     */
    vString: string | null
    /**
     * comment value
     * @field
     */
    vComment: string | null
    /**
     * character value
     * @field
     */
    vChar: number
    /**
     * error value
     * @field
     */
    vError: number
  }

  /**
   * A union holding the value of the token.
   * @union
   */
  class TokenValue {
    // Own properties of GLib-2.0.GLib.TokenValue

    static name: string
  }

  type DateDay = number
  type DateYear = number
  type MainContextPusher = void
  type MutexLocker = void
  type Pid = number
  type Quark = number
  type RWLockReaderLocker = void
  type RWLockWriterLocker = void
  type RecMutexLocker = void
  type RefString = number
  type Strv = string
  type Time = number
  type TimeSpan = number
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace GObject {
  /**
   * Flags to be passed to g_object_bind_property() or
   * g_object_bind_property_full().
   *
   * This enumeration can be extended at later date.
   * @bitfield
   */
  enum BindingFlags {
    /**
     * The default binding; if the source property
     *   changes, the target property is updated with its value.
     */
    DEFAULT,
    /**
     * Bidirectional binding; if either the
     *   property of the source or the property of the target changes,
     *   the other is updated.
     */
    BIDIRECTIONAL,
    /**
     * Synchronize the values of the source and
     *   target properties when creating the binding; the direction of
     *   the synchronization is always from the source to the target.
     */
    SYNC_CREATE,
    /**
     * If the two properties being bound are
     *   booleans, setting one to %TRUE will result in the other being
     *   set to %FALSE and vice versa. This flag will only work for
     *   boolean properties, and cannot be used when passing custom
     *   transformation functions to g_object_bind_property_full().
     */
    INVERT_BOOLEAN,
  }
  /**
   * The connection flags are used to specify the behaviour of a signal's
   * connection.
   * @bitfield
   */
  enum ConnectFlags {
    /**
     * Default behaviour (no special flags). Since: 2.74
     */
    DEFAULT,
    /**
     * If set, the handler should be called after the
     *  default handler of the signal. Normally, the handler is called before
     *  the default handler.
     */
    AFTER,
    /**
     * If set, the instance and data should be swapped when
     *  calling the handler; see g_signal_connect_swapped() for an example.
     */
    SWAPPED,
  }
  enum IOCondition {
    IN,
    OUT,
    PRI,
    ERR,
    HUP,
    NVAL,
  }
  /**
   * Through the #GParamFlags flag values, certain aspects of parameters
   * can be configured.
   *
   * See also: %G_PARAM_STATIC_STRINGS
   * @bitfield
   */
  enum ParamFlags {
    /**
     * the parameter is readable
     */
    READABLE,
    /**
     * the parameter is writable
     */
    WRITABLE,
    /**
     * alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE
     */
    READWRITE,
    /**
     * the parameter will be set upon object construction
     */
    CONSTRUCT,
    /**
     * the parameter can only be set upon object construction
     */
    CONSTRUCT_ONLY,
    /**
     * upon parameter conversion (see g_param_value_convert())
     *  strict validation is not required
     */
    LAX_VALIDATION,
    /**
     * the string used as name when constructing the
     *  parameter is guaranteed to remain valid and
     *  unmodified for the lifetime of the parameter.
     *  Since 2.8
     */
    STATIC_NAME,
    /**
     * internal
     */
    PRIVATE,
    /**
     * the string used as nick when constructing the
     *  parameter is guaranteed to remain valid and
     *  unmmodified for the lifetime of the parameter.
     *  Since 2.8
     */
    STATIC_NICK,
    /**
     * the string used as blurb when constructing the
     *  parameter is guaranteed to remain valid and
     *  unmodified for the lifetime of the parameter.
     *  Since 2.8
     */
    STATIC_BLURB,
    /**
     * calls to g_object_set_property() for this
     *   property will not automatically result in a "notify" signal being
     *   emitted: the implementation must call g_object_notify() themselves
     *   in case the property actually changes.  Since: 2.42.
     */
    EXPLICIT_NOTIFY,
    /**
     * the parameter is deprecated and will be removed
     *  in a future version. A warning will be generated if it is used
     *  while running with G_ENABLE_DIAGNOSTIC=1.
     *  Since 2.26
     */
    DEPRECATED,
  }
  /**
   * The signal flags are used to specify a signal's behaviour.
   * @bitfield
   */
  enum SignalFlags {
    /**
     * Invoke the object method handler in the first emission stage.
     */
    RUN_FIRST,
    /**
     * Invoke the object method handler in the third emission stage.
     */
    RUN_LAST,
    /**
     * Invoke the object method handler in the last emission stage.
     */
    RUN_CLEANUP,
    /**
     * Signals being emitted for an object while currently being in
     *  emission for this very object will not be emitted recursively,
     *  but instead cause the first emission to be restarted.
     */
    NO_RECURSE,
    /**
     * This signal supports "::detail" appendices to the signal name
     *  upon handler connections and emissions.
     */
    DETAILED,
    /**
     * Action signals are signals that may freely be emitted on alive
     *  objects from user code via g_signal_emit() and friends, without
     *  the need of being embedded into extra code that performs pre or
     *  post emission adjustments on the object. They can also be thought
     *  of as object methods which can be called generically by
     *  third-party code.
     */
    ACTION,
    /**
     * No emissions hooks are supported for this signal.
     */
    NO_HOOKS,
    /**
     * Varargs signal emission will always collect the
     *   arguments, even if there are no signal handlers connected.  Since 2.30.
     */
    MUST_COLLECT,
    /**
     * The signal is deprecated and will be removed
     *   in a future version. A warning will be generated if it is connected while
     *   running with G_ENABLE_DIAGNOSTIC=1.  Since 2.32.
     */
    DEPRECATED,
    /**
     * Only used in #GSignalAccumulator accumulator
     *   functions for the #GSignalInvocationHint::run_type field to mark the first
     *   call to the accumulator function for a signal emission.  Since 2.68.
     */
    ACCUMULATOR_FIRST_RUN,
  }
  /**
   * The match types specify what g_signal_handlers_block_matched(),
   * g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched()
   * match signals by.
   * @bitfield
   */
  enum SignalMatchType {
    /**
     * The signal id must be equal.
     */
    ID,
    /**
     * The signal detail must be equal.
     */
    DETAIL,
    /**
     * The closure must be the same.
     */
    CLOSURE,
    /**
     * The C closure callback must be the same.
     */
    FUNC,
    /**
     * The closure data must be the same.
     */
    DATA,
    /**
     * Only unblocked signals may be matched.
     */
    UNBLOCKED,
  }
  /**
   * These flags used to be passed to g_type_init_with_debug_flags() which
   * is now deprecated.
   *
   * If you need to enable debugging features, use the `GOBJECT_DEBUG`
   * environment variable.
   * @bitfield
   */
  enum TypeDebugFlags {
    /**
     * Print no messages
     */
    NONE,
    /**
     * Print messages about object bookkeeping
     */
    OBJECTS,
    /**
     * Print messages about signal emissions
     */
    SIGNALS,
    /**
     * Keep a count of instances of each type
     */
    INSTANCE_COUNT,
    /**
     * Mask covering all debug flags
     */
    MASK,
  }
  /**
   * Bit masks used to check or determine characteristics of a type.
   * @bitfield
   */
  enum TypeFlags {
    /**
     * No special flags. Since: 2.74
     */
    NONE,
    /**
     * Indicates an abstract type. No instances can be
     *  created for an abstract type
     */
    ABSTRACT,
    /**
     * Indicates an abstract value type, i.e. a type
     *  that introduces a value table, but can't be used for
     *  g_value_init()
     */
    VALUE_ABSTRACT,
    /**
     * Indicates a final type. A final type is a non-derivable
     *  leaf node in a deep derivable type hierarchy tree. Since: 2.70
     */
    FINAL,
    /**
     * The type is deprecated and may be removed in a
     *  future version. A warning will be emitted if it is instantiated while
     *  running with `G_ENABLE_DIAGNOSTIC=1`. Since 2.76
     */
    DEPRECATED,
  }
  /**
   * Bit masks used to check or determine specific characteristics of a
   * fundamental type.
   * @bitfield
   */
  enum TypeFundamentalFlags {
    /**
     * Indicates a classed type
     */
    CLASSED,
    /**
     * Indicates an instantiatable type (implies classed)
     */
    INSTANTIATABLE,
    /**
     * Indicates a flat derivable type
     */
    DERIVABLE,
    /**
     * Indicates a deep derivable type (implies derivable)
     */
    DEEP_DERIVABLE,
  }
  /**
   * Mask containing the bits of #GParamSpec.flags which are reserved for GLib.
   */
  const PARAM_MASK: number
  /**
   * #GParamFlags value alias for %G_PARAM_STATIC_NAME | %G_PARAM_STATIC_NICK | %G_PARAM_STATIC_BLURB.
   *
   * It is recommended to use this for all properties by default, as it allows for
   * internal performance improvements in GObject.
   *
   * It is very rare that a property would have a dynamically constructed name,
   * nickname or blurb.
   *
   * Since 2.13.0
   */
  const PARAM_STATIC_STRINGS: number
  /**
   * Minimum shift count to be used for user defined flags, to be stored in
   * #GParamSpec.flags. The maximum allowed is 10.
   */
  const PARAM_USER_SHIFT: number
  /**
   * A mask for all #GSignalFlags bits.
   */
  const SIGNAL_FLAGS_MASK: number
  /**
   * A mask for all #GSignalMatchType bits.
   */
  const SIGNAL_MATCH_MASK: number
  /**
   * A bit in the type number that's supposed to be left untouched.
   */
  const TYPE_FLAG_RESERVED_ID_BIT: GType
  /**
   * An integer constant that represents the number of identifiers reserved
   * for types that are assigned at compile-time.
   */
  const TYPE_FUNDAMENTAL_MAX: number
  /**
   * Shift value used in converting numbers to type IDs.
   */
  const TYPE_FUNDAMENTAL_SHIFT: number
  /**
   * First fundamental type number to create a new fundamental type id with
   * G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE.
   */
  const TYPE_RESERVED_BSE_FIRST: number
  /**
   * Last fundamental type number reserved for BSE.
   */
  const TYPE_RESERVED_BSE_LAST: number
  /**
   * First fundamental type number to create a new fundamental type id with
   * G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib.
   */
  const TYPE_RESERVED_GLIB_FIRST: number
  /**
   * Last fundamental type number reserved for GLib.
   */
  const TYPE_RESERVED_GLIB_LAST: number
  /**
   * First available fundamental type number to create new fundamental
   * type id with G_TYPE_MAKE_FUNDAMENTAL().
   */
  const TYPE_RESERVED_USER_FIRST: number
  /**
   * The maximal number of #GTypeCValues which can be collected for a
   * single #GValue.
   */
  const VALUE_COLLECT_FORMAT_MAX_LENGTH: number
  /**
   * For string values, indicates that the string contained is canonical and will
   * exist for the duration of the process. See g_value_set_interned_string().
   */
  const VALUE_INTERNED_STRING: number
  /**
   * If passed to G_VALUE_COLLECT(), allocated data won't be copied
   * but used verbatim. This does not affect ref-counted types like
   * objects. This does not affect usage of g_value_copy(), the data will
   * be copied if it is not ref-counted.
   */
  const VALUE_NOCOPY_CONTENTS: number
  /**
   * Provide a copy of a boxed structure `src_boxed` which is of type `boxed_type`.
   * @param boxedType The type of `src_boxed`.
   * @param srcBoxed The boxed structure to be copied.
   * @returns The newly created copy of the boxed    structure.
   */
  function boxedCopy(boxedType: GType, srcBoxed: any): any
  /**
   * Free the boxed structure `boxed` which is of type `boxed_type`.
   * @param boxedType The type of `boxed`.
   * @param boxed The boxed structure to be freed.
   */
  function boxedFree(boxedType: GType, boxed: any): void
  /**
   * This function creates a new %G_TYPE_BOXED derived type id for a new
   * boxed type with name `name`.
   *
   * Boxed type handling functions have to be provided to copy and free
   * opaque boxed structures of this type.
   *
   * For the general case, it is recommended to use G_DEFINE_BOXED_TYPE()
   * instead of calling g_boxed_type_register_static() directly. The macro
   * will create the appropriate `*_get_type()` function for the boxed type.
   * @param name Name of the new boxed type.
   * @param boxedCopy Boxed structure copy function.
   * @param boxedFree Boxed structure free function.
   * @returns New %G_TYPE_BOXED derived type id for @name.
   */
  function boxedTypeRegisterStatic(
    name: string,
    boxedCopy: BoxedCopyFunc,
    boxedFree: BoxedFreeFunc
  ): GType
  /**
   * A #GClosureMarshal function for use with signals with handlers that
   * take two boxed pointers as arguments and return a boolean.  If you
   * have such a signal, you will probably also need to use an
   * accumulator, such as g_signal_accumulator_true_handled().
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalBOOLEANBOXEDBOXED(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with handlers that
   * take a flags type as an argument and return a boolean.  If you have
   * such a signal, you will probably also need to use an accumulator,
   * such as g_signal_accumulator_true_handled().
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalBOOLEANFLAGS(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with handlers that
   * take a #GObject and a pointer and produce a string.  It is highly
   * unlikely that your signal handler fits this description.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalSTRINGOBJECTPOINTER(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * boolean argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDBOOLEAN(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * argument which is any boxed pointer type.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDBOXED(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * character argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDCHAR(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with one
   * double-precision floating point argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDDOUBLE(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * argument with an enumerated type.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDENUM(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * argument with a flags types.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDFLAGS(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with one
   * single-precision floating point argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDFLOAT(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * integer argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDINT(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with with a single
   * long integer argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDLONG(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * #GObject argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDOBJECT(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * argument of type #GParamSpec.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDPARAM(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single raw
   * pointer argument type.
   *
   * If it is possible, it is better to use one of the more specific
   * functions such as g_cclosure_marshal_VOID__OBJECT() or
   * g_cclosure_marshal_VOID__OBJECT().
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDPOINTER(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single string
   * argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDSTRING(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * unsigned character argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDUCHAR(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with with a single
   * unsigned integer argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDUINT(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with an unsigned int
   * and a pointer as arguments.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDUINTPOINTER(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * unsigned long integer argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDULONG(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with a single
   * #GVariant argument.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDVARIANT(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A #GClosureMarshal function for use with signals with no arguments.
   * @param closure A #GClosure.
   * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalVOIDVOID(
    closure: TClosure,
    returnValue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * A generic marshaller function implemented via
   * [libffi](http://sourceware.org/libffi/).
   *
   * Normally this function is not passed explicitly to g_signal_new(),
   * but used automatically by GLib when specifying a %NULL marshaller.
   * @param closure A #GClosure.
   * @param returnGvalue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
   * @param nParamValues The length of the `param_values` array.
   * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
   * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
   * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
   */
  function cclosureMarshalGeneric(
    closure: TClosure,
    returnGvalue: any,
    nParamValues: number,
    paramValues: any,
    invocationHint: any | null,
    marshalData: any | null
  ): void
  /**
   * Disconnects a handler from `instance` so it will not be called during
   * any future or currently ongoing emissions of the signal it has been
   * connected to. The `handler_id_ptr` is then set to zero, which is never a valid handler ID value (see g_signal_connect()).
   *
   * If the handler ID is 0 then this function does nothing.
   *
   * There is also a macro version of this function so that the code
   * will be inlined.
   * @param handlerIdPtr A pointer to a handler ID (of type #gulong) of the handler to be disconnected.
   * @param instance The instance to remove the signal handler from.   This pointer may be %NULL or invalid, if the handler ID is zero.
   */
  function clearSignalHandler(handlerIdPtr: number, instance: Object): void
  /**
   * This function is meant to be called from the `complete_type_info`
   * function of a #GTypePlugin implementation, as in the following
   * example:
   *
   *
   * ```c
   * static void
   * my_enum_complete_type_info (GTypePlugin     *plugin,
   *                             GType            g_type,
   *                             GTypeInfo       *info,
   *                             GTypeValueTable *value_table)
   * {
   *   static const GEnumValue values[] = {
   *     { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
   *     { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
   *     { 0, NULL, NULL }
   *   };
   *
   *   g_enum_complete_type_info (type, info, values);
   * }
   * ```
   *
   * @param gEnumType the type identifier of the type being completed
   * @param constValues An array of #GEnumValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0.
   */
  function enumCompleteTypeInfo(
    gEnumType: GType,
    constValues: EnumValue
  ): /* info */ TypeInfo
  /**
   * Returns the #GEnumValue for a value.
   * @param enumClass a #GEnumClass
   * @param value the value to look up
   * @returns the #GEnumValue for @value, or %NULL          if @value is not a member of the enumeration
   */
  function enumGetValue(enumClass: EnumClass, value: number): EnumValue | null
  /**
   * Looks up a #GEnumValue by name.
   * @param enumClass a #GEnumClass
   * @param name the name to look up
   * @returns the #GEnumValue with name @name,          or %NULL if the enumeration doesn't have a member          with that name
   */
  function enumGetValueByName(
    enumClass: EnumClass,
    name: string
  ): EnumValue | null
  /**
   * Looks up a #GEnumValue by nickname.
   * @param enumClass a #GEnumClass
   * @param nick the nickname to look up
   * @returns the #GEnumValue with nickname @nick,          or %NULL if the enumeration doesn't have a member          with that nickname
   */
  function enumGetValueByNick(
    enumClass: EnumClass,
    nick: string
  ): EnumValue | null
  /**
   * Registers a new static enumeration type with the name `name`.
   *
   * It is normally more convenient to let [glib-mkenums][glib-mkenums],
   * generate a my_enum_get_type() function from a usual C enumeration
   * definition  than to write one yourself using g_enum_register_static().
   * @param name A nul-terminated string used as the name of the new type.
   * @param constStaticValues An array of #GEnumValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0. GObject keeps a reference to the data, so it cannot  be stack-allocated.
   * @returns The new type identifier.
   */
  function enumRegisterStatic(name: string, constStaticValues: EnumValue): GType
  /**
   * Pretty-prints `value` in the form of the enum’s name.
   *
   * This is intended to be used for debugging purposes. The format of the output
   * may change in the future.
   * @param gEnumType the type identifier of a #GEnumClass type
   * @param value the value
   * @returns a newly-allocated text string
   */
  function enumToString(gEnumType: GType, value: number): string | null
  /**
   * This function is meant to be called from the complete_type_info()
   * function of a #GTypePlugin implementation, see the example for
   * g_enum_complete_type_info() above.
   * @param gFlagsType the type identifier of the type being completed
   * @param constValues An array of #GFlagsValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0.
   */
  function flagsCompleteTypeInfo(
    gFlagsType: GType,
    constValues: FlagsValue
  ): /* info */ TypeInfo
  /**
   * Returns the first #GFlagsValue which is set in `value`.
   * @param flagsClass a #GFlagsClass
   * @param value the value
   * @returns the first #GFlagsValue which is set in          @value, or %NULL if none is set
   */
  function flagsGetFirstValue(
    flagsClass: FlagsClass,
    value: number
  ): FlagsValue | null
  /**
   * Looks up a #GFlagsValue by name.
   * @param flagsClass a #GFlagsClass
   * @param name the name to look up
   * @returns the #GFlagsValue with name @name,          or %NULL if there is no flag with that name
   */
  function flagsGetValueByName(
    flagsClass: FlagsClass,
    name: string
  ): FlagsValue | null
  /**
   * Looks up a #GFlagsValue by nickname.
   * @param flagsClass a #GFlagsClass
   * @param nick the nickname to look up
   * @returns the #GFlagsValue with nickname @nick,          or %NULL if there is no flag with that nickname
   */
  function flagsGetValueByNick(
    flagsClass: FlagsClass,
    nick: string
  ): FlagsValue | null
  /**
   * Registers a new static flags type with the name `name`.
   *
   * It is normally more convenient to let [glib-mkenums][glib-mkenums]
   * generate a my_flags_get_type() function from a usual C enumeration
   * definition than to write one yourself using g_flags_register_static().
   * @param name A nul-terminated string used as the name of the new type.
   * @param constStaticValues An array of #GFlagsValue structs for the possible  flags values. The array is terminated by a struct with all members being 0.  GObject keeps a reference to the data, so it cannot be stack-allocated.
   * @returns The new type identifier.
   */
  function flagsRegisterStatic(
    name: string,
    constStaticValues: FlagsValue
  ): GType
  /**
   * Pretty-prints `value` in the form of the flag names separated by ` | ` and
   * sorted. Any extra bits will be shown at the end as a hexadecimal number.
   *
   * This is intended to be used for debugging purposes. The format of the output
   * may change in the future.
   * @param flagsType the type identifier of a #GFlagsClass type
   * @param value the value
   * @returns a newly-allocated text string
   */
  function flagsToString(flagsType: GType, value: number): string | null
  function gtypeGetType(): GType
  /**
   * Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
   * property. In many cases, it may be more appropriate to use an enum with
   * g_param_spec_enum(), both to improve code clarity by using explicitly named
   * values, and to allow for more values to be added in future without breaking
   * API.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecBoolean(
    name: string,
    nick: string | null,
    blurb: string | null,
    defaultValue: boolean,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
   * derived property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param boxedType %G_TYPE_BOXED derived type of this property
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecBoxed(
    name: string,
    nick: string | null,
    blurb: string | null,
    boxedType: GType,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecChar(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
   * property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecDouble(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
   * property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param enumType a #GType derived from %G_TYPE_ENUM
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecEnum(
    name: string,
    nick: string | null,
    blurb: string | null,
    enumType: GType,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
   * property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param flagsType a #GType derived from %G_TYPE_FLAGS
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecFlags(
    name: string,
    nick: string | null,
    blurb: string | null,
    flagsType: GType,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecFloat(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecGType instance specifying a
   * %G_TYPE_GTYPE property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param isAType a #GType whose subtypes are allowed as values  of the property (use %G_TYPE_NONE for any type)
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecGtype(
    name: string,
    nick: string | null,
    blurb: string | null,
    isAType: GType,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecInt(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecInt64(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecLong(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
   * derived property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param objectType %G_TYPE_OBJECT derived type of this property
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecObject(
    name: string,
    nick: string | null,
    blurb: string | null,
    objectType: GType,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
   * property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param paramType a #GType derived from %G_TYPE_PARAM
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecParam(
    name: string,
    nick: string | null,
    blurb: string | null,
    paramType: GType,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecPointer instance specifying a pointer property.
   * Where possible, it is better to use g_param_spec_object() or
   * g_param_spec_boxed() to expose memory management information.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecPointer(
    name: string,
    nick: string | null,
    blurb: string | null,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecString instance.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecString(
    name: string,
    nick: string | null,
    blurb: string | null,
    defaultValue: string | null,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecUchar(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecUint(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
   * property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecUint64(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
   * property.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param minimum minimum value for the property specified
   * @param maximum maximum value for the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecUlong(
    name: string,
    nick: string | null,
    blurb: string | null,
    minimum: number,
    maximum: number,
    defaultValue: number,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
   * property. #GValue structures for this property can be accessed with
   * g_value_set_uint() and g_value_get_uint().
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param defaultValue default value for the property specified
   * @param flags flags for the property specified
   * @returns a newly created parameter specification
   */
  function paramSpecUnichar(
    name: string,
    nick: string | null,
    blurb: string | null,
    defaultValue: string,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Creates a new #GParamSpecVariant instance specifying a #GVariant
   * property.
   *
   * If `default_value` is floating, it is consumed.
   *
   * See g_param_spec_internal() for details on property names.
   * @param name canonical name of the property specified
   * @param nick nick name for the property specified
   * @param blurb description of the property specified
   * @param type a #GVariantType
   * @param defaultValue a #GVariant of type `type` to                 use as the default value, or %NULL
   * @param flags flags for the property specified
   * @returns the newly created #GParamSpec
   */
  function paramSpecVariant(
    name: string,
    nick: string | null,
    blurb: string | null,
    type: GLib.VariantType,
    defaultValue: GLib.Variant | null,
    flags: ParamFlags
  ): ParamSpec
  /**
   * Registers `name` as the name of a new static type derived
   * from %G_TYPE_PARAM.
   *
   * The type system uses the information contained in the #GParamSpecTypeInfo
   * structure pointed to by `info` to manage the #GParamSpec type and its
   * instances.
   * @param name 0-terminated string used as the name of the new #GParamSpec type.
   * @param pspecInfo The #GParamSpecTypeInfo for this #GParamSpec type.
   * @returns The new type identifier.
   */
  function paramTypeRegisterStatic(
    name: string,
    pspecInfo: ParamSpecTypeInfo
  ): GType
  /**
   * Transforms `src_value` into `dest_value` if possible, and then
   * validates `dest_value,` in order for it to conform to `pspec`.  If
   * `strict_validation` is %TRUE this function will only succeed if the
   * transformed `dest_value` complied to `pspec` without modifications.
   *
   * See also g_value_type_transformable(), g_value_transform() and
   * g_param_value_validate().
   * @param pspec a valid #GParamSpec
   * @param srcValue source #GValue
   * @param destValue destination #GValue of correct type for `pspec`
   * @param strictValidation %TRUE requires `dest_value` to conform to `pspec` without modifications
   * @returns %TRUE if transformation and validation were successful,  %FALSE otherwise and @dest_value is left untouched.
   */
  function paramValueConvert(
    pspec: ParamSpec,
    srcValue: any,
    destValue: any,
    strictValidation: boolean
  ): boolean
  /**
   * Checks whether `value` contains the default value as specified in `pspec`.
   * @param pspec a valid #GParamSpec
   * @param value a #GValue of correct type for `pspec`
   * @returns whether @value contains the canonical default for this @pspec
   */
  function paramValueDefaults(pspec: ParamSpec, value: any): boolean
  /**
   * Return whether the contents of `value` comply with the specifications
   * set out by `pspec`.
   * @param pspec a valid #GParamSpec
   * @param value a #GValue of correct type for `pspec`
   * @returns whether the contents of @value comply with the specifications   set out by @pspec.
   */
  function paramValueIsValid(pspec: ParamSpec, value: any): boolean
  /**
   * Sets `value` to its default value as specified in `pspec`.
   * @param pspec a valid #GParamSpec
   * @param value a #GValue of correct type for `pspec;` since 2.64, you   can also pass an empty #GValue, initialized with %G_VALUE_INIT
   */
  function paramValueSetDefault(pspec: ParamSpec, value: any): void
  /**
   * Ensures that the contents of `value` comply with the specifications
   * set out by `pspec`. For example, a #GParamSpecInt might require
   * that integers stored in `value` may not be smaller than -42 and not be
   * greater than +42. If `value` contains an integer outside of this range,
   * it is modified accordingly, so the resulting value will fit into the
   * range -42 .. +42.
   * @param pspec a valid #GParamSpec
   * @param value a #GValue of correct type for `pspec`
   * @returns whether modifying @value was necessary to ensure validity
   */
  function paramValueValidate(pspec: ParamSpec, value: any): boolean
  /**
   * Compares `value1` with `value2` according to `pspec,` and return -1, 0 or +1,
   * if `value1` is found to be less than, equal to or greater than `value2`,
   * respectively.
   * @param pspec a valid #GParamSpec
   * @param value1 a #GValue of correct type for `pspec`
   * @param value2 a #GValue of correct type for `pspec`
   * @returns -1, 0 or +1, for a less than, equal to or greater than result
   */
  function paramValuesCmp(pspec: ParamSpec, value1: any, value2: any): number
  /**
   * Creates a new %G_TYPE_POINTER derived type id for a new
   * pointer type with name `name`.
   * @param name the name of the new pointer type.
   * @returns a new %G_TYPE_POINTER derived type id for @name.
   */
  function pointerTypeRegisterStatic(name: string): GType
  /**
   * A predefined #GSignalAccumulator for signals intended to be used as a
   * hook for application code to provide a particular value.  Usually
   * only one such value is desired and multiple handlers for the same
   * signal don't make much sense (except for the case of the default
   * handler defined in the class structure, in which case you will
   * usually want the signal connection to override the class handler).
   *
   * This accumulator will use the return value from the first signal
   * handler that is run as the return value for the signal and not run
   * any further handlers (ie: the first handler "wins").
   * @param ihint standard #GSignalAccumulator parameter
   * @param returnAccu standard #GSignalAccumulator parameter
   * @param handlerReturn standard #GSignalAccumulator parameter
   * @param dummy standard #GSignalAccumulator parameter
   * @returns standard #GSignalAccumulator result
   */
  function signalAccumulatorFirstWins(
    ihint: SignalInvocationHint,
    returnAccu: any,
    handlerReturn: any,
    dummy: any | null
  ): boolean
  /**
   * A predefined #GSignalAccumulator for signals that return a
   * boolean values. The behavior that this accumulator gives is
   * that a return of %TRUE stops the signal emission: no further
   * callbacks will be invoked, while a return of %FALSE allows
   * the emission to continue. The idea here is that a %TRUE return
   * indicates that the callback handled the signal, and no further
   * handling is needed.
   * @param ihint standard #GSignalAccumulator parameter
   * @param returnAccu standard #GSignalAccumulator parameter
   * @param handlerReturn standard #GSignalAccumulator parameter
   * @param dummy standard #GSignalAccumulator parameter
   * @returns standard #GSignalAccumulator result
   */
  function signalAccumulatorTrueHandled(
    ihint: SignalInvocationHint,
    returnAccu: any,
    handlerReturn: any,
    dummy: any | null
  ): boolean
  /**
   * Adds an emission hook for a signal, which will get called for any emission
   * of that signal, independent of the instance. This is possible only
   * for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
   * @param signalId the signal identifier, as returned by g_signal_lookup().
   * @param detail the detail on which to call the hook.
   * @returns the hook id, for later use with g_signal_remove_emission_hook().
   */
  function signalAddEmissionHook(signalId: number, detail: GLib.Quark): number
  /**
   * Calls the original class closure of a signal. This function should only
   * be called from an overridden class closure; see
   * g_signal_override_class_closure() and
   * g_signal_override_class_handler().
   * @param instanceAndParams the argument list of the signal emission.  The first element in the array is a #GValue for the instance the signal  is being emitted on. The rest are any arguments to be passed to the signal.
   * @param returnValue Location for the return value.
   */
  function signalChainFromOverridden(
    instanceAndParams: any[],
    returnValue: any
  ): void
  /**
   * Connects a closure to a signal for a particular object.
   *
   * If `closure` is a floating reference (see g_closure_sink()), this function
   * takes ownership of `closure`.
   *
   * This function cannot fail. If the given signal doesn’t exist, a critical
   * warning is emitted.
   * @param instance the instance to connect to.
   * @param detailedSignal a string of the form "signal-name::detail".
   * @param closure the closure to connect.
   * @param after whether the handler should be called before or after the  default handler of the signal.
   * @returns the handler ID (always greater than 0)
   */
  function signalConnectClosure(
    instance: Object,
    detailedSignal: string,
    closure: TClosure,
    after: boolean
  ): number
  /**
   * Connects a closure to a signal for a particular object.
   *
   * If `closure` is a floating reference (see g_closure_sink()), this function
   * takes ownership of `closure`.
   *
   * This function cannot fail. If the given signal doesn’t exist, a critical
   * warning is emitted.
   * @param instance the instance to connect to.
   * @param signalId the id of the signal.
   * @param detail the detail.
   * @param closure the closure to connect.
   * @param after whether the handler should be called before or after the  default handler of the signal.
   * @returns the handler ID (always greater than 0)
   */
  function signalConnectClosureById(
    instance: Object,
    signalId: number,
    detail: GLib.Quark,
    closure: TClosure,
    after: boolean
  ): number
  /**
   * Emits a signal. Signal emission is done synchronously.
   * The method will only return control after all handlers are called or signal emission was stopped.
   *
   * Note that g_signal_emitv() doesn't change `return_value` if no handlers are
   * connected, in contrast to g_signal_emit() and g_signal_emit_valist().
   * @param instanceAndParams argument list for the signal emission.  The first element in the array is a #GValue for the instance the signal  is being emitted on. The rest are any arguments to be passed to the signal.
   * @param signalId the signal id
   * @param detail the detail
   * @param returnValue Location to store the return value of the signal emission. This must be provided if the specified signal returns a value, but may be ignored otherwise.
   */
  function signalEmitv(
    instanceAndParams: any[],
    signalId: number,
    detail: GLib.Quark,
    returnValue?: any
  ): /* returnValue */ any
  /**
   * Returns the invocation hint of the innermost signal emission of instance.
   * @param instance the instance to query
   * @returns the invocation hint of the innermost     signal emission, or %NULL if not found.
   */
  function signalGetInvocationHint(
    instance: Object
  ): SignalInvocationHint | null
  /**
   * Blocks a handler of an instance so it will not be called during any
   * signal emissions unless it is unblocked again. Thus "blocking" a
   * signal handler means to temporarily deactivate it, a signal handler
   * has to be unblocked exactly the same amount of times it has been
   * blocked before to become active again.
   *
   * The `handler_id` has to be a valid signal handler id, connected to a
   * signal of `instance`.
   * @param instance The instance to block the signal handler of.
   * @param handlerId Handler id of the handler to be blocked.
   */
  function signalHandlerBlock(instance: Object, handlerId: number): void
  /**
   * Disconnects a handler from an instance so it will not be called during
   * any future or currently ongoing emissions of the signal it has been
   * connected to. The `handler_id` becomes invalid and may be reused.
   *
   * The `handler_id` has to be a valid signal handler id, connected to a
   * signal of `instance`.
   * @param instance The instance to remove the signal handler from.
   * @param handlerId Handler id of the handler to be disconnected.
   */
  function signalHandlerDisconnect(instance: Object, handlerId: number): void
  /**
   * Finds the first signal handler that matches certain selection criteria.
   * The criteria mask is passed as an OR-ed combination of #GSignalMatchType
   * flags, and the criteria values are passed as arguments.
   * The match `mask` has to be non-0 for successful matches.
   * If no handler was found, 0 is returned.
   * @param instance The instance owning the signal handler to be found.
   * @param mask Mask indicating which of `signal_id,` `detail,` `closure,` `func`  and/or `data` the handler has to match.
   * @param signalId Signal the handler has to be connected to.
   * @param detail Signal detail the handler has to be connected to.
   * @param func The C closure callback of the handler (useless for non-C closures).
   * @param data The closure data of the handler's closure.
   * @returns A valid non-0 signal handler id for a successful match.
   */
  function signalHandlerFind(
    instance: Object,
    mask: SignalMatchType,
    signalId: number,
    detail: GLib.Quark,
    func: any | null,
    data: any | null
  ): number
  /**
   * Returns whether `handler_id` is the ID of a handler connected to `instance`.
   * @param instance The instance where a signal handler is sought.
   * @param handlerId the handler ID.
   * @returns whether @handler_id identifies a handler connected to @instance.
   */
  function signalHandlerIsConnected(
    instance: Object,
    handlerId: number
  ): boolean
  /**
   * Undoes the effect of a previous g_signal_handler_block() call.  A
   * blocked handler is skipped during signal emissions and will not be
   * invoked, unblocking it (for exactly the amount of times it has been
   * blocked before) reverts its "blocked" state, so the handler will be
   * recognized by the signal system and is called upon future or
   * currently ongoing signal emissions (since the order in which
   * handlers are called during signal emissions is deterministic,
   * whether the unblocked handler in question is called as part of a
   * currently ongoing emission depends on how far that emission has
   * proceeded yet).
   *
   * The `handler_id` has to be a valid id of a signal handler that is
   * connected to a signal of `instance` and is currently blocked.
   * @param instance The instance to unblock the signal handler of.
   * @param handlerId Handler id of the handler to be unblocked.
   */
  function signalHandlerUnblock(instance: Object, handlerId: number): void
  /**
   * Blocks all handlers on an instance that match a certain selection criteria.
   *
   * The criteria mask is passed as a combination of #GSignalMatchType flags, and
   * the criteria values are passed as arguments. A handler must match on all
   * flags set in `mask` to be blocked (i.e. the match is conjunctive).
   *
   * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
   * %G_SIGNAL_MATCH_FUNC
   * or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
   * If no handlers were found, 0 is returned, the number of blocked handlers
   * otherwise.
   *
   * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
   * @param instance The instance to block handlers from.
   * @param mask Mask indicating which of `signal_id,` `detail,` `closure,` `func`  and/or `data` the handlers have to match.
   * @param signalId Signal the handlers have to be connected to.
   * @param detail Signal detail the handlers have to be connected to.
   * @param func The C closure callback of the handlers (useless for non-C closures).
   * @param data The closure data of the handlers' closures.
   * @returns The number of handlers that matched.
   */
  function signalHandlersBlockMatched(
    instance: Object,
    mask: SignalMatchType,
    signalId: number,
    detail: GLib.Quark,
    func: any | null,
    data: any | null
  ): number
  /**
   * Destroy all signal handlers of a type instance. This function is
   * an implementation detail of the #GObject dispose implementation,
   * and should not be used outside of the type system.
   * @param instance The instance whose signal handlers are destroyed
   */
  function signalHandlersDestroy(instance: Object): void
  /**
   * Disconnects all handlers on an instance that match a certain
   * selection criteria.
   *
   * The criteria mask is passed as a combination of #GSignalMatchType flags, and
   * the criteria values are passed as arguments. A handler must match on all
   * flags set in `mask` to be disconnected (i.e. the match is conjunctive).
   *
   * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
   * %G_SIGNAL_MATCH_FUNC or
   * %G_SIGNAL_MATCH_DATA match flags is required for successful
   * matches.  If no handlers were found, 0 is returned, the number of
   * disconnected handlers otherwise.
   *
   * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
   * @param instance The instance to remove handlers from.
   * @param mask Mask indicating which of `signal_id,` `detail,` `closure,` `func`  and/or `data` the handlers have to match.
   * @param signalId Signal the handlers have to be connected to.
   * @param detail Signal detail the handlers have to be connected to.
   * @param func The C closure callback of the handlers (useless for non-C closures).
   * @param data The closure data of the handlers' closures.
   * @returns The number of handlers that matched.
   */
  function signalHandlersDisconnectMatched(
    instance: Object,
    mask: SignalMatchType,
    signalId: number,
    detail: GLib.Quark,
    func: any | null,
    data: any | null
  ): number
  /**
   * Unblocks all handlers on an instance that match a certain selection
   * criteria.
   *
   * The criteria mask is passed as a combination of #GSignalMatchType flags, and
   * the criteria values are passed as arguments. A handler must match on all
   * flags set in `mask` to be unblocked (i.e. the match is conjunctive).
   *
   * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
   * %G_SIGNAL_MATCH_FUNC
   * or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
   * If no handlers were found, 0 is returned, the number of unblocked handlers
   * otherwise. The match criteria should not apply to any handlers that are
   * not currently blocked.
   *
   * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
   * @param instance The instance to unblock handlers from.
   * @param mask Mask indicating which of `signal_id,` `detail,` `closure,` `func`  and/or `data` the handlers have to match.
   * @param signalId Signal the handlers have to be connected to.
   * @param detail Signal detail the handlers have to be connected to.
   * @param func The C closure callback of the handlers (useless for non-C closures).
   * @param data The closure data of the handlers' closures.
   * @returns The number of handlers that matched.
   */
  function signalHandlersUnblockMatched(
    instance: Object,
    mask: SignalMatchType,
    signalId: number,
    detail: GLib.Quark,
    func: any | null,
    data: any | null
  ): number
  /**
   * Returns whether there are any handlers connected to `instance` for the
   * given signal id and detail.
   *
   * If `detail` is 0 then it will only match handlers that were connected
   * without detail.  If `detail` is non-zero then it will match handlers
   * connected both without detail and with the given detail.  This is
   * consistent with how a signal emitted with `detail` would be delivered
   * to those handlers.
   *
   * Since 2.46 this also checks for a non-default class closure being
   * installed, as this is basically always what you want.
   *
   * One example of when you might use this is when the arguments to the
   * signal are difficult to compute. A class implementor may opt to not
   * emit the signal if no one is attached anyway, thus saving the cost
   * of building the arguments.
   * @param instance the object whose signal handlers are sought.
   * @param signalId the signal id.
   * @param detail the detail.
   * @param mayBeBlocked whether blocked handlers should count as match.
   * @returns %TRUE if a handler is connected to the signal, %FALSE          otherwise.
   */
  function signalHasHandlerPending(
    instance: Object,
    signalId: number,
    detail: GLib.Quark,
    mayBeBlocked: boolean
  ): boolean
  /**
   * Validate a signal name. This can be useful for dynamically-generated signals
   * which need to be validated at run-time before actually trying to create them.
   *
   * See [canonical parameter names][canonical-parameter-names] for details of
   * the rules for valid names. The rules for signal names are the same as those
   * for property names.
   * @param name the canonical name of the signal
   * @returns %TRUE if @name is a valid signal name, %FALSE otherwise.
   */
  function signalIsValidName(name: string): boolean
  /**
   * Lists the signals by id that a certain instance or interface type
   * created. Further information about the signals can be acquired through
   * g_signal_query().
   * @param itype Instance or interface type.
   * @returns Newly allocated array of signal IDs.
   */
  function signalListIds(itype: GType): number[]
  /**
   * Given the name of the signal and the type of object it connects to, gets
   * the signal's identifying integer. Emitting the signal by number is
   * somewhat faster than using the name each time.
   *
   * Also tries the ancestors of the given type.
   *
   * The type class passed as `itype` must already have been instantiated (for
   * example, using g_type_class_ref()) for this function to work, as signals are
   * always installed during class initialization.
   *
   * See g_signal_new() for details on allowed signal names.
   * @param name the signal's name.
   * @param itype the type that the signal operates on.
   * @returns the signal's identifying number, or 0 if no signal was found.
   */
  function signalLookup(name: string, itype: GType): number
  /**
   * Given the signal's identifier, finds its name.
   *
   * Two different signals may have the same name, if they have differing types.
   * @param signalId the signal's identifying number.
   * @returns the signal name, or %NULL if the signal number was invalid.
   */
  function signalName(signalId: number): string | null
  /**
   * Creates a new signal. (This is usually done in the class initializer.)
   *
   * See g_signal_new() for details on allowed signal names.
   *
   * If c_marshaller is %NULL, g_cclosure_marshal_generic() will be used as
   * the marshaller for this signal.
   * @param signalName the name for the signal
   * @param itype the type this signal pertains to. It will also pertain to     types which are derived from this type
   * @param signalFlags a combination of #GSignalFlags specifying detail of when     the default handler is to be invoked. You should at least specify     %G_SIGNAL_RUN_FIRST or %G_SIGNAL_RUN_LAST
   * @param classClosure The closure to invoke on signal emission;     may be %NULL
   * @param cMarshaller the function to translate arrays of     parameter values to signal emissions into C language callback     invocations or %NULL
   * @param returnType the type of return value, or %G_TYPE_NONE for a signal     without a return value
   * @param paramTypes an array of types, one for     each parameter (may be %NULL if `n_params` is zero)
   * @returns the signal id
   */
  function signalNewv(
    signalName: string,
    itype: GType,
    signalFlags: SignalFlags,
    classClosure: TClosure | null,
    cMarshaller: SignalCMarshaller | null,
    returnType: GType,
    paramTypes: GType[] | null
  ): number
  /**
   * Overrides the class closure (i.e. the default handler) for the given signal
   * for emissions on instances of `instance_type`. `instance_type` must be derived
   * from the type to which the signal belongs.
   *
   * See g_signal_chain_from_overridden() and
   * g_signal_chain_from_overridden_handler() for how to chain up to the
   * parent class closure from inside the overridden one.
   * @param signalId the signal id
   * @param instanceType the instance type on which to override the class closure  for the signal.
   * @param classClosure the closure.
   */
  function signalOverrideClassClosure(
    signalId: number,
    instanceType: GType,
    classClosure: TClosure
  ): void
  /**
   * Overrides the class closure (i.e. the default handler) for the
   * given signal for emissions on instances of `instance_type` with
   * callback `class_handler`. `instance_type` must be derived from the
   * type to which the signal belongs.
   *
   * See g_signal_chain_from_overridden() and
   * g_signal_chain_from_overridden_handler() for how to chain up to the
   * parent class closure from inside the overridden one.
   * @param signalName the name for the signal
   * @param instanceType the instance type on which to override the class handler  for the signal.
   * @param classHandler the handler.
   */
  function signalOverrideClassHandler(
    signalName: string,
    instanceType: GType,
    classHandler: Callback
  ): void
  /**
   * Internal function to parse a signal name into its `signal_id`
   * and `detail` quark.
   * @param detailedSignal a string of the form "signal-name::detail".
   * @param itype The interface/instance type that introduced "signal-name".
   * @param forceDetailQuark %TRUE forces creation of a #GQuark for the detail.
   * @returns Whether the signal name could successfully be parsed and @signal_id_p and @detail_p contain valid return values.
   */
  function signalParseName(
    detailedSignal: string,
    itype: GType,
    forceDetailQuark: boolean
  ): [
    /* returnType */ boolean,
    /* signalIdP */ number,
    /* detailP */ GLib.Quark,
  ]
  /**
   * Queries the signal system for in-depth information about a
   * specific signal. This function will fill in a user-provided
   * structure to hold signal-specific information. If an invalid
   * signal id is passed in, the `signal_id` member of the #GSignalQuery
   * is 0. All members filled into the #GSignalQuery structure should
   * be considered constant and have to be left untouched.
   * @param signalId The signal id of the signal to query information for.
   */
  function signalQuery(signalId: number): /* query */ SignalQuery
  /**
   * Deletes an emission hook.
   * @param signalId the id of the signal
   * @param hookId the id of the emission hook, as returned by  g_signal_add_emission_hook()
   */
  function signalRemoveEmissionHook(signalId: number, hookId: number): void
  /**
   * Change the #GSignalCVaMarshaller used for a given signal.  This is a
   * specialised form of the marshaller that can often be used for the
   * common case of a single connected signal handler and avoids the
   * overhead of #GValue.  Its use is optional.
   * @param signalId the signal id
   * @param instanceType the instance type on which to set the marshaller.
   * @param vaMarshaller the marshaller to set.
   */
  function signalSetVaMarshaller(
    signalId: number,
    instanceType: GType,
    vaMarshaller: SignalCVaMarshaller
  ): void
  /**
   * Stops a signal's current emission.
   *
   * This will prevent the default method from running, if the signal was
   * %G_SIGNAL_RUN_LAST and you connected normally (i.e. without the "after"
   * flag).
   *
   * Prints a warning if used on a signal which isn't being emitted.
   * @param instance the object whose signal handlers you wish to stop.
   * @param signalId the signal identifier, as returned by g_signal_lookup().
   * @param detail the detail which the signal was emitted with.
   */
  function signalStopEmission(
    instance: Object,
    signalId: number,
    detail: GLib.Quark
  ): void
  /**
   * Stops a signal's current emission.
   *
   * This is just like g_signal_stop_emission() except it will look up the
   * signal id for you.
   * @param instance the object whose signal handlers you wish to stop.
   * @param detailedSignal a string of the form "signal-name::detail".
   */
  function signalStopEmissionByName(
    instance: Object,
    detailedSignal: string
  ): void
  /**
   * Creates a new closure which invokes the function found at the offset
   * `struct_offset` in the class structure of the interface or classed type
   * identified by `itype`.
   * @param itype the #GType identifier of an interface or classed type
   * @param structOffset the offset of the member function of `itype'`s class  structure which is to be invoked by the new closure
   * @returns a floating reference to a new #GCClosure
   */
  function signalTypeCclosureNew(itype: GType, structOffset: number): TClosure
  /**
   * Set the callback for a source as a #GClosure.
   *
   * If the source is not one of the standard GLib types, the `closure_callback`
   * and `closure_marshal` fields of the #GSourceFuncs structure must have been
   * filled in with pointers to appropriate functions.
   * @param source the source
   * @param closure a #GClosure
   */
  function sourceSetClosure(source: GLib.Source, closure: TClosure): void
  /**
   * Sets a dummy callback for `source`. The callback will do nothing, and
   * if the source expects a #gboolean return value, it will return %TRUE.
   * (If the source expects any other type of return value, it will return
   * a 0/%NULL value; whatever g_value_init() initializes a #GValue to for
   * that type.)
   *
   * If the source is not one of the standard GLib types, the
   * `closure_callback` and `closure_marshal` fields of the #GSourceFuncs
   * structure must have been filled in with pointers to appropriate
   * functions.
   * @param source the source
   */
  function sourceSetDummyCallback(source: GLib.Source): void
  /**
   * Return a newly allocated string, which describes the contents of a
   * #GValue.  The main purpose of this function is to describe #GValue
   * contents for debugging output, the way in which the contents are
   * described may change between different GLib versions.
   * @param value #GValue which contents are to be described.
   * @returns Newly allocated string.
   */
  function strdupValueContents(value: any): string | null
  /**
   * Registers a private class structure for a classed type;
   * when the class is allocated, the private structures for
   * the class and all of its parent types are allocated
   * sequentially in the same memory block as the public
   * structures, and are zero-filled.
   *
   * This function should be called in the
   * type's get_type() function after the type is registered.
   * The private structure can be retrieved using the
   * G_TYPE_CLASS_GET_PRIVATE() macro.
   * @param classType GType of a classed type
   * @param privateSize size of private structure
   */
  function typeAddClassPrivate(classType: GType, privateSize: number): void
  function typeAddInstancePrivate(classType: GType, privateSize: number): number
  /**
   * Adds `interface_type` to the dynamic `instance_type`. The information
   * contained in the #GTypePlugin structure pointed to by `plugin`
   * is used to manage the relationship.
   * @param instanceType #GType value of an instantiatable type
   * @param interfaceType #GType value of an interface type
   * @param plugin #GTypePlugin structure to retrieve the #GInterfaceInfo from
   */
  function typeAddInterfaceDynamic(
    instanceType: GType,
    interfaceType: GType,
    plugin: TypePlugin
  ): void
  /**
   * Adds `interface_type` to the static `instance_type`.
   * The information contained in the #GInterfaceInfo structure
   * pointed to by `info` is used to manage the relationship.
   * @param instanceType #GType value of an instantiatable type
   * @param interfaceType #GType value of an interface type
   * @param info #GInterfaceInfo structure for this        (`instance_type,` `interface_type)` combination
   */
  function typeAddInterfaceStatic(
    instanceType: GType,
    interfaceType: GType,
    info: InterfaceInfo
  ): void
  function typeCheckClassIsA(gClass: TypeClass, isAType: GType): boolean
  /**
   * Private helper function to aid implementation of the
   * G_TYPE_CHECK_INSTANCE() macro.
   * @param instance a valid #GTypeInstance structure
   * @returns %TRUE if @instance is valid, %FALSE otherwise
   */
  function typeCheckInstance(instance: TypeInstance): boolean
  function typeCheckInstanceIsA(
    instance: TypeInstance,
    ifaceType: GType
  ): boolean
  function typeCheckInstanceIsFundamentallyA(
    instance: TypeInstance,
    fundamentalType: GType
  ): boolean
  function typeCheckIsValueType(type: GType): boolean
  function typeCheckValue(value: any): boolean
  function typeCheckValueHolds(value: any, type: GType): boolean
  /**
   * Return a newly allocated and 0-terminated array of type IDs, listing
   * the child types of `type`.
   * @param type the parent type
   * @returns Newly allocated     and 0-terminated array of child types, free with g_free()
   */
  function typeChildren(type: GType): GType[]
  function typeClassAdjustPrivateOffset(
    gClass: any | null,
    privateSizeOrOffset: number
  ): void
  /**
   * This function is essentially the same as g_type_class_ref(),
   * except that the classes reference count isn't incremented.
   * As a consequence, this function may return %NULL if the class
   * of the type passed in does not currently exist (hasn't been
   * referenced before).
   * @param type type ID of a classed type
   * @returns the #GTypeClass     structure for the given type ID or %NULL if the class does not     currently exist
   */
  function typeClassPeek(type: GType): TypeClass
  /**
   * A more efficient version of g_type_class_peek() which works only for
   * static types.
   * @param type type ID of a classed type
   * @returns the #GTypeClass     structure for the given type ID or %NULL if the class does not     currently exist or is dynamically loaded
   */
  function typeClassPeekStatic(type: GType): TypeClass
  /**
   * Increments the reference count of the class structure belonging to
   * `type`. This function will demand-create the class if it doesn't
   * exist already.
   * @param type type ID of a classed type
   * @returns the #GTypeClass     structure for the given type ID
   */
  function typeClassRef(type: GType): TypeClass
  /**
   * If the interface type `g_type` is currently in use, returns its
   * default interface vtable.
   * @param gType an interface type
   * @returns the default     vtable for the interface, or %NULL if the type is not currently     in use
   */
  function typeDefaultInterfacePeek(gType: GType): TypeInterface
  /**
   * Increments the reference count for the interface type `g_type,`
   * and returns the default interface vtable for the type.
   *
   * If the type is not currently in use, then the default vtable
   * for the type will be created and initialized by calling
   * the base interface init and default vtable init functions for
   * the type (the `base_init` and `class_init` members of #GTypeInfo).
   * Calling g_type_default_interface_ref() is useful when you
   * want to make sure that signals and properties for an interface
   * have been installed.
   * @param gType an interface type
   * @returns the default     vtable for the interface; call g_type_default_interface_unref()     when you are done using the interface.
   */
  function typeDefaultInterfaceRef(gType: GType): TypeInterface
  /**
   * Decrements the reference count for the type corresponding to the
   * interface default vtable `g_iface`. If the type is dynamic, then
   * when no one is using the interface and all references have
   * been released, the finalize function for the interface's default
   * vtable (the `class_finalize` member of #GTypeInfo) will be called.
   * @param gIface the default vtable     structure for an interface, as returned by g_type_default_interface_ref()
   */
  function typeDefaultInterfaceUnref(gIface: TypeInterface): void
  /**
   * Returns the length of the ancestry of the passed in type. This
   * includes the type itself, so that e.g. a fundamental type has depth 1.
   * @param type a #GType
   * @returns the depth of @type
   */
  function typeDepth(type: GType): number
  /**
   * Ensures that the indicated `type` has been registered with the
   * type system, and its _class_init() method has been run.
   *
   * In theory, simply calling the type's _get_type() method (or using
   * the corresponding macro) is supposed take care of this. However,
   * _get_type() methods are often marked %G_GNUC_CONST for performance
   * reasons, even though this is technically incorrect (since
   * %G_GNUC_CONST requires that the function not have side effects,
   * which _get_type() methods do on the first call). As a result, if
   * you write a bare call to a _get_type() macro, it may get optimized
   * out by the compiler. Using g_type_ensure() guarantees that the
   * type's _get_type() method is called.
   * @param type a #GType
   */
  function typeEnsure(type: GType): void
  /**
   * Frees an instance of a type, returning it to the instance pool for
   * the type, if there is one.
   *
   * Like g_type_create_instance(), this function is reserved for
   * implementors of fundamental types.
   * @param instance an instance of a type
   */
  function typeFreeInstance(instance: TypeInstance): void
  /**
   * Look up the type ID from a given type name, returning 0 if no type
   * has been registered under this name (this is the preferred method
   * to find out by name whether a specific type has been registered
   * yet).
   * @param name type name to look up
   * @returns corresponding type ID or 0
   */
  function typeFromName(name: string): GType
  /**
   * Internal function, used to extract the fundamental type ID portion.
   * Use G_TYPE_FUNDAMENTAL() instead.
   * @param typeId valid type ID
   * @returns fundamental type ID
   */
  function typeFundamental(typeId: GType): GType
  /**
   * Returns the next free fundamental type id which can be used to
   * register a new fundamental type with g_type_register_fundamental().
   * The returned type ID represents the highest currently registered
   * fundamental type identifier.
   * @returns the next available fundamental type ID to be registered,     or 0 if the type system ran out of fundamental type IDs
   */
  function typeFundamentalNext(): GType
  /**
   * Returns the number of instances allocated of the particular type;
   * this is only available if GLib is built with debugging support and
   * the `instance-count` debug flag is set (by setting the `GOBJECT_DEBUG`
   * variable to include `instance-count`).
   * @param type a #GType
   * @returns the number of instances allocated of the given type;   if instance counts are not available, returns 0.
   */
  function typeGetInstanceCount(type: GType): number
  /**
   * Returns the #GTypePlugin structure for `type`.
   * @param type #GType to retrieve the plugin for
   * @returns the corresponding plugin     if @type is a dynamic type, %NULL otherwise
   */
  function typeGetPlugin(type: GType): TypePlugin
  /**
   * Obtains data which has previously been attached to `type`
   * with g_type_set_qdata().
   *
   * Note that this does not take subtyping into account; data
   * attached to one type with g_type_set_qdata() cannot
   * be retrieved from a subtype using g_type_get_qdata().
   * @param type a #GType
   * @param quark a #GQuark id to identify the data
   * @returns the data, or %NULL if no data was found
   */
  function typeGetQdata(type: GType, quark: GLib.Quark): any | null
  /**
   * Returns an opaque serial number that represents the state of the set
   * of registered types. Any time a type is registered this serial changes,
   * which means you can cache information based on type lookups (such as
   * g_type_from_name()) and know if the cache is still valid at a later
   * time by comparing the current serial with the one at the type lookup.
   * @returns An unsigned int, representing the state of type registrations
   */
  function typeGetTypeRegistrationSerial(): number
  /**
   * This function used to initialise the type system.  Since GLib 2.36,
   * the type system is initialised automatically and this function does
   * nothing.
   */
  function typeInit(): void
  /**
   * This function used to initialise the type system with debugging
   * flags.  Since GLib 2.36, the type system is initialised automatically
   * and this function does nothing.
   *
   * If you need to enable debugging features, use the `GOBJECT_DEBUG`
   * environment variable.
   * @param debugFlags bitwise combination of #GTypeDebugFlags values for     debugging purposes
   */
  function typeInitWithDebugFlags(debugFlags: TypeDebugFlags): void
  /**
   * Adds `prerequisite_type` to the list of prerequisites of `interface_type`.
   * This means that any type implementing `interface_type` must also implement
   * `prerequisite_type`. Prerequisites can be thought of as an alternative to
   * interface derivation (which GType doesn't support). An interface can have
   * at most one instantiatable prerequisite type.
   * @param interfaceType #GType value of an interface type
   * @param prerequisiteType #GType value of an interface or instantiatable type
   */
  function typeInterfaceAddPrerequisite(
    interfaceType: GType,
    prerequisiteType: GType
  ): void
  /**
   * Returns the #GTypePlugin structure for the dynamic interface
   * `interface_type` which has been added to `instance_type,` or %NULL
   * if `interface_type` has not been added to `instance_type` or does
   * not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
   * @param instanceType #GType of an instantiatable type
   * @param interfaceType #GType of an interface type
   * @returns the #GTypePlugin for the dynamic     interface @interface_type of @instance_type
   */
  function typeInterfaceGetPlugin(
    instanceType: GType,
    interfaceType: GType
  ): TypePlugin
  /**
   * Returns the most specific instantiatable prerequisite of an
   * interface type. If the interface type has no instantiatable
   * prerequisite, %G_TYPE_INVALID is returned.
   *
   * See g_type_interface_add_prerequisite() for more information
   * about prerequisites.
   * @param interfaceType an interface type
   * @returns the instantiatable prerequisite type or %G_TYPE_INVALID if none
   */
  function typeInterfaceInstantiatablePrerequisite(interfaceType: GType): GType
  /**
   * Returns the #GTypeInterface structure of an interface to which the
   * passed in class conforms.
   * @param instanceClass a #GTypeClass structure
   * @param ifaceType an interface ID which this class conforms to
   * @returns the #GTypeInterface     structure of @iface_type if implemented by @instance_class, %NULL     otherwise
   */
  function typeInterfacePeek(
    instanceClass: TypeClass,
    ifaceType: GType
  ): TypeInterface
  /**
   * Returns the prerequisites of an interfaces type.
   * @param interfaceType an interface type
   * @returns a     newly-allocated zero-terminated array of #GType containing     the prerequisites of @interface_type
   */
  function typeInterfacePrerequisites(interfaceType: GType): GType[]
  /**
   * Return a newly allocated and 0-terminated array of type IDs, listing
   * the interface types that `type` conforms to.
   * @param type the type to list interface types for
   * @returns Newly allocated     and 0-terminated array of interface types, free with g_free()
   */
  function typeInterfaces(type: GType): GType[]
  /**
   * If `is_a_type` is a derivable type, check whether `type` is a
   * descendant of `is_a_type`. If `is_a_type` is an interface, check
   * whether `type` conforms to it.
   * @param type type to check ancestry for
   * @param isAType possible ancestor of `type` or interface that `type`     could conform to
   * @returns %TRUE if @type is a @is_a_type
   */
  function typeIsA(type: GType, isAType: GType): boolean
  /**
   * Get the unique name that is assigned to a type ID.  Note that this
   * function (like all other GType API) cannot cope with invalid type
   * IDs. %G_TYPE_INVALID may be passed to this function, as may be any
   * other validly registered type ID, but randomized type IDs should
   * not be passed in and will most likely lead to a crash.
   * @param type type to return name for
   * @returns static type name or %NULL
   */
  function typeName(type: GType): string | null
  function typeNameFromClass(gClass: TypeClass): string
  function typeNameFromInstance(instance: TypeInstance): string
  /**
   * Given a `leaf_type` and a `root_type` which is contained in its
   * ancestry, return the type that `root_type` is the immediate parent
   * of. In other words, this function determines the type that is
   * derived directly from `root_type` which is also a base class of
   * `leaf_type`.  Given a root type and a leaf type, this function can
   * be used to determine the types and order in which the leaf type is
   * descended from the root type.
   * @param leafType descendant of `root_type` and the type to be returned
   * @param rootType immediate parent of the returned type
   * @returns immediate child of @root_type and ancestor of @leaf_type
   */
  function typeNextBase(leafType: GType, rootType: GType): GType
  /**
   * Return the direct parent type of the passed in type. If the passed
   * in type has no parent, i.e. is a fundamental type, 0 is returned.
   * @param type the derived type
   * @returns the parent type
   */
  function typeParent(type: GType): GType
  /**
   * Get the corresponding quark of the type IDs name.
   * @param type type to return quark of type name for
   * @returns the type names quark or 0
   */
  function typeQname(type: GType): GLib.Quark
  /**
   * Queries the type system for information about a specific type.
   *
   * This function will fill in a user-provided structure to hold
   * type-specific information. If an invalid #GType is passed in, the
   * `type` member of the #GTypeQuery is 0. All members filled into the
   * #GTypeQuery structure should be considered constant and have to be
   * left untouched.
   *
   * Since GLib 2.78, this function allows queries on dynamic types. Previously
   * it only supported static types.
   * @param type #GType of a static, classed type
   */
  function typeQuery(type: GType): /* query */ TypeQuery
  /**
   * Registers `type_name` as the name of a new dynamic type derived from
   * `parent_type`.  The type system uses the information contained in the
   * #GTypePlugin structure pointed to by `plugin` to manage the type and its
   * instances (if not abstract).  The value of `flags` determines the nature
   * (e.g. abstract or not) of the type.
   * @param parentType type from which this type will be derived
   * @param typeName 0-terminated string used as the name of the new type
   * @param plugin #GTypePlugin structure to retrieve the #GTypeInfo from
   * @param flags bitwise combination of #GTypeFlags values
   * @returns the new type identifier or %G_TYPE_INVALID if registration failed
   */
  function typeRegisterDynamic(
    parentType: GType,
    typeName: string,
    plugin: TypePlugin,
    flags: TypeFlags
  ): GType
  /**
   * Registers `type_id` as the predefined identifier and `type_name` as the
   * name of a fundamental type. If `type_id` is already registered, or a
   * type named `type_name` is already registered, the behaviour is undefined.
   * The type system uses the information contained in the #GTypeInfo structure
   * pointed to by `info` and the #GTypeFundamentalInfo structure pointed to by
   * `finfo` to manage the type and its instances. The value of `flags` determines
   * additional characteristics of the fundamental type.
   * @param typeId a predefined type identifier
   * @param typeName 0-terminated string used as the name of the new type
   * @param info #GTypeInfo structure for this type
   * @param finfo #GTypeFundamentalInfo structure for this type
   * @param flags bitwise combination of #GTypeFlags values
   * @returns the predefined type identifier
   */
  function typeRegisterFundamental(
    typeId: GType,
    typeName: string,
    info: TypeInfo,
    finfo: TypeFundamentalInfo,
    flags: TypeFlags
  ): GType
  /**
   * Registers `type_name` as the name of a new static type derived from
   * `parent_type`. The type system uses the information contained in the
   * #GTypeInfo structure pointed to by `info` to manage the type and its
   * instances (if not abstract). The value of `flags` determines the nature
   * (e.g. abstract or not) of the type.
   * @param parentType type from which this type will be derived
   * @param typeName 0-terminated string used as the name of the new type
   * @param info #GTypeInfo structure for this type
   * @param flags bitwise combination of #GTypeFlags values
   * @returns the new type identifier
   */
  function typeRegisterStatic(
    parentType: GType,
    typeName: string,
    info: TypeInfo,
    flags: TypeFlags
  ): GType
  /**
   * Attaches arbitrary data to a type.
   * @param type a #GType
   * @param quark a #GQuark id to identify the data
   * @param data the data
   */
  function typeSetQdata(type: GType, quark: GLib.Quark, data: any | null): void
  function typeTestFlags(type: GType, flags: number): boolean
  /**
   * Returns whether a #GValue of type `src_type` can be copied into
   * a #GValue of type `dest_type`.
   * @param srcType source type to be copied.
   * @param destType destination type for copying.
   * @returns %TRUE if g_value_copy() is possible with @src_type and @dest_type.
   */
  function valueTypeCompatible(srcType: GType, destType: GType): boolean
  /**
   * Check whether g_value_transform() is able to transform values
   * of type `src_type` into values of type `dest_type`. Note that for
   * the types to be transformable, they must be compatible or a
   * transformation function must be registered.
   * @param srcType Source type.
   * @param destType Target type.
   * @returns %TRUE if the transformation is possible, %FALSE otherwise.
   */
  function valueTypeTransformable(srcType: GType, destType: GType): boolean
  function variantGetGtype(): GType
  /**
   * A callback function used by the type system to finalize those portions
   * of a derived types class structure that were setup from the corresponding
   * GBaseInitFunc() function.
   *
   * Class finalization basically works the inverse way in which class
   * initialization is performed.
   *
   * See GClassInitFunc() for a discussion of the class initialization process.
   * @callback
   * @param gClass The #GTypeClass structure to finalize
   */
  interface BaseFinalizeFunc {
    (gClass: TypeClass): void
  }
  /**
   * A callback function used by the type system to do base initialization
   * of the class structures of derived types.
   *
   * This function is called as part of the initialization process of all derived
   * classes and should reallocate or reset all dynamic class members copied over
   * from the parent class.
   *
   * For example, class members (such as strings) that are not sufficiently
   * handled by a plain memory copy of the parent class into the derived class
   * have to be altered. See GClassInitFunc() for a discussion of the class
   * initialization process.
   * @callback
   * @param gClass The #GTypeClass structure to initialize
   */
  interface BaseInitFunc {
    (gClass: TypeClass): void
  }
  /**
   * A function to be called to transform `from_value` to `to_value`.
   *
   * If this is the `transform_to` function of a binding, then `from_value`
   * is the `source_property` on the `source` object, and `to_value` is the
   * `target_property` on the `target` object. If this is the
   * `transform_from` function of a %G_BINDING_BIDIRECTIONAL binding,
   * then those roles are reversed.
   * @callback
   * @param binding a #GBinding
   * @param fromValue the #GValue containing the value to transform
   * @param toValue the #GValue in which to store the transformed value
   * @returns %TRUE if the transformation was successful, and %FALSE   otherwise
   */
  interface BindingTransformFunc {
    (binding: Binding, fromValue: any, toValue: any): boolean
  }
  /**
   * This function is provided by the user and should produce a copy
   * of the passed in boxed structure.
   * @callback
   * @param boxed The boxed structure to be copied.
   * @returns The newly created copy of the boxed structure.
   */
  interface BoxedCopyFunc {
    (boxed: any): any
  }
  /**
   * This function is provided by the user and should free the boxed
   * structure passed.
   * @callback
   * @param boxed The boxed structure to be freed.
   */
  interface BoxedFreeFunc {
    (boxed: any): void
  }
  /**
   * The type used for callback functions in structure definitions and function
   * signatures.
   *
   * This doesn't mean that all callback functions must take no  parameters and
   * return void. The required signature of a callback function is determined by
   * the context in which is used (e.g. the signal to which it is connected).
   *
   * Use G_CALLBACK() to cast the callback function to a #GCallback.
   * @callback
   */
  interface Callback {
    (): void
  }
  /**
   * A callback function used by the type system to finalize a class.
   *
   * This function is rarely needed, as dynamically allocated class resources
   * should be handled by GBaseInitFunc() and GBaseFinalizeFunc().
   *
   * Also, specification of a GClassFinalizeFunc() in the #GTypeInfo
   * structure of a static type is invalid, because classes of static types
   * will never be finalized (they are artificially kept alive when their
   * reference count drops to zero).
   * @callback
   * @param gClass The #GTypeClass structure to finalize
   * @param classData The `class_data` member supplied via the #GTypeInfo structure
   */
  interface ClassFinalizeFunc {
    (gClass: TypeClass, classData: any | null): void
  }
  /**
   * A callback function used by the type system to initialize the class
   * of a specific type.
   *
   * This function should initialize all static class members.
   *
   * The initialization process of a class involves:
   *
   * - Copying common members from the parent class over to the
   *   derived class structure.
   * - Zero initialization of the remaining members not copied
   *   over from the parent class.
   * - Invocation of the GBaseInitFunc() initializers of all parent
   *   types and the class' type.
   * - Invocation of the class' GClassInitFunc() initializer.
   *
   * Since derived classes are partially initialized through a memory copy
   * of the parent class, the general rule is that GBaseInitFunc() and
   * GBaseFinalizeFunc() should take care of necessary reinitialization
   * and release of those class members that were introduced by the type
   * that specified these GBaseInitFunc()/GBaseFinalizeFunc().
   * GClassInitFunc() should only care about initializing static
   * class members, while dynamic class members (such as allocated strings
   * or reference counted resources) are better handled by a GBaseInitFunc()
   * for this type, so proper initialization of the dynamic class members
   * is performed for class initialization of derived types as well.
   *
   * An example may help to correspond the intend of the different class
   * initializers:
   *
   *
   * ```c
   * typedef struct {
   *   GObjectClass parent_class;
   *   gint         static_integer;
   *   gchar       *dynamic_string;
   * } TypeAClass;
   * static void
   * type_a_base_class_init (TypeAClass *class)
   * {
   *   class->dynamic_string = g_strdup ("some string");
   * }
   * static void
   * type_a_base_class_finalize (TypeAClass *class)
   * {
   *   g_free (class->dynamic_string);
   * }
   * static void
   * type_a_class_init (TypeAClass *class)
   * {
   *   class->static_integer = 42;
   * }
   *
   * typedef struct {
   *   TypeAClass   parent_class;
   *   gfloat       static_float;
   *   GString     *dynamic_gstring;
   * } TypeBClass;
   * static void
   * type_b_base_class_init (TypeBClass *class)
   * {
   *   class->dynamic_gstring = g_string_new ("some other string");
   * }
   * static void
   * type_b_base_class_finalize (TypeBClass *class)
   * {
   *   g_string_free (class->dynamic_gstring);
   * }
   * static void
   * type_b_class_init (TypeBClass *class)
   * {
   *   class->static_float = 3.14159265358979323846;
   * }
   * ```
   *
   *
   * Initialization of TypeBClass will first cause initialization of
   * TypeAClass (derived classes reference their parent classes, see
   * g_type_class_ref() on this).
   *
   * Initialization of TypeAClass roughly involves zero-initializing its fields,
   * then calling its GBaseInitFunc() type_a_base_class_init() to allocate
   * its dynamic members (dynamic_string), and finally calling its GClassInitFunc()
   * type_a_class_init() to initialize its static members (static_integer).
   * The first step in the initialization process of TypeBClass is then
   * a plain memory copy of the contents of TypeAClass into TypeBClass and
   * zero-initialization of the remaining fields in TypeBClass.
   * The dynamic members of TypeAClass within TypeBClass now need
   * reinitialization which is performed by calling type_a_base_class_init()
   * with an argument of TypeBClass.
   *
   * After that, the GBaseInitFunc() of TypeBClass, type_b_base_class_init()
   * is called to allocate the dynamic members of TypeBClass (dynamic_gstring),
   * and finally the GClassInitFunc() of TypeBClass, type_b_class_init(),
   * is called to complete the initialization process with the static members
   * (static_float).
   *
   * Corresponding finalization counter parts to the GBaseInitFunc() functions
   * have to be provided to release allocated resources at class finalization
   * time.
   * @callback
   * @param gClass The #GTypeClass structure to initialize.
   * @param classData The `class_data` member supplied via the #GTypeInfo structure.
   */
  interface ClassInitFunc {
    (gClass: TypeClass, classData: any | null): void
  }
  /**
   * The type used for marshaller functions.
   * @callback
   * @param closure the #GClosure to which the marshaller belongs
   * @param returnValue a #GValue to store the return  value. May be %NULL if the callback of `closure` doesn't return a  value.
   * @param paramValues an array of  #GValues holding the arguments on which to invoke the  callback of `closure`
   * @param invocationHint the invocation hint given as the  last argument to g_closure_invoke()
   * @param marshalData additional data specified when  registering the marshaller, see g_closure_set_marshal() and  g_closure_set_meta_marshal()
   */
  interface ClosureMarshal {
    (
      closure: TClosure,
      returnValue: any | null,
      paramValues: any[],
      invocationHint: any | null,
      marshalData: any | null
    ): void
  }
  /**
   * The type used for the various notification callbacks which can be registered
   * on closures.
   * @callback
   * @param data data specified when registering the notification callback
   * @param closure the #GClosure on which the notification is emitted
   */
  interface ClosureNotify {
    (data: any | null, closure: TClosure): void
  }
  /**
   * A callback function used by the type system to initialize a new
   * instance of a type.
   *
   * This function initializes all instance members and allocates any resources
   * required by it.
   *
   * Initialization of a derived instance involves calling all its parent
   * types instance initializers, so the class member of the instance
   * is altered during its initialization to always point to the class that
   * belongs to the type the current initializer was introduced for.
   *
   * The extended members of `instance` are guaranteed to have been filled with
   * zeros before this function is called.
   * @callback
   * @param instance The instance to initialize
   * @param gClass The class of the type the instance is    created for
   */
  interface InstanceInitFunc {
    (instance: TypeInstance, gClass: TypeClass): void
  }
  /**
   * A callback function used by the type system to finalize an interface.
   *
   * This function should destroy any internal data and release any resources
   * allocated by the corresponding GInterfaceInitFunc() function.
   * @callback
   * @param gIface The interface structure to finalize
   * @param ifaceData The `interface_data` supplied via the #GInterfaceInfo structure
   */
  interface InterfaceFinalizeFunc {
    (gIface: TypeInterface, ifaceData: any | null): void
  }
  /**
   * A callback function used by the type system to initialize a new
   * interface.
   *
   * This function should initialize all internal data and* allocate any
   * resources required by the interface.
   *
   * The members of `iface_data` are guaranteed to have been filled with
   * zeros before this function is called.
   * @callback
   * @param gIface The interface structure to initialize
   * @param ifaceData The `interface_data` supplied via the #GInterfaceInfo structure
   */
  interface InterfaceInitFunc {
    (gIface: TypeInterface, ifaceData: any | null): void
  }
  /**
   * The type of the `finalize` function of #GObjectClass.
   * @callback
   * @param object the #GObject being finalized
   */
  interface ObjectFinalizeFunc {
    (object: Object): void
  }
  /**
   * The type of the `get_property` function of #GObjectClass.
   * @callback
   * @param object a #GObject
   * @param propertyId the numeric id under which the property was registered with  g_object_class_install_property().
   * @param value a #GValue to return the property value in
   * @param pspec the #GParamSpec describing the property
   */
  interface ObjectGetPropertyFunc {
    (object: Object, propertyId: number, value: any, pspec: ParamSpec): void
  }
  /**
   * The type of the `set_property` function of #GObjectClass.
   * @callback
   * @param object a #GObject
   * @param propertyId the numeric id under which the property was registered with  g_object_class_install_property().
   * @param value the new value for the property
   * @param pspec the #GParamSpec describing the property
   */
  interface ObjectSetPropertyFunc {
    (object: Object, propertyId: number, value: any, pspec: ParamSpec): void
  }
  /**
   * The signal accumulator is a special callback function that can be used
   * to collect return values of the various callbacks that are called
   * during a signal emission.
   *
   * The signal accumulator is specified at signal creation time, if it is
   * left %NULL, no accumulation of callback return values is performed.
   * The return value of signal emissions is then the value returned by the
   * last callback.
   * @callback
   * @param ihint Signal invocation hint, see #GSignalInvocationHint.
   * @param returnAccu Accumulator to collect callback return values in, this  is the return value of the current signal emission.
   * @param handlerReturn A #GValue holding the return value of the signal handler.
   * @param data Callback data that was specified when creating the signal.
   * @returns The accumulator function returns whether the signal emission  should be aborted. Returning %TRUE will continue with  the signal emission. Returning %FALSE will abort the current emission.  Since 2.62, returning %FALSE will skip to the CLEANUP stage. In this case,  emission will occur as normal in the CLEANUP stage and the handler's  return value will be accumulated.
   */
  interface SignalAccumulator {
    (
      ihint: SignalInvocationHint,
      returnAccu: any,
      handlerReturn: any,
      data: any | null
    ): boolean
  }
  /**
   * A simple function pointer to get invoked when the signal is emitted.
   *
   * Emission hooks allow you to tie a hook to the signal type, so that it will
   * trap all emissions of that signal, from any object.
   *
   * You may not attach these to signals created with the %G_SIGNAL_NO_HOOKS flag.
   * @callback
   * @param ihint Signal invocation hint, see #GSignalInvocationHint.
   * @param paramValues the instance on which  the signal was emitted, followed by the parameters of the emission.
   * @param data user data associated with the hook.
   * @returns whether it wants to stay connected. If it returns %FALSE, the signal  hook is disconnected (and destroyed).
   */
  interface SignalEmissionHook {
    (ihint: SignalInvocationHint, paramValues: any[], data: any | null): boolean
  }
  /**
   * A callback function used for notification when the state
   * of a toggle reference changes.
   *
   * See also: g_object_add_toggle_ref()
   * @callback
   * @param data Callback data passed to g_object_add_toggle_ref()
   * @param object The object on which g_object_add_toggle_ref() was called.
   * @param isLastRef %TRUE if the toggle reference is now the  last reference to the object. %FALSE if the toggle  reference was the last reference and there are now other  references.
   */
  interface ToggleNotify {
    (data: any | null, object: Object, isLastRef: boolean): void
  }
  /**
   * A callback function which is called when the reference count of a class
   * drops to zero.
   *
   * It may use g_type_class_ref() to prevent the class from being freed. You
   * should not call g_type_class_unref() from a #GTypeClassCacheFunc function
   * to prevent infinite recursion, use g_type_class_unref_uncached() instead.
   *
   * The functions have to check the class id passed in to figure
   * whether they actually want to cache the class of this type, since all
   * classes are routed through the same #GTypeClassCacheFunc chain.
   * @callback
   * @param cacheData data that was given to the g_type_add_class_cache_func() call
   * @param gClass The #GTypeClass structure which is    unreferenced
   * @returns %TRUE to stop further #GTypeClassCacheFuncs from being  called, %FALSE to continue
   */
  interface TypeClassCacheFunc {
    (cacheData: any | null, gClass: TypeClass): boolean
  }
  /**
   * A callback called after an interface vtable is initialized.
   *
   * See g_type_add_interface_check().
   * @callback
   * @param checkData data passed to g_type_add_interface_check()
   * @param gIface the interface that has been    initialized
   */
  interface TypeInterfaceCheckFunc {
    (checkData: any | null, gIface: TypeInterface): void
  }
  /**
   * The type of the `complete_interface_info` function of #GTypePluginClass.
   * @callback
   * @param plugin the #GTypePlugin
   * @param instanceType the #GType of an instantiatable type to which the interface  is added
   * @param interfaceType the #GType of the interface whose info is completed
   * @param info the #GInterfaceInfo to fill in
   */
  interface TypePluginCompleteInterfaceInfo {
    (
      plugin: TypePlugin,
      instanceType: GType,
      interfaceType: GType,
      info: InterfaceInfo
    ): void
  }
  /**
   * The type of the `complete_type_info` function of #GTypePluginClass.
   * @callback
   * @param plugin the #GTypePlugin
   * @param gType the #GType whose info is completed
   * @param info the #GTypeInfo struct to fill in
   * @param valueTable the #GTypeValueTable to fill in
   */
  interface TypePluginCompleteTypeInfo {
    (
      plugin: TypePlugin,
      gType: GType,
      info: TypeInfo,
      valueTable: TypeValueTable
    ): void
  }
  /**
   * The type of the `unuse_plugin` function of #GTypePluginClass.
   * @callback
   * @param plugin the #GTypePlugin whose use count should be decreased
   */
  interface TypePluginUnuse {
    (plugin: TypePlugin): void
  }
  /**
   * The type of the `use_plugin` function of #GTypePluginClass, which gets called
   * to increase the use count of `plugin`.
   * @callback
   * @param plugin the #GTypePlugin whose use count should be increased
   */
  interface TypePluginUse {
    (plugin: TypePlugin): void
  }
  /**
   * This function is responsible for converting the values collected from
   * a variadic argument list into contents suitable for storage in a #GValue.
   *
   * This function should setup `value` similar to #GTypeValueInitFunc; e.g.
   * for a string value that does not allow `NULL` pointers, it needs to either
   * emit an error, or do an implicit conversion by storing an empty string.
   *
   * The `value` passed in to this function has a zero-filled data array, so
   * just like for #GTypeValueInitFunc it is guaranteed to not contain any old
   * contents that might need freeing.
   *
   * The `n_collect_values` argument is the string length of the `collect_format`
   * field of #GTypeValueTable, and `collect_values` is an array of #GTypeCValue
   * with length of `n_collect_values,` containing the collected values according
   * to `collect_format`.
   *
   * The `collect_flags` argument provided as a hint by the caller. It may
   * contain the flag %G_VALUE_NOCOPY_CONTENTS indicating that the collected
   * value contents may be considered ‘static’ for the duration of the `value`
   * lifetime. Thus an extra copy of the contents stored in `collect_values` is
   * not required for assignment to `value`.
   *
   * For our above string example, we continue with:
   *
   *
   * ```c
   * if (!collect_values[0].v_pointer)
   *   value->data[0].v_pointer = g_strdup ("");
   * else if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
   *   {
   *     value->data[0].v_pointer = collect_values[0].v_pointer;
   *     // keep a flag for the value_free() implementation to not free this string
   *     value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS;
   *   }
   * else
   *   value->data[0].v_pointer = g_strdup (collect_values[0].v_pointer);
   * return NULL;
   * ```
   *
   *
   * It should be noted, that it is generally a bad idea to follow the
   * %G_VALUE_NOCOPY_CONTENTS hint for reference counted types. Due to
   * reentrancy requirements and reference count assertions performed
   * by the signal emission code, reference counts should always be
   * incremented for reference counted contents stored in the `value->data`
   * array. To deviate from our string example for a moment, and taking
   * a look at an exemplary implementation for `GTypeValueTable.collect_value()`
   * of `GObject`:
   *
   *
   * ```c
   * GObject *object = G_OBJECT (collect_values[0].v_pointer);
   * g_return_val_if_fail (object != NULL,
   *    g_strdup_printf ("Object %p passed as invalid NULL pointer", object));
   * // never honour G_VALUE_NOCOPY_CONTENTS for ref-counted types
   * value->data[0].v_pointer = g_object_ref (object);
   * return NULL;
   * ```
   *
   *
   * The reference count for valid objects is always incremented, regardless
   * of `collect_flags`. For invalid objects, the example returns a newly
   * allocated string without altering `value`.
   *
   * Upon success, `collect_value()` needs to return `NULL`. If, however,
   * an error condition occurred, `collect_value()` should return a newly
   * allocated string containing an error diagnostic.
   *
   * The calling code makes no assumptions about the `value` contents being
   * valid upon error returns, `value` is simply thrown away without further
   * freeing. As such, it is a good idea to not allocate `GValue` contents
   * prior to returning an error; however, `collect_values()` is not obliged
   * to return a correctly setup `value` for error returns, simply because
   * any non-`NULL` return is considered a fatal programming error, and
   * further program behaviour is undefined.
   * @callback
   * @param value the value to initialize
   * @param collectValues the collected values
   * @param collectFlags optional flags
   * @returns `NULL` on success, otherwise a   newly allocated error string on failure
   */
  interface TypeValueCollectFunc {
    (
      value: any,
      collectValues: TypeCValue[],
      collectFlags: number
    ): string | null
  }
  /**
   * Copies the content of a #GValue into another.
   *
   * The `dest_value` is a #GValue with zero-filled data section and `src_value`
   * is a properly initialized #GValue of same type, or derived type.
   *
   * The purpose of this function is to copy the contents of `src_value`
   * into `dest_value` in a way, that even after `src_value` has been freed, the
   * contents of `dest_value` remain valid. String type example:
   *
   *
   * ```c
   * dest_value->data[0].v_pointer = g_strdup (src_value->data[0].v_pointer);
   * ```
   *
   * @callback
   * @param srcValue the value to copy
   */
  interface TypeValueCopyFunc {
    (srcValue: any): void
  }
  /**
   * Frees any old contents that might be left in the `value->data` array of
   * the given value.
   *
   * No resources may remain allocated through the #GValue contents after this
   * function returns. E.g. for our above string type:
   *
   *
   * ```c
   * // only free strings without a specific flag for static storage
   * if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS))
   *   g_free (value->data[0].v_pointer);
   * ```
   *
   * @callback
   * @param value the value to free
   */
  interface TypeValueFreeFunc {
    (value: any): void
  }
  /**
   * Initializes the value contents by setting the fields of the `value->data`
   * array.
   *
   * The data array of the #GValue passed into this function was zero-filled
   * with `memset()`, so no care has to be taken to free any old contents.
   * For example, in the case of a string value that may never be %NULL, the
   * implementation might look like:
   *
   *
   * ```c
   * value->data[0].v_pointer = g_strdup ("");
   * ```
   *
   * @callback
   * @param value the value to initialize
   */
  interface TypeValueInitFunc {
    (value: any): void
  }
  /**
   * This function is responsible for storing the `value`
   * contents into arguments passed through a variadic argument list which
   * got collected into `collect_values` according to `lcopy_format`.
   *
   * The `n_collect_values` argument equals the string length of
   * `lcopy_format`, and `collect_flags` may contain %G_VALUE_NOCOPY_CONTENTS.
   *
   * In contrast to #GTypeValueCollectFunc, this function is obliged to always
   * properly support %G_VALUE_NOCOPY_CONTENTS.
   *
   * Similar to #GTypeValueCollectFunc the function may prematurely abort by
   * returning a newly allocated string describing an error condition. To
   * complete the string example:
   *
   *
   * ```c
   * gchar **string_p = collect_values[0].v_pointer;
   * g_return_val_if_fail (string_p != NULL,
   *   g_strdup ("string location passed as NULL"));
   *
   * if (collect_flags & G_VALUE_NOCOPY_CONTENTS)
   *   *string_p = value->data[0].v_pointer;
   * else
   *   *string_p = g_strdup (value->data[0].v_pointer);
   * ```
   *
   *
   * And an illustrative version of this function for reference-counted
   * types:
   *
   *
   * ```c
   * GObject **object_p = collect_values[0].v_pointer;
   * g_return_val_if_fail (object_p != NULL,
   *   g_strdup ("object location passed as NULL"));
   *
   * if (value->data[0].v_pointer == NULL)
   *   *object_p = NULL;
   * else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) // always honour
   *   *object_p = value->data[0].v_pointer;
   * else
   *   *object_p = g_object_ref (value->data[0].v_pointer);
   *
   * return NULL;
   * ```
   *
   * @callback
   * @param value the value to lcopy
   * @param collectValues the collected   locations for storage
   * @param collectFlags optional flags
   * @returns `NULL` on success, otherwise   a newly allocated error string on failure
   */
  interface TypeValueLCopyFunc {
    (
      value: any,
      collectValues: TypeCValue[],
      collectFlags: number
    ): string | null
  }
  /**
   * If the value contents fit into a pointer, such as objects or strings,
   * return this pointer, so the caller can peek at the current contents.
   *
   * To extend on our above string example:
   *
   *
   * ```c
   * return value->data[0].v_pointer;
   * ```
   *
   * @callback
   * @param value the value to peek
   * @returns a pointer to the value contents
   */
  interface TypeValuePeekPointerFunc {
    (value: any): any | null
  }
  /**
   * The type of value transformation functions which can be registered with
   * g_value_register_transform_func().
   *
   * `dest_value` will be initialized to the correct destination type.
   * @callback
   * @param srcValue Source value.
   * @param destValue Target value.
   */
  interface ValueTransform {
    (srcValue: any, destValue: any): void
  }
  /**
   * A #GWeakNotify function can be added to an object as a callback that gets
   * triggered when the object is finalized.
   *
   * Since the object is already being disposed when the #GWeakNotify is called,
   * there's not much you could do with the object, apart from e.g. using its
   * address as hash-index or the like.
   *
   * In particular, this means it’s invalid to call g_object_ref(),
   * g_weak_ref_init(), g_weak_ref_set(), g_object_add_toggle_ref(),
   * g_object_weak_ref(), g_object_add_weak_pointer() or any function which calls
   * them on the object from this callback.
   * @callback
   * @param data data that was provided when the weak reference was established
   * @param whereTheObjectWas the object being disposed
   */
  interface WeakNotify {
    (data: any | null, whereTheObjectWas: Object): void
  }
  module TypePlugin {
    // Constructor properties interface

    interface ConstructorProperties extends Object.ConstructorProperties {}
  }

  interface TypePlugin {
    // Own properties of GObject-2.0.GObject.TypePlugin

    __gtype__: number

    // Owm methods of GObject-2.0.GObject.TypePlugin

    /**
     * Calls the `complete_interface_info` function from the
     * #GTypePluginClass of `plugin`. There should be no need to use this
     * function outside of the GObject type system itself.
     * @param instanceType the #GType of an instantiatable type to which the interface  is added
     * @param interfaceType the #GType of the interface whose info is completed
     * @param info the #GInterfaceInfo to fill in
     */
    completeInterfaceInfo(
      instanceType: GType,
      interfaceType: GType,
      info: InterfaceInfo
    ): void
    /**
     * Calls the `complete_type_info` function from the #GTypePluginClass of `plugin`.
     * There should be no need to use this function outside of the GObject
     * type system itself.
     * @param gType the #GType whose info is completed
     * @param info the #GTypeInfo struct to fill in
     * @param valueTable the #GTypeValueTable to fill in
     */
    completeTypeInfo(
      gType: GType,
      info: TypeInfo,
      valueTable: TypeValueTable
    ): void
    /**
     * Calls the `unuse_plugin` function from the #GTypePluginClass of
     * `plugin`.  There should be no need to use this function outside of
     * the GObject type system itself.
     */
    unuse(): void
    /**
     * Calls the `use_plugin` function from the #GTypePluginClass of
     * `plugin`.  There should be no need to use this function outside of
     * the GObject type system itself.
     */
    use(): void

    // Class property signals of GObject-2.0.GObject.TypePlugin

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An interface that handles the lifecycle of dynamically loaded types.
   *
   * The GObject type system supports dynamic loading of types.
   * It goes as follows:
   *
   * 1. The type is initially introduced (usually upon loading the module
   *    the first time, or by your main application that knows what modules
   *    introduces what types), like this:
   *    ```c
   *    new_type_id = g_type_register_dynamic (parent_type_id,
   *                                           "TypeName",
   *                                           new_type_plugin,
   *                                           type_flags);
   *    ```
   *    where `new_type_plugin` is an implementation of the
   *    `GTypePlugin` interface.
   *
   * 2. The type's implementation is referenced, e.g. through
   *    [func`GObject`.TypeClass.ref] or through [func`GObject`.type_create_instance]
   *    (this is being called by [ctor`GObject`.Object.new]) or through one of the above
   *    done on a type derived from `new_type_id`.
   *
   * 3. This causes the type system to load the type's implementation by calling
   *    [method`GObject`.TypePlugin.use] and [method`GObject`.TypePlugin.complete_type_info]
   *    on `new_type_plugin`.
   *
   * 4. At some point the type's implementation isn't required anymore, e.g. after
   *    [method`GObject`.TypeClass.unref] or [func`GObject`.type_free_instance]
   *    (called when the reference count of an instance drops to zero).
   *
   * 5. This causes the type system to throw away the information retrieved
   *    from [method`GObject`.TypePlugin.complete_type_info] and then it calls
   *    [method`GObject`.TypePlugin.unuse] on `new_type_plugin`.
   *
   * 6. Things may repeat from the second step.
   *
   * So basically, you need to implement a `GTypePlugin` type that
   * carries a use_count, once use_count goes from zero to one, you need
   * to load the implementation to successfully handle the upcoming
   * [method`GObject`.TypePlugin.complete_type_info] call. Later, maybe after
   * succeeding use/unuse calls, once use_count drops to zero, you can
   * unload the implementation again. The type system makes sure to call
   * [method`GObject`.TypePlugin.use] and [method`GObject`.TypePlugin.complete_type_info]
   * again when the type is needed again.
   *
   * [class`GObject`.TypeModule] is an implementation of `GTypePlugin` that
   * already implements most of this except for the actual module loading and
   * unloading. It even handles multiple registered types per module.
   * @interface
   */
  class TypePlugin extends Object {
    // Own properties of GObject-2.0.GObject.TypePlugin

    static name: string

    // Constructors of GObject-2.0.GObject.TypePlugin

    constructor(config?: TypePlugin.ConstructorProperties)
    _init(config?: TypePlugin.ConstructorProperties): void
  }

  // See https://github.com/romgrk/node-gtk/blob/master/lib/overrides/GObject.js

  export type GType<T = unknown> = {
    __type__(arg: never): T
    name: string
  }

  // TODO: What about the generated class Closure
  export type TClosure<R = any, P = any> = (...args: P[]) => R

  export let TYPE_INVALID: 0n
  export let TYPE_NONE: GType<undefined>
  export let TYPE_INTERFACE: GType<unknown>
  export let TYPE_CHAR: GType<string>
  export let TYPE_UCHAR: GType<string>
  export let TYPE_BOOLEAN: GType<boolean>
  export let TYPE_INT: GType<number>
  export let TYPE_UINT: GType<number>
  export let TYPE_LONG: GType<number>
  export let TYPE_ULONG: GType<number>
  export let TYPE_INT64: GType<number>
  export let TYPE_UINT64: GType<number>
  export let TYPE_ENUM: GType<number>
  export let TYPE_FLAGS: GType<number>
  export let TYPE_FLOAT: GType<number>
  export let TYPE_DOUBLE: GType<number>
  export let TYPE_STRING: GType<string>
  export let TYPE_POINTER: GType<undefined>
  export let TYPE_BOXED: GType<unknown>
  export let TYPE_PARAM: GType<unknown>
  export let TYPE_OBJECT: GType<object>
  export let TYPE_GTYPE: GType<unknown>
  export let TYPE_VARIANT: GType<unknown>
  export let TYPE_UNICHAR: GType<number>

  export function typeFromName(name: "void"): typeof TYPE_INVALID
  export function typeFromName(name: "GInterface"): typeof TYPE_INTERFACE
  export function typeFromName(name: "gchar"): typeof TYPE_CHAR
  export function typeFromName(name: "guchar"): typeof TYPE_UCHAR
  export function typeFromName(name: "gboolean"): typeof TYPE_BOOLEAN
  export function typeFromName(name: "gint"): typeof TYPE_INT
  export function typeFromName(name: "guint"): typeof TYPE_UINT
  export function typeFromName(name: "glong"): typeof TYPE_LONG
  export function typeFromName(name: "gulong"): typeof TYPE_ULONG
  export function typeFromName(name: "gint64"): typeof TYPE_INT64
  export function typeFromName(name: "guint64"): typeof TYPE_UINT64
  export function typeFromName(name: "GEnum"): typeof TYPE_ENUM
  export function typeFromName(name: "GFlags"): typeof TYPE_FLAGS
  export function typeFromName(name: "gfloat"): typeof TYPE_FLOAT
  export function typeFromName(name: "gdouble"): typeof TYPE_DOUBLE
  export function typeFromName(name: "gchararray"): typeof TYPE_STRING
  export function typeFromName(name: "gpointer"): typeof TYPE_POINTER
  export function typeFromName(name: "GBoxed"): typeof TYPE_BOXED
  export function typeFromName(name: "GParam"): typeof TYPE_PARAM
  export function typeFromName(name: "GObject"): typeof TYPE_OBJECT
  export function typeFromName(name: "GType"): typeof TYPE_GTYPE
  export function typeFromName(name: "GVariant"): typeof TYPE_VARIANT

  module Binding {
    // Constructor properties interface

    interface ConstructorProperties extends Object.ConstructorProperties {
      // Own constructor properties of GObject-2.0.GObject.Binding

      /**
       * Flags to be used to control the #GBinding
       */
      flags?: BindingFlags | null
      /**
       * The #GObject that should be used as the source of the binding
       */
      source?: Object | null
      /**
       * The name of the property of #GBinding:source that should be used
       * as the source of the binding.
       *
       * This should be in [canonical form][canonical-parameter-names] to get the
       * best performance.
       */
      source_property?: string | null
      /**
       * The #GObject that should be used as the target of the binding
       */
      target?: Object | null
      /**
       * The name of the property of #GBinding:target that should be used
       * as the target of the binding.
       *
       * This should be in [canonical form][canonical-parameter-names] to get the
       * best performance.
       */
      target_property?: string | null
    }
  }

  interface Binding {
    // Own properties of GObject-2.0.GObject.Binding

    /**
     * Flags to be used to control the #GBinding
     */
    readonly flags: BindingFlags
    /**
     * The #GObject that should be used as the source of the binding
     */
    readonly source: Object
    /**
     * The name of the property of #GBinding:source that should be used
     * as the source of the binding.
     *
     * This should be in [canonical form][canonical-parameter-names] to get the
     * best performance.
     */
    readonly sourceProperty: string | null
    /**
     * The #GObject that should be used as the target of the binding
     */
    readonly target: Object
    /**
     * The name of the property of #GBinding:target that should be used
     * as the target of the binding.
     *
     * This should be in [canonical form][canonical-parameter-names] to get the
     * best performance.
     */
    readonly targetProperty: string | null
    __gtype__: number

    // Owm methods of GObject-2.0.GObject.Binding

    /**
     * Retrieves the #GObject instance used as the source of the binding.
     *
     * A #GBinding can outlive the source #GObject as the binding does not hold a
     * strong reference to the source. If the source is destroyed before the
     * binding then this function will return %NULL.
     * @returns the source #GObject, or %NULL if the     source does not exist any more.
     */
    dupSource(): Object | null
    /**
     * Retrieves the #GObject instance used as the target of the binding.
     *
     * A #GBinding can outlive the target #GObject as the binding does not hold a
     * strong reference to the target. If the target is destroyed before the
     * binding then this function will return %NULL.
     * @returns the target #GObject, or %NULL if the     target does not exist any more.
     */
    dupTarget(): Object | null
    /**
     * Retrieves the flags passed when constructing the #GBinding.
     * @returns the #GBindingFlags used by the #GBinding
     */
    getFlags(): BindingFlags
    /**
     * Retrieves the #GObject instance used as the source of the binding.
     *
     * A #GBinding can outlive the source #GObject as the binding does not hold a
     * strong reference to the source. If the source is destroyed before the
     * binding then this function will return %NULL.
     *
     * Use g_binding_dup_source() if the source or binding are used from different
     * threads as otherwise the pointer returned from this function might become
     * invalid if the source is finalized from another thread in the meantime.
     * @returns the source #GObject, or %NULL if the     source does not exist any more.
     */
    getSource(): Object | null
    /**
     * Retrieves the name of the property of #GBinding:source used as the source
     * of the binding.
     * @returns the name of the source property
     */
    getSourceProperty(): string
    /**
     * Retrieves the #GObject instance used as the target of the binding.
     *
     * A #GBinding can outlive the target #GObject as the binding does not hold a
     * strong reference to the target. If the target is destroyed before the
     * binding then this function will return %NULL.
     *
     * Use g_binding_dup_target() if the target or binding are used from different
     * threads as otherwise the pointer returned from this function might become
     * invalid if the target is finalized from another thread in the meantime.
     * @returns the target #GObject, or %NULL if the     target does not exist any more.
     */
    getTarget(): Object | null
    /**
     * Retrieves the name of the property of #GBinding:target used as the target
     * of the binding.
     * @returns the name of the target property
     */
    getTargetProperty(): string
    /**
     * Explicitly releases the binding between the source and the target
     * property expressed by `binding`.
     *
     * This function will release the reference that is being held on
     * the `binding` instance if the binding is still bound; if you want to hold on
     * to the #GBinding instance after calling g_binding_unbind(), you will need
     * to hold a reference to it.
     *
     * Note however that this function does not take ownership of `binding,` it
     * only unrefs the reference that was initially created by
     * g_object_bind_property() and is owned by the binding.
     */
    unbind(): void

    // Class property signals of GObject-2.0.GObject.Binding

    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::source", ...args: any[]): void
    connect(
      sigName: "notify::source-property",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::source-property",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::source-property",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::source-property",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::source-property", ...args: any[]): void
    connect(
      sigName: "notify::target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::target", ...args: any[]): void
    connect(
      sigName: "notify::target-property",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::target-property",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::target-property",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::target-property",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::target-property", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GObject` instance (or source) and another property on another `GObject`
   * instance (or target).
   *
   * Whenever the source property changes, the same value is applied to the
   * target property; for instance, the following binding:
   *
   * ```c
   *   g_object_bind_property (object1, "property-a",
   *                           object2, "property-b",
   *                           G_BINDING_DEFAULT);
   * ```
   *
   * will cause the property named "property-b" of `object2` to be updated
   * every time [method`GObject`.set] or the specific accessor changes the value of
   * the property "property-a" of `object1`.
   *
   * It is possible to create a bidirectional binding between two properties
   * of two `GObject` instances, so that if either property changes, the
   * other is updated as well, for instance:
   *
   * ```c
   *   g_object_bind_property (object1, "property-a",
   *                           object2, "property-b",
   *                           G_BINDING_BIDIRECTIONAL);
   * ```
   *
   * will keep the two properties in sync.
   *
   * It is also possible to set a custom transformation function (in both
   * directions, in case of a bidirectional binding) to apply a custom
   * transformation from the source value to the target value before
   * applying it; for instance, the following binding:
   *
   * ```c
   *   g_object_bind_property_full (adjustment1, "value",
   *                                adjustment2, "value",
   *                                G_BINDING_BIDIRECTIONAL,
   *                                celsius_to_fahrenheit,
   *                                fahrenheit_to_celsius,
   *                                NULL, NULL);
   * ```
   *
   * will keep the "value" property of the two adjustments in sync; the
   * `celsius_to_fahrenheit` function will be called whenever the "value"
   * property of `adjustment1` changes and will transform the current value
   * of the property before applying it to the "value" property of `adjustment2`.
   *
   * Vice versa, the `fahrenheit_to_celsius` function will be called whenever
   * the "value" property of `adjustment2` changes, and will transform the
   * current value of the property before applying it to the "value" property
   * of `adjustment1`.
   *
   * Note that #GBinding does not resolve cycles by itself; a cycle like
   *
   * ```
   *   object1:propertyA -> object2:propertyB
   *   object2:propertyB -> object3:propertyC
   *   object3:propertyC -> object1:propertyA
   * ```
   *
   * might lead to an infinite loop. The loop, in this particular case,
   * can be avoided if the objects emit the `GObject::notify` signal only
   * if the value has effectively been changed. A binding is implemented
   * using the `GObject::notify` signal, so it is susceptible to all the
   * various ways of blocking a signal emission, like [func`GObject`.signal_stop_emission]
   * or [func`GObject`.signal_handler_block].
   *
   * A binding will be severed, and the resources it allocates freed, whenever
   * either one of the `GObject` instances it refers to are finalized, or when
   * the #GBinding instance loses its last reference.
   *
   * Bindings for languages with garbage collection can use
   * [method`GObject`.Binding.unbind] to explicitly release a binding between the source
   * and target properties, instead of relying on the last reference on the
   * binding, source, and target instances to drop.
   * @class
   */
  class Binding extends Object {
    // Own properties of GObject-2.0.GObject.Binding

    static name: string

    // Constructors of GObject-2.0.GObject.Binding

    constructor(config?: Binding.ConstructorProperties)
    _init(config?: Binding.ConstructorProperties): void
  }

  module BindingGroup {
    // Constructor properties interface

    interface ConstructorProperties extends Object.ConstructorProperties {
      // Own constructor properties of GObject-2.0.GObject.BindingGroup

      /**
       * The source object used for binding properties.
       */
      source?: Object | null
    }
  }

  interface BindingGroup {
    // Own properties of GObject-2.0.GObject.BindingGroup

    /**
     * The source object used for binding properties.
     */
    source: Object
    __gtype__: number

    // Owm methods of GObject-2.0.GObject.BindingGroup

    /**
     * Creates a binding between `source_property` on the source object
     * and `target_property` on `target`. Whenever the `source_property`
     * is changed the `target_property` is updated using the same value.
     * The binding flag %G_BINDING_SYNC_CREATE is automatically specified.
     *
     * See g_object_bind_property() for more information.
     * @param sourceProperty the property on the source to bind
     * @param target the target #GObject
     * @param targetProperty the property on `target` to bind
     * @param flags the flags used to create the #GBinding
     */
    bind(
      sourceProperty: string,
      target: Object,
      targetProperty: string,
      flags: BindingFlags
    ): void
    /**
     * Creates a binding between `source_property` on the source object and
     * `target_property` on `target,` allowing you to set the transformation
     * functions to be used by the binding. The binding flag
     * %G_BINDING_SYNC_CREATE is automatically specified.
     *
     * This function is the language bindings friendly version of
     * g_binding_group_bind_property_full(), using #GClosures
     * instead of function pointers.
     *
     * See g_object_bind_property_with_closures() for more information.
     * @param sourceProperty the property on the source to bind
     * @param target the target #GObject
     * @param targetProperty the property on `target` to bind
     * @param flags the flags used to create the #GBinding
     * @param transformTo a #GClosure wrapping the     transformation function from the source object to the `target,`     or %NULL to use the default
     * @param transformFrom a #GClosure wrapping the     transformation function from the `target` to the source object,     or %NULL to use the default
     */
    bindFull(
      sourceProperty: string,
      target: Object,
      targetProperty: string,
      flags: BindingFlags,
      transformTo: TClosure | null,
      transformFrom: TClosure | null
    ): void
    /**
     * Gets the source object used for binding properties.
     * @returns a #GObject or %NULL.
     */
    dupSource(): Object | null
    /**
     * Sets `source` as the source object used for creating property
     * bindings. If there is already a source object all bindings from it
     * will be removed.
     *
     * Note that all properties that have been bound must exist on `source`.
     * @param source the source #GObject,   or %NULL to clear it
     */
    setSource(source: Object | null): void

    // Class property signals of GObject-2.0.GObject.BindingGroup

    connect(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::source", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GBindingGroup` can be used to bind multiple properties
   * from an object collectively.
   *
   * Use the various methods to bind properties from a single source
   * object to multiple destination objects. Properties can be bound
   * bidirectionally and are connected when the source object is set
   * with [method`GObject`.BindingGroup.set_source].
   * @class
   */
  class BindingGroup extends Object {
    // Own properties of GObject-2.0.GObject.BindingGroup

    static name: string

    // Constructors of GObject-2.0.GObject.BindingGroup

    constructor(config?: BindingGroup.ConstructorProperties)
    /**
     * Creates a new #GBindingGroup.
     * @constructor
     * @returns a new #GBindingGroup
     */
    constructor()
    /**
     * Creates a new #GBindingGroup.
     * @constructor
     * @returns a new #GBindingGroup
     */
    static new(): BindingGroup
    _init(config?: BindingGroup.ConstructorProperties): void
  }

  module InitiallyUnowned {
    // Constructor properties interface

    interface ConstructorProperties extends Object.ConstructorProperties {}
  }

  interface InitiallyUnowned {
    // Own properties of GObject-2.0.GObject.InitiallyUnowned

    __gtype__: number

    // Own fields of GObject-2.0.GObject.InitiallyUnowned

    gTypeInstance: TypeInstance

    // Class property signals of GObject-2.0.GObject.InitiallyUnowned

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A type for objects that have an initially floating reference.
   *
   * All the fields in the `GInitiallyUnowned` structure are private to the
   * implementation and should never be accessed directly.
   * @class
   */
  class InitiallyUnowned extends Object {
    // Own properties of GObject-2.0.GObject.InitiallyUnowned

    static name: string

    // Constructors of GObject-2.0.GObject.InitiallyUnowned

    constructor(config?: InitiallyUnowned.ConstructorProperties)
    _init(config?: InitiallyUnowned.ConstructorProperties): void
  }

  module Object {
    // Signal callback interfaces

    /**
     * Signal callback interface for `notify`
     */
    interface NotifySignalCallback {
      (pspec: ParamSpec): void
    }

    // Constructor properties interface

    interface ConstructorProperties {}
  }

  interface Object {
    // Own properties of GObject-2.0.GObject.Object

    __gtype__: number

    // Own fields of GObject-2.0.GObject.Object

    gTypeInstance: TypeInstance

    // Owm methods of GObject-2.0.GObject.Object

    /**
     * Creates a binding between `source_property` on `source` and `target_property`
     * on `target`.
     *
     * Whenever the `source_property` is changed the `target_property` is
     * updated using the same value. For instance:
     *
     *
     * ```c
     *   g_object_bind_property (action, "active", widget, "sensitive", 0);
     * ```
     *
     *
     * Will result in the "sensitive" property of the widget #GObject instance to be
     * updated with the same value of the "active" property of the action #GObject
     * instance.
     *
     * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
     * if `target_property` on `target` changes then the `source_property` on `source`
     * will be updated as well.
     *
     * The binding will automatically be removed when either the `source` or the
     * `target` instances are finalized. To remove the binding without affecting the
     * `source` and the `target` you can just call g_object_unref() on the returned
     * #GBinding instance.
     *
     * Removing the binding by calling g_object_unref() on it must only be done if
     * the binding, `source` and `target` are only used from a single thread and it
     * is clear that both `source` and `target` outlive the binding. Especially it
     * is not safe to rely on this if the binding, `source` or `target` can be
     * finalized from different threads. Keep another reference to the binding and
     * use g_binding_unbind() instead to be on the safe side.
     *
     * A #GObject can have multiple bindings.
     * @param sourceProperty the property on `source` to bind
     * @param target the target #GObject
     * @param targetProperty the property on `target` to bind
     * @param flags flags to pass to #GBinding
     * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
     */
    bindProperty(
      sourceProperty: string,
      target: Object,
      targetProperty: string,
      flags: BindingFlags
    ): Binding
    /**
     * Creates a binding between `source_property` on `source` and `target_property`
     * on `target,` allowing you to set the transformation functions to be used by
     * the binding.
     *
     * This function is the language bindings friendly version of
     * g_object_bind_property_full(), using #GClosures instead of
     * function pointers.
     * @param sourceProperty the property on `source` to bind
     * @param target the target #GObject
     * @param targetProperty the property on `target` to bind
     * @param flags flags to pass to #GBinding
     * @param transformTo a #GClosure wrapping the transformation function     from the `source` to the `target,` or %NULL to use the default
     * @param transformFrom a #GClosure wrapping the transformation function     from the `target` to the `source,` or %NULL to use the default
     * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
     */
    bindPropertyFull(
      sourceProperty: string,
      target: Object,
      targetProperty: string,
      flags: BindingFlags,
      transformTo: TClosure,
      transformFrom: TClosure
    ): Binding
    /**
     * This function is intended for #GObject implementations to re-enforce
     * a [floating][floating-ref] object reference. Doing this is seldom
     * required: all #GInitiallyUnowneds are created with a floating reference
     * which usually just needs to be sunken by calling g_object_ref_sink().
     */
    forceFloating(): void
    /**
     * Increases the freeze count on `object`. If the freeze count is
     * non-zero, the emission of "notify" signals on `object` is
     * stopped. The signals are queued until the freeze count is decreased
     * to zero. Duplicate notifications are squashed so that at most one
     * #GObject::notify signal is emitted for each property modified while the
     * object is frozen.
     *
     * This is necessary for accessors that modify multiple properties to prevent
     * premature notification while the object is still being modified.
     */
    freezeNotify(): void
    /**
     * Gets a named field from the objects table of associations (see g_object_set_data()).
     * @param key name of the key for that association
     * @returns the data if found,          or %NULL if no such data exists.
     */
    getData(key: string): any | null
    // Has conflict: getProperty(propertyName: string, value: any): void
    /**
     * This function gets back user data pointers stored via
     * g_object_set_qdata().
     * @param quark A #GQuark, naming the user data pointer
     * @returns The user data pointer set, or %NULL
     */
    getQdata(quark: GLib.Quark): any | null
    /**
     * Gets `n_properties` properties for an `object`.
     * Obtained properties will be set to `values`. All properties must be valid.
     * Warnings will be emitted and undefined behaviour may result if invalid
     * properties are passed in.
     * @param names the names of each property to get
     * @param values the values of each property to get
     */
    getv(names: string[], values: any[]): void
    /**
     * Checks whether `object` has a [floating][floating-ref] reference.
     * @returns %TRUE if @object has a floating reference
     */
    isFloating(): boolean
    // Has conflict: notify(propertyName: string): void
    /**
     * Emits a "notify" signal for the property specified by `pspec` on `object`.
     *
     * This function omits the property name lookup, hence it is faster than
     * g_object_notify().
     *
     * One way to avoid using g_object_notify() from within the
     * class that registered the properties, and using g_object_notify_by_pspec()
     * instead, is to store the GParamSpec used with
     * g_object_class_install_property() inside a static array, e.g.:
     *
     *
     * ```c
     *   typedef enum
     *   {
     *     PROP_FOO = 1,
     *     PROP_LAST
     *   } MyObjectProperty;
     *
     *   static GParamSpec *properties[PROP_LAST];
     *
     *   static void
     *   my_object_class_init (MyObjectClass *klass)
     *   {
     *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
     *                                              0, 100,
     *                                              50,
     *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
     *     g_object_class_install_property (gobject_class,
     *                                      PROP_FOO,
     *                                      properties[PROP_FOO]);
     *   }
     * ```
     *
     *
     * and then notify a change on the "foo" property with:
     *
     *
     * ```c
     *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
     * ```
     *
     * @param pspec the #GParamSpec of a property installed on the class of `object`.
     */
    notifyByPspec(pspec: ParamSpec): void
    /**
     * Increases the reference count of `object`.
     *
     * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
     * of `object` will be propagated to the return type (using the GCC typeof()
     * extension), so any casting the caller needs to do on the return type must be
     * explicit.
     * @returns the same @object
     */
    ref(): Object
    /**
     * Increase the reference count of `object,` and possibly remove the
     * [floating][floating-ref] reference, if `object` has a floating reference.
     *
     * In other words, if the object is floating, then this call "assumes
     * ownership" of the floating reference, converting it to a normal
     * reference by clearing the floating flag while leaving the reference
     * count unchanged.  If the object is not floating, then this call
     * adds a new normal reference increasing the reference count by one.
     *
     * Since GLib 2.56, the type of `object` will be propagated to the return type
     * under the same conditions as for g_object_ref().
     * @returns @object
     */
    refSink(): Object
    /**
     * Releases all references to other objects. This can be used to break
     * reference cycles.
     *
     * This function should only be called from object system implementations.
     */
    runDispose(): void
    /**
     * Each object carries around a table of associations from
     * strings to pointers.  This function lets you set an association.
     *
     * If the object already had an association with that name,
     * the old association will be destroyed.
     *
     * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
     * This means a copy of `key` is kept permanently (even after `object` has been
     * finalized) — so it is recommended to only use a small, bounded set of values
     * for `key` in your program, to avoid the #GQuark storage growing unbounded.
     * @param key name of the key
     * @param data data to associate with that key
     */
    setData(key: string, data: any | null): void
    // Has conflict: setProperty(propertyName: string, value: any): void
    /**
     * Remove a specified datum from the object's data associations,
     * without invoking the association's destroy handler.
     * @param key name of the key
     * @returns the data if found, or %NULL          if no such data exists.
     */
    stealData(key: string): any | null
    /**
     * This function gets back user data pointers stored via
     * g_object_set_qdata() and removes the `data` from object
     * without invoking its destroy() function (if any was
     * set).
     * Usually, calling this function is only required to update
     * user data pointers with a destroy notifier, for example:
     *
     * ```c
     * void
     * object_add_to_user_list (GObject     *object,
     *                          const gchar *new_string)
     * {
     *   // the quark, naming the object data
     *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
     *   // retrieve the old string list
     *   GList *list = g_object_steal_qdata (object, quark_string_list);
     *
     *   // prepend new string
     *   list = g_list_prepend (list, g_strdup (new_string));
     *   // this changed 'list', so we need to set it again
     *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
     * }
     * static void
     * free_string_list (gpointer data)
     * {
     *   GList *node, *list = data;
     *
     *   for (node = list; node; node = node->next)
     *     g_free (node->data);
     *   g_list_free (list);
     * }
     * ```
     *
     * Using g_object_get_qdata() in the above example, instead of
     * g_object_steal_qdata() would have left the destroy function set,
     * and thus the partial string list would have been freed upon
     * g_object_set_qdata_full().
     * @param quark A #GQuark, naming the user data pointer
     * @returns The user data pointer set, or %NULL
     */
    stealQdata(quark: GLib.Quark): any | null
    /**
     * Reverts the effect of a previous call to
     * g_object_freeze_notify(). The freeze count is decreased on `object`
     * and when it reaches zero, queued "notify" signals are emitted.
     *
     * Duplicate notifications for each property are squashed so that at most one
     * #GObject::notify signal is emitted for each property, in the reverse order
     * in which they have been queued.
     *
     * It is an error to call this function when the freeze count is zero.
     */
    thawNotify(): void
    /**
     * Decreases the reference count of `object`. When its reference count
     * drops to 0, the object is finalized (i.e. its memory is freed).
     *
     * If the pointer to the #GObject may be reused in future (for example, if it is
     * an instance variable of another object), it is recommended to clear the
     * pointer to %NULL rather than retain a dangling pointer to a potentially
     * invalid #GObject instance. Use g_clear_object() for this.
     */
    unref(): void
    /**
     * This function essentially limits the life time of the `closure` to
     * the life time of the object. That is, when the object is finalized,
     * the `closure` is invalidated by calling g_closure_invalidate() on
     * it, in order to prevent invocations of the closure with a finalized
     * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
     * added as marshal guards to the `closure,` to ensure that an extra
     * reference count is held on `object` during invocation of the
     * `closure`.  Usually, this function will be called on closures that
     * use this `object` as closure data.
     * @param closure #GClosure to watch
     */
    watchClosure(closure: TClosure): void
    /**
     * Sets a property on an object.
     * @param propertyName the name of the property to set
     * @param value the value
     */
    setProperty<T = any>(propertyName: string, value: T): void
    /**
     * Gets a property of an object.
     *
     * The `value` can be:
     *
     *  - an empty #GValue initialized by %G_VALUE_INIT, which will be
     *    automatically initialized with the expected type of the property
     *    (since GLib 2.60)
     *  - a #GValue initialized with the expected type of the property
     *  - a #GValue initialized with a type to which the expected type
     *    of the property can be transformed
     *
     * In general, a copy is made of the property contents and the caller is
     * responsible for freeing the memory by calling g_value_unset().
     *
     * Note that g_object_get_property() is really intended for language
     * bindings, g_object_get() is much more convenient for C programming.
     * @param propertyName the name of the property to get
     * @param value return location for the property value
     */
    getProperty<T = unknown>(propertyName: string): T

    // Own virtual methods of GObject-2.0.GObject.Object

    /**
     * the `constructed` function is called by g_object_new() as the
     *  final step of the object creation process.  At the point of the call, all
     *  construction properties have been set on the object.  The purpose of this
     *  call is to allow for object initialisation steps that can only be performed
     *  after construction properties have been set.  `constructed` implementors
     *  should chain up to the `constructed` call of their parent class to allow it
     *  to complete its initialisation.
     * @virtual
     */
    constructed(): void
    /**
     * emits property change notification for a bunch
     *  of properties. Overriding `dispatch_properties_changed` should be rarely
     *  needed.
     * @virtual
     * @param nPspecs
     * @param pspecs
     */
    dispatchPropertiesChanged(nPspecs: number, pspecs: ParamSpec): void
    /**
     * the `dispose` function is supposed to drop all references to other
     *  objects, but keep the instance otherwise intact, so that client method
     *  invocations still work. It may be run multiple times (due to reference
     *  loops). Before returning, `dispose` should chain up to the `dispose` method
     *  of the parent class.
     * @virtual
     */
    dispose(): void
    /**
     * instance finalization function, should finish the finalization of
     *  the instance begun in `dispose` and chain up to the `finalize` method of the
     *  parent class.
     * @virtual
     */
    finalize(): void
    // Has conflict: getProperty(propertyId: number, value: any, pspec: ParamSpec): void
    /**
     * Emits a "notify" signal for the property `property_name` on `object`.
     *
     * When possible, eg. when signaling a property change from within the class
     * that registered the property, you should use g_object_notify_by_pspec()
     * instead.
     *
     * Note that emission of the notify signal may be blocked with
     * g_object_freeze_notify(). In this case, the signal emissions are queued
     * and will be emitted (in reverse order) when g_object_thaw_notify() is
     * called.
     * @virtual
     * @param pspec
     */
    notify(pspec: ParamSpec): void
    // Has conflict: setProperty(propertyId: number, value: any, pspec: ParamSpec): void

    // Own signals of GObject-2.0.GObject.Object

    connect(sigName: "notify", callback: Object.NotifySignalCallback): number
    on(
      sigName: "notify",
      callback: Object.NotifySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify",
      callback: Object.NotifySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify",
      callback: Object.NotifySignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "notify", ...args: any[]): void

    // Class property signals of GObject-2.0.GObject.Object

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The base object type.
   *
   * `GObject` is the fundamental type providing the common attributes and
   * methods for all object types in GTK, Pango and other libraries
   * based on GObject. The `GObject` class provides methods for object
   * construction and destruction, property access methods, and signal
   * support. Signals are described in detail [here][gobject-Signals].
   *
   * For a tutorial on implementing a new `GObject` class, see [How to define and
   * implement a new GObject](tutorial.html#how-to-define-and-implement-a-new-gobject).
   * For a list of naming conventions for GObjects and their methods, see the
   * [GType conventions](concepts.html#conventions). For the high-level concepts
   * behind GObject, read
   * [Instantiatable classed types: Objects](concepts.html#instantiatable-classed-types-objects).
   *
   * Since GLib 2.72, all `GObject`s are guaranteed to be aligned to at least the
   * alignment of the largest basic GLib type (typically this is `guint64` or
   * `gdouble`). If you need larger alignment for an element in a `GObject`, you
   * should allocate it on the heap (aligned), or arrange for your `GObject` to be
   * appropriately padded. This guarantee applies to the `GObject` (or derived)
   * struct, the `GObjectClass` (or derived) struct, and any private data allocated
   * by `G_ADD_PRIVATE()`.
   * @class
   */
  class Object {
    // Own properties of GObject-2.0.GObject.Object

    static name: string

    // Constructors of GObject-2.0.GObject.Object

    constructor(config?: Object.ConstructorProperties)
    /**
     * Creates a new instance of a #GObject subtype and sets its properties.
     *
     * Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY)
     * which are not explicitly specified are set to their default values.
     * @constructor
     * @param objectType the type id of the #GObject subtype to instantiate
     * @param parameters an array of #GParameter
     * @returns a new instance of @object_type
     */
    static newv(objectType: GType, parameters: Parameter[]): Object
    _init(config?: Object.ConstructorProperties): void
    static compatControl(what: number, data: any | null): number
    /**
     * Find the #GParamSpec with the given name for an
     * interface. Generally, the interface vtable passed in as `g_iface`
     * will be the default vtable from g_type_default_interface_ref(), or,
     * if you know the interface has already been loaded,
     * g_type_default_interface_peek().
     * @param gIface any interface vtable for the  interface, or the default vtable for the interface
     * @param propertyName name of a property to look up.
     * @returns the #GParamSpec for the property of the          interface with the name @property_name, or %NULL if no          such property exists.
     */
    static interfaceFindProperty(
      gIface: TypeInterface,
      propertyName: string
    ): ParamSpec
    /**
     * Add a property to an interface; this is only useful for interfaces
     * that are added to GObject-derived types. Adding a property to an
     * interface forces all objects classes with that interface to have a
     * compatible property. The compatible property could be a newly
     * created #GParamSpec, but normally
     * g_object_class_override_property() will be used so that the object
     * class only needs to provide an implementation and inherits the
     * property description, default value, bounds, and so forth from the
     * interface property.
     *
     * This function is meant to be called from the interface's default
     * vtable initialization function (the `class_init` member of
     * #GTypeInfo.) It must not be called after after `class_init` has
     * been called for any object types implementing this interface.
     *
     * If `pspec` is a floating reference, it will be consumed.
     * @param gIface any interface vtable for the    interface, or the default  vtable for the interface.
     * @param pspec the #GParamSpec for the new property
     */
    static interfaceInstallProperty(
      gIface: TypeInterface,
      pspec: ParamSpec
    ): void
    /**
     * Lists the properties of an interface.Generally, the interface
     * vtable passed in as `g_iface` will be the default vtable from
     * g_type_default_interface_ref(), or, if you know the interface has
     * already been loaded, g_type_default_interface_peek().
     * @param gIface any interface vtable for the  interface, or the default vtable for the interface
     * @returns a   pointer to an array of pointers to #GParamSpec   structures. The paramspecs are owned by GLib, but the   array should be freed with g_free() when you are done with   it.
     */
    static interfaceListProperties(gIface: TypeInterface): ParamSpec[]
  }

  interface ParamSpec {
    // Own fields of GObject-2.0.GObject.ParamSpec

    /**
     * private `GTypeInstance` portion
     * @field
     */
    gTypeInstance: TypeInstance
    /**
     * name of this parameter: always an interned string
     * @field
     */
    name: string
    /**
     * `GParamFlags` flags for this parameter
     * @field
     */
    flags: ParamFlags
    /**
     * the `GValue` type for this parameter
     * @field
     */
    valueType: GType
    /**
     * `GType` type that uses (introduces) this parameter
     * @field
     */
    ownerType: GType

    // Owm methods of GObject-2.0.GObject.ParamSpec

    /**
     * Get the short description of a #GParamSpec.
     * @returns the short description of @pspec.
     */
    getBlurb(): string | null
    /**
     * Gets the default value of `pspec` as a pointer to a #GValue.
     *
     * The #GValue will remain valid for the life of `pspec`.
     * @returns a pointer to a #GValue which must not be modified
     */
    getDefaultValue(): any
    /**
     * Get the name of a #GParamSpec.
     *
     * The name is always an "interned" string (as per g_intern_string()).
     * This allows for pointer-value comparisons.
     * @returns the name of @pspec.
     */
    getName(): string
    /**
     * Gets the GQuark for the name.
     * @returns the GQuark for @pspec->name.
     */
    getNameQuark(): GLib.Quark
    /**
     * Get the nickname of a #GParamSpec.
     * @returns the nickname of @pspec.
     */
    getNick(): string
    /**
     * Gets back user data pointers stored via g_param_spec_set_qdata().
     * @param quark a #GQuark, naming the user data pointer
     * @returns the user data pointer set, or %NULL
     */
    getQdata(quark: GLib.Quark): any | null
    /**
     * If the paramspec redirects operations to another paramspec,
     * returns that paramspec. Redirect is used typically for
     * providing a new implementation of a property in a derived
     * type while preserving all the properties from the parent
     * type. Redirection is established by creating a property
     * of type #GParamSpecOverride. See g_object_class_override_property()
     * for an example of the use of this capability.
     * @returns paramspec to which requests on this          paramspec should be redirected, or %NULL if none.
     */
    getRedirectTarget(): ParamSpec | null
    /**
     * Sets an opaque, named pointer on a #GParamSpec. The name is
     * specified through a #GQuark (retrieved e.g. via
     * g_quark_from_static_string()), and the pointer can be gotten back
     * from the `pspec` with g_param_spec_get_qdata().  Setting a
     * previously set user data pointer, overrides (frees) the old pointer
     * set, using %NULL as pointer essentially removes the data stored.
     * @param quark a #GQuark, naming the user data pointer
     * @param data an opaque user data pointer
     */
    setQdata(quark: GLib.Quark, data: any | null): void
    /**
     * The initial reference count of a newly created #GParamSpec is 1,
     * even though no one has explicitly called g_param_spec_ref() on it
     * yet. So the initial reference count is flagged as "floating", until
     * someone calls `g_param_spec_ref (pspec); g_param_spec_sink
     * (pspec);` in sequence on it, taking over the initial
     * reference count (thus ending up with a `pspec` that has a reference
     * count of 1 still, but is not flagged "floating" anymore).
     */
    sink(): void
    /**
     * Gets back user data pointers stored via g_param_spec_set_qdata()
     * and removes the `data` from `pspec` without invoking its destroy()
     * function (if any was set).  Usually, calling this function is only
     * required to update user data pointers with a destroy notifier.
     * @param quark a #GQuark, naming the user data pointer
     * @returns the user data pointer set, or %NULL
     */
    stealQdata(quark: GLib.Quark): any | null

    // Own virtual methods of GObject-2.0.GObject.ParamSpec

    /**
     * The instance finalization function (optional), should chain
     *  up to the finalize method of the parent class.
     * @virtual
     */
    finalize(): void
    /**
     * Checks if contents of `value` comply with the specifications
     *   set out by this type, without modifying the value. This vfunc is optional.
     *   If it isn't set, GObject will use `value_validate`. Since 2.74
     * @virtual
     * @param value
     */
    valueIsValid(value: any): boolean
    /**
     * Resets a `value` to the default value for this type
     *  (recommended, the default is g_value_reset()), see
     *  g_param_value_set_default().
     * @virtual
     * @param value
     */
    valueSetDefault(value: any): void
    /**
     * Ensures that the contents of `value` comply with the
     *  specifications set out by this type (optional), see
     *  g_param_value_validate().
     * @virtual
     * @param value
     */
    valueValidate(value: any): boolean
    /**
     * Compares `value1` with `value2` according to this type
     *  (recommended, the default is memcmp()), see g_param_values_cmp().
     * @virtual
     * @param value1
     * @param value2
     */
    valuesCmp(value1: any, value2: any): number
  }

  /**
   * `GParamSpec` encapsulates the metadata required to specify parameters, such as `GObject` properties.
   *
   * ## Parameter names
   *
   * A property name consists of one or more segments consisting of ASCII letters
   * and digits, separated by either the `-` or `_` character. The first
   * character of a property name must be a letter. These are the same rules as
   * for signal naming (see [func`GObject`.signal_new]).
   *
   * When creating and looking up a `GParamSpec`, either separator can be
   * used, but they cannot be mixed. Using `-` is considerably more
   * efficient, and is the ‘canonical form’. Using `_` is discouraged.
   * @class
   */
  class ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpec

    static name: string

    // Constructors of GObject-2.0.GObject.ParamSpec

    /**
     * Validate a property name for a #GParamSpec. This can be useful for
     * dynamically-generated properties which need to be validated at run-time
     * before actually trying to create them.
     *
     * See [canonical parameter names][canonical-parameter-names] for details of
     * the rules for valid names.
     * @param name the canonical name of the property
     * @returns %TRUE if @name is a valid property name, %FALSE otherwise.
     */
    static isValidName(name: string): boolean
  }

  interface ParamSpecBoolean {
    // Own fields of GObject-2.0.GObject.ParamSpecBoolean

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: boolean
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for boolean properties.
   * @class
   */
  class ParamSpecBoolean extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecBoolean

    static name: string
  }

  interface ParamSpecBoxed {
    // Own fields of GObject-2.0.GObject.ParamSpecBoxed

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for boxed properties.
   * @class
   */
  class ParamSpecBoxed extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecBoxed

    static name: string
  }

  interface ParamSpecChar {
    // Own fields of GObject-2.0.GObject.ParamSpecChar

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for character properties.
   * @class
   */
  class ParamSpecChar extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecChar

    static name: string
  }

  interface ParamSpecDouble {
    // Own fields of GObject-2.0.GObject.ParamSpecDouble

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
    /**
     * values closer than `epsilon` will be considered identical
     *  by g_param_values_cmp(); the default value is 1e-90.
     * @field
     */
    epsilon: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for double properties.
   * @class
   */
  class ParamSpecDouble extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecDouble

    static name: string
  }

  interface ParamSpecEnum {
    // Own fields of GObject-2.0.GObject.ParamSpecEnum

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * the #GEnumClass for the enum
     * @field
     */
    enumClass: EnumClass
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for enum
   * properties.
   * @class
   */
  class ParamSpecEnum extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecEnum

    static name: string
  }

  interface ParamSpecFlags {
    // Own fields of GObject-2.0.GObject.ParamSpecFlags

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * the #GFlagsClass for the flags
     * @field
     */
    flagsClass: FlagsClass
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for flags
   * properties.
   * @class
   */
  class ParamSpecFlags extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecFlags

    static name: string
  }

  interface ParamSpecFloat {
    // Own fields of GObject-2.0.GObject.ParamSpecFloat

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
    /**
     * values closer than `epsilon` will be considered identical
     *  by g_param_values_cmp(); the default value is 1e-30.
     * @field
     */
    epsilon: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for float properties.
   * @class
   */
  class ParamSpecFloat extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecFloat

    static name: string
  }

  interface ParamSpecGType {
    // Own fields of GObject-2.0.GObject.ParamSpecGType

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * a #GType whose subtypes can occur as values
     * @field
     */
    isAType: GType
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for #GType properties.
   * @class
   */
  class ParamSpecGType extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecGType

    static name: string
  }

  interface ParamSpecInt {
    // Own fields of GObject-2.0.GObject.ParamSpecInt

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for integer properties.
   * @class
   */
  class ParamSpecInt extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecInt

    static name: string
  }

  interface ParamSpecInt64 {
    // Own fields of GObject-2.0.GObject.ParamSpecInt64

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for 64bit integer properties.
   * @class
   */
  class ParamSpecInt64 extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecInt64

    static name: string
  }

  interface ParamSpecLong {
    // Own fields of GObject-2.0.GObject.ParamSpecLong

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for long integer properties.
   * @class
   */
  class ParamSpecLong extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecLong

    static name: string
  }

  interface ParamSpecObject {
    // Own fields of GObject-2.0.GObject.ParamSpecObject

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for object properties.
   * @class
   */
  class ParamSpecObject extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecObject

    static name: string
  }

  interface ParamSpecOverride {}

  /**
   * A #GParamSpec derived structure that redirects operations to
   * other types of #GParamSpec.
   *
   * All operations other than getting or setting the value are redirected,
   * including accessing the nick and blurb, validating a value, and so
   * forth.
   *
   * See g_param_spec_get_redirect_target() for retrieving the overridden
   * property. #GParamSpecOverride is used in implementing
   * g_object_class_override_property(), and will not be directly useful
   * unless you are implementing a new base type similar to GObject.
   * @class
   */
  class ParamSpecOverride extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecOverride

    static name: string
  }

  interface ParamSpecParam {
    // Own fields of GObject-2.0.GObject.ParamSpecParam

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for %G_TYPE_PARAM
   * properties.
   * @class
   */
  class ParamSpecParam extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecParam

    static name: string
  }

  interface ParamSpecPointer {
    // Own fields of GObject-2.0.GObject.ParamSpecPointer

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for pointer properties.
   * @class
   */
  class ParamSpecPointer extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecPointer

    static name: string
  }

  interface ParamSpecString {
    // Own fields of GObject-2.0.GObject.ParamSpecString

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: string | null
    /**
     * a string containing the allowed values for the first byte
     * @field
     */
    csetFirst: string | null
    /**
     * a string containing the allowed values for the subsequent bytes
     * @field
     */
    csetNth: string | null
    /**
     * the replacement byte for bytes which don't match `cset_first` or `cset_nth`.
     * @field
     */
    substitutor: number
    /**
     * replace empty string by %NULL
     * @field
     */
    nullFoldIfEmpty: number
    /**
     * replace %NULL strings by an empty string
     * @field
     */
    ensureNonNull: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for string
   * properties.
   * @class
   */
  class ParamSpecString extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecString

    static name: string
  }

  interface ParamSpecUChar {
    // Own fields of GObject-2.0.GObject.ParamSpecUChar

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for unsigned character properties.
   * @class
   */
  class ParamSpecUChar extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecUChar

    static name: string
  }

  interface ParamSpecUInt {
    // Own fields of GObject-2.0.GObject.ParamSpecUInt

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for unsigned integer properties.
   * @class
   */
  class ParamSpecUInt extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecUInt

    static name: string
  }

  interface ParamSpecUInt64 {
    // Own fields of GObject-2.0.GObject.ParamSpecUInt64

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for unsigned 64bit integer properties.
   * @class
   */
  class ParamSpecUInt64 extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecUInt64

    static name: string
  }

  interface ParamSpecULong {
    // Own fields of GObject-2.0.GObject.ParamSpecULong

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * minimum value for the property specified
     * @field
     */
    minimum: number
    /**
     * maximum value for the property specified
     * @field
     */
    maximum: number
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for unsigned long integer properties.
   * @class
   */
  class ParamSpecULong extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecULong

    static name: string
  }

  interface ParamSpecUnichar {
    // Own fields of GObject-2.0.GObject.ParamSpecUnichar

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * default value for the property specified
     * @field
     */
    defaultValue: string
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for unichar (unsigned integer) properties.
   * @class
   */
  class ParamSpecUnichar extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecUnichar

    static name: string
  }

  interface ParamSpecValueArray {
    // Own fields of GObject-2.0.GObject.ParamSpecValueArray

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * a #GParamSpec describing the elements contained in arrays of this property, may be %NULL
     * @field
     */
    elementSpec: ParamSpec
    /**
     * if greater than 0, arrays of this property will always have this many elements
     * @field
     */
    fixedNElements: number
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for #GValueArray properties.
   * @class
   */
  class ParamSpecValueArray extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecValueArray

    static name: string
  }

  interface ParamSpecVariant {
    // Own fields of GObject-2.0.GObject.ParamSpecVariant

    /**
     * private #GParamSpec portion
     * @field
     */
    parentInstance: ParamSpec
    /**
     * a #GVariantType, or %NULL
     * @field
     */
    type: GLib.VariantType
    /**
     * a #GVariant, or %NULL
     * @field
     */
    defaultValue: GLib.Variant
  }

  /**
   * A #GParamSpec derived structure that contains the meta data for #GVariant properties.
   *
   * When comparing values with g_param_values_cmp(), scalar values with the same
   * type will be compared with g_variant_compare(). Other non-%NULL variants will
   * be checked for equality with g_variant_equal(), and their sort order is
   * otherwise undefined. %NULL is ordered before non-%NULL variants. Two %NULL
   * values compare equal.
   * @class
   */
  class ParamSpecVariant extends ParamSpec {
    // Own properties of GObject-2.0.GObject.ParamSpecVariant

    static name: string
  }

  module SignalGroup {
    // Signal callback interfaces

    /**
     * Signal callback interface for `bind`
     */
    interface BindSignalCallback {
      (instance: Object): void
    }

    /**
     * Signal callback interface for `unbind`
     */
    interface UnbindSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties extends Object.ConstructorProperties {
      // Own constructor properties of GObject-2.0.GObject.SignalGroup

      /**
       * The target instance used when connecting signals.
       */
      target?: Object | null
      /**
       * The #GType of the target property.
       */
      target_type?: GType | null
    }
  }

  interface SignalGroup {
    // Own properties of GObject-2.0.GObject.SignalGroup

    /**
     * The target instance used when connecting signals.
     */
    target: Object
    /**
     * The #GType of the target property.
     */
    readonly targetType: GType
    __gtype__: number

    // Owm methods of GObject-2.0.GObject.SignalGroup

    /**
     * Blocks all signal handlers managed by `self` so they will not
     * be called during any signal emissions. Must be unblocked exactly
     * the same number of times it has been blocked to become active again.
     *
     * This blocked state will be kept across changes of the target instance.
     */
    block(): void
    /**
     * Connects `closure` to the signal `detailed_signal` on #GSignalGroup:target.
     *
     * You cannot connect a signal handler after #GSignalGroup:target has been set.
     * @param detailedSignal a string of the form `signal-name` with optional `::signal-detail`
     * @param closure the closure to connect.
     * @param after whether the handler should be called before or after the  default handler of the signal.
     */
    connectClosure(
      detailedSignal: string,
      closure: TClosure,
      after: boolean
    ): void
    /**
     * Connects `c_handler` to the signal `detailed_signal`
     * on the target instance of `self`.
     *
     * You cannot connect a signal handler after #GSignalGroup:target has been set.
     * @param detailedSignal a string of the form "signal-name::detail"
     * @param cHandler the #GCallback to connect
     * @param flags the flags used to create the signal connection
     */
    connectData(
      detailedSignal: string,
      cHandler: Callback,
      flags: ConnectFlags
    ): void
    /**
     * Connects `c_handler` to the signal `detailed_signal`
     * on the target instance of `self`.
     *
     * The instance on which the signal is emitted and `data`
     * will be swapped when calling `c_handler`.
     *
     * You cannot connect a signal handler after #GSignalGroup:target has been set.
     * @param detailedSignal a string of the form "signal-name::detail"
     * @param cHandler the #GCallback to connect
     */
    connectSwapped(detailedSignal: string, cHandler: Callback): void
    /**
     * Gets the target instance used when connecting signals.
     * @returns The target instance
     */
    dupTarget(): Object | null
    /**
     * Sets the target instance used when connecting signals. Any signal
     * that has been registered with g_signal_group_connect_object() or
     * similar functions will be connected to this object.
     *
     * If the target instance was previously set, signals will be
     * disconnected from that object prior to connecting to `target`.
     * @param target The target instance used     when connecting signals.
     */
    setTarget(target: Object | null): void
    /**
     * Unblocks all signal handlers managed by `self` so they will be
     * called again during any signal emissions unless it is blocked
     * again. Must be unblocked exactly the same number of times it
     * has been blocked to become active again.
     */
    unblock(): void

    // Own signals of GObject-2.0.GObject.SignalGroup

    connect(sigName: "bind", callback: SignalGroup.BindSignalCallback): number
    on(
      sigName: "bind",
      callback: SignalGroup.BindSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "bind",
      callback: SignalGroup.BindSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "bind",
      callback: SignalGroup.BindSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "bind", ...args: any[]): void
    connect(
      sigName: "unbind",
      callback: SignalGroup.UnbindSignalCallback
    ): number
    on(
      sigName: "unbind",
      callback: SignalGroup.UnbindSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unbind",
      callback: SignalGroup.UnbindSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unbind",
      callback: SignalGroup.UnbindSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unbind", ...args: any[]): void

    // Class property signals of GObject-2.0.GObject.SignalGroup

    connect(
      sigName: "notify::target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::target", ...args: any[]): void
    connect(
      sigName: "notify::target-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::target-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::target-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::target-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::target-type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSignalGroup` manages a collection of signals on a `GObject`.
   *
   * `GSignalGroup` simplifies the process of connecting  many signals to a `GObject`
   * as a group. As such there is no API to disconnect a signal from the group.
   *
   * In particular, this allows you to:
   *
   *  - Change the target instance, which automatically causes disconnection
   *    of the signals from the old instance and connecting to the new instance.
   *  - Block and unblock signals as a group
   *  - Ensuring that blocked state transfers across target instances.
   *
   * One place you might want to use such a structure is with `GtkTextView` and
   * `GtkTextBuffer`. Often times, you'll need to connect to many signals on
   * `GtkTextBuffer` from a `GtkTextView` subclass. This allows you to create a
   * signal group during instance construction, simply bind the
   * `GtkTextView:buffer` property to `GSignalGroup:target` and connect
   * all the signals you need. When the `GtkTextView:buffer` property changes
   * all of the signals will be transitioned correctly.
   * @class
   */
  class SignalGroup extends Object {
    // Own properties of GObject-2.0.GObject.SignalGroup

    static name: string

    // Constructors of GObject-2.0.GObject.SignalGroup

    constructor(config?: SignalGroup.ConstructorProperties)
    /**
     * Creates a new #GSignalGroup for target instances of `target_type`.
     * @constructor
     * @param targetType the #GType of the target instance.
     * @returns a new #GSignalGroup
     */
    constructor(targetType: GType)
    /**
     * Creates a new #GSignalGroup for target instances of `target_type`.
     * @constructor
     * @param targetType the #GType of the target instance.
     * @returns a new #GSignalGroup
     */
    static new(targetType: GType): SignalGroup
    _init(config?: SignalGroup.ConstructorProperties): void
  }

  module TypeModule {
    // Constructor properties interface

    interface ConstructorProperties
      extends TypePlugin.ConstructorProperties,
        Object.ConstructorProperties {}
  }

  interface TypeModule extends TypePlugin {
    // Own properties of GObject-2.0.GObject.TypeModule

    __gtype__: number

    // Own fields of GObject-2.0.GObject.TypeModule

    parentInstance: Object
    useCount: number
    typeInfos: any[]
    interfaceInfos: any[]
    /**
     * the name of the module
     * @field
     */
    name: string | null

    // Owm methods of GObject-2.0.GObject.TypeModule

    /**
     * Registers an additional interface for a type, whose interface lives
     * in the given type plugin. If the interface was already registered
     * for the type in this plugin, nothing will be done.
     *
     * As long as any instances of the type exist, the type plugin will
     * not be unloaded.
     *
     * Since 2.56 if `module` is %NULL this will call g_type_add_interface_static()
     * instead. This can be used when making a static build of the module.
     * @param instanceType type to which to add the interface.
     * @param interfaceType interface type to add
     * @param interfaceInfo type information structure
     */
    addInterface(
      instanceType: GType,
      interfaceType: GType,
      interfaceInfo: InterfaceInfo
    ): void
    /**
     * Looks up or registers an enumeration that is implemented with a particular
     * type plugin. If a type with name `type_name` was previously registered,
     * the #GType identifier for the type is returned, otherwise the type
     * is newly registered, and the resulting #GType identifier returned.
     *
     * As long as any instances of the type exist, the type plugin will
     * not be unloaded.
     *
     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
     * instead. This can be used when making a static build of the module.
     * @param name name for the type
     * @param constStaticValues an array of #GEnumValue structs for the                       possible enumeration values. The array is                       terminated by a struct with all members being                       0.
     * @returns the new or existing type ID
     */
    registerEnum(name: string, constStaticValues: EnumValue): GType
    /**
     * Looks up or registers a flags type that is implemented with a particular
     * type plugin. If a type with name `type_name` was previously registered,
     * the #GType identifier for the type is returned, otherwise the type
     * is newly registered, and the resulting #GType identifier returned.
     *
     * As long as any instances of the type exist, the type plugin will
     * not be unloaded.
     *
     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
     * instead. This can be used when making a static build of the module.
     * @param name name for the type
     * @param constStaticValues an array of #GFlagsValue structs for the                       possible flags values. The array is                       terminated by a struct with all members being                       0.
     * @returns the new or existing type ID
     */
    registerFlags(name: string, constStaticValues: FlagsValue): GType
    /**
     * Looks up or registers a type that is implemented with a particular
     * type plugin. If a type with name `type_name` was previously registered,
     * the #GType identifier for the type is returned, otherwise the type
     * is newly registered, and the resulting #GType identifier returned.
     *
     * When reregistering a type (typically because a module is unloaded
     * then reloaded, and reinitialized), `module` and `parent_type` must
     * be the same as they were previously.
     *
     * As long as any instances of the type exist, the type plugin will
     * not be unloaded.
     *
     * Since 2.56 if `module` is %NULL this will call g_type_register_static()
     * instead. This can be used when making a static build of the module.
     * @param parentType the type for the parent class
     * @param typeName name for the type
     * @param typeInfo type information structure
     * @param flags flags field providing details about the type
     * @returns the new or existing type ID
     */
    registerType(
      parentType: GType,
      typeName: string,
      typeInfo: TypeInfo,
      flags: TypeFlags
    ): GType
    /**
     * Sets the name for a #GTypeModule
     * @param name a human-readable name to use in error messages.
     */
    setName(name: string): void
    /**
     * Decreases the use count of a #GTypeModule by one. If the
     * result is zero, the module will be unloaded. (However, the
     * #GTypeModule will not be freed, and types associated with the
     * #GTypeModule are not unregistered. Once a #GTypeModule is
     * initialized, it must exist forever.)
     */
    unuse(): void
    /**
     * Increases the use count of a #GTypeModule by one. If the
     * use count was zero before, the plugin will be loaded.
     * If loading the plugin fails, the use count is reset to
     * its prior value.
     * @returns %FALSE if the plugin needed to be loaded and  loading the plugin failed.
     */
    use(): boolean

    // Overloads of use

    /**
     * Calls the `use_plugin` function from the #GTypePluginClass of
     * `plugin`.  There should be no need to use this function outside of
     * the GObject type system itself.
     */
    use(): void

    // Own virtual methods of GObject-2.0.GObject.TypeModule

    /**
     * loads the module and registers one or more types using
     *  g_type_module_register_type().
     * @virtual
     */
    load(): boolean
    /**
     * unloads the module
     * @virtual
     */
    unload(): void

    // Class property signals of GObject-2.0.GObject.TypeModule

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GTypeModule` provides a simple implementation of the `GTypePlugin`
   * interface.
   *
   * The model of `GTypeModule` is a dynamically loaded module which
   * implements some number of types and interface implementations.
   *
   * When the module is loaded, it registers its types and interfaces
   * using [method`GObject`.TypeModule.register_type] and
   * [method`GObject`.TypeModule.add_interface].
   * As long as any instances of these types and interface implementations
   * are in use, the module is kept loaded. When the types and interfaces
   * are gone, the module may be unloaded. If the types and interfaces
   * become used again, the module will be reloaded. Note that the last
   * reference cannot be released from within the module code, since that
   * would lead to the caller's code being unloaded before `g_object_unref()`
   * returns to it.
   *
   * Keeping track of whether the module should be loaded or not is done by
   * using a use count - it starts at zero, and whenever it is greater than
   * zero, the module is loaded. The use count is maintained internally by
   * the type system, but also can be explicitly controlled by
   * [method`GObject`.TypeModule.use] and [method`GObject`.TypeModule.unuse].
   * Typically, when loading a module for the first type, `g_type_module_use()`
   * will be used to load it so that it can initialize its types. At some later
   * point, when the module no longer needs to be loaded except for the type
   * implementations it contains, `g_type_module_unuse()` is called.
   *
   * `GTypeModule` does not actually provide any implementation of module
   * loading and unloading. To create a particular module type you must
   * derive from `GTypeModule` and implement the load and unload functions
   * in `GTypeModuleClass`.
   * @class
   */
  class TypeModule extends Object {
    // Own properties of GObject-2.0.GObject.TypeModule

    static name: string

    // Constructors of GObject-2.0.GObject.TypeModule

    constructor(config?: TypeModule.ConstructorProperties)
    _init(config?: TypeModule.ConstructorProperties): void
  }

  interface CClosure {
    // Own fields of GObject-2.0.GObject.CClosure

    /**
     * the #GClosure
     * @field
     */
    closure: TClosure
    /**
     * the callback function
     * @field
     */
    callback: any
  }

  /**
   * A #GCClosure is a specialization of #GClosure for C function callbacks.
   * @record
   */
  class CClosure {
    // Own properties of GObject-2.0.GObject.CClosure

    static name: string

    // Constructors of GObject-2.0.GObject.CClosure

    /**
     * A #GClosureMarshal function for use with signals with handlers that
     * take two boxed pointers as arguments and return a boolean.  If you
     * have such a signal, you will probably also need to use an
     * accumulator, such as g_signal_accumulator_true_handled().
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalBOOLEANBOXEDBOXED(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with handlers that
     * take a flags type as an argument and return a boolean.  If you have
     * such a signal, you will probably also need to use an accumulator,
     * such as g_signal_accumulator_true_handled().
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalBOOLEANFLAGS(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with handlers that
     * take a #GObject and a pointer and produce a string.  It is highly
     * unlikely that your signal handler fits this description.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalSTRINGOBJECTPOINTER(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * boolean argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDBOOLEAN(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * argument which is any boxed pointer type.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDBOXED(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * character argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDCHAR(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with one
     * double-precision floating point argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDDOUBLE(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * argument with an enumerated type.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDENUM(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * argument with a flags types.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDFLAGS(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with one
     * single-precision floating point argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDFLOAT(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * integer argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDINT(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with with a single
     * long integer argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDLONG(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * #GObject argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDOBJECT(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * argument of type #GParamSpec.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDPARAM(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single raw
     * pointer argument type.
     *
     * If it is possible, it is better to use one of the more specific
     * functions such as g_cclosure_marshal_VOID__OBJECT() or
     * g_cclosure_marshal_VOID__OBJECT().
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDPOINTER(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single string
     * argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDSTRING(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * unsigned character argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDUCHAR(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with with a single
     * unsigned integer argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDUINT(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with an unsigned int
     * and a pointer as arguments.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDUINTPOINTER(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * unsigned long integer argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDULONG(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with a single
     * #GVariant argument.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDVARIANT(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A #GClosureMarshal function for use with signals with no arguments.
     * @param closure A #GClosure.
     * @param returnValue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalVOIDVOID(
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
    /**
     * A generic marshaller function implemented via
     * [libffi](http://sourceware.org/libffi/).
     *
     * Normally this function is not passed explicitly to g_signal_new(),
     * but used automatically by GLib when specifying a %NULL marshaller.
     * @param closure A #GClosure.
     * @param returnGvalue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
     * @param nParamValues The length of the `param_values` array.
     * @param paramValues An array of #GValues holding the arguments   on which to invoke the callback of closure.
     * @param invocationHint The invocation hint given as the last argument to   g_closure_invoke().
     * @param marshalData Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
     */
    static marshalGeneric(
      closure: TClosure,
      returnGvalue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any | null,
      marshalData: any | null
    ): void
  }

  interface Closure {
    // Own fields of GObject-2.0.GObject.Closure

    /**
     * Indicates whether the closure is currently being invoked with
     *   g_closure_invoke()
     * @field
     */
    inMarshal: number
    /**
     * Indicates whether the closure has been invalidated by
     *   g_closure_invalidate()
     * @field
     */
    isInvalid: number
    marshal: (
      closure: TClosure,
      returnValue: any,
      nParamValues: number,
      paramValues: any,
      invocationHint: any,
      marshalData: any
    ) => void

    // Owm methods of GObject-2.0.GObject.Closure

    /**
     * Sets a flag on the closure to indicate that its calling
     * environment has become invalid, and thus causes any future
     * invocations of g_closure_invoke() on this `closure` to be
     * ignored.
     *
     * Also, invalidation notifiers installed on the closure will
     * be called at this point. Note that unless you are holding a
     * reference to the closure yourself, the invalidation notifiers may
     * unref the closure and cause it to be destroyed, so if you need to
     * access the closure after calling g_closure_invalidate(), make sure
     * that you've previously called g_closure_ref().
     *
     * Note that g_closure_invalidate() will also be called when the
     * reference count of a closure drops to zero (unless it has already
     * been invalidated before).
     */
    invalidate(): void
    /**
     * Invokes the closure, i.e. executes the callback represented by the `closure`.
     * @param paramValues an array of                #GValues holding the arguments on which to                invoke the callback of `closure`
     * @param invocationHint a context-dependent invocation hint
     */
    invoke(
      paramValues: any[],
      invocationHint: any | null
    ): /* returnValue */ any
    /**
     * Increments the reference count on a closure to force it staying
     * alive while the caller holds a pointer to it.
     * @returns The @closure passed in, for convenience
     */
    ref(): TClosure
    /**
     * Takes over the initial ownership of a closure.
     *
     * Each closure is initially created in a "floating" state, which means
     * that the initial reference count is not owned by any caller.
     *
     * This function checks to see if the object is still floating, and if so,
     * unsets the floating state and decreases the reference count. If the
     * closure is not floating, g_closure_sink() does nothing.
     *
     * The reason for the existence of the floating state is to prevent
     * cumbersome code sequences like:
     *
     *
     * ```c
     * closure = g_cclosure_new (cb_func, cb_data);
     * g_source_set_closure (source, closure);
     * g_closure_unref (closure); // GObject doesn't really need this
     * ```
     *
     *
     * Because g_source_set_closure() (and similar functions) take ownership of the
     * initial reference count, if it is unowned, we instead can write:
     *
     *
     * ```c
     * g_source_set_closure (source, g_cclosure_new (cb_func, cb_data));
     * ```
     *
     *
     * Generally, this function is used together with g_closure_ref(). An example
     * of storing a closure for later notification looks like:
     *
     *
     * ```c
     * static GClosure *notify_closure = NULL;
     * void
     * foo_notify_set_closure (GClosure *closure)
     * {
     *   if (notify_closure)
     *     g_closure_unref (notify_closure);
     *   notify_closure = closure;
     *   if (notify_closure)
     *     {
     *       g_closure_ref (notify_closure);
     *       g_closure_sink (notify_closure);
     *     }
     * }
     * ```
     *
     *
     * Because g_closure_sink() may decrement the reference count of a closure
     * (if it hasn't been called on `closure` yet) just like g_closure_unref(),
     * g_closure_ref() should be called prior to this function.
     */
    sink(): void
    /**
     * Decrements the reference count of a closure after it was previously
     * incremented by the same caller.
     *
     * If no other callers are using the closure, then the closure will be
     * destroyed and freed.
     */
    unref(): void
  }

  /**
   * A `GClosure` represents a callback supplied by the programmer.
   *
   * It will generally comprise a function of some kind and a marshaller
   * used to call it. It is the responsibility of the marshaller to
   * convert the arguments for the invocation from #GValues into
   * a suitable form, perform the callback on the converted arguments,
   * and transform the return value back into a #GValue.
   *
   * In the case of C programs, a closure usually just holds a pointer
   * to a function and maybe a data argument, and the marshaller
   * converts between #GValue and native C types. The GObject
   * library provides the #GCClosure type for this purpose. Bindings for
   * other languages need marshallers which convert between #GValues
   * and suitable representations in the runtime of the language in
   * order to use functions written in that language as callbacks. Use
   * g_closure_set_marshal() to set the marshaller on such a custom
   * closure implementation.
   *
   * Within GObject, closures play an important role in the
   * implementation of signals. When a signal is registered, the
   * `c_marshaller` argument to g_signal_new() specifies the default C
   * marshaller for any closure which is connected to this
   * signal. GObject provides a number of C marshallers for this
   * purpose, see the g_cclosure_marshal_*() functions. Additional C
   * marshallers can be generated with the [glib-genmarshal][glib-genmarshal]
   * utility.  Closures can be explicitly connected to signals with
   * g_signal_connect_closure(), but it usually more convenient to let
   * GObject create a closure automatically by using one of the
   * g_signal_connect_*() functions which take a callback function/user
   * data pair.
   *
   * Using closures has a number of important advantages over a simple
   * callback function/data pointer combination:
   *
   * - Closures allow the callee to get the types of the callback parameters,
   *   which means that language bindings don't have to write individual glue
   *   for each callback type.
   *
   * - The reference counting of #GClosure makes it easy to handle reentrancy
   *   right; if a callback is removed while it is being invoked, the closure
   *   and its parameters won't be freed until the invocation finishes.
   *
   * - g_closure_invalidate() and invalidation notifiers allow callbacks to be
   *   automatically removed when the objects they point to go away.
   * @record
   */
  class Closure {
    // Own properties of GObject-2.0.GObject.Closure

    static name: string

    // Constructors of GObject-2.0.GObject.Closure

    /**
     * A variant of g_closure_new_simple() which stores `object` in the
     * `data` field of the closure and calls g_object_watch_closure() on
     * `object` and the created closure. This function is mainly useful
     * when implementing new types of closures.
     * @constructor
     * @param sizeofClosure the size of the structure to allocate, must be at least  `sizeof (GClosure)`
     * @param object a #GObject pointer to store in the `data` field of the newly  allocated #GClosure
     * @returns a newly allocated #GClosure
     */
    static newObject(sizeofClosure: number, object: Object): Closure
    /**
     * Allocates a struct of the given size and initializes the initial
     * part as a #GClosure.
     *
     * This function is mainly useful when implementing new types of closures:
     *
     *
     * ```c
     * typedef struct _MyClosure MyClosure;
     * struct _MyClosure
     * {
     *   GClosure closure;
     *   // extra data goes here
     * };
     *
     * static void
     * my_closure_finalize (gpointer  notify_data,
     *                      GClosure *closure)
     * {
     *   MyClosure *my_closure = (MyClosure *)closure;
     *
     *   // free extra data here
     * }
     *
     * MyClosure *my_closure_new (gpointer data)
     * {
     *   GClosure *closure;
     *   MyClosure *my_closure;
     *
     *   closure = g_closure_new_simple (sizeof (MyClosure), data);
     *   my_closure = (MyClosure *) closure;
     *
     *   // initialize extra data here
     *
     *   g_closure_add_finalize_notifier (closure, notify_data,
     *                                    my_closure_finalize);
     *   return my_closure;
     * }
     * ```
     *
     * @constructor
     * @param sizeofClosure the size of the structure to allocate, must be at least                  `sizeof (GClosure)`
     * @param data data to store in the `data` field of the newly allocated #GClosure
     * @returns a floating reference to a new #GClosure
     */
    static newSimple(sizeofClosure: number, data: any | null): Closure
  }

  interface ClosureNotifyData {
    // Own fields of GObject-2.0.GObject.ClosureNotifyData

    data: any
    notify: ClosureNotify
  }

  class ClosureNotifyData {
    // Own properties of GObject-2.0.GObject.ClosureNotifyData

    static name: string
  }

  interface EnumClass {
    // Own fields of GObject-2.0.GObject.EnumClass

    /**
     * the parent class
     * @field
     */
    gTypeClass: TypeClass
    /**
     * the smallest possible value.
     * @field
     */
    minimum: number
    /**
     * the largest possible value.
     * @field
     */
    maximum: number
    /**
     * the number of possible values.
     * @field
     */
    nValues: number
    /**
     * an array of #GEnumValue structs describing the
     *  individual values.
     * @field
     */
    values: EnumValue
  }

  /**
   * The class of an enumeration type holds information about its
   * possible values.
   * @record
   */
  class EnumClass {
    // Own properties of GObject-2.0.GObject.EnumClass

    static name: string
  }

  interface EnumValue {
    // Own fields of GObject-2.0.GObject.EnumValue

    /**
     * the enum value
     * @field
     */
    value: number
    /**
     * the name of the value
     * @field
     */
    valueName: string
    /**
     * the nickname of the value
     * @field
     */
    valueNick: string
  }

  /**
   * A structure which contains a single enum value, its name, and its
   * nickname.
   * @record
   */
  class EnumValue {
    // Own properties of GObject-2.0.GObject.EnumValue

    static name: string
  }

  interface FlagsClass {
    // Own fields of GObject-2.0.GObject.FlagsClass

    /**
     * the parent class
     * @field
     */
    gTypeClass: TypeClass
    /**
     * a mask covering all possible values.
     * @field
     */
    mask: number
    /**
     * the number of possible values.
     * @field
     */
    nValues: number
    /**
     * an array of #GFlagsValue structs describing the
     *  individual values.
     * @field
     */
    values: FlagsValue
  }

  /**
   * The class of a flags type holds information about its
   * possible values.
   * @record
   */
  class FlagsClass {
    // Own properties of GObject-2.0.GObject.FlagsClass

    static name: string
  }

  interface FlagsValue {
    // Own fields of GObject-2.0.GObject.FlagsValue

    /**
     * the flags value
     * @field
     */
    value: number
    /**
     * the name of the value
     * @field
     */
    valueName: string
    /**
     * the nickname of the value
     * @field
     */
    valueNick: string
  }

  /**
   * A structure which contains a single flags value, its name, and its
   * nickname.
   * @record
   */
  class FlagsValue {
    // Own properties of GObject-2.0.GObject.FlagsValue

    static name: string
  }

  interface InitiallyUnownedClass {
    // Own fields of GObject-2.0.GObject.InitiallyUnownedClass

    /**
     * the parent class
     * @field
     */
    gTypeClass: TypeClass
    /**
     * the generic setter for all properties of this type. Should be
     *  overridden for every type with properties. If implementations of
     *  `set_property` don't emit property change notification explicitly, this will
     *  be done implicitly by the type system. However, if the notify signal is
     *  emitted explicitly, the type system will not emit it a second time.
     * @field
     */
    setProperty: (
      object: Object,
      propertyId: number,
      value: any,
      pspec: ParamSpec
    ) => void
    /**
     * the generic getter for all properties of this type. Should be
     *  overridden for every type with properties.
     * @field
     */
    getProperty: (
      object: Object,
      propertyId: number,
      value: any,
      pspec: ParamSpec
    ) => void
    /**
     * the `dispose` function is supposed to drop all references to other
     *  objects, but keep the instance otherwise intact, so that client method
     *  invocations still work. It may be run multiple times (due to reference
     *  loops). Before returning, `dispose` should chain up to the `dispose` method
     *  of the parent class.
     * @field
     */
    dispose: (object: Object) => void
    /**
     * instance finalization function, should finish the finalization of
     *  the instance begun in `dispose` and chain up to the `finalize` method of the
     *  parent class.
     * @field
     */
    finalize: (object: Object) => void
    /**
     * emits property change notification for a bunch
     *  of properties. Overriding `dispatch_properties_changed` should be rarely
     *  needed.
     * @field
     */
    dispatchPropertiesChanged: (
      object: Object,
      nPspecs: number,
      pspecs: ParamSpec
    ) => void
    /**
     * the class closure for the notify signal
     * @field
     */
    notify: (object: Object, pspec: ParamSpec) => void
    /**
     * the `constructed` function is called by g_object_new() as the
     *  final step of the object creation process.  At the point of the call, all
     *  construction properties have been set on the object.  The purpose of this
     *  call is to allow for object initialisation steps that can only be performed
     *  after construction properties have been set.  `constructed` implementors
     *  should chain up to the `constructed` call of their parent class to allow it
     *  to complete its initialisation.
     * @field
     */
    constructed: (object: Object) => void
  }

  /**
   * The class structure for the GInitiallyUnowned type.
   * @record
   */
  abstract class InitiallyUnownedClass {
    // Own properties of GObject-2.0.GObject.InitiallyUnownedClass

    static name: string
  }

  interface InterfaceInfo {
    // Own fields of GObject-2.0.GObject.InterfaceInfo

    /**
     * location of the interface initialization function
     * @field
     */
    interfaceInit: InterfaceInitFunc
    /**
     * location of the interface finalization function
     * @field
     */
    interfaceFinalize: InterfaceFinalizeFunc
    /**
     * user-supplied data passed to the interface init/finalize functions
     * @field
     */
    interfaceData: any
  }

  /**
   * A structure that provides information to the type system which is
   * used specifically for managing interface types.
   * @record
   */
  class InterfaceInfo {
    // Own properties of GObject-2.0.GObject.InterfaceInfo

    static name: string
  }

  interface ObjectClass {
    // Own fields of GObject-2.0.GObject.ObjectClass

    /**
     * the parent class
     * @field
     */
    gTypeClass: TypeClass
    /**
     * the generic setter for all properties of this type. Should be
     *  overridden for every type with properties. If implementations of
     *  `set_property` don't emit property change notification explicitly, this will
     *  be done implicitly by the type system. However, if the notify signal is
     *  emitted explicitly, the type system will not emit it a second time.
     * @field
     */
    setProperty: (
      object: Object,
      propertyId: number,
      value: any,
      pspec: ParamSpec
    ) => void
    /**
     * the generic getter for all properties of this type. Should be
     *  overridden for every type with properties.
     * @field
     */
    getProperty: (
      object: Object,
      propertyId: number,
      value: any,
      pspec: ParamSpec
    ) => void
    /**
     * the `dispose` function is supposed to drop all references to other
     *  objects, but keep the instance otherwise intact, so that client method
     *  invocations still work. It may be run multiple times (due to reference
     *  loops). Before returning, `dispose` should chain up to the `dispose` method
     *  of the parent class.
     * @field
     */
    dispose: (object: Object) => void
    /**
     * instance finalization function, should finish the finalization of
     *  the instance begun in `dispose` and chain up to the `finalize` method of the
     *  parent class.
     * @field
     */
    finalize: (object: Object) => void
    /**
     * emits property change notification for a bunch
     *  of properties. Overriding `dispatch_properties_changed` should be rarely
     *  needed.
     * @field
     */
    dispatchPropertiesChanged: (
      object: Object,
      nPspecs: number,
      pspecs: ParamSpec
    ) => void
    /**
     * the class closure for the notify signal
     * @field
     */
    notify: (object: Object, pspec: ParamSpec) => void
    /**
     * the `constructed` function is called by g_object_new() as the
     *  final step of the object creation process.  At the point of the call, all
     *  construction properties have been set on the object.  The purpose of this
     *  call is to allow for object initialisation steps that can only be performed
     *  after construction properties have been set.  `constructed` implementors
     *  should chain up to the `constructed` call of their parent class to allow it
     *  to complete its initialisation.
     * @field
     */
    constructed: (object: Object) => void

    // Owm methods of GObject-2.0.GObject.ObjectClass

    /**
     * Looks up the #GParamSpec for a property of a class.
     * @param propertyName the name of the property to look up
     * @returns the #GParamSpec for the property, or          %NULL if the class doesn't have a property of that name
     */
    findProperty(
      oclass: Object | Function | GType,
      propertyName: string
    ): ParamSpec
    /**
     * Installs new properties from an array of #GParamSpecs.
     *
     * All properties should be installed during the class initializer.  It
     * is possible to install properties after that, but doing so is not
     * recommend, and specifically, is not guaranteed to be thread-safe vs.
     * use of properties on the same type on other threads.
     *
     * The property id of each property is the index of each #GParamSpec in
     * the `pspecs` array.
     *
     * The property id of 0 is treated specially by #GObject and it should not
     * be used to store a #GParamSpec.
     *
     * This function should be used if you plan to use a static array of
     * #GParamSpecs and g_object_notify_by_pspec(). For instance, this
     * class initialization:
     *
     *
     * ```c
     * typedef enum {
     *   PROP_FOO = 1,
     *   PROP_BAR,
     *   N_PROPERTIES
     * } MyObjectProperty;
     *
     * static GParamSpec *obj_properties[N_PROPERTIES] = { NULL, };
     *
     * static void
     * my_object_class_init (MyObjectClass *klass)
     * {
     *   GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
     *
     *   obj_properties[PROP_FOO] =
     *     g_param_spec_int ("foo", NULL, NULL,
     *                       -1, G_MAXINT,
     *                       0,
     *                       G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
     *
     *   obj_properties[PROP_BAR] =
     *     g_param_spec_string ("bar", NULL, NULL,
     *                          NULL,
     *                          G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
     *
     *   gobject_class->set_property = my_object_set_property;
     *   gobject_class->get_property = my_object_get_property;
     *   g_object_class_install_properties (gobject_class,
     *                                      G_N_ELEMENTS (obj_properties),
     *                                      obj_properties);
     * }
     * ```
     *
     *
     * allows calling g_object_notify_by_pspec() to notify of property changes:
     *
     *
     * ```c
     * void
     * my_object_set_foo (MyObject *self, gint foo)
     * {
     *   if (self->foo != foo)
     *     {
     *       self->foo = foo;
     *       g_object_notify_by_pspec (G_OBJECT (self), obj_properties[PROP_FOO]);
     *     }
     *  }
     * ```
     *
     * @param pspecs the #GParamSpecs array   defining the new properties
     */
    installProperties(
      oclass: Object | Function | GType,
      pspecs: ParamSpec[]
    ): void
    /**
     * Installs a new property.
     *
     * All properties should be installed during the class initializer.  It
     * is possible to install properties after that, but doing so is not
     * recommend, and specifically, is not guaranteed to be thread-safe vs.
     * use of properties on the same type on other threads.
     *
     * Note that it is possible to redefine a property in a derived class,
     * by installing a property with the same name. This can be useful at times,
     * e.g. to change the range of allowed values or the default value.
     * @param propertyId the id for the new property
     * @param pspec the #GParamSpec for the new property
     */
    installProperty(
      oclass: Object | Function | GType,
      propertyId: number,
      pspec: ParamSpec
    ): void
    /**
     * Get an array of #GParamSpec* for all properties of a class.
     * @returns an array of          #GParamSpec* which should be freed after use
     */
    listProperties(oclass: Object | Function | GType): ParamSpec[]
    /**
     * Registers `property_id` as referring to a property with the name
     * `name` in a parent class or in an interface implemented by `oclass`.
     * This allows this class to "override" a property implementation in
     * a parent class or to provide the implementation of a property from
     * an interface.
     *
     * Internally, overriding is implemented by creating a property of type
     * #GParamSpecOverride; generally operations that query the properties of
     * the object class, such as g_object_class_find_property() or
     * g_object_class_list_properties() will return the overridden
     * property. However, in one case, the `construct_properties` argument of
     * the `constructor` virtual function, the #GParamSpecOverride is passed
     * instead, so that the `param_id` field of the #GParamSpec will be
     * correct.  For virtually all uses, this makes no difference. If you
     * need to get the overridden property, you can call
     * g_param_spec_get_redirect_target().
     * @param propertyId the new property ID
     * @param name the name of a property registered in a parent class or  in an interface of this class.
     */
    overrideProperty(
      oclass: Object | Function | GType,
      propertyId: number,
      name: string
    ): void
  }

  /**
   * The class structure for the GObject type.
   *
   *
   * ```c
   * // Example of implementing a singleton using a constructor.
   * static MySingleton *the_singleton = NULL;
   *
   * static GObject*
   * my_singleton_constructor (GType                  type,
   *                           guint                  n_construct_params,
   *                           GObjectConstructParam *construct_params)
   * {
   *   GObject *object;
   *
   *   if (!the_singleton)
   *     {
   *       object = G_OBJECT_CLASS (parent_class)->constructor (type,
   *                                                            n_construct_params,
   *                                                            construct_params);
   *       the_singleton = MY_SINGLETON (object);
   *     }
   *   else
   *     object = g_object_ref (G_OBJECT (the_singleton));
   *
   *   return object;
   * }
   * ```
   *
   * @record
   */
  abstract class ObjectClass {
    // Own properties of GObject-2.0.GObject.ObjectClass

    static name: string
  }

  interface ObjectConstructParam {
    // Own fields of GObject-2.0.GObject.ObjectConstructParam

    /**
     * the #GParamSpec of the construct parameter
     * @field
     */
    pspec: ParamSpec
    /**
     * the value to set the parameter to
     * @field
     */
    value: any
  }

  /**
   * The GObjectConstructParam struct is an auxiliary structure used to hand
   * #GParamSpec/#GValue pairs to the `constructor` of a #GObjectClass.
   * @record
   */
  class ObjectConstructParam {
    // Own properties of GObject-2.0.GObject.ObjectConstructParam

    static name: string
  }

  interface ParamSpecClass {
    // Own fields of GObject-2.0.GObject.ParamSpecClass

    /**
     * the parent class
     * @field
     */
    gTypeClass: TypeClass
    /**
     * the #GValue type for this parameter
     * @field
     */
    valueType: GType
    /**
     * The instance finalization function (optional), should chain
     *  up to the finalize method of the parent class.
     * @field
     */
    finalize: (pspec: ParamSpec) => void
    /**
     * Resets a `value` to the default value for this type
     *  (recommended, the default is g_value_reset()), see
     *  g_param_value_set_default().
     * @field
     */
    valueSetDefault: (pspec: ParamSpec, value: any) => void
    /**
     * Ensures that the contents of `value` comply with the
     *  specifications set out by this type (optional), see
     *  g_param_value_validate().
     * @field
     */
    valueValidate: (pspec: ParamSpec, value: any) => boolean
    /**
     * Compares `value1` with `value2` according to this type
     *  (recommended, the default is memcmp()), see g_param_values_cmp().
     * @field
     */
    valuesCmp: (pspec: ParamSpec, value1: any, value2: any) => number
    /**
     * Checks if contents of `value` comply with the specifications
     *   set out by this type, without modifying the value. This vfunc is optional.
     *   If it isn't set, GObject will use `value_validate`. Since 2.74
     * @field
     */
    valueIsValid: (pspec: ParamSpec, value: any) => boolean
  }

  /**
   * The class structure for the GParamSpec type.
   * Normally, GParamSpec classes are filled by
   * g_param_type_register_static().
   * @record
   */
  abstract class ParamSpecClass {
    // Own properties of GObject-2.0.GObject.ParamSpecClass

    static name: string
  }

  interface ParamSpecPool {
    // Owm methods of GObject-2.0.GObject.ParamSpecPool

    /**
     * Frees the resources allocated by a #GParamSpecPool.
     */
    free(): void
    /**
     * Inserts a #GParamSpec in the pool.
     * @param pspec the #GParamSpec to insert
     * @param ownerType a #GType identifying the owner of `pspec`
     */
    insert(pspec: ParamSpec, ownerType: GType): void
    /**
     * Gets an array of all #GParamSpecs owned by `owner_type` in
     * the pool.
     * @param ownerType the owner to look for
     * @returns a newly          allocated array containing pointers to all #GParamSpecs          owned by @owner_type in the pool
     */
    list(ownerType: GType): ParamSpec[]
    /**
     * Gets an #GList of all #GParamSpecs owned by `owner_type` in
     * the pool.
     * @param ownerType the owner to look for
     * @returns a          #GList of all #GParamSpecs owned by @owner_type in          the pool#GParamSpecs.
     */
    listOwned(ownerType: GType): ParamSpec[]
    /**
     * Looks up a #GParamSpec in the pool.
     * @param paramName the name to look for
     * @param ownerType the owner to look for
     * @param walkAncestors If %TRUE, also try to find a #GParamSpec with `param_name`  owned by an ancestor of `owner_type`.
     * @returns The found #GParamSpec, or %NULL if no matching #GParamSpec was found.
     */
    lookup(
      paramName: string,
      ownerType: GType,
      walkAncestors: boolean
    ): ParamSpec | null
    /**
     * Removes a #GParamSpec from the pool.
     * @param pspec the #GParamSpec to remove
     */
    remove(pspec: ParamSpec): void
  }

  /**
   * A #GParamSpecPool maintains a collection of #GParamSpecs which can be
   * quickly accessed by owner and name.
   *
   * The implementation of the #GObject property system uses such a pool to
   * store the #GParamSpecs of the properties all object types.
   * @record
   */
  class ParamSpecPool {
    // Own properties of GObject-2.0.GObject.ParamSpecPool

    static name: string
  }

  interface ParamSpecTypeInfo {
    // Own fields of GObject-2.0.GObject.ParamSpecTypeInfo

    /**
     * Size of the instance (object) structure.
     * @field
     */
    instanceSize: number
    /**
     * Prior to GLib 2.10, it specified the number of pre-allocated (cached) instances to reserve memory for (0 indicates no caching). Since GLib 2.10, it is ignored, since instances are allocated with the [slice allocator][glib-Memory-Slices] now.
     * @field
     */
    nPreallocs: number
    /**
     * Location of the instance initialization function (optional).
     * @field
     */
    instanceInit: (pspec: ParamSpec) => void
    /**
     * The #GType of values conforming to this #GParamSpec
     * @field
     */
    valueType: GType
    /**
     * The instance finalization function (optional).
     * @field
     */
    finalize: (pspec: ParamSpec) => void
    /**
     * Resets a `value` to the default value for `pspec`
     *  (recommended, the default is g_value_reset()), see
     *  g_param_value_set_default().
     * @field
     */
    valueSetDefault: (pspec: ParamSpec, value: any) => void
    /**
     * Ensures that the contents of `value` comply with the
     *  specifications set out by `pspec` (optional), see
     *  g_param_value_validate().
     * @field
     */
    valueValidate: (pspec: ParamSpec, value: any) => boolean
    /**
     * Compares `value1` with `value2` according to `pspec`
     *  (recommended, the default is memcmp()), see g_param_values_cmp().
     * @field
     */
    valuesCmp: (pspec: ParamSpec, value1: any, value2: any) => number
  }

  /**
   * This structure is used to provide the type system with the information
   * required to initialize and destruct (finalize) a parameter's class and
   * instances thereof.
   *
   * The initialized structure is passed to the g_param_type_register_static()
   * The type system will perform a deep copy of this structure, so its memory
   * does not need to be persistent across invocation of
   * g_param_type_register_static().
   * @record
   */
  class ParamSpecTypeInfo {
    // Own properties of GObject-2.0.GObject.ParamSpecTypeInfo

    static name: string
  }

  interface Parameter {
    // Own fields of GObject-2.0.GObject.Parameter

    /**
     * the parameter name
     * @field
     */
    name: string
    /**
     * the parameter value
     * @field
     */
    value: any
  }

  /**
   * The GParameter struct is an auxiliary structure used
   * to hand parameter name/value pairs to g_object_newv().
   * @record
   */
  class Parameter {
    // Own properties of GObject-2.0.GObject.Parameter

    static name: string
  }

  interface SignalInvocationHint {
    // Own fields of GObject-2.0.GObject.SignalInvocationHint

    /**
     * The signal id of the signal invoking the callback
     * @field
     */
    signalId: number
    /**
     * The detail passed on for this emission
     * @field
     */
    detail: GLib.Quark
    /**
     * The stage the signal emission is currently in, this
     *  field will contain one of %G_SIGNAL_RUN_FIRST,
     *  %G_SIGNAL_RUN_LAST or %G_SIGNAL_RUN_CLEANUP and %G_SIGNAL_ACCUMULATOR_FIRST_RUN.
     *  %G_SIGNAL_ACCUMULATOR_FIRST_RUN is only set for the first run of the accumulator
     *  function for a signal emission.
     * @field
     */
    runType: SignalFlags
  }

  /**
   * The #GSignalInvocationHint structure is used to pass on additional information
   * to callbacks during a signal emission.
   * @record
   */
  class SignalInvocationHint {
    // Own properties of GObject-2.0.GObject.SignalInvocationHint

    static name: string
  }

  interface SignalQuery {
    // Own fields of GObject-2.0.GObject.SignalQuery

    /**
     * The signal id of the signal being queried, or 0 if the
     *  signal to be queried was unknown.
     * @field
     */
    signalId: number
    /**
     * The signal name.
     * @field
     */
    signalName: string
    /**
     * The interface/instance type that this signal can be emitted for.
     * @field
     */
    itype: GType
    /**
     * The signal flags as passed in to g_signal_new().
     * @field
     */
    signalFlags: SignalFlags
    /**
     * The return type for user callbacks.
     * @field
     */
    returnType: GType
    /**
     * The number of parameters that user callbacks take.
     * @field
     */
    nParams: number
    /**
     * The individual parameter types for
     *  user callbacks, note that the effective callback signature is:
     *
     * ```c
     *  `return_type` callback (#gpointer     data1,
     *  [param_types param_names,]
     *  gpointer     data2);
     *  ```
     *
     * @field
     */
    paramTypes: GType[]
  }

  /**
   * A structure holding in-depth information for a specific signal.
   *
   * See also: g_signal_query()
   * @record
   */
  class SignalQuery {
    // Own properties of GObject-2.0.GObject.SignalQuery

    static name: string
  }

  interface TypeClass {
    // Owm methods of GObject-2.0.GObject.TypeClass

    /**
     * Registers a private structure for an instantiatable type.
     *
     * When an object is allocated, the private structures for
     * the type and all of its parent types are allocated
     * sequentially in the same memory block as the public
     * structures, and are zero-filled.
     *
     * Note that the accumulated size of the private structures of
     * a type and all its parent types cannot exceed 64 KiB.
     *
     * This function should be called in the type's class_init() function.
     * The private structure can be retrieved using the
     * G_TYPE_INSTANCE_GET_PRIVATE() macro.
     *
     * The following example shows attaching a private structure
     * MyObjectPrivate to an object MyObject defined in the standard
     * GObject fashion in the type's class_init() function.
     *
     * Note the use of a structure member "priv" to avoid the overhead
     * of repeatedly calling MY_OBJECT_GET_PRIVATE().
     *
     *
     * ```c
     * typedef struct _MyObject        MyObject;
     * typedef struct _MyObjectPrivate MyObjectPrivate;
     *
     * struct _MyObject {
     *  GObject parent;
     *
     *  MyObjectPrivate *priv;
     * };
     *
     * struct _MyObjectPrivate {
     *   int some_field;
     * };
     *
     * static void
     * my_object_class_init (MyObjectClass *klass)
     * {
     *   g_type_class_add_private (klass, sizeof (MyObjectPrivate));
     * }
     *
     * static void
     * my_object_init (MyObject *my_object)
     * {
     *   my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
     *                                                  MY_TYPE_OBJECT,
     *                                                  MyObjectPrivate);
     *   // my_object->priv->some_field will be automatically initialised to 0
     * }
     *
     * static int
     * my_object_get_some_field (MyObject *my_object)
     * {
     *   MyObjectPrivate *priv;
     *
     *   g_return_val_if_fail (MY_IS_OBJECT (my_object), 0);
     *
     *   priv = my_object->priv;
     *
     *   return priv->some_field;
     * }
     * ```
     *
     * @param privateSize size of private structure
     */
    addPrivate(privateSize: number): void
    getPrivate(privateType: GType): any | null
    /**
     * This is a convenience function often needed in class initializers.
     * It returns the class structure of the immediate parent type of the
     * class passed in.  Since derived classes hold a reference count on
     * their parent classes as long as they are instantiated, the returned
     * class will always exist.
     *
     * This function is essentially equivalent to:
     * g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)))
     * @returns the parent class     of @g_class
     */
    peekParent(): TypeClass
    /**
     * Decrements the reference count of the class structure being passed in.
     * Once the last reference count of a class has been released, classes
     * may be finalized by the type system, so further dereferencing of a
     * class pointer after g_type_class_unref() are invalid.
     */
    unref(): void
  }

  /**
   * An opaque structure used as the base of all classes.
   * @record
   */
  class TypeClass {
    // Own properties of GObject-2.0.GObject.TypeClass

    static name: string

    // Constructors of GObject-2.0.GObject.TypeClass

    static adjustPrivateOffset(
      gClass: any | null,
      privateSizeOrOffset: number
    ): void
    /**
     * This function is essentially the same as g_type_class_ref(),
     * except that the classes reference count isn't incremented.
     * As a consequence, this function may return %NULL if the class
     * of the type passed in does not currently exist (hasn't been
     * referenced before).
     * @param type type ID of a classed type
     * @returns the #GTypeClass     structure for the given type ID or %NULL if the class does not     currently exist
     */
    static peek(type: GType): TypeClass
    /**
     * A more efficient version of g_type_class_peek() which works only for
     * static types.
     * @param type type ID of a classed type
     * @returns the #GTypeClass     structure for the given type ID or %NULL if the class does not     currently exist or is dynamically loaded
     */
    static peekStatic(type: GType): TypeClass
    /**
     * Increments the reference count of the class structure belonging to
     * `type`. This function will demand-create the class if it doesn't
     * exist already.
     * @param type type ID of a classed type
     * @returns the #GTypeClass     structure for the given type ID
     */
    static ref(type: GType): TypeClass
  }

  interface TypeFundamentalInfo {
    // Own fields of GObject-2.0.GObject.TypeFundamentalInfo

    /**
     * #GTypeFundamentalFlags describing the characteristics of the fundamental type
     * @field
     */
    typeFlags: TypeFundamentalFlags
  }

  /**
   * A structure that provides information to the type system which is
   * used specifically for managing fundamental types.
   * @record
   */
  class TypeFundamentalInfo {
    // Own properties of GObject-2.0.GObject.TypeFundamentalInfo

    static name: string
  }

  interface TypeInfo {
    // Own fields of GObject-2.0.GObject.TypeInfo

    /**
     * Size of the class structure (required for interface, classed and instantiatable types)
     * @field
     */
    classSize: number
    /**
     * Location of the base initialization function (optional)
     * @field
     */
    baseInit: BaseInitFunc
    /**
     * Location of the base finalization function (optional)
     * @field
     */
    baseFinalize: BaseFinalizeFunc
    /**
     * Location of the class initialization function for
     *  classed and instantiatable types. Location of the default vtable
     *  inititalization function for interface types. (optional) This function
     *  is used both to fill in virtual functions in the class or default vtable,
     *  and to do type-specific setup such as registering signals and object
     *  properties.
     * @field
     */
    classInit: ClassInitFunc
    /**
     * Location of the class finalization function for
     *  classed and instantiatable types. Location of the default vtable
     *  finalization function for interface types. (optional)
     * @field
     */
    classFinalize: ClassFinalizeFunc
    /**
     * User-supplied data passed to the class init/finalize functions
     * @field
     */
    classData: any
    /**
     * Size of the instance (object) structure (required for instantiatable types only)
     * @field
     */
    instanceSize: number
    /**
     * Prior to GLib 2.10, it specified the number of pre-allocated (cached) instances to reserve memory for (0 indicates no caching). Since GLib 2.10 this field is ignored.
     * @field
     */
    nPreallocs: number
    /**
     * Location of the instance initialization function (optional, for instantiatable types only)
     * @field
     */
    instanceInit: InstanceInitFunc
    /**
     * A #GTypeValueTable function table for generic handling of GValues
     *  of this type (usually only useful for fundamental types)
     * @field
     */
    valueTable: TypeValueTable
  }

  /**
   * This structure is used to provide the type system with the information
   * required to initialize and destruct (finalize) a type's class and
   * its instances.
   *
   * The initialized structure is passed to the g_type_register_static() function
   * (or is copied into the provided #GTypeInfo structure in the
   * g_type_plugin_complete_type_info()). The type system will perform a deep
   * copy of this structure, so its memory does not need to be persistent
   * across invocation of g_type_register_static().
   * @record
   */
  class TypeInfo {
    // Own properties of GObject-2.0.GObject.TypeInfo

    static name: string
  }

  interface TypeInstance {
    // Owm methods of GObject-2.0.GObject.TypeInstance

    getPrivate(privateType: GType): any | null
  }

  /**
   * An opaque structure used as the base of all type instances.
   * @record
   */
  class TypeInstance {
    // Own properties of GObject-2.0.GObject.TypeInstance

    static name: string
  }

  interface TypeInterface {
    // Owm methods of GObject-2.0.GObject.TypeInterface

    /**
     * Returns the corresponding #GTypeInterface structure of the parent type
     * of the instance type to which `g_iface` belongs. This is useful when
     * deriving the implementation of an interface from the parent type and
     * then possibly overriding some methods.
     * @returns the     corresponding #GTypeInterface structure of the parent type of the     instance type to which @g_iface belongs, or %NULL if the parent     type doesn't conform to the interface
     */
    peekParent(): TypeInterface
  }

  /**
   * An opaque structure used as the base of all interface types.
   * @record
   */
  class TypeInterface {
    // Own properties of GObject-2.0.GObject.TypeInterface

    static name: string

    // Constructors of GObject-2.0.GObject.TypeInterface

    /**
     * Adds `prerequisite_type` to the list of prerequisites of `interface_type`.
     * This means that any type implementing `interface_type` must also implement
     * `prerequisite_type`. Prerequisites can be thought of as an alternative to
     * interface derivation (which GType doesn't support). An interface can have
     * at most one instantiatable prerequisite type.
     * @param interfaceType #GType value of an interface type
     * @param prerequisiteType #GType value of an interface or instantiatable type
     */
    static addPrerequisite(interfaceType: GType, prerequisiteType: GType): void
    /**
     * Returns the #GTypePlugin structure for the dynamic interface
     * `interface_type` which has been added to `instance_type,` or %NULL
     * if `interface_type` has not been added to `instance_type` or does
     * not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
     * @param instanceType #GType of an instantiatable type
     * @param interfaceType #GType of an interface type
     * @returns the #GTypePlugin for the dynamic     interface @interface_type of @instance_type
     */
    static getPlugin(instanceType: GType, interfaceType: GType): TypePlugin
    /**
     * Returns the most specific instantiatable prerequisite of an
     * interface type. If the interface type has no instantiatable
     * prerequisite, %G_TYPE_INVALID is returned.
     *
     * See g_type_interface_add_prerequisite() for more information
     * about prerequisites.
     * @param interfaceType an interface type
     * @returns the instantiatable prerequisite type or %G_TYPE_INVALID if none
     */
    static instantiatablePrerequisite(interfaceType: GType): GType
    /**
     * Returns the #GTypeInterface structure of an interface to which the
     * passed in class conforms.
     * @param instanceClass a #GTypeClass structure
     * @param ifaceType an interface ID which this class conforms to
     * @returns the #GTypeInterface     structure of @iface_type if implemented by @instance_class, %NULL     otherwise
     */
    static peek(instanceClass: TypeClass, ifaceType: GType): TypeInterface
    /**
     * Returns the prerequisites of an interfaces type.
     * @param interfaceType an interface type
     * @returns a     newly-allocated zero-terminated array of #GType containing     the prerequisites of @interface_type
     */
    static prerequisites(interfaceType: GType): GType[]
  }

  interface TypeModuleClass {
    // Own fields of GObject-2.0.GObject.TypeModuleClass

    /**
     * the parent class
     * @field
     */
    parentClass: ObjectClass
    /**
     * loads the module and registers one or more types using
     *  g_type_module_register_type().
     * @field
     */
    load: (module: TypeModule) => boolean
    /**
     * unloads the module
     * @field
     */
    unload: (module: TypeModule) => void
    reserved1: () => void
    reserved2: () => void
    reserved3: () => void
    reserved4: () => void
  }

  /**
   * In order to implement dynamic loading of types based on #GTypeModule,
   * the `load` and `unload` functions in #GTypeModuleClass must be implemented.
   * @record
   */
  abstract class TypeModuleClass {
    // Own properties of GObject-2.0.GObject.TypeModuleClass

    static name: string
  }

  interface TypePluginClass {
    // Own fields of GObject-2.0.GObject.TypePluginClass

    /**
     * Increases the use count of the plugin.
     * @field
     */
    usePlugin: TypePluginUse
    /**
     * Decreases the use count of the plugin.
     * @field
     */
    unusePlugin: TypePluginUnuse
    /**
     * Fills in the #GTypeInfo and
     *  #GTypeValueTable structs for the type. The structs are initialized
     *  with `memset(s, 0, sizeof (s))` before calling this function.
     * @field
     */
    completeTypeInfo: TypePluginCompleteTypeInfo
    /**
     * Fills in missing parts of the #GInterfaceInfo
     *  for the interface. The structs is initialized with
     *  `memset(s, 0, sizeof (s))` before calling this function.
     * @field
     */
    completeInterfaceInfo: TypePluginCompleteInterfaceInfo
  }

  /**
   * The #GTypePlugin interface is used by the type system in order to handle
   * the lifecycle of dynamically loaded types.
   * @record
   */
  class TypePluginClass {
    // Own properties of GObject-2.0.GObject.TypePluginClass

    static name: string
  }

  interface TypeQuery {
    // Own fields of GObject-2.0.GObject.TypeQuery

    /**
     * the #GType value of the type
     * @field
     */
    type: GType
    /**
     * the name of the type
     * @field
     */
    typeName: string
    /**
     * the size of the class structure
     * @field
     */
    classSize: number
    /**
     * the size of the instance structure
     * @field
     */
    instanceSize: number
  }

  /**
   * A structure holding information for a specific type.
   *
   * See also: g_type_query()
   * @record
   */
  class TypeQuery {
    // Own properties of GObject-2.0.GObject.TypeQuery

    static name: string
  }

  interface TypeValueTable {
    // Own fields of GObject-2.0.GObject.TypeValueTable

    /**
     * Function to initialize a GValue
     * @field
     */
    valueInit: TypeValueInitFunc
    /**
     * Function to free a GValue
     * @field
     */
    valueFree: TypeValueFreeFunc
    /**
     * Function to copy a GValue
     * @field
     */
    valueCopy: TypeValueCopyFunc
    /**
     * Function to peek the contents of a GValue if they fit
     *   into a pointer
     * @field
     */
    valuePeekPointer: TypeValuePeekPointerFunc
    /**
     * A string format describing how to collect the contents of
     *   this value bit-by-bit. Each character in the format represents
     *   an argument to be collected, and the characters themselves indicate
     *   the type of the argument. Currently supported arguments are:
     *    - `'i'`: Integers, passed as `collect_values[].v_int`
     *    - `'l'`: Longs, passed as `collect_values[].v_long`
     *    - `'d'`: Doubles, passed as `collect_values[].v_double`
     *    - `'p'`: Pointers, passed as `collect_values[].v_pointer`
     *   It should be noted that for variable argument list construction,
     *   ANSI C promotes every type smaller than an integer to an int, and
     *   floats to doubles. So for collection of short int or char, `'i'`
     *   needs to be used, and for collection of floats `'d'`.
     * @field
     */
    collectFormat: string
    /**
     * Function to initialize a GValue from the values
     *   collected from variadic arguments
     * @field
     */
    collectValue: TypeValueCollectFunc
    /**
     * Format description of the arguments to collect for `lcopy_value,`
     *   analogous to `collect_format`. Usually, `lcopy_format` string consists
     *   only of `'p'`s to provide lcopy_value() with pointers to storage locations.
     * @field
     */
    lcopyFormat: string
    /**
     * Function to store the contents of a value into the
     *   locations collected from variadic arguments
     * @field
     */
    lcopyValue: TypeValueLCopyFunc
  }

  /**
   * The #GTypeValueTable provides the functions required by the #GValue
   * implementation, to serve as a container for values of a type.
   * @record
   */
  class TypeValueTable {
    // Own properties of GObject-2.0.GObject.TypeValueTable

    static name: string
  }

  interface Value {
    // Own fields of GObject-2.0.GObject.Value

    data: _Value__data__union[]

    // Owm methods of GObject-2.0.GObject.Value

    /**
     * Copies the value of `src_value` into `dest_value`.
     * @param destValue An initialized #GValue structure of the same type as `src_value`.
     */
    copy(destValue: any): void
    /**
     * Get the contents of a %G_TYPE_OBJECT derived #GValue, increasing
     * its reference count. If the contents of the #GValue are %NULL, then
     * %NULL will be returned.
     * @returns object content of @value,          should be unreferenced when no longer needed.
     */
    dupObject(): Object | null
    /**
     * Get a copy the contents of a %G_TYPE_STRING #GValue.
     * @returns a newly allocated copy of the string content of @value
     */
    dupString(): string | null
    /**
     * Get the contents of a variant #GValue, increasing its refcount. The returned
     * #GVariant is never floating.
     * @returns variant contents of @value (may be %NULL);    should be unreffed using g_variant_unref() when no longer needed
     */
    dupVariant(): GLib.Variant | null
    /**
     * Determines if `value` will fit inside the size of a pointer value.
     * This is an internal function introduced mainly for C marshallers.
     * @returns %TRUE if @value will fit inside a pointer value.
     */
    fitsPointer(): boolean
    /**
     * Get the contents of a %G_TYPE_BOOLEAN #GValue.
     * @returns boolean contents of @value
     */
    getBoolean(): boolean
    // Has conflict: getBoxed(): any | null
    /**
     * Do not use this function; it is broken on platforms where the %char
     * type is unsigned, such as ARM and PowerPC.  See g_value_get_schar().
     *
     * Get the contents of a %G_TYPE_CHAR #GValue.
     * @returns character contents of @value
     */
    getChar(): number
    /**
     * Get the contents of a %G_TYPE_DOUBLE #GValue.
     * @returns double contents of @value
     */
    getDouble(): number
    /**
     * Get the contents of a %G_TYPE_ENUM #GValue.
     * @returns enum contents of @value
     */
    getEnum(): number
    /**
     * Get the contents of a %G_TYPE_FLAGS #GValue.
     * @returns flags contents of @value
     */
    getFlags(): number
    /**
     * Get the contents of a %G_TYPE_FLOAT #GValue.
     * @returns float contents of @value
     */
    getFloat(): number
    /**
     * Get the contents of a %G_TYPE_GTYPE #GValue.
     * @returns the #GType stored in @value
     */
    getGtype(): GType
    /**
     * Get the contents of a %G_TYPE_INT #GValue.
     * @returns integer contents of @value
     */
    getInt(): number
    /**
     * Get the contents of a %G_TYPE_INT64 #GValue.
     * @returns 64bit integer contents of @value
     */
    getInt64(): number
    /**
     * Get the contents of a %G_TYPE_LONG #GValue.
     * @returns long integer contents of @value
     */
    getLong(): number
    /**
     * Get the contents of a %G_TYPE_OBJECT derived #GValue.
     * @returns object contents of @value
     */
    getObject(): Object | null
    /**
     * Get the contents of a %G_TYPE_PARAM #GValue.
     * @returns #GParamSpec content of @value
     */
    getParam(): ParamSpec
    /**
     * Get the contents of a pointer #GValue.
     * @returns pointer contents of @value
     */
    getPointer(): any | null
    /**
     * Get the contents of a %G_TYPE_CHAR #GValue.
     * @returns signed 8 bit integer contents of @value
     */
    getSchar(): number
    /**
     * Get the contents of a %G_TYPE_STRING #GValue.
     * @returns string content of @value
     */
    getString(): string | null
    /**
     * Get the contents of a %G_TYPE_UCHAR #GValue.
     * @returns unsigned character contents of @value
     */
    getUchar(): number
    /**
     * Get the contents of a %G_TYPE_UINT #GValue.
     * @returns unsigned integer contents of @value
     */
    getUint(): number
    /**
     * Get the contents of a %G_TYPE_UINT64 #GValue.
     * @returns unsigned 64bit integer contents of @value
     */
    getUint64(): number
    /**
     * Get the contents of a %G_TYPE_ULONG #GValue.
     * @returns unsigned long integer contents of @value
     */
    getUlong(): number
    /**
     * Get the contents of a variant #GValue.
     * @returns variant contents of @value (may be %NULL)
     */
    getVariant(): GLib.Variant | null
    /**
     * Initializes `value` with the default value of `type`.
     * @param gType Type the #GValue should hold values of.
     * @returns the #GValue structure that has been passed in
     */
    init(gType: GType): any
    /**
     * Initializes and sets `value` from an instantiatable type via the
     * value_table's collect_value() function.
     *
     * Note: The `value` will be initialised with the exact type of
     * `instance`.  If you wish to set the `value'`s type to a different GType
     * (such as a parent class GType), you need to manually call
     * g_value_init() and g_value_set_instance().
     * @param instance the instance
     */
    initFromInstance(instance: TypeInstance): void
    /**
     * Returns the value contents as pointer. This function asserts that
     * g_value_fits_pointer() returned %TRUE for the passed in value.
     * This is an internal function introduced mainly for C marshallers.
     * @returns the value contents as pointer
     */
    peekPointer(): any | null
    /**
     * Clears the current value in `value` and resets it to the default value
     * (as if the value had just been initialized).
     * @returns the #GValue structure that has been passed in
     */
    reset(): any
    /**
     * Set the contents of a %G_TYPE_BOOLEAN #GValue to `v_boolean`.
     * @param vBoolean boolean value to be set
     */
    setBoolean(vBoolean: boolean): void
    /**
     * Set the contents of a %G_TYPE_BOXED derived #GValue to `v_boxed`.
     * @param vBoxed boxed value to be set
     */
    setBoxed(vBoxed: any | null): void
    /**
     * This is an internal function introduced mainly for C marshallers.
     * @param vBoxed duplicated unowned boxed value to be set
     */
    setBoxedTakeOwnership(vBoxed: any | null): void
    /**
     * Set the contents of a %G_TYPE_CHAR #GValue to `v_char`.
     * @param vChar character value to be set
     */
    setChar(vChar: number): void
    /**
     * Set the contents of a %G_TYPE_DOUBLE #GValue to `v_double`.
     * @param vDouble double value to be set
     */
    setDouble(vDouble: number): void
    /**
     * Set the contents of a %G_TYPE_ENUM #GValue to `v_enum`.
     * @param vEnum enum value to be set
     */
    setEnum(vEnum: number): void
    /**
     * Set the contents of a %G_TYPE_FLAGS #GValue to `v_flags`.
     * @param vFlags flags value to be set
     */
    setFlags(vFlags: number): void
    /**
     * Set the contents of a %G_TYPE_FLOAT #GValue to `v_float`.
     * @param vFloat float value to be set
     */
    setFloat(vFloat: number): void
    /**
     * Set the contents of a %G_TYPE_GTYPE #GValue to `v_gtype`.
     * @param vGtype #GType to be set
     */
    setGtype(vGtype: GType): void
    /**
     * Sets `value` from an instantiatable type via the
     * value_table's collect_value() function.
     * @param instance the instance
     */
    setInstance(instance: any | null): void
    /**
     * Set the contents of a %G_TYPE_INT #GValue to `v_int`.
     * @param vInt integer value to be set
     */
    setInt(vInt: number): void
    /**
     * Set the contents of a %G_TYPE_INT64 #GValue to `v_int6`4.
     * @param vInt64 64bit integer value to be set
     */
    setInt64(vInt64: number): void
    /**
     * Set the contents of a %G_TYPE_STRING #GValue to `v_string`.  The string is
     * assumed to be static and interned (canonical, for example from
     * g_intern_string()), and is thus not duplicated when setting the #GValue.
     * @param vString static string to be set
     */
    setInternedString(vString: string | null): void
    /**
     * Set the contents of a %G_TYPE_LONG #GValue to `v_long`.
     * @param vLong long integer value to be set
     */
    setLong(vLong: number): void
    /**
     * Set the contents of a %G_TYPE_OBJECT derived #GValue to `v_object`.
     *
     * g_value_set_object() increases the reference count of `v_object`
     * (the #GValue holds a reference to `v_object)`.  If you do not wish
     * to increase the reference count of the object (i.e. you wish to
     * pass your current reference to the #GValue because you no longer
     * need it), use g_value_take_object() instead.
     *
     * It is important that your #GValue holds a reference to `v_object` (either its
     * own, or one it has taken) to ensure that the object won't be destroyed while
     * the #GValue still exists).
     * @param vObject object value to be set
     */
    setObject(vObject: Object | null): void
    /**
     * Set the contents of a %G_TYPE_PARAM #GValue to `param`.
     * @param param the #GParamSpec to be set
     */
    setParam(param: ParamSpec | null): void
    /**
     * Set the contents of a pointer #GValue to `v_pointer`.
     * @param vPointer pointer value to be set
     */
    setPointer(vPointer: any | null): void
    /**
     * Set the contents of a %G_TYPE_CHAR #GValue to `v_char`.
     * @param vChar signed 8 bit integer to be set
     */
    setSchar(vChar: number): void
    /**
     * Set the contents of a %G_TYPE_BOXED derived #GValue to `v_boxed`.
     *
     * The boxed value is assumed to be static, and is thus not duplicated
     * when setting the #GValue.
     * @param vBoxed static boxed value to be set
     */
    setStaticBoxed(vBoxed: any | null): void
    /**
     * Set the contents of a %G_TYPE_STRING #GValue to `v_string`.
     * The string is assumed to be static, and is thus not duplicated
     * when setting the #GValue.
     *
     * If the the string is a canonical string, using g_value_set_interned_string()
     * is more appropriate.
     * @param vString static string to be set
     */
    setStaticString(vString: string | null): void
    /**
     * Set the contents of a %G_TYPE_STRING #GValue to a copy of `v_string`.
     * @param vString caller-owned string to be duplicated for the #GValue
     */
    setString(vString: string | null): void
    /**
     * This is an internal function introduced mainly for C marshallers.
     * @param vString duplicated unowned string to be set
     */
    setStringTakeOwnership(vString: string | null): void
    /**
     * Set the contents of a %G_TYPE_UCHAR #GValue to `v_uchar`.
     * @param vUchar unsigned character value to be set
     */
    setUchar(vUchar: number): void
    /**
     * Set the contents of a %G_TYPE_UINT #GValue to `v_uint`.
     * @param vUint unsigned integer value to be set
     */
    setUint(vUint: number): void
    /**
     * Set the contents of a %G_TYPE_UINT64 #GValue to `v_uint6`4.
     * @param vUint64 unsigned 64bit integer value to be set
     */
    setUint64(vUint64: number): void
    /**
     * Set the contents of a %G_TYPE_ULONG #GValue to `v_ulong`.
     * @param vUlong unsigned long integer value to be set
     */
    setUlong(vUlong: number): void
    /**
     * Set the contents of a variant #GValue to `variant`.
     * If the variant is floating, it is consumed.
     * @param variant a #GVariant, or %NULL
     */
    setVariant(variant: GLib.Variant | null): void
    /**
     * Steal ownership on contents of a %G_TYPE_STRING #GValue.
     * As a result of this operation the value's contents will be reset to %NULL.
     *
     * The purpose of this call is to provide a way to avoid an extra copy
     * when some object have been serialized into string through #GValue API.
     *
     * NOTE: for safety and compatibility purposes, if #GValue contains
     * static string, or an interned one, this function will return a copy
     * of the string. Otherwise the transfer notation would be ambiguous.
     * @returns string content of @value;  Should be freed with g_free() when no longer needed.
     */
    stealString(): string | null
    /**
     * Sets the contents of a %G_TYPE_BOXED derived #GValue to `v_boxed`
     * and takes over the ownership of the caller’s reference to `v_boxed;`
     * the caller doesn’t have to unref it any more.
     * @param vBoxed duplicated unowned boxed value to be set
     */
    takeBoxed(vBoxed: any | null): void
    /**
     * Sets the contents of a %G_TYPE_STRING #GValue to `v_string`.
     * @param vString string to take ownership of
     */
    takeString(vString: string | null): void
    /**
     * Set the contents of a variant #GValue to `variant,` and takes over
     * the ownership of the caller's reference to `variant;`
     * the caller doesn't have to unref it any more (i.e. the reference
     * count of the variant is not increased).
     *
     * If `variant` was floating then its floating reference is converted to
     * a hard reference.
     *
     * If you want the #GValue to hold its own reference to `variant,` use
     * g_value_set_variant() instead.
     *
     * This is an internal function introduced mainly for C marshallers.
     * @param variant a #GVariant, or %NULL
     */
    takeVariant(variant: GLib.Variant | null): void
    /**
     * Tries to cast the contents of `src_value` into a type appropriate
     * to store in `dest_value,` e.g. to transform a %G_TYPE_INT value
     * into a %G_TYPE_FLOAT value. Performing transformations between
     * value types might incur precision lossage. Especially
     * transformations into strings might reveal seemingly arbitrary
     * results and shouldn't be relied upon for production code (such
     * as rcfile value or object property serialization).
     * @param destValue Target value.
     * @returns Whether a transformation rule was found and could be applied.  Upon failing transformations, @dest_value is left untouched.
     */
    transform(destValue: any): boolean
    /**
     * Clears the current value in `value` (if any) and "unsets" the type,
     * this releases all resources associated with this GValue. An unset
     * value is the same as an uninitialized (zero-filled) #GValue
     * structure.
     */
    unset(): void
    /**
     * Get the contents of a %G_TYPE_BOXED derived #GValue.
     * @returns boxed contents of @value
     */
    getBoxed<T = unknown>(): T
  }

  /**
   * An opaque structure used to hold different types of values.
   *
   * The data within the structure has protected scope: it is accessible only
   * to functions within a #GTypeValueTable structure, or implementations of
   * the g_value_*() API. That is, code portions which implement new fundamental
   * types.
   *
   * #GValue users cannot make any assumptions about how data is stored
   * within the 2 element `data` union, and the `g_type` member should
   * only be accessed through the G_VALUE_TYPE() macro.
   * @record
   */
  class Value {
    // Own properties of GObject-2.0.GObject.Value

    static name: string

    // Constructors of GObject-2.0.GObject.Value

    /**
     * Returns whether a #GValue of type `src_type` can be copied into
     * a #GValue of type `dest_type`.
     * @param srcType source type to be copied.
     * @param destType destination type for copying.
     * @returns %TRUE if g_value_copy() is possible with @src_type and @dest_type.
     */
    static typeCompatible(srcType: GType, destType: GType): boolean
    /**
     * Check whether g_value_transform() is able to transform values
     * of type `src_type` into values of type `dest_type`. Note that for
     * the types to be transformable, they must be compatible or a
     * transformation function must be registered.
     * @param srcType Source type.
     * @param destType Target type.
     * @returns %TRUE if the transformation is possible, %FALSE otherwise.
     */
    static typeTransformable(srcType: GType, destType: GType): boolean
  }

  interface ValueArray {
    // Own fields of GObject-2.0.GObject.ValueArray

    /**
     * number of values contained in the array
     * @field
     */
    nValues: number
    /**
     * array of values
     * @field
     */
    values: any

    // Owm methods of GObject-2.0.GObject.ValueArray

    /**
     * Insert a copy of `value` as last element of `value_array`. If `value` is
     * %NULL, an uninitialized value is appended.
     * @param value #GValue to copy into #GValueArray, or %NULL
     * @returns the #GValueArray passed in as @value_array
     */
    append(value: any | null): ValueArray
    /**
     * Construct an exact copy of a #GValueArray by duplicating all its
     * contents.
     * @returns Newly allocated copy of #GValueArray
     */
    copy(): ValueArray
    /**
     * Return a pointer to the value at `index_` containd in `value_array`.
     * @param index index of the value of interest
     * @returns pointer to a value at @index_ in @value_array
     */
    getNth(index: number): any
    /**
     * Insert a copy of `value` at specified position into `value_array`. If `value`
     * is %NULL, an uninitialized value is inserted.
     * @param index insertion position, must be <= value_array->;n_values
     * @param value #GValue to copy into #GValueArray, or %NULL
     * @returns the #GValueArray passed in as @value_array
     */
    insert(index: number, value: any | null): ValueArray
    /**
     * Insert a copy of `value` as first element of `value_array`. If `value` is
     * %NULL, an uninitialized value is prepended.
     * @param value #GValue to copy into #GValueArray, or %NULL
     * @returns the #GValueArray passed in as @value_array
     */
    prepend(value: any | null): ValueArray
    /**
     * Remove the value at position `index_` from `value_array`.
     * @param index position of value to remove, which must be less than     `value_array->`n_values
     * @returns the #GValueArray passed in as @value_array
     */
    remove(index: number): ValueArray
    /**
     * Sort `value_array` using `compare_func` to compare the elements according
     * to the semantics of #GCompareDataFunc.
     *
     * The current implementation uses the same sorting algorithm as standard
     * C qsort() function.
     * @param compareFunc function to compare elements
     * @returns the #GValueArray passed in as @value_array
     */
    sort(compareFunc: GLib.CompareDataFunc): ValueArray
  }

  /**
   * A `GValueArray` is a container structure to hold an array of generic values.
   *
   * The prime purpose of a `GValueArray` is for it to be used as an
   * object property that holds an array of values. A `GValueArray` wraps
   * an array of `GValue` elements in order for it to be used as a boxed
   * type through `G_TYPE_VALUE_ARRAY`.
   *
   * `GValueArray` is deprecated in favour of `GArray` since GLib 2.32.
   * It is possible to create a `GArray` that behaves like a `GValueArray`
   * by using the size of `GValue` as the element size, and by setting
   * [method`GObject`.Value.unset] as the clear function using
   * [func`GLib`.Array.set_clear_func], for instance, the following code:
   *
   * ```c
   *   GValueArray *array = g_value_array_new (10);
   * ```
   *
   * can be replaced by:
   *
   * ```c
   *   GArray *array = g_array_sized_new (FALSE, TRUE, sizeof (GValue), 10);
   *   g_array_set_clear_func (array, (GDestroyNotify) g_value_unset);
   * ```
   * @record
   */
  class ValueArray {
    // Own properties of GObject-2.0.GObject.ValueArray

    static name: string

    // Constructors of GObject-2.0.GObject.ValueArray

    /**
     * Allocate and initialize a new #GValueArray, optionally preserve space
     * for `n_prealloced` elements. New arrays always contain 0 elements,
     * regardless of the value of `n_prealloced`.
     * @constructor
     * @param nPrealloced number of values to preallocate space for
     * @returns a newly allocated #GValueArray with 0 values
     */
    constructor(nPrealloced: number)
    /**
     * Allocate and initialize a new #GValueArray, optionally preserve space
     * for `n_prealloced` elements. New arrays always contain 0 elements,
     * regardless of the value of `n_prealloced`.
     * @constructor
     * @param nPrealloced number of values to preallocate space for
     * @returns a newly allocated #GValueArray with 0 values
     */
    static new(nPrealloced: number): ValueArray
  }

  interface WeakRef {}

  /**
   * A structure containing a weak reference to a #GObject.
   *
   * A `GWeakRef` can either be empty (i.e. point to %NULL), or point to an
   * object for as long as at least one "strong" reference to that object
   * exists. Before the object's #GObjectClass.dispose method is called,
   * every #GWeakRef associated with becomes empty (i.e. points to %NULL).
   *
   * Like #GValue, #GWeakRef can be statically allocated, stack- or
   * heap-allocated, or embedded in larger structures.
   *
   * Unlike g_object_weak_ref() and g_object_add_weak_pointer(), this weak
   * reference is thread-safe: converting a weak pointer to a reference is
   * atomic with respect to invalidation of weak pointers to destroyed
   * objects.
   *
   * If the object's #GObjectClass.dispose method results in additional
   * references to the object being held (‘re-referencing’), any #GWeakRefs taken
   * before it was disposed will continue to point to %NULL.  Any #GWeakRefs taken
   * during disposal and after re-referencing, or after disposal has returned due
   * to the re-referencing, will continue to point to the object until its refcount
   * goes back to zero, at which point they too will be invalidated.
   *
   * It is invalid to take a #GWeakRef on an object during #GObjectClass.dispose
   * without first having or creating a strong reference to the object.
   * @record
   */
  class WeakRef {
    // Own properties of GObject-2.0.GObject.WeakRef

    static name: string
  }

  interface TypeCValue {
    // Own fields of GObject-2.0.GObject.TypeCValue

    /**
     * the field for holding integer values
     * @field
     */
    vInt: number
    /**
     * the field for holding long integer values
     * @field
     */
    vLong: number
    /**
     * the field for holding 64 bit integer values
     * @field
     */
    vInt64: number
    /**
     * the field for holding floating point values
     * @field
     */
    vDouble: number
    /**
     * the field for holding pointers
     * @field
     */
    vPointer: any
  }

  /**
   * A union holding one collected value.
   * @union
   */
  class TypeCValue {
    // Own properties of GObject-2.0.GObject.TypeCValue

    static name: string
  }

  interface _Value__data__union {
    // Own fields of GObject-2.0.GObject._Value__data__union

    vInt: number
    vUint: number
    vLong: number
    vUlong: number
    vInt64: number
    vUint64: number
    vFloat: number
    vDouble: number
    vPointer: any
  }

  class _Value__data__union {
    // Own properties of GObject-2.0.GObject._Value__data__union

    static name: string
  }

  type SignalCMarshaller = ClosureMarshal
  type SignalCVaMarshaller = any
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace Graphene {
  /**
   * Specify the order of the rotations on each axis.
   *
   * The %GRAPHENE_EULER_ORDER_DEFAULT value is special, and is used
   * as an alias for one of the other orders.
   */
  enum EulerOrder {
    /**
     * Rotate in the default order; the
     *   default order is one of the following enumeration values
     */
    DEFAULT,
    /**
     * Rotate in the X, Y, and Z order. Deprecated in
     *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SXYZ
     */
    XYZ,
    /**
     * Rotate in the Y, Z, and X order. Deprecated in
     *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SYZX
     */
    YZX,
    /**
     * Rotate in the Z, X, and Y order. Deprecated in
     *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SZXY
     */
    ZXY,
    /**
     * Rotate in the X, Z, and Y order. Deprecated in
     *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SXZY
     */
    XZY,
    /**
     * Rotate in the Y, X, and Z order. Deprecated in
     *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SYXZ
     */
    YXZ,
    /**
     * Rotate in the Z, Y, and X order. Deprecated in
     *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SZYX
     */
    ZYX,
    /**
     * Defines a static rotation along the X, Y, and Z axes (Since: 1.10)
     */
    SXYZ,
    /**
     * Defines a static rotation along the X, Y, and X axes (Since: 1.10)
     */
    SXYX,
    /**
     * Defines a static rotation along the X, Z, and Y axes (Since: 1.10)
     */
    SXZY,
    /**
     * Defines a static rotation along the X, Z, and X axes (Since: 1.10)
     */
    SXZX,
    /**
     * Defines a static rotation along the Y, Z, and X axes (Since: 1.10)
     */
    SYZX,
    /**
     * Defines a static rotation along the Y, Z, and Y axes (Since: 1.10)
     */
    SYZY,
    /**
     * Defines a static rotation along the Y, X, and Z axes (Since: 1.10)
     */
    SYXZ,
    /**
     * Defines a static rotation along the Y, X, and Y axes (Since: 1.10)
     */
    SYXY,
    /**
     * Defines a static rotation along the Z, X, and Y axes (Since: 1.10)
     */
    SZXY,
    /**
     * Defines a static rotation along the Z, X, and Z axes (Since: 1.10)
     */
    SZXZ,
    /**
     * Defines a static rotation along the Z, Y, and X axes (Since: 1.10)
     */
    SZYX,
    /**
     * Defines a static rotation along the Z, Y, and Z axes (Since: 1.10)
     */
    SZYZ,
    /**
     * Defines a relative rotation along the Z, Y, and X axes (Since: 1.10)
     */
    RZYX,
    /**
     * Defines a relative rotation along the X, Y, and X axes (Since: 1.10)
     */
    RXYX,
    /**
     * Defines a relative rotation along the Y, Z, and X axes (Since: 1.10)
     */
    RYZX,
    /**
     * Defines a relative rotation along the X, Z, and X axes (Since: 1.10)
     */
    RXZX,
    /**
     * Defines a relative rotation along the X, Z, and Y axes (Since: 1.10)
     */
    RXZY,
    /**
     * Defines a relative rotation along the Y, Z, and Y axes (Since: 1.10)
     */
    RYZY,
    /**
     * Defines a relative rotation along the Z, X, and Y axes (Since: 1.10)
     */
    RZXY,
    /**
     * Defines a relative rotation along the Y, X, and Y axes (Since: 1.10)
     */
    RYXY,
    /**
     * Defines a relative rotation along the Y, X, and Z axes (Since: 1.10)
     */
    RYXZ,
    /**
     * Defines a relative rotation along the Z, X, and Z axes (Since: 1.10)
     */
    RZXZ,
    /**
     * Defines a relative rotation along the X, Y, and Z axes (Since: 1.10)
     */
    RXYZ,
    /**
     * Defines a relative rotation along the Z, Y, and Z axes (Since: 1.10)
     */
    RZYZ,
  }
  /**
   * The type of intersection.
   */
  enum RayIntersectionKind {
    /**
     * No intersection
     */
    NONE,
    /**
     * The ray is entering the intersected
     *   object
     */
    ENTER,
    /**
     * The ray is leaving the intersected
     *   object
     */
    LEAVE,
  }
  const PI: number
  const PI_2: number
  /**
   * Evaluates to the number of components of a #graphene_vec2_t.
   *
   * This symbol is useful when declaring a C array of floating
   * point values to be used with graphene_vec2_init_from_float() and
   * graphene_vec2_to_float(), e.g.
   *
   *
   * ```
   *   float v[GRAPHENE_VEC2_LEN];
   *
   *   // vec is defined elsewhere
   *   graphene_vec2_to_float (&vec, v);
   *
   *   for (int i = 0; i < GRAPHENE_VEC2_LEN; i++)
   *     fprintf (stdout, "component %d: %g\n", i, v[i]);
   * ```
   *
   */
  const VEC2_LEN: number
  /**
   * Evaluates to the number of components of a #graphene_vec3_t.
   *
   * This symbol is useful when declaring a C array of floating
   * point values to be used with graphene_vec3_init_from_float() and
   * graphene_vec3_to_float(), e.g.
   *
   *
   * ```
   *   float v[GRAPHENE_VEC3_LEN];
   *
   *   // vec is defined elsewhere
   *   graphene_vec3_to_float (&vec, v);
   *
   *   for (int i = 0; i < GRAPHENE_VEC2_LEN; i++)
   *     fprintf (stdout, "component %d: %g\n", i, v[i]);
   * ```
   *
   */
  const VEC3_LEN: number
  /**
   * Evaluates to the number of components of a #graphene_vec4_t.
   *
   * This symbol is useful when declaring a C array of floating
   * point values to be used with graphene_vec4_init_from_float() and
   * graphene_vec4_to_float(), e.g.
   *
   *
   * ```
   *   float v[GRAPHENE_VEC4_LEN];
   *
   *   // vec is defined elsewhere
   *   graphene_vec4_to_float (&vec, v);
   *
   *   for (int i = 0; i < GRAPHENE_VEC4_LEN; i++)
   *     fprintf (stdout, "component %d: %g\n", i, v[i]);
   * ```
   *
   */
  const VEC4_LEN: number
  /**
   * A degenerate #graphene_box_t that can only be expanded.
   *
   * The returned value is owned by Graphene and should not be modified or freed.
   * @returns a #graphene_box_t
   */
  function boxEmpty(): Box
  /**
   * A degenerate #graphene_box_t that cannot be expanded.
   *
   * The returned value is owned by Graphene and should not be modified or freed.
   * @returns a #graphene_box_t
   */
  function boxInfinite(): Box
  /**
   * A #graphene_box_t with the minimum vertex set at (-1, -1, -1) and the
   * maximum vertex set at (0, 0, 0).
   *
   * The returned value is owned by Graphene and should not be modified or freed.
   * @returns a #graphene_box_t
   */
  function boxMinusOne(): Box
  /**
   * A #graphene_box_t with the minimum vertex set at (0, 0, 0) and the
   * maximum vertex set at (1, 1, 1).
   *
   * The returned value is owned by Graphene and should not be modified or freed.
   * @returns a #graphene_box_t
   */
  function boxOne(): Box
  /**
   * A #graphene_box_t with the minimum vertex set at (-1, -1, -1) and the
   * maximum vertex set at (1, 1, 1).
   *
   * The returned value is owned by Graphene and should not be modified or freed.
   * @returns a #graphene_box_t
   */
  function boxOneMinusOne(): Box
  /**
   * A #graphene_box_t with both the minimum and maximum vertices set at (0, 0, 0).
   *
   * The returned value is owned by Graphene and should not be modified or freed.
   * @returns a #graphene_box_t
   */
  function boxZero(): Box
  /**
   * Retrieves a constant point with all three coordinates set to 0.
   * @returns a zero point
   */
  function point3dZero(): Point3D
  /**
   * Returns a point fixed at (0, 0).
   * @returns a fixed point
   */
  function pointZero(): Point
  /**
   * Allocates a new #graphene_rect_t.
   *
   * The contents of the returned rectangle are undefined.
   * @returns the newly allocated rectangle
   */
  function rectAlloc(): Rect
  /**
   * Returns a degenerate rectangle with origin fixed at (0, 0) and
   * a size of 0, 0.
   * @returns a fixed rectangle
   */
  function rectZero(): Rect
  /**
   * A constant pointer to a zero #graphene_size_t, useful for
   * equality checks and interpolations.
   * @returns a constant size
   */
  function sizeZero(): Size
  /**
   * Retrieves a constant vector with (1, 1) components.
   * @returns the one vector
   */
  function vec2One(): Vec2
  /**
   * Retrieves a constant vector with (1, 0) components.
   * @returns the X axis vector
   */
  function vec2XAxis(): Vec2
  /**
   * Retrieves a constant vector with (0, 1) components.
   * @returns the Y axis vector
   */
  function vec2YAxis(): Vec2
  /**
   * Retrieves a constant vector with (0, 0) components.
   * @returns the zero vector
   */
  function vec2Zero(): Vec2
  /**
   * Provides a constant pointer to a vector with three components,
   * all sets to 1.
   * @returns a constant vector
   */
  function vec3One(): Vec3
  /**
   * Provides a constant pointer to a vector with three components
   * with values set to (1, 0, 0).
   * @returns a constant vector
   */
  function vec3XAxis(): Vec3
  /**
   * Provides a constant pointer to a vector with three components
   * with values set to (0, 1, 0).
   * @returns a constant vector
   */
  function vec3YAxis(): Vec3
  /**
   * Provides a constant pointer to a vector with three components
   * with values set to (0, 0, 1).
   * @returns a constant vector
   */
  function vec3ZAxis(): Vec3
  /**
   * Provides a constant pointer to a vector with three components,
   * all sets to 0.
   * @returns a constant vector
   */
  function vec3Zero(): Vec3
  /**
   * Retrieves a pointer to a #graphene_vec4_t with all its
   * components set to 1.
   * @returns a constant vector
   */
  function vec4One(): Vec4
  /**
   * Retrieves a pointer to a #graphene_vec4_t with its
   * components set to (0, 0, 0, 1).
   * @returns a constant vector
   */
  function vec4WAxis(): Vec4
  /**
   * Retrieves a pointer to a #graphene_vec4_t with its
   * components set to (1, 0, 0, 0).
   * @returns a constant vector
   */
  function vec4XAxis(): Vec4
  /**
   * Retrieves a pointer to a #graphene_vec4_t with its
   * components set to (0, 1, 0, 0).
   * @returns a constant vector
   */
  function vec4YAxis(): Vec4
  /**
   * Retrieves a pointer to a #graphene_vec4_t with its
   * components set to (0, 0, 1, 0).
   * @returns a constant vector
   */
  function vec4ZAxis(): Vec4
  /**
   * Retrieves a pointer to a #graphene_vec4_t with all its
   * components set to 0.
   * @returns a constant vector
   */
  function vec4Zero(): Vec4
  interface Box {
    // Owm methods of Graphene-1.0.Graphene.Box

    /**
     * Checks whether the #graphene_box_t `a` contains the given
     * #graphene_box_t `b`.
     * @param b a #graphene_box_t
     * @returns `true` if the box is contained in the given box
     */
    containsBox(b: Box): boolean
    /**
     * Checks whether `box` contains the given `point`.
     * @param point the coordinates to check
     * @returns `true` if the point is contained in the given box
     */
    containsPoint(point: Point3D): boolean
    /**
     * Checks whether the two given boxes are equal.
     * @param b a #graphene_box_t
     * @returns `true` if the boxes are equal
     */
    equal(b: Box): boolean
    /**
     * Expands the dimensions of `box` to include the coordinates at `point`.
     * @param point the coordinates of the point to include
     */
    expand(point: Point3D): /* res */ Box
    /**
     * Expands the dimensions of `box` by the given `scalar` value.
     *
     * If `scalar` is positive, the #graphene_box_t will grow; if `scalar` is
     * negative, the #graphene_box_t will shrink.
     * @param scalar a scalar value
     */
    expandScalar(scalar: number): /* res */ Box
    /**
     * Expands the dimensions of `box` to include the coordinates of the
     * given vector.
     * @param vec the coordinates of the point to include, as a #graphene_vec3_t
     */
    expandVec3(vec: Vec3): /* res */ Box
    /**
     * Frees the resources allocated by graphene_box_alloc().
     */
    free(): void
    /**
     * Computes the bounding #graphene_sphere_t capable of containing the given
     * #graphene_box_t.
     */
    getBoundingSphere(): /* sphere */ Sphere
    /**
     * Retrieves the coordinates of the center of a #graphene_box_t.
     */
    getCenter(): /* center */ Point3D
    /**
     * Retrieves the size of the `box` on the Z axis.
     * @returns the depth of the box
     */
    getDepth(): number
    /**
     * Retrieves the size of the `box` on the Y axis.
     * @returns the height of the box
     */
    getHeight(): number
    /**
     * Retrieves the coordinates of the maximum point of the given
     * #graphene_box_t.
     */
    getMax(): /* max */ Point3D
    /**
     * Retrieves the coordinates of the minimum point of the given
     * #graphene_box_t.
     */
    getMin(): /* min */ Point3D
    /**
     * Retrieves the size of the box on all three axes, and stores
     * it into the given `size` vector.
     */
    getSize(): /* size */ Vec3
    /**
     * Computes the vertices of the given #graphene_box_t.
     */
    getVertices(): /* vertices */ Vec3[]
    /**
     * Retrieves the size of the `box` on the X axis.
     * @returns the width of the box
     */
    getWidth(): number
    /**
     * Initializes the given #graphene_box_t with two vertices.
     * @param min the coordinates of the minimum vertex
     * @param max the coordinates of the maximum vertex
     * @returns the initialized #graphene_box_t
     */
    init(min: Point3D | null, max: Point3D | null): Box
    /**
     * Initializes the given #graphene_box_t with the vertices of
     * another #graphene_box_t.
     * @param src a #graphene_box_t
     * @returns the initialized #graphene_box_t
     */
    initFromBox(src: Box): Box
    /**
     * Initializes the given #graphene_box_t with the given array
     * of vertices.
     *
     * If `n_points` is 0, the returned box is initialized with
     * graphene_box_empty().
     * @param points an array of #graphene_point3d_t
     * @returns the initialized #graphene_box_t
     */
    initFromPoints(points: Point3D[]): Box
    /**
     * Initializes the given #graphene_box_t with two vertices
     * stored inside #graphene_vec3_t.
     * @param min the coordinates of the minimum vertex
     * @param max the coordinates of the maximum vertex
     * @returns the initialized #graphene_box_t
     */
    initFromVec3(min: Vec3 | null, max: Vec3 | null): Box
    /**
     * Initializes the given #graphene_box_t with the given array
     * of vertices.
     *
     * If `n_vectors` is 0, the returned box is initialized with
     * graphene_box_empty().
     * @param vectors an array of #graphene_vec3_t
     * @returns the initialized #graphene_box_t
     */
    initFromVectors(vectors: Vec3[]): Box
    /**
     * Intersects the two given #graphene_box_t.
     *
     * If the two boxes do not intersect, `res` will contain a degenerate box
     * initialized with graphene_box_empty().
     * @param b a #graphene_box_t
     * @returns true if the two boxes intersect
     */
    intersection(b: Box): [/* returnType */ boolean, /* res */ Box]
    /**
     * Unions the two given #graphene_box_t.
     * @param b the box to union to `a`
     */
    union(b: Box): /* res */ Box
  }

  /**
   * A 3D box, described as the volume between a minimum and
   * a maximum vertices.
   * @record
   */
  class Box {
    // Own properties of Graphene-1.0.Graphene.Box

    static name: string

    // Constructors of Graphene-1.0.Graphene.Box

    /**
     * Allocates a new #graphene_box_t.
     *
     * The contents of the returned structure are undefined.
     * @constructor
     * @returns the newly allocated #graphene_box_t structure.   Use graphene_box_free() to free the resources allocated by this function
     */
    static alloc(): Box
    /**
     * A degenerate #graphene_box_t that can only be expanded.
     *
     * The returned value is owned by Graphene and should not be modified or freed.
     * @returns a #graphene_box_t
     */
    static empty(): Box
    /**
     * A degenerate #graphene_box_t that cannot be expanded.
     *
     * The returned value is owned by Graphene and should not be modified or freed.
     * @returns a #graphene_box_t
     */
    static infinite(): Box
    /**
     * A #graphene_box_t with the minimum vertex set at (-1, -1, -1) and the
     * maximum vertex set at (0, 0, 0).
     *
     * The returned value is owned by Graphene and should not be modified or freed.
     * @returns a #graphene_box_t
     */
    static minusOne(): Box
    /**
     * A #graphene_box_t with the minimum vertex set at (0, 0, 0) and the
     * maximum vertex set at (1, 1, 1).
     *
     * The returned value is owned by Graphene and should not be modified or freed.
     * @returns a #graphene_box_t
     */
    static one(): Box
    /**
     * A #graphene_box_t with the minimum vertex set at (-1, -1, -1) and the
     * maximum vertex set at (1, 1, 1).
     *
     * The returned value is owned by Graphene and should not be modified or freed.
     * @returns a #graphene_box_t
     */
    static oneMinusOne(): Box
    /**
     * A #graphene_box_t with both the minimum and maximum vertices set at (0, 0, 0).
     *
     * The returned value is owned by Graphene and should not be modified or freed.
     * @returns a #graphene_box_t
     */
    static zero(): Box
  }

  interface Euler {
    // Owm methods of Graphene-1.0.Graphene.Euler

    /**
     * Checks if two #graphene_euler_t are equal.
     * @param b a #graphene_euler_t
     * @returns `true` if the two #graphene_euler_t are equal
     */
    equal(b: Euler): boolean
    /**
     * Frees the resources allocated by graphene_euler_alloc().
     */
    free(): void
    /**
     * Retrieves the first component of the Euler angle vector,
     * depending on the order of rotation.
     *
     * See also: graphene_euler_get_x()
     * @returns the first component of the Euler angle vector, in radians
     */
    getAlpha(): number
    /**
     * Retrieves the second component of the Euler angle vector,
     * depending on the order of rotation.
     *
     * See also: graphene_euler_get_y()
     * @returns the second component of the Euler angle vector, in radians
     */
    getBeta(): number
    /**
     * Retrieves the third component of the Euler angle vector,
     * depending on the order of rotation.
     *
     * See also: graphene_euler_get_z()
     * @returns the third component of the Euler angle vector, in radians
     */
    getGamma(): number
    /**
     * Retrieves the order used to apply the rotations described in the
     * #graphene_euler_t structure, when converting to and from other
     * structures, like #graphene_quaternion_t and #graphene_matrix_t.
     *
     * This function does not return the %GRAPHENE_EULER_ORDER_DEFAULT
     * enumeration value; it will return the effective order of rotation
     * instead.
     * @returns the order used to apply the rotations
     */
    getOrder(): EulerOrder
    /**
     * Retrieves the rotation angle on the X axis, in degrees.
     * @returns the rotation angle
     */
    getX(): number
    /**
     * Retrieves the rotation angle on the Y axis, in degrees.
     * @returns the rotation angle
     */
    getY(): number
    /**
     * Retrieves the rotation angle on the Z axis, in degrees.
     * @returns the rotation angle
     */
    getZ(): number
    /**
     * Initializes a #graphene_euler_t using the given angles.
     *
     * The order of the rotations is %GRAPHENE_EULER_ORDER_DEFAULT.
     * @param x rotation angle on the X axis, in degrees
     * @param y rotation angle on the Y axis, in degrees
     * @param z rotation angle on the Z axis, in degrees
     * @returns the initialized #graphene_euler_t
     */
    init(x: number, y: number, z: number): Euler
    /**
     * Initializes a #graphene_euler_t using the angles and order of
     * another #graphene_euler_t.
     *
     * If the #graphene_euler_t `src` is %NULL, this function is equivalent
     * to calling graphene_euler_init() with all angles set to 0.
     * @param src a #graphene_euler_t
     * @returns the initialized #graphene_euler_t
     */
    initFromEuler(src: Euler | null): Euler
    /**
     * Initializes a #graphene_euler_t using the given rotation matrix.
     *
     * If the #graphene_matrix_t `m` is %NULL, the #graphene_euler_t will
     * be initialized with all angles set to 0.
     * @param m a rotation matrix
     * @param order the order used to apply the rotations
     * @returns the initialized #graphene_euler_t
     */
    initFromMatrix(m: Matrix | null, order: EulerOrder): Euler
    /**
     * Initializes a #graphene_euler_t using the given normalized quaternion.
     *
     * If the #graphene_quaternion_t `q` is %NULL, the #graphene_euler_t will
     * be initialized with all angles set to 0.
     * @param q a normalized #graphene_quaternion_t
     * @param order the order used to apply the rotations
     * @returns the initialized #graphene_euler_t
     */
    initFromQuaternion(q: Quaternion | null, order: EulerOrder): Euler
    /**
     * Initializes a #graphene_euler_t using the given angles
     * and order of rotation.
     * @param x rotation angle on the X axis, in radians
     * @param y rotation angle on the Y axis, in radians
     * @param z rotation angle on the Z axis, in radians
     * @param order order of rotations
     * @returns the initialized #graphene_euler_t
     */
    initFromRadians(x: number, y: number, z: number, order: EulerOrder): Euler
    /**
     * Initializes a #graphene_euler_t using the angles contained in a
     * #graphene_vec3_t.
     *
     * If the #graphene_vec3_t `v` is %NULL, the #graphene_euler_t will be
     * initialized with all angles set to 0.
     * @param v a #graphene_vec3_t containing the rotation   angles in degrees
     * @param order the order used to apply the rotations
     * @returns the initialized #graphene_euler_t
     */
    initFromVec3(v: Vec3 | null, order: EulerOrder): Euler
    /**
     * Initializes a #graphene_euler_t with the given angles and `order`.
     * @param x rotation angle on the X axis, in degrees
     * @param y rotation angle on the Y axis, in degrees
     * @param z rotation angle on the Z axis, in degrees
     * @param order the order used to apply the rotations
     * @returns the initialized #graphene_euler_t
     */
    initWithOrder(x: number, y: number, z: number, order: EulerOrder): Euler
    /**
     * Reorders a #graphene_euler_t using `order`.
     *
     * This function is equivalent to creating a #graphene_quaternion_t from the
     * given #graphene_euler_t, and then converting the quaternion into another
     * #graphene_euler_t.
     * @param order the new order
     */
    reorder(order: EulerOrder): /* res */ Euler
    /**
     * Converts a #graphene_euler_t into a transformation matrix expressing
     * the extrinsic composition of rotations described by the Euler angles.
     *
     * The rotations are applied over the reference frame axes in the order
     * associated with the #graphene_euler_t; for instance, if the order
     * used to initialize `e` is %GRAPHENE_EULER_ORDER_XYZ:
     *
     *  * the first rotation moves the body around the X axis with
     *    an angle φ
     *  * the second rotation moves the body around the Y axis with
     *    an angle of ϑ
     *  * the third rotation moves the body around the Z axis with
     *    an angle of ψ
     *
     * The rotation sign convention is right-handed, to preserve compatibility
     * between Euler-based, quaternion-based, and angle-axis-based rotations.
     */
    toMatrix(): /* res */ Matrix
    /**
     * Converts a #graphene_euler_t into a #graphene_quaternion_t.
     */
    toQuaternion(): /* res */ Quaternion
    /**
     * Retrieves the angles of a #graphene_euler_t and initializes a
     * #graphene_vec3_t with them.
     */
    toVec3(): /* res */ Vec3
  }

  /**
   * Describe a rotation using Euler angles.
   *
   * The contents of the #graphene_euler_t structure are private
   * and should never be accessed directly.
   * @record
   */
  class Euler {
    // Own properties of Graphene-1.0.Graphene.Euler

    static name: string

    // Constructors of Graphene-1.0.Graphene.Euler

    /**
     * Allocates a new #graphene_euler_t.
     *
     * The contents of the returned structure are undefined.
     * @constructor
     * @returns the newly allocated #graphene_euler_t
     */
    static alloc(): Euler
  }

  interface Frustum {
    // Owm methods of Graphene-1.0.Graphene.Frustum

    /**
     * Checks whether a point is inside the volume defined by the given
     * #graphene_frustum_t.
     * @param point a #graphene_point3d_t
     * @returns `true` if the point is inside the frustum
     */
    containsPoint(point: Point3D): boolean
    /**
     * Checks whether the two given #graphene_frustum_t are equal.
     * @param b a #graphene_frustum_t
     * @returns `true` if the given frustums are equal
     */
    equal(b: Frustum): boolean
    /**
     * Frees the resources allocated by graphene_frustum_alloc().
     */
    free(): void
    /**
     * Retrieves the planes that define the given #graphene_frustum_t.
     */
    getPlanes(): /* planes */ Plane[]
    /**
     * Initializes the given #graphene_frustum_t using the provided
     * clipping planes.
     * @param p0 a clipping plane
     * @param p1 a clipping plane
     * @param p2 a clipping plane
     * @param p3 a clipping plane
     * @param p4 a clipping plane
     * @param p5 a clipping plane
     * @returns the initialized frustum
     */
    init(
      p0: Plane,
      p1: Plane,
      p2: Plane,
      p3: Plane,
      p4: Plane,
      p5: Plane
    ): Frustum
    /**
     * Initializes the given #graphene_frustum_t using the clipping
     * planes of another #graphene_frustum_t.
     * @param src a #graphene_frustum_t
     * @returns the initialized frustum
     */
    initFromFrustum(src: Frustum): Frustum
    /**
     * Initializes a #graphene_frustum_t using the given `matrix`.
     * @param matrix a #graphene_matrix_t
     * @returns the initialized frustum
     */
    initFromMatrix(matrix: Matrix): Frustum
    /**
     * Checks whether the given `box` intersects a plane of
     * a #graphene_frustum_t.
     * @param box a #graphene_box_t
     * @returns `true` if the box intersects the frustum
     */
    intersectsBox(box: Box): boolean
    /**
     * Checks whether the given `sphere` intersects a plane of
     * a #graphene_frustum_t.
     * @param sphere a #graphene_sphere_t
     * @returns `true` if the sphere intersects the frustum
     */
    intersectsSphere(sphere: Sphere): boolean
  }

  /**
   * A 3D volume delimited by 2D clip planes.
   *
   * The contents of the `graphene_frustum_t` are private, and should not be
   * modified directly.
   * @record
   */
  class Frustum {
    // Own properties of Graphene-1.0.Graphene.Frustum

    static name: string

    // Constructors of Graphene-1.0.Graphene.Frustum

    /**
     * Allocates a new #graphene_frustum_t structure.
     *
     * The contents of the returned structure are undefined.
     * @constructor
     * @returns the newly allocated #graphene_frustum_t   structure. Use graphene_frustum_free() to free the resources   allocated by this function.
     */
    static alloc(): Frustum
  }

  interface Matrix {
    // Owm methods of Graphene-1.0.Graphene.Matrix

    /**
     * Decomposes a transformation matrix into its component transformations.
     *
     * The algorithm for decomposing a matrix is taken from the
     * [CSS3 Transforms specification](http://dev.w3.org/csswg/css-transforms/);
     * specifically, the decomposition code is based on the equivalent code
     * published in "Graphics Gems II", edited by Jim Arvo, and
     * [available online](http://web.archive.org/web/20150512160205/http://tog.acm.org/resources/GraphicsGems/gemsii/unmatrix.c).
     * @returns `true` if the matrix could be decomposed
     */
    decompose(): [
      /* returnType */ boolean,
      /* translate */ Vec3,
      /* scale */ Vec3,
      /* rotate */ Quaternion,
      /* shear */ Vec3,
      /* perspective */ Vec4,
    ]
    /**
     * Computes the determinant of the given matrix.
     * @returns the value of the determinant
     */
    determinant(): number
    /**
     * Checks whether the two given #graphene_matrix_t matrices are equal.
     * @param b a #graphene_matrix_t
     * @returns `true` if the two matrices are equal, and `false` otherwise
     */
    equal(b: Matrix): boolean
    /**
     * Checks whether the two given #graphene_matrix_t matrices are
     * byte-by-byte equal.
     *
     * While this function is faster than graphene_matrix_equal(), it
     * can also return false negatives, so it should be used in
     * conjuction with either graphene_matrix_equal() or
     * graphene_matrix_near(). For instance:
     *
     *
     * ```c
     *   if (graphene_matrix_equal_fast (a, b))
     *     {
     *       // matrices are definitely the same
     *     }
     *   else
     *     {
     *       if (graphene_matrix_equal (a, b))
     *         // matrices contain the same values within an epsilon of FLT_EPSILON
     *       else if (graphene_matrix_near (a, b, 0.0001))
     *         // matrices contain the same values within an epsilon of 0.0001
     *       else
     *         // matrices are not equal
     *     }
     * ```
     *
     * @param b a #graphene_matrix_t
     * @returns `true` if the matrices are equal. and `false` otherwise
     */
    equalFast(b: Matrix): boolean
    /**
     * Frees the resources allocated by graphene_matrix_alloc().
     */
    free(): void
    /**
     * Retrieves the given row vector at `index_` inside a matrix.
     * @param index the index of the row vector, between 0 and 3
     */
    getRow(index: number): /* res */ Vec4
    /**
     * Retrieves the value at the given `row` and `col` index.
     * @param row the row index
     * @param col the column index
     * @returns the value at the given indices
     */
    getValue(row: number, col: number): number
    /**
     * Retrieves the scaling factor on the X axis in `m`.
     * @returns the value of the scaling factor
     */
    getXScale(): number
    /**
     * Retrieves the translation component on the X axis from `m`.
     * @returns the translation component
     */
    getXTranslation(): number
    /**
     * Retrieves the scaling factor on the Y axis in `m`.
     * @returns the value of the scaling factor
     */
    getYScale(): number
    /**
     * Retrieves the translation component on the Y axis from `m`.
     * @returns the translation component
     */
    getYTranslation(): number
    /**
     * Retrieves the scaling factor on the Z axis in `m`.
     * @returns the value of the scaling factor
     */
    getZScale(): number
    /**
     * Retrieves the translation component on the Z axis from `m`.
     * @returns the translation component
     */
    getZTranslation(): number
    /**
     * Initializes a #graphene_matrix_t from the values of an affine
     * transformation matrix.
     *
     * The arguments map to the following matrix layout:
     *
     *
     * ```<!-- language="plain" -->
     *   ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
     *   ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
     *   ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
     * ```
     *
     *
     * This function can be used to convert between an affine matrix type
     * from other libraries and a #graphene_matrix_t.
     * @param xx the xx member
     * @param yx the yx member
     * @param xy the xy member
     * @param yy the yy member
     * @param x0 the x0 member
     * @param y0 the y0 member
     * @returns the initialized matrix
     */
    initFrom2d(
      xx: number,
      yx: number,
      xy: number,
      yy: number,
      x0: number,
      y0: number
    ): Matrix
    /**
     * Initializes a #graphene_matrix_t with the given array of floating
     * point values.
     * @param v an array of at least 16 floating   point values
     * @returns the initialized matrix
     */
    initFromFloat(v: number[]): Matrix
    /**
     * Initializes a #graphene_matrix_t using the values of the
     * given matrix.
     * @param src a #graphene_matrix_t
     * @returns the initialized matrix
     */
    initFromMatrix(src: Matrix): Matrix
    /**
     * Initializes a #graphene_matrix_t with the given four row
     * vectors.
     * @param v0 the first row vector
     * @param v1 the second row vector
     * @param v2 the third row vector
     * @param v3 the fourth row vector
     * @returns the initialized matrix
     */
    initFromVec4(v0: Vec4, v1: Vec4, v2: Vec4, v3: Vec4): Matrix
    /**
     * Initializes a #graphene_matrix_t compatible with #graphene_frustum_t.
     *
     * See also: graphene_frustum_init_from_matrix()
     * @param left distance of the left clipping plane
     * @param right distance of the right clipping plane
     * @param bottom distance of the bottom clipping plane
     * @param top distance of the top clipping plane
     * @param zNear distance of the near clipping plane
     * @param zFar distance of the far clipping plane
     * @returns the initialized matrix
     */
    initFrustum(
      left: number,
      right: number,
      bottom: number,
      top: number,
      zNear: number,
      zFar: number
    ): Matrix
    /**
     * Initializes a #graphene_matrix_t with the identity matrix.
     * @returns the initialized matrix
     */
    initIdentity(): Matrix
    /**
     * Initializes a #graphene_matrix_t so that it positions the "camera"
     * at the given `eye` coordinates towards an object at the `center`
     * coordinates. The top of the camera is aligned to the direction
     * of the `up` vector.
     *
     * Before the transform, the camera is assumed to be placed at the
     * origin, looking towards the negative Z axis, with the top side of
     * the camera facing in the direction of the Y axis and the right
     * side in the direction of the X axis.
     *
     * In theory, one could use `m` to transform a model of such a camera
     * into world-space. However, it is more common to use the inverse of
     * `m` to transform another object from world coordinates to the view
     * coordinates of the camera. Typically you would then apply the
     * camera projection transform to get from view to screen
     * coordinates.
     * @param eye the vector describing the position to look from
     * @param center the vector describing the position to look at
     * @param up the vector describing the world's upward direction; usually,   this is the graphene_vec3_y_axis() vector
     * @returns the initialized matrix
     */
    initLookAt(eye: Vec3, center: Vec3, up: Vec3): Matrix
    /**
     * Initializes a #graphene_matrix_t with an orthographic projection.
     * @param left the left edge of the clipping plane
     * @param right the right edge of the clipping plane
     * @param top the top edge of the clipping plane
     * @param bottom the bottom edge of the clipping plane
     * @param zNear the distance of the near clipping plane
     * @param zFar the distance of the far clipping plane
     * @returns the initialized matrix
     */
    initOrtho(
      left: number,
      right: number,
      top: number,
      bottom: number,
      zNear: number,
      zFar: number
    ): Matrix
    /**
     * Initializes a #graphene_matrix_t with a perspective projection.
     * @param fovy the field of view angle, in degrees
     * @param aspect the aspect value
     * @param zNear the near Z plane
     * @param zFar the far Z plane
     * @returns the initialized matrix
     */
    initPerspective(
      fovy: number,
      aspect: number,
      zNear: number,
      zFar: number
    ): Matrix
    /**
     * Initializes `m` to represent a rotation of `angle` degrees on
     * the axis represented by the `axis` vector.
     * @param angle the rotation angle, in degrees
     * @param axis the axis vector as a #graphene_vec3_t
     * @returns the initialized matrix
     */
    initRotate(angle: number, axis: Vec3): Matrix
    /**
     * Initializes a #graphene_matrix_t with the given scaling factors.
     * @param x the scale factor on the X axis
     * @param y the scale factor on the Y axis
     * @param z the scale factor on the Z axis
     * @returns the initialized matrix
     */
    initScale(x: number, y: number, z: number): Matrix
    /**
     * Initializes a #graphene_matrix_t with a skew transformation
     * with the given factors.
     * @param xSkew skew factor, in radians, on the X axis
     * @param ySkew skew factor, in radians, on the Y axis
     * @returns the initialized matrix
     */
    initSkew(xSkew: number, ySkew: number): Matrix
    /**
     * Initializes a #graphene_matrix_t with a translation to the
     * given coordinates.
     * @param p the translation coordinates
     * @returns the initialized matrix
     */
    initTranslate(p: Point3D): Matrix
    /**
     * Linearly interpolates the two given #graphene_matrix_t by
     * interpolating the decomposed transformations separately.
     *
     * If either matrix cannot be reduced to their transformations
     * then the interpolation cannot be performed, and this function
     * will return an identity matrix.
     * @param b a #graphene_matrix_t
     * @param factor the linear interpolation factor
     */
    interpolate(b: Matrix, factor: number): /* res */ Matrix
    /**
     * Inverts the given matrix.
     * @returns `true` if the matrix is invertible
     */
    inverse(): [/* returnType */ boolean, /* res */ Matrix]
    /**
     * Checks whether the given #graphene_matrix_t is compatible with an
     * a 2D affine transformation matrix.
     * @returns `true` if the matrix is compatible with an affine   transformation matrix
     */
    is2d(): boolean
    /**
     * Checks whether a #graphene_matrix_t has a visible back face.
     * @returns `true` if the back face of the matrix is visible
     */
    isBackfaceVisible(): boolean
    /**
     * Checks whether the given #graphene_matrix_t is the identity matrix.
     * @returns `true` if the matrix is the identity matrix
     */
    isIdentity(): boolean
    /**
     * Checks whether a matrix is singular.
     * @returns `true` if the matrix is singular
     */
    isSingular(): boolean
    /**
     * Multiplies two #graphene_matrix_t.
     *
     * Matrix multiplication is not commutative in general; the order of the factors matters.
     * The product of this multiplication is (`a` × `b)`
     * @param b a #graphene_matrix_t
     */
    multiply(b: Matrix): /* res */ Matrix
    /**
     * Compares the two given #graphene_matrix_t matrices and checks
     * whether their values are within the given `epsilon` of each
     * other.
     * @param b a #graphene_matrix_t
     * @param epsilon the threshold between the two matrices
     * @returns `true` if the two matrices are near each other, and   `false` otherwise
     */
    near(b: Matrix, epsilon: number): boolean
    /**
     * Normalizes the given #graphene_matrix_t.
     */
    normalize(): /* res */ Matrix
    /**
     * Applies a perspective of `depth` to the matrix.
     * @param depth the depth of the perspective
     */
    perspective(depth: number): /* res */ Matrix
    /**
     * Prints the contents of a matrix to the standard error stream.
     *
     * This function is only useful for debugging; there are no guarantees
     * made on the format of the output.
     */
    print(): void
    /**
     * Projects a #graphene_point_t using the matrix `m`.
     * @param p a #graphene_point_t
     */
    projectPoint(p: Point): /* res */ Point
    /**
     * Projects all corners of a #graphene_rect_t using the given matrix.
     *
     * See also: graphene_matrix_project_point()
     * @param r a #graphene_rect_t
     */
    projectRect(r: Rect): /* res */ Quad
    /**
     * Projects a #graphene_rect_t using the given matrix.
     *
     * The resulting rectangle is the axis aligned bounding rectangle capable
     * of fully containing the projected rectangle.
     * @param r a #graphene_rect_t
     */
    projectRectBounds(r: Rect): /* res */ Rect
    /**
     * Adds a rotation transformation to `m,` using the given `angle`
     * and `axis` vector.
     *
     * This is the equivalent of calling graphene_matrix_init_rotate() and
     * then multiplying the matrix `m` with the rotation matrix.
     * @param angle the rotation angle, in degrees
     * @param axis the rotation axis, as a #graphene_vec3_t
     */
    rotate(angle: number, axis: Vec3): void
    /**
     * Adds a rotation transformation to `m,` using the given
     * #graphene_euler_t.
     * @param e a rotation described by a #graphene_euler_t
     */
    rotateEuler(e: Euler): void
    /**
     * Adds a rotation transformation to `m,` using the given
     * #graphene_quaternion_t.
     *
     * This is the equivalent of calling graphene_quaternion_to_matrix() and
     * then multiplying `m` with the rotation matrix.
     * @param q a rotation described by a #graphene_quaternion_t
     */
    rotateQuaternion(q: Quaternion): void
    /**
     * Adds a rotation transformation around the X axis to `m,` using
     * the given `angle`.
     *
     * See also: graphene_matrix_rotate()
     * @param angle the rotation angle, in degrees
     */
    rotateX(angle: number): void
    /**
     * Adds a rotation transformation around the Y axis to `m,` using
     * the given `angle`.
     *
     * See also: graphene_matrix_rotate()
     * @param angle the rotation angle, in degrees
     */
    rotateY(angle: number): void
    /**
     * Adds a rotation transformation around the Z axis to `m,` using
     * the given `angle`.
     *
     * See also: graphene_matrix_rotate()
     * @param angle the rotation angle, in degrees
     */
    rotateZ(angle: number): void
    /**
     * Adds a scaling transformation to `m,` using the three
     * given factors.
     *
     * This is the equivalent of calling graphene_matrix_init_scale() and then
     * multiplying the matrix `m` with the scale matrix.
     * @param factorX scaling factor on the X axis
     * @param factorY scaling factor on the Y axis
     * @param factorZ scaling factor on the Z axis
     */
    scale(factorX: number, factorY: number, factorZ: number): void
    /**
     * Adds a skew of `factor` on the X and Y axis to the given matrix.
     * @param factor skew factor
     */
    skewXy(factor: number): void
    /**
     * Adds a skew of `factor` on the X and Z axis to the given matrix.
     * @param factor skew factor
     */
    skewXz(factor: number): void
    /**
     * Adds a skew of `factor` on the Y and Z axis to the given matrix.
     * @param factor skew factor
     */
    skewYz(factor: number): void
    /**
     * Converts a #graphene_matrix_t to an affine transformation
     * matrix, if the given matrix is compatible.
     *
     * The returned values have the following layout:
     *
     *
     * ```<!-- language="plain" -->
     *   ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
     *   ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
     *   ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
     * ```
     *
     *
     * This function can be used to convert between a #graphene_matrix_t
     * and an affine matrix type from other libraries.
     * @returns `true` if the matrix is compatible with an affine   transformation matrix
     */
    to2d(): [
      /* returnType */ boolean,
      /* xx */ number,
      /* yx */ number,
      /* xy */ number,
      /* yy */ number,
      /* x0 */ number,
      /* y0 */ number,
    ]
    /**
     * Converts a #graphene_matrix_t to an array of floating point
     * values.
     */
    toFloat(): /* v */ number[]
    /**
     * Transforms each corner of a #graphene_rect_t using the given matrix `m`.
     *
     * The result is the axis aligned bounding rectangle containing the coplanar
     * quadrilateral.
     *
     * See also: graphene_matrix_transform_point()
     * @param r a #graphene_rect_t
     */
    transformBounds(r: Rect): /* res */ Rect
    /**
     * Transforms the vertices of a #graphene_box_t using the given matrix `m`.
     *
     * The result is the axis aligned bounding box containing the transformed
     * vertices.
     * @param b a #graphene_box_t
     */
    transformBox(b: Box): /* res */ Box
    /**
     * Transforms the given #graphene_point_t using the matrix `m`.
     *
     * Unlike graphene_matrix_transform_vec3(), this function will take into
     * account the fourth row vector of the #graphene_matrix_t when computing
     * the dot product of each row vector of the matrix.
     *
     * See also: graphene_simd4x4f_point3_mul()
     * @param p a #graphene_point_t
     */
    transformPoint(p: Point): /* res */ Point
    /**
     * Transforms the given #graphene_point3d_t using the matrix `m`.
     *
     * Unlike graphene_matrix_transform_vec3(), this function will take into
     * account the fourth row vector of the #graphene_matrix_t when computing
     * the dot product of each row vector of the matrix.
     *
     * See also: graphene_simd4x4f_point3_mul()
     * @param p a #graphene_point3d_t
     */
    transformPoint3d(p: Point3D): /* res */ Point3D
    /**
     * Transform a #graphene_ray_t using the given matrix `m`.
     * @param r a #graphene_ray_t
     */
    transformRay(r: Ray): /* res */ Ray
    /**
     * Transforms each corner of a #graphene_rect_t using the given matrix `m`.
     *
     * The result is a coplanar quadrilateral.
     *
     * See also: graphene_matrix_transform_point()
     * @param r a #graphene_rect_t
     */
    transformRect(r: Rect): /* res */ Quad
    /**
     * Transforms a #graphene_sphere_t using the given matrix `m`. The
     * result is the bounding sphere containing the transformed sphere.
     * @param s a #graphene_sphere_t
     */
    transformSphere(s: Sphere): /* res */ Sphere
    /**
     * Transforms the given #graphene_vec3_t using the matrix `m`.
     *
     * This function will multiply the X, Y, and Z row vectors of the matrix `m`
     * with the corresponding components of the vector `v`. The W row vector will
     * be ignored.
     *
     * See also: graphene_simd4x4f_vec3_mul()
     * @param v a #graphene_vec3_t
     */
    transformVec3(v: Vec3): /* res */ Vec3
    /**
     * Transforms the given #graphene_vec4_t using the matrix `m`.
     *
     * See also: graphene_simd4x4f_vec4_mul()
     * @param v a #graphene_vec4_t
     */
    transformVec4(v: Vec4): /* res */ Vec4
    /**
     * Adds a translation transformation to `m` using the coordinates
     * of the given #graphene_point3d_t.
     *
     * This is the equivalent of calling graphene_matrix_init_translate() and
     * then multiplying `m` with the translation matrix.
     * @param pos a #graphene_point3d_t
     */
    translate(pos: Point3D): void
    /**
     * Transposes the given matrix.
     */
    transpose(): /* res */ Matrix
    /**
     * Unprojects the given `point` using the `projection` matrix and
     * a `modelview` matrix.
     * @param modelview a #graphene_matrix_t for the modelview matrix; this is   the inverse of the modelview used when projecting the point
     * @param point a #graphene_point3d_t with the coordinates of the point
     */
    unprojectPoint3d(modelview: Matrix, point: Point3D): /* res */ Point3D
    /**
     * Undoes the transformation on the corners of a #graphene_rect_t using the
     * given matrix, within the given axis aligned rectangular `bounds`.
     * @param r a #graphene_rect_t
     * @param bounds the bounds of the transformation
     */
    untransformBounds(r: Rect, bounds: Rect): /* res */ Rect
    /**
     * Undoes the transformation of a #graphene_point_t using the
     * given matrix, within the given axis aligned rectangular `bounds`.
     * @param p a #graphene_point_t
     * @param bounds the bounds of the transformation
     * @returns `true` if the point was successfully untransformed
     */
    untransformPoint(
      p: Point,
      bounds: Rect
    ): [/* returnType */ boolean, /* res */ Point]
  }

  /**
   * A structure capable of holding a 4x4 matrix.
   *
   * The contents of the #graphene_matrix_t structure are private and
   * should never be accessed directly.
   * @record
   */
  class Matrix {
    // Own properties of Graphene-1.0.Graphene.Matrix

    static name: string

    // Constructors of Graphene-1.0.Graphene.Matrix

    /**
     * Allocates a new #graphene_matrix_t.
     * @constructor
     * @returns the newly allocated matrix
     */
    static alloc(): Matrix
  }

  interface Plane {
    // Owm methods of Graphene-1.0.Graphene.Plane

    /**
     * Computes the distance of `point` from a #graphene_plane_t.
     * @param point a #graphene_point3d_t
     * @returns the distance of the given #graphene_point3d_t from the plane
     */
    distance(point: Point3D): number
    /**
     * Checks whether the two given #graphene_plane_t are equal.
     * @param b a #graphene_plane_t
     * @returns `true` if the given planes are equal
     */
    equal(b: Plane): boolean
    /**
     * Frees the resources allocated by graphene_plane_alloc().
     */
    free(): void
    /**
     * Retrieves the distance along the normal vector of the
     * given #graphene_plane_t from the origin.
     * @returns the constant value of the plane
     */
    getConstant(): number
    /**
     * Retrieves the normal vector pointing towards the origin of the
     * given #graphene_plane_t.
     */
    getNormal(): /* normal */ Vec3
    /**
     * Initializes the given #graphene_plane_t using the given `normal` vector
     * and `constant` values.
     * @param normal a unit length normal vector defining the plane   pointing towards the origin; if unset, we use the X axis by default
     * @param constant the distance from the origin to the plane along the   normal vector; the sign determines the half-space occupied by the   plane
     * @returns the initialized plane
     */
    init(normal: Vec3 | null, constant: number): Plane
    /**
     * Initializes the given #graphene_plane_t using the normal
     * vector and constant of another #graphene_plane_t.
     * @param src a #graphene_plane_t
     * @returns the initialized plane
     */
    initFromPlane(src: Plane): Plane
    /**
     * Initializes the given #graphene_plane_t using the given normal vector
     * and an arbitrary co-planar point.
     * @param normal a normal vector defining the plane pointing towards the origin
     * @param point a #graphene_point3d_t
     * @returns the initialized plane
     */
    initFromPoint(normal: Vec3, point: Point3D): Plane
    /**
     * Initializes the given #graphene_plane_t using the 3 provided co-planar
     * points.
     *
     * The winding order is counter-clockwise, and determines which direction
     * the normal vector will point.
     * @param a a #graphene_point3d_t
     * @param b a #graphene_point3d_t
     * @param c a #graphene_point3d_t
     * @returns the initialized plane
     */
    initFromPoints(a: Point3D, b: Point3D, c: Point3D): Plane
    /**
     * Initializes the given #graphene_plane_t using the components of
     * the given #graphene_vec4_t vector.
     * @param src a #graphene_vec4_t containing the normal vector in its first   three components, and the distance in its fourth component
     * @returns the initialized plane
     */
    initFromVec4(src: Vec4): Plane
    /**
     * Negates the normal vector and constant of a #graphene_plane_t, effectively
     * mirroring the plane across the origin.
     */
    negate(): /* res */ Plane
    /**
     * Normalizes the vector of the given #graphene_plane_t,
     * and adjusts the constant accordingly.
     */
    normalize(): /* res */ Plane
    /**
     * Transforms a #graphene_plane_t `p` using the given `matrix`
     * and `normal_matrix`.
     *
     * If `normal_matrix` is %NULL, a transformation matrix for the plane
     * normal will be computed from `matrix`. If you are transforming
     * multiple planes using the same `matrix` it's recommended to compute
     * the normal matrix beforehand to avoid incurring in the cost of
     * recomputing it every time.
     * @param matrix a #graphene_matrix_t
     * @param normalMatrix a #graphene_matrix_t
     */
    transform(matrix: Matrix, normalMatrix: Matrix | null): /* res */ Plane
  }

  /**
   * A 2D plane that extends infinitely in a 3D volume.
   *
   * The contents of the `graphene_plane_t` are private, and should not be
   * modified directly.
   * @record
   */
  class Plane {
    // Own properties of Graphene-1.0.Graphene.Plane

    static name: string

    // Constructors of Graphene-1.0.Graphene.Plane

    /**
     * Allocates a new #graphene_plane_t structure.
     *
     * The contents of the returned structure are undefined.
     * @constructor
     * @returns the newly allocated #graphene_plane_t.   Use graphene_plane_free() to free the resources allocated by   this function
     */
    static alloc(): Plane
  }

  interface Point {
    // Own fields of Graphene-1.0.Graphene.Point

    /**
     * the X coordinate of the point
     * @field
     */
    x: number
    /**
     * the Y coordinate of the point
     * @field
     */
    y: number

    // Owm methods of Graphene-1.0.Graphene.Point

    /**
     * Computes the distance between `a` and `b`.
     * @param b a #graphene_point_t
     * @returns the distance between the two points
     */
    distance(
      b: Point
    ): [/* returnType */ number, /* dX */ number, /* dY */ number]
    /**
     * Checks if the two points `a` and `b` point to the same
     * coordinates.
     *
     * This function accounts for floating point fluctuations; if
     * you want to control the fuzziness of the match, you can use
     * graphene_point_near() instead.
     * @param b a #graphene_point_t
     * @returns `true` if the points have the same coordinates
     */
    equal(b: Point): boolean
    /**
     * Frees the resources allocated by graphene_point_alloc().
     */
    free(): void
    /**
     * Initializes `p` to the given `x` and `y` coordinates.
     *
     * It's safe to call this function multiple times.
     * @param x the X coordinate
     * @param y the Y coordinate
     * @returns the initialized point
     */
    init(x: number, y: number): Point
    /**
     * Initializes `p` with the same coordinates of `src`.
     * @param src the #graphene_point_t to use
     * @returns the initialized point
     */
    initFromPoint(src: Point): Point
    /**
     * Initializes `p` with the coordinates inside the given #graphene_vec2_t.
     * @param src a #graphene_vec2_t
     * @returns the initialized point
     */
    initFromVec2(src: Vec2): Point
    /**
     * Linearly interpolates the coordinates of `a` and `b` using the
     * given `factor`.
     * @param b a #graphene_point_t
     * @param factor the linear interpolation factor
     */
    interpolate(b: Point, factor: number): /* res */ Point
    /**
     * Checks whether the two points `a` and `b` are within
     * the threshold of `epsilon`.
     * @param b a #graphene_point_t
     * @param epsilon threshold between the two points
     * @returns `true` if the distance is within @epsilon
     */
    near(b: Point, epsilon: number): boolean
    /**
     * Stores the coordinates of the given #graphene_point_t into a
     * #graphene_vec2_t.
     */
    toVec2(): /* v */ Vec2
  }

  /**
   * A point with two coordinates.
   * @record
   */
  class Point {
    // Own properties of Graphene-1.0.Graphene.Point

    static name: string

    // Constructors of Graphene-1.0.Graphene.Point

    /**
     * Allocates a new #graphene_point_t structure.
     *
     * The coordinates of the returned point are (0, 0).
     *
     * It's possible to chain this function with graphene_point_init()
     * or graphene_point_init_from_point(), e.g.:
     *
     *
     * ```c
     *   graphene_point_t *
     *   point_new (float x, float y)
     *   {
     *     return graphene_point_init (graphene_point_alloc (), x, y);
     *   }
     *
     *   graphene_point_t *
     *   point_copy (const graphene_point_t *p)
     *   {
     *     return graphene_point_init_from_point (graphene_point_alloc (), p);
     *   }
     * ```
     *
     * @constructor
     * @returns the newly allocated #graphene_point_t.   Use graphene_point_free() to free the resources allocated by   this function.
     */
    static alloc(): Point
    /**
     * Creates a new Point with the given values
     * @param x
     * @param y
     */
    static create(x: number, y: number): Point
    /**
     * Returns a point fixed at (0, 0).
     * @returns a fixed point
     */
    static zero(): Point
  }

  interface Point3D {
    // Own fields of Graphene-1.0.Graphene.Point3D

    /**
     * the X coordinate
     * @field
     */
    x: number
    /**
     * the Y coordinate
     * @field
     */
    y: number
    /**
     * the Z coordinate
     * @field
     */
    z: number

    // Owm methods of Graphene-1.0.Graphene.Point3D

    /**
     * Computes the cross product of the two given #graphene_point3d_t.
     * @param b a #graphene_point3d_t
     */
    cross(b: Point3D): /* res */ Point3D
    /**
     * Computes the distance between the two given #graphene_point3d_t.
     * @param b a #graphene_point3d_t
     * @returns the distance between two points
     */
    distance(b: Point3D): [/* returnType */ number, /* delta */ Vec3]
    /**
     * Computes the dot product of the two given #graphene_point3d_t.
     * @param b a #graphene_point3d_t
     * @returns the value of the dot product
     */
    dot(b: Point3D): number
    /**
     * Checks whether two given points are equal.
     * @param b a #graphene_point3d_t
     * @returns `true` if the points are equal
     */
    equal(b: Point3D): boolean
    /**
     * Frees the resources allocated via graphene_point3d_alloc().
     */
    free(): void
    /**
     * Initializes a #graphene_point3d_t with the given coordinates.
     * @param x the X coordinate of the point
     * @param y the Y coordinate of the point
     * @param z the Z coordinate of the point
     * @returns the initialized #graphene_point3d_t
     */
    init(x: number, y: number, z: number): Point3D
    /**
     * Initializes a #graphene_point3d_t using the coordinates of
     * another #graphene_point3d_t.
     * @param src a #graphene_point3d_t
     * @returns the initialized point
     */
    initFromPoint(src: Point3D): Point3D
    /**
     * Initializes a #graphene_point3d_t using the components
     * of a #graphene_vec3_t.
     * @param v a #graphene_vec3_t
     * @returns the initialized #graphene_point3d_t
     */
    initFromVec3(v: Vec3): Point3D
    /**
     * Linearly interpolates each component of `a` and `b` using the
     * provided `factor,` and places the result in `res`.
     * @param b a #graphene_point3d_t
     * @param factor the interpolation factor
     */
    interpolate(b: Point3D, factor: number): /* res */ Point3D
    /**
     * Computes the length of the vector represented by the
     * coordinates of the given #graphene_point3d_t.
     * @returns the length of the vector represented by the point
     */
    length(): number
    /**
     * Checks whether the two points are near each other, within
     * an `epsilon` factor.
     * @param b a #graphene_point3d_t
     * @param epsilon fuzzyness factor
     * @returns `true` if the points are near each other
     */
    near(b: Point3D, epsilon: number): boolean
    /**
     * Computes the normalization of the vector represented by the
     * coordinates of the given #graphene_point3d_t.
     */
    normalize(): /* res */ Point3D
    /**
     * Normalizes the coordinates of a #graphene_point3d_t using the
     * given viewport and clipping planes.
     *
     * The coordinates of the resulting #graphene_point3d_t will be
     * in the [ -1, 1 ] range.
     * @param viewport a #graphene_rect_t representing a viewport
     * @param zNear the coordinate of the near clipping plane, or 0 for   the default near clipping plane
     * @param zFar the coordinate of the far clipping plane, or 1 for the   default far clipping plane
     */
    normalizeViewport(
      viewport: Rect,
      zNear: number,
      zFar: number
    ): /* res */ Point3D
    /**
     * Scales the coordinates of the given #graphene_point3d_t by
     * the given `factor`.
     * @param factor the scaling factor
     */
    scale(factor: number): /* res */ Point3D
    /**
     * Stores the coordinates of a #graphene_point3d_t into a
     * #graphene_vec3_t.
     */
    toVec3(): /* v */ Vec3
  }

  /**
   * A point with three components: X, Y, and Z.
   * @record
   */
  class Point3D {
    // Own properties of Graphene-1.0.Graphene.Point3D

    static name: string

    // Constructors of Graphene-1.0.Graphene.Point3D

    /**
     * Allocates a #graphene_point3d_t structure.
     * @constructor
     * @returns the newly allocated structure.   Use graphene_point3d_free() to free the resources   allocated by this function.
     */
    static alloc(): Point3D
    /**
     * Retrieves a constant point with all three coordinates set to 0.
     * @returns a zero point
     */
    static zero(): Point3D
  }

  interface Quad {
    // Owm methods of Graphene-1.0.Graphene.Quad

    /**
     * Computes the bounding rectangle of `q` and places it into `r`.
     */
    bounds(): /* r */ Rect
    /**
     * Checks if the given #graphene_quad_t contains the given #graphene_point_t.
     * @param p a #graphene_point_t
     * @returns `true` if the point is inside the #graphene_quad_t
     */
    contains(p: Point): boolean
    /**
     * Frees the resources allocated by graphene_quad_alloc()
     */
    free(): void
    /**
     * Retrieves the point of a #graphene_quad_t at the given index.
     * @param index the index of the point to retrieve
     * @returns a #graphene_point_t
     */
    getPoint(index: number): Point
    /**
     * Initializes a #graphene_quad_t with the given points.
     * @param p1 the first point of the quadrilateral
     * @param p2 the second point of the quadrilateral
     * @param p3 the third point of the quadrilateral
     * @param p4 the fourth point of the quadrilateral
     * @returns the initialized #graphene_quad_t
     */
    init(p1: Point, p2: Point, p3: Point, p4: Point): Quad
    /**
     * Initializes a #graphene_quad_t using an array of points.
     * @param points an array of 4 #graphene_point_t
     * @returns the initialized #graphene_quad_t
     */
    initFromPoints(points: Point[]): Quad
    /**
     * Initializes a #graphene_quad_t using the four corners of the
     * given #graphene_rect_t.
     * @param r a #graphene_rect_t
     * @returns the initialized #graphene_quad_t
     */
    initFromRect(r: Rect): Quad
  }

  /**
   * A 4 vertex quadrilateral, as represented by four #graphene_point_t.
   *
   * The contents of a #graphene_quad_t are private and should never be
   * accessed directly.
   * @record
   */
  class Quad {
    // Own properties of Graphene-1.0.Graphene.Quad

    static name: string

    // Constructors of Graphene-1.0.Graphene.Quad

    /**
     * Allocates a new #graphene_quad_t instance.
     *
     * The contents of the returned instance are undefined.
     * @constructor
     * @returns the newly created #graphene_quad_t instance
     */
    static alloc(): Quad
  }

  interface Quaternion {
    // Owm methods of Graphene-1.0.Graphene.Quaternion

    /**
     * Adds two #graphene_quaternion_t `a` and `b`.
     * @param b a #graphene_quaternion_t
     */
    add(b: Quaternion): /* res */ Quaternion
    /**
     * Computes the dot product of two #graphene_quaternion_t.
     * @param b a #graphene_quaternion_t
     * @returns the value of the dot products
     */
    dot(b: Quaternion): number
    /**
     * Checks whether the given quaternions are equal.
     * @param b a #graphene_quaternion_t
     * @returns `true` if the quaternions are equal
     */
    equal(b: Quaternion): boolean
    /**
     * Releases the resources allocated by graphene_quaternion_alloc().
     */
    free(): void
    /**
     * Initializes a #graphene_quaternion_t using the given four values.
     * @param x the first component of the quaternion
     * @param y the second component of the quaternion
     * @param z the third component of the quaternion
     * @param w the fourth component of the quaternion
     * @returns the initialized quaternion
     */
    init(x: number, y: number, z: number, w: number): Quaternion
    /**
     * Initializes a #graphene_quaternion_t using an `angle` on a
     * specific `axis`.
     * @param angle the rotation on a given axis, in degrees
     * @param axis the axis of rotation, expressed as a vector
     * @returns the initialized quaternion
     */
    initFromAngleVec3(angle: number, axis: Vec3): Quaternion
    /**
     * Initializes a #graphene_quaternion_t using the values of
     * the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
     * on each axis.
     *
     * See also: graphene_quaternion_init_from_euler()
     * @param degX rotation angle on the X axis (yaw), in degrees
     * @param degY rotation angle on the Y axis (pitch), in degrees
     * @param degZ rotation angle on the Z axis (roll), in degrees
     * @returns the initialized quaternion
     */
    initFromAngles(degX: number, degY: number, degZ: number): Quaternion
    /**
     * Initializes a #graphene_quaternion_t using the given #graphene_euler_t.
     * @param e a #graphene_euler_t
     * @returns the initialized #graphene_quaternion_t
     */
    initFromEuler(e: Euler): Quaternion
    /**
     * Initializes a #graphene_quaternion_t using the rotation components
     * of a transformation matrix.
     * @param m a #graphene_matrix_t
     * @returns the initialized quaternion
     */
    initFromMatrix(m: Matrix): Quaternion
    /**
     * Initializes a #graphene_quaternion_t with the values from `src`.
     * @param src a #graphene_quaternion_t
     * @returns the initialized quaternion
     */
    initFromQuaternion(src: Quaternion): Quaternion
    /**
     * Initializes a #graphene_quaternion_t using the values of
     * the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
     * on each axis.
     *
     * See also: graphene_quaternion_init_from_euler()
     * @param radX rotation angle on the X axis (yaw), in radians
     * @param radY rotation angle on the Y axis (pitch), in radians
     * @param radZ rotation angle on the Z axis (roll), in radians
     * @returns the initialized quaternion
     */
    initFromRadians(radX: number, radY: number, radZ: number): Quaternion
    /**
     * Initializes a #graphene_quaternion_t with the values from `src`.
     * @param src a #graphene_vec4_t
     * @returns the initialized quaternion
     */
    initFromVec4(src: Vec4): Quaternion
    /**
     * Initializes a #graphene_quaternion_t using the identity
     * transformation.
     * @returns the initialized quaternion
     */
    initIdentity(): Quaternion
    /**
     * Inverts a #graphene_quaternion_t, and returns the conjugate
     * quaternion of `q`.
     */
    invert(): /* res */ Quaternion
    /**
     * Multiplies two #graphene_quaternion_t `a` and `b`.
     * @param b a #graphene_quaternion_t
     */
    multiply(b: Quaternion): /* res */ Quaternion
    /**
     * Normalizes a #graphene_quaternion_t.
     */
    normalize(): /* res */ Quaternion
    /**
     * Scales all the elements of a #graphene_quaternion_t `q` using
     * the given scalar factor.
     * @param factor a scaling factor
     */
    scale(factor: number): /* res */ Quaternion
    /**
     * Interpolates between the two given quaternions using a spherical
     * linear interpolation, or [SLERP](http://en.wikipedia.org/wiki/Slerp),
     * using the given interpolation `factor`.
     * @param b a #graphene_quaternion_t
     * @param factor the linear interpolation factor
     */
    slerp(b: Quaternion, factor: number): /* res */ Quaternion
    /**
     * Converts a quaternion into an `angle,` `axis` pair.
     */
    toAngleVec3(): [/* angle */ number, /* axis */ Vec3]
    /**
     * Converts a #graphene_quaternion_t to its corresponding rotations
     * on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
     * on each axis.
     */
    toAngles(): [/* degX */ number, /* degY */ number, /* degZ */ number]
    /**
     * Converts a quaternion into a transformation matrix expressing
     * the rotation defined by the #graphene_quaternion_t.
     */
    toMatrix(): /* m */ Matrix
    /**
     * Converts a #graphene_quaternion_t to its corresponding rotations
     * on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
     * on each axis.
     */
    toRadians(): [/* radX */ number, /* radY */ number, /* radZ */ number]
    /**
     * Copies the components of a #graphene_quaternion_t into a
     * #graphene_vec4_t.
     */
    toVec4(): /* res */ Vec4
  }

  /**
   * A quaternion.
   *
   * The contents of the #graphene_quaternion_t structure are private
   * and should never be accessed directly.
   * @record
   */
  class Quaternion {
    // Own properties of Graphene-1.0.Graphene.Quaternion

    static name: string

    // Constructors of Graphene-1.0.Graphene.Quaternion

    /**
     * Allocates a new #graphene_quaternion_t.
     *
     * The contents of the returned value are undefined.
     * @constructor
     * @returns the newly allocated #graphene_quaternion_t
     */
    static alloc(): Quaternion
  }

  interface Ray {
    // Owm methods of Graphene-1.0.Graphene.Ray

    /**
     * Checks whether the two given #graphene_ray_t are equal.
     * @param b a #graphene_ray_t
     * @returns `true` if the given rays are equal
     */
    equal(b: Ray): boolean
    /**
     * Frees the resources allocated by graphene_ray_alloc().
     */
    free(): void
    /**
     * Computes the point on the given #graphene_ray_t that is closest to the
     * given point `p`.
     * @param p a #graphene_point3d_t
     */
    getClosestPointToPoint(p: Point3D): /* res */ Point3D
    /**
     * Retrieves the direction of the given #graphene_ray_t.
     */
    getDirection(): /* direction */ Vec3
    /**
     * Computes the distance of the origin of the given #graphene_ray_t from the
     * given plane.
     *
     * If the ray does not intersect the plane, this function returns `INFINITY`.
     * @param p a #graphene_plane_t
     * @returns the distance of the origin of the ray from the plane
     */
    getDistanceToPlane(p: Plane): number
    /**
     * Computes the distance of the closest approach between the
     * given #graphene_ray_t `r` and the point `p`.
     *
     * The closest approach to a ray from a point is the distance
     * between the point and the projection of the point on the
     * ray itself.
     * @param p a #graphene_point3d_t
     * @returns the distance of the point
     */
    getDistanceToPoint(p: Point3D): number
    /**
     * Retrieves the origin of the given #graphene_ray_t.
     */
    getOrigin(): /* origin */ Point3D
    /**
     * Retrieves the coordinates of a point at the distance `t` along the
     * given #graphene_ray_t.
     * @param t the distance along the ray
     */
    getPositionAt(t: number): /* position */ Point3D
    /**
     * Initializes the given #graphene_ray_t using the given `origin`
     * and `direction` values.
     * @param origin the origin of the ray
     * @param direction the direction vector
     * @returns the initialized ray
     */
    init(origin: Point3D | null, direction: Vec3 | null): Ray
    /**
     * Initializes the given #graphene_ray_t using the origin and direction
     * values of another #graphene_ray_t.
     * @param src a #graphene_ray_t
     * @returns the initialized ray
     */
    initFromRay(src: Ray): Ray
    /**
     * Initializes the given #graphene_ray_t using the given vectors.
     * @param origin a #graphene_vec3_t
     * @param direction a #graphene_vec3_t
     * @returns the initialized ray
     */
    initFromVec3(origin: Vec3 | null, direction: Vec3 | null): Ray
    /**
     * Intersects the given #graphene_ray_t `r` with the given
     * #graphene_box_t `b`.
     * @param b a #graphene_box_t
     * @returns the type of intersection
     */
    intersectBox(
      b: Box
    ): [/* returnType */ RayIntersectionKind, /* tOut */ number]
    /**
     * Intersects the given #graphene_ray_t `r` with the given
     * #graphene_sphere_t `s`.
     * @param s a #graphene_sphere_t
     * @returns the type of intersection
     */
    intersectSphere(
      s: Sphere
    ): [/* returnType */ RayIntersectionKind, /* tOut */ number]
    /**
     * Intersects the given #graphene_ray_t `r` with the given
     * #graphene_triangle_t `t`.
     * @param t a #graphene_triangle_t
     * @returns the type of intersection
     */
    intersectTriangle(
      t: Triangle
    ): [/* returnType */ RayIntersectionKind, /* tOut */ number]
    /**
     * Checks whether the given #graphene_ray_t `r` intersects the
     * given #graphene_box_t `b`.
     *
     * See also: graphene_ray_intersect_box()
     * @param b a #graphene_box_t
     * @returns `true` if the ray intersects the box
     */
    intersectsBox(b: Box): boolean
    /**
     * Checks if the given #graphene_ray_t `r` intersects the
     * given #graphene_sphere_t `s`.
     *
     * See also: graphene_ray_intersect_sphere()
     * @param s a #graphene_sphere_t
     * @returns `true` if the ray intersects the sphere
     */
    intersectsSphere(s: Sphere): boolean
    /**
     * Checks whether the given #graphene_ray_t `r` intersects the
     * given #graphene_triangle_t `b`.
     *
     * See also: graphene_ray_intersect_triangle()
     * @param t a #graphene_triangle_t
     * @returns `true` if the ray intersects the triangle
     */
    intersectsTriangle(t: Triangle): boolean
  }

  /**
   * A ray emitted from an origin in a given direction.
   *
   * The contents of the `graphene_ray_t` structure are private, and should not
   * be modified directly.
   * @record
   */
  class Ray {
    // Own properties of Graphene-1.0.Graphene.Ray

    static name: string

    // Constructors of Graphene-1.0.Graphene.Ray

    /**
     * Allocates a new #graphene_ray_t structure.
     *
     * The contents of the returned structure are undefined.
     * @constructor
     * @returns the newly allocated #graphene_ray_t.   Use graphene_ray_free() to free the resources allocated by   this function
     */
    static alloc(): Ray
  }

  interface Rect {
    // Own fields of Graphene-1.0.Graphene.Rect

    /**
     * the coordinates of the origin of the rectangle
     * @field
     */
    origin: Point
    /**
     * the size of the rectangle
     * @field
     */
    size: Size

    // Owm methods of Graphene-1.0.Graphene.Rect

    /**
     * Checks whether a #graphene_rect_t contains the given coordinates.
     * @param p a #graphene_point_t
     * @returns `true` if the rectangle contains the point
     */
    containsPoint(p: Point): boolean
    /**
     * Checks whether a #graphene_rect_t fully contains the given
     * rectangle.
     * @param b a #graphene_rect_t
     * @returns `true` if the rectangle @a fully contains @b
     */
    containsRect(b: Rect): boolean
    /**
     * Checks whether the two given rectangle are equal.
     * @param b a #graphene_rect_t
     * @returns `true` if the rectangles are equal
     */
    equal(b: Rect): boolean
    /**
     * Expands a #graphene_rect_t to contain the given #graphene_point_t.
     * @param p a #graphene_point_t
     */
    expand(p: Point): /* res */ Rect
    /**
     * Frees the resources allocated by graphene_rect_alloc().
     */
    free(): void
    /**
     * Compute the area of given normalized rectangle.
     * @returns the area of the normalized rectangle
     */
    getArea(): number
    /**
     * Retrieves the coordinates of the bottom-left corner of the given rectangle.
     */
    getBottomLeft(): /* p */ Point
    /**
     * Retrieves the coordinates of the bottom-right corner of the given rectangle.
     */
    getBottomRight(): /* p */ Point
    /**
     * Retrieves the coordinates of the center of the given rectangle.
     */
    getCenter(): /* p */ Point
    /**
     * Retrieves the normalized height of the given rectangle.
     * @returns the normalized height of the rectangle
     */
    getHeight(): number
    /**
     * Retrieves the coordinates of the top-left corner of the given rectangle.
     */
    getTopLeft(): /* p */ Point
    /**
     * Retrieves the coordinates of the top-right corner of the given rectangle.
     */
    getTopRight(): /* p */ Point
    /**
     * Computes the four vertices of a #graphene_rect_t.
     */
    getVertices(): /* vertices */ Vec2[]
    /**
     * Retrieves the normalized width of the given rectangle.
     * @returns the normalized width of the rectangle
     */
    getWidth(): number
    /**
     * Retrieves the normalized X coordinate of the origin of the given
     * rectangle.
     * @returns the normalized X coordinate of the rectangle
     */
    getX(): number
    /**
     * Retrieves the normalized Y coordinate of the origin of the given
     * rectangle.
     * @returns the normalized Y coordinate of the rectangle
     */
    getY(): number
    /**
     * Initializes the given #graphene_rect_t with the given values.
     *
     * This function will implicitly normalize the #graphene_rect_t
     * before returning.
     * @param x the X coordinate of the `graphene_rect_t`.origin
     * @param y the Y coordinate of the `graphene_rect_t`.origin
     * @param width the width of the `graphene_rect_t`.size
     * @param height the height of the `graphene_rect_t`.size
     * @returns the initialized rectangle
     */
    init(x: number, y: number, width: number, height: number): Rect
    /**
     * Initializes `r` using the given `src` rectangle.
     *
     * This function will implicitly normalize the #graphene_rect_t
     * before returning.
     * @param src a #graphene_rect_t
     * @returns the initialized rectangle
     */
    initFromRect(src: Rect): Rect
    /**
     * Changes the given rectangle to be smaller, or larger depending on the
     * given inset parameters.
     *
     * To create an inset rectangle, use positive `d_x` or `d_y` values; to
     * create a larger, encompassing rectangle, use negative `d_x` or `d_y`
     * values.
     *
     * The origin of the rectangle is offset by `d_x` and `d_y,` while the size
     * is adjusted by `(2 * `d_x,` 2 * `d_y)``. If `d_x` and `d_y` are positive
     * values, the size of the rectangle is decreased; if `d_x` and `d_y` are
     * negative values, the size of the rectangle is increased.
     *
     * If the size of the resulting inset rectangle has a negative width or
     * height then the size will be set to zero.
     * @param dX the horizontal inset
     * @param dY the vertical inset
     * @returns the inset rectangle
     */
    inset(dX: number, dY: number): Rect
    /**
     * Changes the given rectangle to be smaller, or larger depending on the
     * given inset parameters.
     *
     * To create an inset rectangle, use positive `d_x` or `d_y` values; to
     * create a larger, encompassing rectangle, use negative `d_x` or `d_y`
     * values.
     *
     * The origin of the rectangle is offset by `d_x` and `d_y,` while the size
     * is adjusted by `(2 * `d_x,` 2 * `d_y)``. If `d_x` and `d_y` are positive
     * values, the size of the rectangle is decreased; if `d_x` and `d_y` are
     * negative values, the size of the rectangle is increased.
     *
     * If the size of the resulting inset rectangle has a negative width or
     * height then the size will be set to zero.
     * @param dX the horizontal inset
     * @param dY the vertical inset
     */
    insetR(dX: number, dY: number): /* res */ Rect
    /**
     * Linearly interpolates the origin and size of the two given
     * rectangles.
     * @param b a #graphene_rect_t
     * @param factor the linear interpolation factor
     */
    interpolate(b: Rect, factor: number): /* res */ Rect
    /**
     * Computes the intersection of the two given rectangles.
     *
     * ![](rectangle-intersection.png)
     *
     * The intersection in the image above is the blue outline.
     *
     * If the two rectangles do not intersect, `res` will contain
     * a degenerate rectangle with origin in (0, 0) and a size of 0.
     * @param b a #graphene_rect_t
     * @returns `true` if the two rectangles intersect
     */
    intersection(b: Rect): [/* returnType */ boolean, /* res */ Rect]
    /**
     * Normalizes the passed rectangle.
     *
     * This function ensures that the size of the rectangle is made of
     * positive values, and that the origin is the top-left corner of
     * the rectangle.
     * @returns the normalized rectangle
     */
    normalize(): Rect
    /**
     * Normalizes the passed rectangle.
     *
     * This function ensures that the size of the rectangle is made of
     * positive values, and that the origin is in the top-left corner
     * of the rectangle.
     */
    normalizeR(): /* res */ Rect
    /**
     * Offsets the origin by `d_x` and `d_y`.
     *
     * The size of the rectangle is unchanged.
     * @param dX the horizontal offset
     * @param dY the vertical offset
     * @returns the offset rectangle
     */
    offset(dX: number, dY: number): Rect
    /**
     * Offsets the origin of the given rectangle by `d_x` and `d_y`.
     *
     * The size of the rectangle is left unchanged.
     * @param dX the horizontal offset
     * @param dY the vertical offset
     */
    offsetR(dX: number, dY: number): /* res */ Rect
    /**
     * Rounds the origin and size of the given rectangle to
     * their nearest integer values; the rounding is guaranteed
     * to be large enough to have an area bigger or equal to the
     * original rectangle, but might not fully contain its extents.
     * Use graphene_rect_round_extents() in case you need to round
     * to a rectangle that covers fully the original one.
     *
     * This function is the equivalent of calling `floor` on
     * the coordinates of the origin, and `ceil` on the size.
     */
    round(): /* res */ Rect
    /**
     * Rounds the origin of the given rectangle to its nearest
     * integer value and and recompute the size so that the
     * rectangle is large enough to contain all the conrners
     * of the original rectangle.
     *
     * This function is the equivalent of calling `floor` on
     * the coordinates of the origin, and recomputing the size
     * calling `ceil` on the bottom-right coordinates.
     *
     * If you want to be sure that the rounded rectangle
     * completely covers the area that was covered by the
     * original rectangle — i.e. you want to cover the area
     * including all its corners — this function will make sure
     * that the size is recomputed taking into account the ceiling
     * of the coordinates of the bottom-right corner.
     * If the difference between the original coordinates and the
     * coordinates of the rounded rectangle is greater than the
     * difference between the original size and and the rounded
     * size, then the move of the origin would not be compensated
     * by a move in the anti-origin, leaving the corners of the
     * original rectangle outside the rounded one.
     */
    roundExtents(): /* res */ Rect
    /**
     * Rounds the origin and the size of the given rectangle to
     * their nearest integer values; the rounding is guaranteed
     * to be large enough to contain the original rectangle.
     * @returns the pixel-aligned rectangle.
     */
    roundToPixel(): Rect
    /**
     * Scales the size and origin of a rectangle horizontaly by `s_h,`
     * and vertically by `s_v`. The result `res` is normalized.
     * @param sH horizontal scale factor
     * @param sV vertical scale factor
     */
    scale(sH: number, sV: number): /* res */ Rect
    /**
     * Computes the union of the two given rectangles.
     *
     * ![](rectangle-union.png)
     *
     * The union in the image above is the blue outline.
     * @param b a #graphene_rect_t
     */
    union(b: Rect): /* res */ Rect
  }

  /**
   * The location and size of a rectangle region.
   *
   * The width and height of a #graphene_rect_t can be negative; for instance,
   * a #graphene_rect_t with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
   * equivalent to a #graphene_rect_t with an origin of [ 10, 10 ] and a size
   * of [ -10, -10 ].
   *
   * Application code can normalize rectangles using graphene_rect_normalize();
   * this function will ensure that the width and height of a rectangle are
   * positive values. All functions taking a #graphene_rect_t as an argument
   * will internally operate on a normalized copy; all functions returning a
   * #graphene_rect_t will always return a normalized rectangle.
   * @record
   */
  class Rect {
    // Own properties of Graphene-1.0.Graphene.Rect

    static name: string

    // Constructors of Graphene-1.0.Graphene.Rect

    /**
     * Creates a new Rect with the given values
     * @param x
     * @param y
     * @param width
     * @param height
     */
    static create(x: number, y: number, width: number, height: number): Rect
    /**
     * Allocates a new #graphene_rect_t.
     *
     * The contents of the returned rectangle are undefined.
     * @returns the newly allocated rectangle
     */
    static alloc(): Rect
    /**
     * Returns a degenerate rectangle with origin fixed at (0, 0) and
     * a size of 0, 0.
     * @returns a fixed rectangle
     */
    static zero(): Rect
  }

  interface Simd4F {}

  class Simd4F {
    // Own properties of Graphene-1.0.Graphene.Simd4F

    static name: string
  }

  interface Simd4X4F {}

  class Simd4X4F {
    // Own properties of Graphene-1.0.Graphene.Simd4X4F

    static name: string
  }

  interface Size {
    // Own fields of Graphene-1.0.Graphene.Size

    /**
     * the width
     * @field
     */
    width: number
    /**
     * the height
     * @field
     */
    height: number

    // Owm methods of Graphene-1.0.Graphene.Size

    /**
     * Checks whether the two give #graphene_size_t are equal.
     * @param b a #graphene_size_t
     * @returns `true` if the sizes are equal
     */
    equal(b: Size): boolean
    /**
     * Frees the resources allocated by graphene_size_alloc().
     */
    free(): void
    /**
     * Initializes a #graphene_size_t using the given `width` and `height`.
     * @param width the width
     * @param height the height
     * @returns the initialized #graphene_size_t
     */
    init(width: number, height: number): Size
    /**
     * Initializes a #graphene_size_t using the width and height of
     * the given `src`.
     * @param src a #graphene_size_t
     * @returns the initialized #graphene_size_t
     */
    initFromSize(src: Size): Size
    /**
     * Linearly interpolates the two given #graphene_size_t using the given
     * interpolation `factor`.
     * @param b a #graphene_size_t
     * @param factor the linear interpolation factor
     */
    interpolate(b: Size, factor: number): /* res */ Size
    /**
     * Scales the components of a #graphene_size_t using the given `factor`.
     * @param factor the scaling factor
     */
    scale(factor: number): /* res */ Size
  }

  /**
   * A size.
   * @record
   */
  class Size {
    // Own properties of Graphene-1.0.Graphene.Size

    static name: string

    // Constructors of Graphene-1.0.Graphene.Size

    /**
     * Allocates a new #graphene_size_t.
     *
     * The contents of the returned value are undefined.
     * @constructor
     * @returns the newly allocated #graphene_size_t
     */
    static alloc(): Size
    /**
     * Creates a new Size with the given values
     * @param width
     * @param height
     */
    static create(width: number, height: number): Size
    /**
     * A constant pointer to a zero #graphene_size_t, useful for
     * equality checks and interpolations.
     * @returns a constant size
     */
    static zero(): Size
  }

  interface Sphere {
    // Owm methods of Graphene-1.0.Graphene.Sphere

    /**
     * Checks whether the given `point` is contained in the volume
     * of a #graphene_sphere_t.
     * @param point a #graphene_point3d_t
     * @returns `true` if the sphere contains the point
     */
    containsPoint(point: Point3D): boolean
    /**
     * Computes the distance of the given `point` from the surface of
     * a #graphene_sphere_t.
     * @param point a #graphene_point3d_t
     * @returns the distance of the point
     */
    distance(point: Point3D): number
    /**
     * Checks whether two #graphene_sphere_t are equal.
     * @param b a #graphene_sphere_t
     * @returns `true` if the spheres are equal
     */
    equal(b: Sphere): boolean
    /**
     * Frees the resources allocated by graphene_sphere_alloc().
     */
    free(): void
    /**
     * Computes the bounding box capable of containing the
     * given #graphene_sphere_t.
     */
    getBoundingBox(): /* box */ Box
    /**
     * Retrieves the coordinates of the center of a #graphene_sphere_t.
     */
    getCenter(): /* center */ Point3D
    /**
     * Retrieves the radius of a #graphene_sphere_t.
     */
    getRadius(): number
    /**
     * Initializes the given #graphene_sphere_t with the given `center` and `radius`.
     * @param center the coordinates of the center of the sphere, or %NULL   for a center in (0, 0, 0)
     * @param radius the radius of the sphere
     * @returns the initialized #graphene_sphere_t
     */
    init(center: Point3D | null, radius: number): Sphere
    /**
     * Initializes the given #graphene_sphere_t using the given array
     * of 3D coordinates so that the sphere includes them.
     *
     * The center of the sphere can either be specified, or will be center
     * of the 3D volume that encompasses all `points`.
     * @param points an array of #graphene_point3d_t
     * @param center the center of the sphere
     * @returns the initialized #graphene_sphere_t
     */
    initFromPoints(points: Point3D[], center: Point3D | null): Sphere
    /**
     * Initializes the given #graphene_sphere_t using the given array
     * of 3D coordinates so that the sphere includes them.
     *
     * The center of the sphere can either be specified, or will be center
     * of the 3D volume that encompasses all `vectors`.
     * @param vectors an array of #graphene_vec3_t
     * @param center the center of the sphere
     * @returns the initialized #graphene_sphere_t
     */
    initFromVectors(vectors: Vec3[], center: Point3D | null): Sphere
    /**
     * Checks whether the sphere has a zero radius.
     * @returns `true` if the sphere is empty
     */
    isEmpty(): boolean
    /**
     * Translates the center of the given #graphene_sphere_t using the `point`
     * coordinates as the delta of the translation.
     * @param point the coordinates of the translation
     */
    translate(point: Point3D): /* res */ Sphere
  }

  /**
   * A sphere, represented by its center and radius.
   * @record
   */
  class Sphere {
    // Own properties of Graphene-1.0.Graphene.Sphere

    static name: string

    // Constructors of Graphene-1.0.Graphene.Sphere

    /**
     * Allocates a new #graphene_sphere_t.
     *
     * The contents of the newly allocated structure are undefined.
     * @constructor
     * @returns the newly allocated #graphene_sphere_t. Use   graphene_sphere_free() to free the resources allocated by this function
     */
    static alloc(): Sphere
  }

  interface Triangle {
    // Owm methods of Graphene-1.0.Graphene.Triangle

    /**
     * Checks whether the given triangle `t` contains the point `p`.
     * @param p a #graphene_point3d_t
     * @returns `true` if the point is inside the triangle
     */
    containsPoint(p: Point3D): boolean
    /**
     * Checks whether the two given #graphene_triangle_t are equal.
     * @param b a #graphene_triangle_t
     * @returns `true` if the triangles are equal
     */
    equal(b: Triangle): boolean
    /**
     * Frees the resources allocated by graphene_triangle_alloc().
     */
    free(): void
    /**
     * Computes the area of the given #graphene_triangle_t.
     * @returns the area of the triangle
     */
    getArea(): number
    /**
     * Computes the [barycentric coordinates](http://en.wikipedia.org/wiki/Barycentric_coordinate_system)
     * of the given point `p`.
     *
     * The point `p` must lie on the same plane as the triangle `t;` if the
     * point is not coplanar, the result of this function is undefined.
     *
     * If we place the origin in the coordinates of the triangle's A point,
     * the barycentric coordinates are `u`, which is on the AC vector; and `v`
     * which is on the AB vector:
     *
     * ![](triangle-barycentric.png)
     *
     * The returned #graphene_vec2_t contains the following values, in order:
     *
     *  - `res.x = u`
     *  - `res.y = v`
     * @param p a #graphene_point3d_t
     * @returns `true` if the barycentric coordinates are valid
     */
    getBarycoords(p: Point3D | null): [/* returnType */ boolean, /* res */ Vec2]
    /**
     * Computes the bounding box of the given #graphene_triangle_t.
     */
    getBoundingBox(): /* res */ Box
    /**
     * Computes the coordinates of the midpoint of the given #graphene_triangle_t.
     *
     * The midpoint G is the [centroid](https://en.wikipedia.org/wiki/Centroid#Triangle_centroid)
     * of the triangle, i.e. the intersection of its medians.
     */
    getMidpoint(): /* res */ Point3D
    /**
     * Computes the normal vector of the given #graphene_triangle_t.
     */
    getNormal(): /* res */ Vec3
    /**
     * Computes the plane based on the vertices of the given #graphene_triangle_t.
     */
    getPlane(): /* res */ Plane
    /**
     * Retrieves the three vertices of the given #graphene_triangle_t and returns
     * their coordinates as #graphene_point3d_t.
     */
    getPoints(): [/* a */ Point3D, /* b */ Point3D, /* c */ Point3D]
    /**
     * Computes the UV coordinates of the given point `p`.
     *
     * The point `p` must lie on the same plane as the triangle `t;` if the point
     * is not coplanar, the result of this function is undefined. If `p` is %NULL,
     * the point will be set in (0, 0, 0).
     *
     * The UV coordinates will be placed in the `res` vector:
     *
     *  - `res.x = u`
     *  - `res.y = v`
     *
     * See also: graphene_triangle_get_barycoords()
     * @param p a #graphene_point3d_t
     * @param uvA the UV coordinates of the first point
     * @param uvB the UV coordinates of the second point
     * @param uvC the UV coordinates of the third point
     * @returns `true` if the coordinates are valid
     */
    getUv(
      p: Point3D | null,
      uvA: Vec2,
      uvB: Vec2,
      uvC: Vec2
    ): [/* returnType */ boolean, /* res */ Vec2]
    /**
     * Retrieves the three vertices of the given #graphene_triangle_t.
     */
    getVertices(): [/* a */ Vec3, /* b */ Vec3, /* c */ Vec3]
    /**
     * Initializes a #graphene_triangle_t using the three given arrays
     * of floating point values, each representing the coordinates of
     * a point in 3D space.
     * @param a an array of 3 floating point values
     * @param b an array of 3 floating point values
     * @param c an array of 3 floating point values
     * @returns the initialized #graphene_triangle_t
     */
    initFromFloat(a: number[], b: number[], c: number[]): Triangle
    /**
     * Initializes a #graphene_triangle_t using the three given 3D points.
     * @param a a #graphene_point3d_t
     * @param b a #graphene_point3d_t
     * @param c a #graphene_point3d_t
     * @returns the initialized #graphene_triangle_t
     */
    initFromPoint3d(
      a: Point3D | null,
      b: Point3D | null,
      c: Point3D | null
    ): Triangle
    /**
     * Initializes a #graphene_triangle_t using the three given vectors.
     * @param a a #graphene_vec3_t
     * @param b a #graphene_vec3_t
     * @param c a #graphene_vec3_t
     * @returns the initialized #graphene_triangle_t
     */
    initFromVec3(a: Vec3 | null, b: Vec3 | null, c: Vec3 | null): Triangle
  }

  /**
   * A triangle.
   * @record
   */
  class Triangle {
    // Own properties of Graphene-1.0.Graphene.Triangle

    static name: string

    // Constructors of Graphene-1.0.Graphene.Triangle

    /**
     * Allocates a new #graphene_triangle_t.
     *
     * The contents of the returned structure are undefined.
     * @constructor
     * @returns the newly allocated #graphene_triangle_t   structure. Use graphene_triangle_free() to free the resources   allocated by this function
     */
    static alloc(): Triangle
  }

  interface Vec2 {
    // Owm methods of Graphene-1.0.Graphene.Vec2

    /**
     * Adds each component of the two passed vectors and places
     * each result into the components of `res`.
     * @param b a #graphene_vec2_t
     */
    add(b: Vec2): /* res */ Vec2
    /**
     * Divides each component of the first operand `a` by the corresponding
     * component of the second operand `b,` and places the results into the
     * vector `res`.
     * @param b a #graphene_vec2_t
     */
    divide(b: Vec2): /* res */ Vec2
    /**
     * Computes the dot product of the two given vectors.
     * @param b a #graphene_vec2_t
     * @returns the dot product of the vectors
     */
    dot(b: Vec2): number
    /**
     * Checks whether the two given #graphene_vec2_t are equal.
     * @param v2 a #graphene_vec2_t
     * @returns `true` if the two vectors are equal, and false otherwise
     */
    equal(v2: Vec2): boolean
    /**
     * Frees the resources allocated by `v`
     */
    free(): void
    /**
     * Retrieves the X component of the #graphene_vec2_t.
     * @returns the value of the X component
     */
    getX(): number
    /**
     * Retrieves the Y component of the #graphene_vec2_t.
     * @returns the value of the Y component
     */
    getY(): number
    /**
     * Initializes a #graphene_vec2_t using the given values.
     *
     * This function can be called multiple times.
     * @param x the X field of the vector
     * @param y the Y field of the vector
     * @returns the initialized vector
     */
    init(x: number, y: number): Vec2
    /**
     * Initializes `v` with the contents of the given array.
     * @param src an array of floating point values   with at least two elements
     * @returns the initialized vector
     */
    initFromFloat(src: number[]): Vec2
    /**
     * Copies the contents of `src` into `v`.
     * @param src a #graphene_vec2_t
     * @returns the initialized vector
     */
    initFromVec2(src: Vec2): Vec2
    /**
     * Linearly interpolates `v1` and `v2` using the given `factor`.
     * @param v2 a #graphene_vec2_t
     * @param factor the interpolation factor
     */
    interpolate(v2: Vec2, factor: number): /* res */ Vec2
    /**
     * Computes the length of the given vector.
     * @returns the length of the vector
     */
    length(): number
    /**
     * Compares the two given vectors and places the maximum
     * values of each component into `res`.
     * @param b a #graphene_vec2_t
     */
    max(b: Vec2): /* res */ Vec2
    /**
     * Compares the two given vectors and places the minimum
     * values of each component into `res`.
     * @param b a #graphene_vec2_t
     */
    min(b: Vec2): /* res */ Vec2
    /**
     * Multiplies each component of the two passed vectors and places
     * each result into the components of `res`.
     * @param b a #graphene_vec2_t
     */
    multiply(b: Vec2): /* res */ Vec2
    /**
     * Compares the two given #graphene_vec2_t vectors and checks
     * whether their values are within the given `epsilon`.
     * @param v2 a #graphene_vec2_t
     * @param epsilon the threshold between the two vectors
     * @returns `true` if the two vectors are near each other
     */
    near(v2: Vec2, epsilon: number): boolean
    /**
     * Negates the given #graphene_vec2_t.
     */
    negate(): /* res */ Vec2
    /**
     * Computes the normalized vector for the given vector `v`.
     */
    normalize(): /* res */ Vec2
    /**
     * Multiplies all components of the given vector with the given scalar `factor`.
     * @param factor the scalar factor
     */
    scale(factor: number): /* res */ Vec2
    /**
     * Subtracts from each component of the first operand `a` the
     * corresponding component of the second operand `b` and places
     * each result into the components of `res`.
     * @param b a #graphene_vec2_t
     */
    subtract(b: Vec2): /* res */ Vec2
    /**
     * Stores the components of `v` into an array.
     */
    toFloat(): /* dest */ number[]
  }

  /**
   * A structure capable of holding a vector with two dimensions, x and y.
   *
   * The contents of the #graphene_vec2_t structure are private and should
   * never be accessed directly.
   * @record
   */
  class Vec2 {
    // Own properties of Graphene-1.0.Graphene.Vec2

    static name: string

    // Constructors of Graphene-1.0.Graphene.Vec2

    /**
     * Allocates a new #graphene_vec2_t structure.
     *
     * The contents of the returned structure are undefined.
     *
     * Use graphene_vec2_init() to initialize the vector.
     * @constructor
     * @returns the newly allocated #graphene_vec2_t   structure. Use graphene_vec2_free() to free the resources allocated   by this function.
     */
    static alloc(): Vec2
    /**
     * Retrieves a constant vector with (1, 1) components.
     * @returns the one vector
     */
    static one(): Vec2
    /**
     * Retrieves a constant vector with (1, 0) components.
     * @returns the X axis vector
     */
    static xAxis(): Vec2
    /**
     * Retrieves a constant vector with (0, 1) components.
     * @returns the Y axis vector
     */
    static yAxis(): Vec2
    /**
     * Retrieves a constant vector with (0, 0) components.
     * @returns the zero vector
     */
    static zero(): Vec2
  }

  interface Vec3 {
    // Owm methods of Graphene-1.0.Graphene.Vec3

    /**
     * Adds each component of the two given vectors.
     * @param b a #graphene_vec3_t
     */
    add(b: Vec3): /* res */ Vec3
    /**
     * Computes the cross product of the two given vectors.
     * @param b a #graphene_vec3_t
     */
    cross(b: Vec3): /* res */ Vec3
    /**
     * Divides each component of the first operand `a` by the corresponding
     * component of the second operand `b,` and places the results into the
     * vector `res`.
     * @param b a #graphene_vec3_t
     */
    divide(b: Vec3): /* res */ Vec3
    /**
     * Computes the dot product of the two given vectors.
     * @param b a #graphene_vec3_t
     * @returns the value of the dot product
     */
    dot(b: Vec3): number
    /**
     * Checks whether the two given #graphene_vec3_t are equal.
     * @param v2 a #graphene_vec3_t
     * @returns `true` if the two vectors are equal, and false otherwise
     */
    equal(v2: Vec3): boolean
    /**
     * Frees the resources allocated by `v`
     */
    free(): void
    /**
     * Retrieves the first component of the given vector `v`.
     * @returns the value of the first component of the vector
     */
    getX(): number
    /**
     * Creates a #graphene_vec2_t that contains the first and second
     * components of the given #graphene_vec3_t.
     */
    getXy(): /* res */ Vec2
    /**
     * Creates a #graphene_vec3_t that contains the first two components of
     * the given #graphene_vec3_t, and the third component set to 0.
     */
    getXy0(): /* res */ Vec3
    /**
     * Converts a #graphene_vec3_t in a #graphene_vec4_t using 0.0
     * as the value for the fourth component of the resulting vector.
     */
    getXyz0(): /* res */ Vec4
    /**
     * Converts a #graphene_vec3_t in a #graphene_vec4_t using 1.0
     * as the value for the fourth component of the resulting vector.
     */
    getXyz1(): /* res */ Vec4
    /**
     * Converts a #graphene_vec3_t in a #graphene_vec4_t using `w` as
     * the value of the fourth component of the resulting vector.
     * @param w the value of the W component
     */
    getXyzw(w: number): /* res */ Vec4
    /**
     * Retrieves the second component of the given vector `v`.
     * @returns the value of the second component of the vector
     */
    getY(): number
    /**
     * Retrieves the third component of the given vector `v`.
     * @returns the value of the third component of the vector
     */
    getZ(): number
    /**
     * Initializes a #graphene_vec3_t using the given values.
     *
     * This function can be called multiple times.
     * @param x the X field of the vector
     * @param y the Y field of the vector
     * @param z the Z field of the vector
     * @returns a pointer to the initialized   vector
     */
    init(x: number, y: number, z: number): Vec3
    /**
     * Initializes a #graphene_vec3_t with the values from an array.
     * @param src an array of 3 floating point values
     * @returns the initialized vector
     */
    initFromFloat(src: number[]): Vec3
    /**
     * Initializes a #graphene_vec3_t with the values of another
     * #graphene_vec3_t.
     * @param src a #graphene_vec3_t
     * @returns the initialized vector
     */
    initFromVec3(src: Vec3): Vec3
    /**
     * Linearly interpolates `v1` and `v2` using the given `factor`.
     * @param v2 a #graphene_vec3_t
     * @param factor the interpolation factor
     */
    interpolate(v2: Vec3, factor: number): /* res */ Vec3
    /**
     * Retrieves the length of the given vector `v`.
     * @returns the value of the length of the vector
     */
    length(): number
    /**
     * Compares each component of the two given vectors and creates a
     * vector that contains the maximum values.
     * @param b a #graphene_vec3_t
     */
    max(b: Vec3): /* res */ Vec3
    /**
     * Compares each component of the two given vectors and creates a
     * vector that contains the minimum values.
     * @param b a #graphene_vec3_t
     */
    min(b: Vec3): /* res */ Vec3
    /**
     * Multiplies each component of the two given vectors.
     * @param b a #graphene_vec3_t
     */
    multiply(b: Vec3): /* res */ Vec3
    /**
     * Compares the two given #graphene_vec3_t vectors and checks
     * whether their values are within the given `epsilon`.
     * @param v2 a #graphene_vec3_t
     * @param epsilon the threshold between the two vectors
     * @returns `true` if the two vectors are near each other
     */
    near(v2: Vec3, epsilon: number): boolean
    /**
     * Negates the given #graphene_vec3_t.
     */
    negate(): /* res */ Vec3
    /**
     * Normalizes the given #graphene_vec3_t.
     */
    normalize(): /* res */ Vec3
    /**
     * Multiplies all components of the given vector with the given scalar `factor`.
     * @param factor the scalar factor
     */
    scale(factor: number): /* res */ Vec3
    /**
     * Subtracts from each component of the first operand `a` the
     * corresponding component of the second operand `b` and places
     * each result into the components of `res`.
     * @param b a #graphene_vec3_t
     */
    subtract(b: Vec3): /* res */ Vec3
    /**
     * Copies the components of a #graphene_vec3_t into the given array.
     */
    toFloat(): /* dest */ number[]
  }

  /**
   * A structure capable of holding a vector with three dimensions: x, y, and z.
   *
   * The contents of the #graphene_vec3_t structure are private and should
   * never be accessed directly.
   * @record
   */
  class Vec3 {
    // Own properties of Graphene-1.0.Graphene.Vec3

    static name: string

    // Constructors of Graphene-1.0.Graphene.Vec3

    /**
     * Allocates a new #graphene_vec3_t structure.
     *
     * The contents of the returned structure are undefined.
     *
     * Use graphene_vec3_init() to initialize the vector.
     * @constructor
     * @returns the newly allocated #graphene_vec3_t   structure. Use graphene_vec3_free() to free the resources allocated   by this function.
     */
    static alloc(): Vec3
    /**
     * Provides a constant pointer to a vector with three components,
     * all sets to 1.
     * @returns a constant vector
     */
    static one(): Vec3
    /**
     * Provides a constant pointer to a vector with three components
     * with values set to (1, 0, 0).
     * @returns a constant vector
     */
    static xAxis(): Vec3
    /**
     * Provides a constant pointer to a vector with three components
     * with values set to (0, 1, 0).
     * @returns a constant vector
     */
    static yAxis(): Vec3
    /**
     * Provides a constant pointer to a vector with three components
     * with values set to (0, 0, 1).
     * @returns a constant vector
     */
    static zAxis(): Vec3
    /**
     * Provides a constant pointer to a vector with three components,
     * all sets to 0.
     * @returns a constant vector
     */
    static zero(): Vec3
  }

  interface Vec4 {
    // Owm methods of Graphene-1.0.Graphene.Vec4

    /**
     * Adds each component of the two given vectors.
     * @param b a #graphene_vec4_t
     */
    add(b: Vec4): /* res */ Vec4
    /**
     * Divides each component of the first operand `a` by the corresponding
     * component of the second operand `b,` and places the results into the
     * vector `res`.
     * @param b a #graphene_vec4_t
     */
    divide(b: Vec4): /* res */ Vec4
    /**
     * Computes the dot product of the two given vectors.
     * @param b a #graphene_vec4_t
     * @returns the value of the dot product
     */
    dot(b: Vec4): number
    /**
     * Checks whether the two given #graphene_vec4_t are equal.
     * @param v2 a #graphene_vec4_t
     * @returns `true` if the two vectors are equal, and false otherwise
     */
    equal(v2: Vec4): boolean
    /**
     * Frees the resources allocated by `v`
     */
    free(): void
    /**
     * Retrieves the value of the fourth component of the given #graphene_vec4_t.
     * @returns the value of the fourth component
     */
    getW(): number
    /**
     * Retrieves the value of the first component of the given #graphene_vec4_t.
     * @returns the value of the first component
     */
    getX(): number
    /**
     * Creates a #graphene_vec2_t that contains the first two components
     * of the given #graphene_vec4_t.
     */
    getXy(): /* res */ Vec2
    /**
     * Creates a #graphene_vec3_t that contains the first three components
     * of the given #graphene_vec4_t.
     */
    getXyz(): /* res */ Vec3
    /**
     * Retrieves the value of the second component of the given #graphene_vec4_t.
     * @returns the value of the second component
     */
    getY(): number
    /**
     * Retrieves the value of the third component of the given #graphene_vec4_t.
     * @returns the value of the third component
     */
    getZ(): number
    /**
     * Initializes a #graphene_vec4_t using the given values.
     *
     * This function can be called multiple times.
     * @param x the X field of the vector
     * @param y the Y field of the vector
     * @param z the Z field of the vector
     * @param w the W field of the vector
     * @returns a pointer to the initialized   vector
     */
    init(x: number, y: number, z: number, w: number): Vec4
    /**
     * Initializes a #graphene_vec4_t with the values inside the given array.
     * @param src an array of four floating point values
     * @returns the initialized vector
     */
    initFromFloat(src: number[]): Vec4
    /**
     * Initializes a #graphene_vec4_t using the components of a
     * #graphene_vec2_t and the values of `z` and `w`.
     * @param src a #graphene_vec2_t
     * @param z the value for the third component of `v`
     * @param w the value for the fourth component of `v`
     * @returns the initialized vector
     */
    initFromVec2(src: Vec2, z: number, w: number): Vec4
    /**
     * Initializes a #graphene_vec4_t using the components of a
     * #graphene_vec3_t and the value of `w`.
     * @param src a #graphene_vec3_t
     * @param w the value for the fourth component of `v`
     * @returns the initialized vector
     */
    initFromVec3(src: Vec3, w: number): Vec4
    /**
     * Initializes a #graphene_vec4_t using the components of
     * another #graphene_vec4_t.
     * @param src a #graphene_vec4_t
     * @returns the initialized vector
     */
    initFromVec4(src: Vec4): Vec4
    /**
     * Linearly interpolates `v1` and `v2` using the given `factor`.
     * @param v2 a #graphene_vec4_t
     * @param factor the interpolation factor
     */
    interpolate(v2: Vec4, factor: number): /* res */ Vec4
    /**
     * Computes the length of the given #graphene_vec4_t.
     * @returns the length of the vector
     */
    length(): number
    /**
     * Compares each component of the two given vectors and creates a
     * vector that contains the maximum values.
     * @param b a #graphene_vec4_t
     */
    max(b: Vec4): /* res */ Vec4
    /**
     * Compares each component of the two given vectors and creates a
     * vector that contains the minimum values.
     * @param b a #graphene_vec4_t
     */
    min(b: Vec4): /* res */ Vec4
    /**
     * Multiplies each component of the two given vectors.
     * @param b a #graphene_vec4_t
     */
    multiply(b: Vec4): /* res */ Vec4
    /**
     * Compares the two given #graphene_vec4_t vectors and checks
     * whether their values are within the given `epsilon`.
     * @param v2 a #graphene_vec4_t
     * @param epsilon the threshold between the two vectors
     * @returns `true` if the two vectors are near each other
     */
    near(v2: Vec4, epsilon: number): boolean
    /**
     * Negates the given #graphene_vec4_t.
     */
    negate(): /* res */ Vec4
    /**
     * Normalizes the given #graphene_vec4_t.
     */
    normalize(): /* res */ Vec4
    /**
     * Multiplies all components of the given vector with the given scalar `factor`.
     * @param factor the scalar factor
     */
    scale(factor: number): /* res */ Vec4
    /**
     * Subtracts from each component of the first operand `a` the
     * corresponding component of the second operand `b` and places
     * each result into the components of `res`.
     * @param b a #graphene_vec4_t
     */
    subtract(b: Vec4): /* res */ Vec4
    /**
     * Stores the components of the given #graphene_vec4_t into an array
     * of floating point values.
     */
    toFloat(): /* dest */ number[]
  }

  /**
   * A structure capable of holding a vector with four dimensions: x, y, z, and w.
   *
   * The contents of the #graphene_vec4_t structure are private and should
   * never be accessed directly.
   * @record
   */
  class Vec4 {
    // Own properties of Graphene-1.0.Graphene.Vec4

    static name: string

    // Constructors of Graphene-1.0.Graphene.Vec4

    /**
     * Allocates a new #graphene_vec4_t structure.
     *
     * The contents of the returned structure are undefined.
     *
     * Use graphene_vec4_init() to initialize the vector.
     * @constructor
     * @returns the newly allocated #graphene_vec4_t   structure. Use graphene_vec4_free() to free the resources allocated   by this function.
     */
    static alloc(): Vec4
    /**
     * Retrieves a pointer to a #graphene_vec4_t with all its
     * components set to 1.
     * @returns a constant vector
     */
    static one(): Vec4
    /**
     * Retrieves a pointer to a #graphene_vec4_t with its
     * components set to (0, 0, 0, 1).
     * @returns a constant vector
     */
    static wAxis(): Vec4
    /**
     * Retrieves a pointer to a #graphene_vec4_t with its
     * components set to (1, 0, 0, 0).
     * @returns a constant vector
     */
    static xAxis(): Vec4
    /**
     * Retrieves a pointer to a #graphene_vec4_t with its
     * components set to (0, 1, 0, 0).
     * @returns a constant vector
     */
    static yAxis(): Vec4
    /**
     * Retrieves a pointer to a #graphene_vec4_t with its
     * components set to (0, 0, 1, 0).
     * @returns a constant vector
     */
    static zAxis(): Vec4
    /**
     * Retrieves a pointer to a #graphene_vec4_t with all its
     * components set to 0.
     * @returns a constant vector
     */
    static zero(): Vec4
  }
}

type Gdk40 = typeof Gdk

declare global {
  interface NodeGtkGi {
    require(ns: "Gdk", ver?: "4.0"): Gdk40
  }
}

type Cairo10 = typeof cairo

declare global {
  interface NodeGtkGi {
    require(ns: "cairo", ver?: "1.0"): Cairo10
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace cairo {
  enum Status {
    SUCCESS,
    NO_MEMORY,
    INVALID_RESTORE,
    INVALID_POP_GROUP,
    NO_CURRENT_POINT,
    INVALID_MATRIX,
    INVALID_STATUS,
    NULL_POINTER,
    INVALID_STRING,
    INVALID_PATH_DATA,
    READ_ERROR,
    WRITE_ERROR,
    SURFACE_FINISHED,
    SURFACE_TYPE_MISMATCH,
    PATTERN_TYPE_MISMATCH,
    INVALID_CONTENT,
    INVALID_FORMAT,
    INVALID_VISUAL,
    FILE_NOT_FOUND,
    INVALID_DASH,
    INVALID_DSC_COMMENT,
    INVALID_INDEX,
    CLIP_NOT_REPRESENTABLE,
    TEMP_FILE_ERROR,
    INVALID_STRIDE,
    FONT_TYPE_MISMATCH,
    USER_FONT_IMMUTABLE,
    USER_FONT_ERROR,
    NEGATIVE_COUNT,
    INVALID_CLUSTERS,
    INVALID_SLANT,
    INVALID_WEIGHT,
    INVALID_SIZE,
    USER_FONT_NOT_IMPLEMENTED,
    DEVICE_TYPE_MISMATCH,
    DEVICE_ERROR,
    INVALID_MESH_CONSTRUCTION,
    DEVICE_FINISHED,
    JBIG2_GLOBAL_MISSING,
  }
  enum Content {
    COLOR,
    ALPHA,
    COLOR_ALPHA,
  }
  enum Operator {
    CLEAR,
    SOURCE,
    OVER,
    IN,
    OUT,
    ATOP,
    DEST,
    DEST_OVER,
    DEST_IN,
    DEST_OUT,
    DEST_ATOP,
    XOR,
    ADD,
    SATURATE,
    MULTIPLY,
    SCREEN,
    OVERLAY,
    DARKEN,
    LIGHTEN,
    COLOR_DODGE,
    COLOR_BURN,
    HARD_LIGHT,
    SOFT_LIGHT,
    DIFFERENCE,
    EXCLUSION,
    HSL_HUE,
    HSL_SATURATION,
    HSL_COLOR,
    HSL_LUMINOSITY,
  }
  enum Antialias {
    DEFAULT,
    NONE,
    GRAY,
    SUBPIXEL,
    FAST,
    GOOD,
    BEST,
  }
  enum FillRule {
    WINDING,
    EVEN_ODD,
  }
  enum LineCap {
    BUTT,
    ROUND,
    SQUARE,
  }
  enum LineJoin {
    MITER,
    ROUND,
    BEVEL,
  }
  enum TextClusterFlags {
    BACKWARD,
  }
  enum FontSlant {
    NORMAL,
    ITALIC,
    OBLIQUE,
  }
  enum FontWeight {
    NORMAL,
    BOLD,
  }
  enum SubpixelOrder {
    DEFAULT,
    RGB,
    BGR,
    VRGB,
    VBGR,
  }
  enum HintStyle {
    DEFAULT,
    NONE,
    SLIGHT,
    MEDIUM,
    FULL,
  }
  enum HintMetrics {
    DEFAULT,
    OFF,
    ON,
  }
  enum FontType {
    TOY,
    FT,
    WIN32,
    QUARTZ,
    USER,
  }
  enum PathDataType {
    MOVE_TO,
    LINE_TO,
    CURVE_TO,
    CLOSE_PATH,
  }
  enum DeviceType {
    DRM,
    GL,
    SCRIPT,
    XCB,
    XLIB,
    XML,
    COGL,
    WIN32,
    INVALID,
  }
  enum SurfaceType {
    IMAGE,
    PDF,
    PS,
    XLIB,
    XCB,
    GLITZ,
    QUARTZ,
    WIN32,
    BEOS,
    DIRECTFB,
    SVG,
    OS2,
    WIN32_PRINTING,
    QUARTZ_IMAGE,
    SCRIPT,
    QT,
    RECORDING,
    VG,
    GL,
    DRM,
    TEE,
    XML,
    SKIA,
    SUBSURFACE,
    COGL,
  }
  enum Format {
    INVALID,
    ARGB32,
    RGB24,
    A8,
    A1,
    RGB16_565,
    RGB30,
  }
  enum PatternType {
    SOLID,
    SURFACE,
    LINEAR,
    RADIAL,
    MESH,
    RASTER_SOURCE,
  }
  enum Extend {
    NONE,
    REPEAT,
    REFLECT,
    PAD,
  }
  enum Filter {
    FAST,
    GOOD,
    BEST,
    NEAREST,
    BILINEAR,
    GAUSSIAN,
  }
  enum RegionOverlap {
    IN,
    OUT,
    PART,
  }
  function imageSurfaceCreate(): void
  interface Context {}

  class Context {
    // Own properties of cairo-1.0.cairo.Context

    static name: string
  }

  interface Device {}

  class Device {
    // Own properties of cairo-1.0.cairo.Device

    static name: string
  }

  interface Surface {}

  class Surface {
    // Own properties of cairo-1.0.cairo.Surface

    static name: string
  }

  interface Matrix {}

  class Matrix {
    // Own properties of cairo-1.0.cairo.Matrix

    static name: string
  }

  interface Pattern {}

  class Pattern {
    // Own properties of cairo-1.0.cairo.Pattern

    static name: string
  }

  interface Region {}

  class Region {
    // Own properties of cairo-1.0.cairo.Region

    static name: string
  }

  interface FontOptions {}

  class FontOptions {
    // Own properties of cairo-1.0.cairo.FontOptions

    static name: string
  }

  interface FontFace {}

  class FontFace {
    // Own properties of cairo-1.0.cairo.FontFace

    static name: string
  }

  interface ScaledFont {}

  class ScaledFont {
    // Own properties of cairo-1.0.cairo.ScaledFont

    static name: string
  }

  interface Path {}

  class Path {
    // Own properties of cairo-1.0.cairo.Path

    static name: string
  }

  interface Rectangle {
    // Own fields of cairo-1.0.cairo.Rectangle

    x: number
    y: number
    width: number
    height: number
  }

  class Rectangle {
    // Own properties of cairo-1.0.cairo.Rectangle

    static name: string
  }

  interface RectangleInt {
    // Own fields of cairo-1.0.cairo.RectangleInt

    x: number
    y: number
    width: number
    height: number
  }

  class RectangleInt {
    // Own properties of cairo-1.0.cairo.RectangleInt

    static name: string
  }
}

type PangoCairo10 = typeof PangoCairo

declare global {
  interface NodeGtkGi {
    require(ns: "PangoCairo", ver?: "1.0"): PangoCairo10
  }
}

type Pango10 = typeof Pango

declare global {
  interface NodeGtkGi {
    require(ns: "Pango", ver?: "1.0"): Pango10
  }
}

type HarfBuzz00 = typeof HarfBuzz

declare global {
  interface NodeGtkGi {
    require(ns: "HarfBuzz", ver?: "0.0"): HarfBuzz00
  }
}

type Freetype220 = typeof freetype2

declare global {
  interface NodeGtkGi {
    require(ns: "freetype2", ver?: "2.0"): Freetype220
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace freetype2 {
  interface Bitmap {}

  class Bitmap {
    // Own properties of freetype2-2.0.freetype2.Bitmap

    static name: string
  }

  interface Face {}

  class Face {
    // Own properties of freetype2-2.0.freetype2.Face

    static name: string
  }

  interface Library {}

  class Library {
    // Own properties of freetype2-2.0.freetype2.Library

    static name: string
  }

  type Int32 = number
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace HarfBuzz {
  /**
   * The selectors defined for specifying AAT feature settings.
   */
  enum aat_layout_feature_selector_t {
    /**
     * Initial, unset feature selector
     */
    INVALID,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALL_TYPOGRAPHIC
     */
    ALL_TYPE_FEATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALL_TYPOGRAPHIC
     */
    ALL_TYPE_FEATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    REQUIRED_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    REQUIRED_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    COMMON_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    COMMON_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    RARE_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    RARE_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    LOGOS_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    LOGOS_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    REBUS_PICTURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    REBUS_PICTURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    DIPHTHONG_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    DIPHTHONG_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    SQUARED_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    SQUARED_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    ABBREV_SQUARED_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    ABBREV_SQUARED_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    SYMBOL_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    SYMBOL_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    CONTEXTUAL_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    CONTEXTUAL_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    HISTORICAL_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    HISTORICAL_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    UNCONNECTED,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    PARTIALLY_CONNECTED,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
     */
    CURSIVE,
    /**
     * Deprecated
     */
    UPPER_AND_LOWER_CASE,
    /**
     * Deprecated
     */
    ALL_CAPS,
    /**
     * Deprecated
     */
    ALL_LOWER_CASE,
    /**
     * Deprecated
     */
    SMALL_CAPS,
    /**
     * Deprecated
     */
    INITIAL_CAPS,
    /**
     * Deprecated
     */
    INITIAL_CAPS_AND_SMALL_CAPS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_SUBSTITUTION
     */
    SUBSTITUTE_VERTICAL_FORMS_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_SUBSTITUTION
     */
    SUBSTITUTE_VERTICAL_FORMS_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LINGUISTIC_REARRANGEMENT
     */
    LINGUISTIC_REARRANGEMENT_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LINGUISTIC_REARRANGEMENT
     */
    LINGUISTIC_REARRANGEMENT_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING
     */
    MONOSPACED_NUMBERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING
     */
    PROPORTIONAL_NUMBERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING
     */
    THIRD_WIDTH_NUMBERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING
     */
    QUARTER_WIDTH_NUMBERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    WORD_INITIAL_SWASHES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    WORD_INITIAL_SWASHES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    WORD_FINAL_SWASHES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    WORD_FINAL_SWASHES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    LINE_INITIAL_SWASHES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    LINE_INITIAL_SWASHES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    LINE_FINAL_SWASHES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    LINE_FINAL_SWASHES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    NON_FINAL_SWASHES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
     */
    NON_FINAL_SWASHES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE
     */
    SHOW_DIACRITICS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE
     */
    HIDE_DIACRITICS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE
     */
    DECOMPOSE_DIACRITICS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
     */
    NORMAL_POSITION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
     */
    SUPERIORS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
     */
    INFERIORS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
     */
    ORDINALS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
     */
    SCIENTIFIC_INFERIORS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS
     */
    NO_FRACTIONS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS
     */
    VERTICAL_FRACTIONS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS
     */
    DIAGONAL_FRACTIONS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_OVERLAPPING_CHARACTERS_TYPE
     */
    PREVENT_OVERLAP_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_OVERLAPPING_CHARACTERS_TYPE
     */
    PREVENT_OVERLAP_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    HYPHENS_TO_EM_DASH_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    HYPHENS_TO_EM_DASH_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    HYPHEN_TO_EN_DASH_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    HYPHEN_TO_EN_DASH_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    SLASHED_ZERO_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    SLASHED_ZERO_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    FORM_INTERROBANG_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    FORM_INTERROBANG_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    SMART_QUOTES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    SMART_QUOTES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    PERIODS_TO_ELLIPSIS_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
     */
    PERIODS_TO_ELLIPSIS_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    HYPHEN_TO_MINUS_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    HYPHEN_TO_MINUS_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    ASTERISK_TO_MULTIPLY_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    ASTERISK_TO_MULTIPLY_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    SLASH_TO_DIVIDE_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    SLASH_TO_DIVIDE_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    INEQUALITY_LIGATURES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    INEQUALITY_LIGATURES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    EXPONENTS_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    EXPONENTS_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    MATHEMATICAL_GREEK_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
     */
    MATHEMATICAL_GREEK_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
     */
    NO_ORNAMENTS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
     */
    DINGBATS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
     */
    PI_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
     */
    FLEURONS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
     */
    DECORATIVE_BORDERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
     */
    INTERNATIONAL_SYMBOLS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
     */
    MATH_SYMBOLS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_ALTERNATIVES
     */
    NO_ALTERNATES,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
     */
    DESIGN_LEVEL1,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
     */
    DESIGN_LEVEL2,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
     */
    DESIGN_LEVEL3,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
     */
    DESIGN_LEVEL4,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
     */
    DESIGN_LEVEL5,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
     */
    NO_STYLE_OPTIONS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
     */
    DISPLAY_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
     */
    ENGRAVED_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
     */
    ILLUMINATED_CAPS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
     */
    TITLING_CAPS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
     */
    TALL_CAPS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    TRADITIONAL_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    SIMPLIFIED_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    JIS1978_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    JIS1983_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    JIS1990_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    TRADITIONAL_ALT_ONE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    TRADITIONAL_ALT_TWO,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    TRADITIONAL_ALT_THREE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    TRADITIONAL_ALT_FOUR,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    TRADITIONAL_ALT_FIVE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    EXPERT_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    JIS2004_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    HOJO_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    NLCCHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
     */
    TRADITIONAL_NAMES_CHARACTERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_CASE
     */
    LOWER_CASE_NUMBERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_CASE
     */
    UPPER_CASE_NUMBERS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
     */
    PROPORTIONAL_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
     */
    MONOSPACED_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
     */
    HALF_WIDTH_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
     */
    THIRD_WIDTH_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
     */
    QUARTER_WIDTH_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
     */
    ALT_PROPORTIONAL_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
     */
    ALT_HALF_WIDTH_TEXT,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    NO_TRANSLITERATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    HANJA_TO_HANGUL,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    HIRAGANA_TO_KATAKANA,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    KATAKANA_TO_HIRAGANA,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    KANA_TO_ROMANIZATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    ROMANIZATION_TO_HIRAGANA,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    ROMANIZATION_TO_KATAKANA,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    HANJA_TO_HANGUL_ALT_ONE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    HANJA_TO_HANGUL_ALT_TWO,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
     */
    HANJA_TO_HANGUL_ALT_THREE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    NO_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    BOX_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    ROUNDED_BOX_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    CIRCLE_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    INVERTED_CIRCLE_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    PARENTHESIS_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    PERIOD_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    ROMAN_NUMERAL_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    DIAMOND_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    INVERTED_BOX_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
     */
    INVERTED_ROUNDED_BOX_ANNOTATION,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_KANA_SPACING_TYPE
     */
    FULL_WIDTH_KANA,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_KANA_SPACING_TYPE
     */
    PROPORTIONAL_KANA,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE
     */
    FULL_WIDTH_IDEOGRAPHS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE
     */
    PROPORTIONAL_IDEOGRAPHS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE
     */
    HALF_WIDTH_IDEOGRAPHS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
     */
    CANONICAL_COMPOSITION_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
     */
    CANONICAL_COMPOSITION_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
     */
    COMPATIBILITY_COMPOSITION_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
     */
    COMPATIBILITY_COMPOSITION_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
     */
    TRANSCODING_COMPOSITION_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
     */
    TRANSCODING_COMPOSITION_OFF,
    /**
     * Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_RUBY_KANA_OFF instead
     */
    NO_RUBY_KANA,
    /**
     * Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_RUBY_KANA_ON instead
     */
    RUBY_KANA,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_RUBY_KANA
     */
    RUBY_KANA_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_RUBY_KANA
     */
    RUBY_KANA_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
     */
    NO_CJK_SYMBOL_ALTERNATIVES,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
     */
    CJK_SYMBOL_ALT_ONE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
     */
    CJK_SYMBOL_ALT_TWO,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
     */
    CJK_SYMBOL_ALT_THREE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
     */
    CJK_SYMBOL_ALT_FOUR,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
     */
    CJK_SYMBOL_ALT_FIVE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
     */
    NO_IDEOGRAPHIC_ALTERNATIVES,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
     */
    IDEOGRAPHIC_ALT_ONE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
     */
    IDEOGRAPHIC_ALT_TWO,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
     */
    IDEOGRAPHIC_ALT_THREE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
     */
    IDEOGRAPHIC_ALT_FOUR,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
     */
    IDEOGRAPHIC_ALT_FIVE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_VERTICAL_ROMAN_PLACEMENT_TYPE
     */
    CJK_VERTICAL_ROMAN_CENTERED,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_VERTICAL_ROMAN_PLACEMENT_TYPE
     */
    CJK_VERTICAL_ROMAN_HBASELINE,
    /**
     * Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_CJK_ITALIC_ROMAN_OFF instead
     */
    NO_CJK_ITALIC_ROMAN,
    /**
     * Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_CJK_ITALIC_ROMAN_ON instead
     */
    CJK_ITALIC_ROMAN,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ITALIC_CJK_ROMAN
     */
    CJK_ITALIC_ROMAN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ITALIC_CJK_ROMAN
     */
    CJK_ITALIC_ROMAN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT
     */
    CASE_SENSITIVE_LAYOUT_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT
     */
    CASE_SENSITIVE_LAYOUT_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT
     */
    CASE_SENSITIVE_SPACING_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT
     */
    CASE_SENSITIVE_SPACING_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA
     */
    ALTERNATE_HORIZ_KANA_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA
     */
    ALTERNATE_HORIZ_KANA_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA
     */
    ALTERNATE_VERT_KANA_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA
     */
    ALTERNATE_VERT_KANA_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    NO_STYLISTIC_ALTERNATES,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_ONE_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_ONE_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_TWO_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_TWO_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_THREE_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_THREE_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_FOUR_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_FOUR_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_FIVE_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_FIVE_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_SIX_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_SIX_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_SEVEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_SEVEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_EIGHT_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_EIGHT_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_NINE_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_NINE_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_TEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_TEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_ELEVEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_ELEVEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_TWELVE_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_TWELVE_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_THIRTEEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_THIRTEEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_FOURTEEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_FOURTEEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_FIFTEEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_FIFTEEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_SIXTEEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_SIXTEEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_SEVENTEEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_SEVENTEEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_EIGHTEEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_EIGHTEEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_NINETEEN_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_NINETEEN_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_TWENTY_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
     */
    STYLISTIC_ALT_TWENTY_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
     */
    CONTEXTUAL_ALTERNATES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
     */
    CONTEXTUAL_ALTERNATES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
     */
    SWASH_ALTERNATES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
     */
    SWASH_ALTERNATES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
     */
    CONTEXTUAL_SWASH_ALTERNATES_ON,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
     */
    CONTEXTUAL_SWASH_ALTERNATES_OFF,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE
     */
    DEFAULT_LOWER_CASE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE
     */
    LOWER_CASE_SMALL_CAPS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE
     */
    LOWER_CASE_PETITE_CAPS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE
     */
    DEFAULT_UPPER_CASE,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE
     */
    UPPER_CASE_SMALL_CAPS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE
     */
    UPPER_CASE_PETITE_CAPS,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE
     */
    HALF_WIDTH_CJK_ROMAN,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE
     */
    PROPORTIONAL_CJK_ROMAN,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE
     */
    DEFAULT_CJK_ROMAN,
    /**
     * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE
     */
    FULL_WIDTH_CJK_ROMAN,
  }
  /**
   * The possible feature types defined for AAT shaping, from Apple [Font Feature Registry](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html).
   */
  enum aat_layout_feature_type_t {
    /**
     * Initial, unset feature type
     */
    INVALID,
    /**
     * [All Typographic Features](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type0)
     */
    ALL_TYPOGRAPHIC,
    /**
     * [Ligatures](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type1)
     */
    LIGATURES,
    /**
     * [Cursive Connection](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type2)
     */
    CURSIVE_CONNECTION,
    /**
     * [Letter Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type3)
     */
    LETTER_CASE,
    /**
     * [Vertical Substitution](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type4)
     */
    VERTICAL_SUBSTITUTION,
    /**
     * [Linguistic Rearrangement](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type5)
     */
    LINGUISTIC_REARRANGEMENT,
    /**
     * [Number Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type6)
     */
    NUMBER_SPACING,
    /**
     * [Smart Swash](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type8)
     */
    SMART_SWASH_TYPE,
    /**
     * [Diacritics](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type9)
     */
    DIACRITICS_TYPE,
    /**
     * [Vertical Position](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type10)
     */
    VERTICAL_POSITION,
    /**
     * [Fractions](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type11)
     */
    FRACTIONS,
    /**
     * [Overlapping Characters](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type13)
     */
    OVERLAPPING_CHARACTERS_TYPE,
    /**
     * [Typographic Extras](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type14)
     */
    TYPOGRAPHIC_EXTRAS,
    /**
     * [Mathematical Extras](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type15)
     */
    MATHEMATICAL_EXTRAS,
    /**
     * [Ornament Sets](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type16)
     */
    ORNAMENT_SETS_TYPE,
    /**
     * [Character Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type17)
     */
    CHARACTER_ALTERNATIVES,
    /**
     * [Design Complexity](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type18)
     */
    DESIGN_COMPLEXITY_TYPE,
    /**
     * [Style Options](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type19)
     */
    STYLE_OPTIONS,
    /**
     * [Character Shape](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type20)
     */
    CHARACTER_SHAPE,
    /**
     * [Number Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type21)
     */
    NUMBER_CASE,
    /**
     * [Text Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type22)
     */
    TEXT_SPACING,
    /**
     * [Transliteration](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type23)
     */
    TRANSLITERATION,
    /**
     * [Annotation](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type24)
     */
    ANNOTATION_TYPE,
    /**
     * [Kana Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type25)
     */
    KANA_SPACING_TYPE,
    /**
     * [Ideographic Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type26)
     */
    IDEOGRAPHIC_SPACING_TYPE,
    /**
     * [Unicode Decomposition](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type27)
     */
    UNICODE_DECOMPOSITION_TYPE,
    /**
     * [Ruby Kana](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type28)
     */
    RUBY_KANA,
    /**
     * [CJK Symbol Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type29)
     */
    CJK_SYMBOL_ALTERNATIVES_TYPE,
    /**
     * [Ideographic Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type30)
     */
    IDEOGRAPHIC_ALTERNATIVES_TYPE,
    /**
     * [CJK Vertical Roman Placement](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type31)
     */
    CJK_VERTICAL_ROMAN_PLACEMENT_TYPE,
    /**
     * [Italic CJK Roman](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type32)
     */
    ITALIC_CJK_ROMAN,
    /**
     * [Case Sensitive Layout](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type33)
     */
    CASE_SENSITIVE_LAYOUT,
    /**
     * [Alternate Kana](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type34)
     */
    ALTERNATE_KANA,
    /**
     * [Stylistic Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type35)
     */
    STYLISTIC_ALTERNATIVES,
    /**
     * [Contextual Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type36)
     */
    CONTEXTUAL_ALTERNATIVES,
    /**
     * [Lower Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type37)
     */
    LOWER_CASE,
    /**
     * [Upper Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type38)
     */
    UPPER_CASE,
    /**
     * [Language Tag](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type39)
     */
    LANGUAGE_TAG_TYPE,
    /**
     * [CJK Roman Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type103)
     */
    CJK_ROMAN_SPACING_TYPE,
  }
  /**
   * Data type for holding HarfBuzz's clustering behavior options. The cluster level
   * dictates one aspect of how HarfBuzz will treat non-base characters
   * during shaping.
   *
   * In `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES,` non-base
   * characters are merged into the cluster of the base character that precedes them.
   *
   * In `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS,` non-base characters are initially
   * assigned their own cluster values, which are not merged into preceding base
   * clusters. This allows HarfBuzz to perform additional operations like reorder
   * sequences of adjacent marks.
   *
   * `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES` is the default, because it maintains
   * backward compatibility with older versions of HarfBuzz. New client programs that
   * do not need to maintain such backward compatibility are recommended to use
   * `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS` instead of the default.
   */
  enum buffer_cluster_level_t {
    /**
     * Return cluster values grouped by graphemes into
     *   monotone order.
     */
    MONOTONE_GRAPHEMES,
    /**
     * Return cluster values grouped into monotone order.
     */
    MONOTONE_CHARACTERS,
    /**
     * Don't group cluster values.
     */
    CHARACTERS,
    /**
     * Default cluster level,
     *   equal to `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES`.
     */
    DEFAULT,
  }
  /**
   * The type of #hb_buffer_t contents.
   */
  enum buffer_content_type_t {
    /**
     * Initial value for new buffer.
     */
    INVALID,
    /**
     * The buffer contains input characters (before shaping).
     */
    UNICODE,
    /**
     * The buffer contains output glyphs (after shaping).
     */
    GLYPHS,
  }
  /**
   * The buffer serialization and de-serialization format used in
   * hb_buffer_serialize_glyphs() and hb_buffer_deserialize_glyphs().
   */
  enum buffer_serialize_format_t {
    /**
     * a human-readable, plain text format.
     */
    TEXT,
    /**
     * a machine-readable JSON format.
     */
    JSON,
    /**
     * invalid format.
     */
    INVALID,
  }
  /**
   * The direction of a text segment or buffer.
   *
   * A segment can also be tested for horizontal or vertical
   * orientation (irrespective of specific direction) with
   * HB_DIRECTION_IS_HORIZONTAL() or HB_DIRECTION_IS_VERTICAL().
   */
  enum direction_t {
    /**
     * Initial, unset direction.
     */
    INVALID,
    /**
     * Text is set horizontally from left to right.
     */
    LTR,
    /**
     * Text is set horizontally from right to left.
     */
    RTL,
    /**
     * Text is set vertically from top to bottom.
     */
    TTB,
    /**
     * Text is set vertically from bottom to top.
     */
    BTT,
  }
  /**
   * Data type holding the memory modes available to
   * client programs.
   *
   * Regarding these various memory-modes:
   *
   * - In no case shall the HarfBuzz client modify memory
   *   that is passed to HarfBuzz in a blob.  If there is
   *   any such possibility, `HB_MEMORY_MODE_DUPLICATE` should be used
   *   such that HarfBuzz makes a copy immediately,
   *
   * - Use `HB_MEMORY_MODE_READONLY` otherwise, unless you really really
   *   really know what you are doing,
   *
   * - `HB_MEMORY_MODE_WRITABLE` is appropriate if you really made a
   *   copy of data solely for the purpose of passing to
   *   HarfBuzz and doing that just once (no reuse!),
   *
   * - If the font is mmap()ed, it's okay to use
   *   `HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE,` however, using that mode
   *   correctly is very tricky.  Use `HB_MEMORY_MODE_READONLY` instead.
   */
  enum memory_mode_t {
    /**
     * HarfBuzz immediately makes a copy of the data.
     */
    DUPLICATE,
    /**
     * HarfBuzz client will never modify the data,
     *     and HarfBuzz will never modify the data.
     */
    READONLY,
    /**
     * HarfBuzz client made a copy of the data solely
     *     for HarfBuzz, so HarfBuzz may modify the data.
     */
    WRITABLE,
    /**
     * See above
     */
    READONLY_MAY_MAKE_WRITABLE,
  }
  /**
   * Baseline tags from [Baseline Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/baselinetags) registry.
   */
  enum ot_layout_baseline_tag_t {
    /**
     * The baseline used by alphabetic scripts such as Latin, Cyrillic and Greek.
     * In vertical writing mode, the alphabetic baseline for characters rotated 90 degrees clockwise.
     * (This would not apply to alphabetic characters that remain upright in vertical writing mode, since these
     * characters are not rotated.)
     */
    ROMAN,
    /**
     * The hanging baseline. In horizontal direction, this is the horizontal
     * line from which syllables seem, to hang in Tibetan and other similar scripts. In vertical writing mode,
     * for Tibetan (or some other similar script) characters rotated 90 degrees clockwise.
     */
    HANGING,
    /**
     * Ideographic character face bottom or left edge,
     * if the direction is horizontal or vertical, respectively.
     */
    IDEO_FACE_BOTTOM_OR_LEFT,
    /**
     * Ideographic character face top or right edge,
     * if the direction is horizontal or vertical, respectively.
     */
    IDEO_FACE_TOP_OR_RIGHT,
    /**
     * The center of the ideographic character face. Since: 4.0.0
     */
    IDEO_FACE_CENTRAL,
    /**
     * Ideographic em-box bottom or left edge,
     * if the direction is horizontal or vertical, respectively.
     */
    IDEO_EMBOX_BOTTOM_OR_LEFT,
    /**
     * Ideographic em-box top or right edge baseline,
     */
    IDEO_EMBOX_TOP_OR_RIGHT,
    /**
     * The center of the ideographic em-box. Since: 4.0.0
     * if the direction is horizontal or vertical, respectively.
     */
    IDEO_EMBOX_CENTRAL,
    /**
     * The baseline about which mathematical characters are centered.
     * In vertical writing mode when mathematical characters rotated 90 degrees clockwise, are centered.
     */
    MATH,
  }
  /**
   * The GDEF classes defined for glyphs.
   */
  enum ot_layout_glyph_class_t {
    /**
     * Glyphs not matching the other classifications
     */
    UNCLASSIFIED,
    /**
     * Spacing, single characters, capable of accepting marks
     */
    BASE_GLYPH,
    /**
     * Glyphs that represent ligation of multiple characters
     */
    LIGATURE,
    /**
     * Non-spacing, combining glyphs that represent marks
     */
    MARK,
    /**
     * Spacing glyphs that represent part of a single character
     */
    COMPONENT,
  }
  /**
   * The 'MATH' table constants, refer to
   * [OpenType documentation](https://docs.microsoft.com/en-us/typography/opentype/spec/math#mathconstants-table)
   * For more explanations.
   */
  enum ot_math_constant_t {
    /**
     * scriptPercentScaleDown
     */
    SCRIPT_PERCENT_SCALE_DOWN,
    /**
     * scriptScriptPercentScaleDown
     */
    SCRIPT_SCRIPT_PERCENT_SCALE_DOWN,
    /**
     * delimitedSubFormulaMinHeight
     */
    DELIMITED_SUB_FORMULA_MIN_HEIGHT,
    /**
     * displayOperatorMinHeight
     */
    DISPLAY_OPERATOR_MIN_HEIGHT,
    /**
     * mathLeading
     */
    MATH_LEADING,
    /**
     * axisHeight
     */
    AXIS_HEIGHT,
    /**
     * accentBaseHeight
     */
    ACCENT_BASE_HEIGHT,
    /**
     * flattenedAccentBaseHeight
     */
    FLATTENED_ACCENT_BASE_HEIGHT,
    /**
     * subscriptShiftDown
     */
    SUBSCRIPT_SHIFT_DOWN,
    /**
     * subscriptTopMax
     */
    SUBSCRIPT_TOP_MAX,
    /**
     * subscriptBaselineDropMin
     */
    SUBSCRIPT_BASELINE_DROP_MIN,
    /**
     * superscriptShiftUp
     */
    SUPERSCRIPT_SHIFT_UP,
    /**
     * superscriptShiftUpCramped
     */
    SUPERSCRIPT_SHIFT_UP_CRAMPED,
    /**
     * superscriptBottomMin
     */
    SUPERSCRIPT_BOTTOM_MIN,
    /**
     * superscriptBaselineDropMax
     */
    SUPERSCRIPT_BASELINE_DROP_MAX,
    /**
     * subSuperscriptGapMin
     */
    SUB_SUPERSCRIPT_GAP_MIN,
    /**
     * superscriptBottomMaxWithSubscript
     */
    SUPERSCRIPT_BOTTOM_MAX_WITH_SUBSCRIPT,
    /**
     * spaceAfterScript
     */
    SPACE_AFTER_SCRIPT,
    /**
     * upperLimitGapMin
     */
    UPPER_LIMIT_GAP_MIN,
    /**
     * upperLimitBaselineRiseMin
     */
    UPPER_LIMIT_BASELINE_RISE_MIN,
    /**
     * lowerLimitGapMin
     */
    LOWER_LIMIT_GAP_MIN,
    /**
     * lowerLimitBaselineDropMin
     */
    LOWER_LIMIT_BASELINE_DROP_MIN,
    /**
     * stackTopShiftUp
     */
    STACK_TOP_SHIFT_UP,
    /**
     * stackTopDisplayStyleShiftUp
     */
    STACK_TOP_DISPLAY_STYLE_SHIFT_UP,
    /**
     * stackBottomShiftDown
     */
    STACK_BOTTOM_SHIFT_DOWN,
    /**
     * stackBottomDisplayStyleShiftDown
     */
    STACK_BOTTOM_DISPLAY_STYLE_SHIFT_DOWN,
    /**
     * stackGapMin
     */
    STACK_GAP_MIN,
    /**
     * stackDisplayStyleGapMin
     */
    STACK_DISPLAY_STYLE_GAP_MIN,
    /**
     * stretchStackTopShiftUp
     */
    STRETCH_STACK_TOP_SHIFT_UP,
    /**
     * stretchStackBottomShiftDown
     */
    STRETCH_STACK_BOTTOM_SHIFT_DOWN,
    /**
     * stretchStackGapAboveMin
     */
    STRETCH_STACK_GAP_ABOVE_MIN,
    /**
     * stretchStackGapBelowMin
     */
    STRETCH_STACK_GAP_BELOW_MIN,
    /**
     * fractionNumeratorShiftUp
     */
    FRACTION_NUMERATOR_SHIFT_UP,
    /**
     * fractionNumeratorDisplayStyleShiftUp
     */
    FRACTION_NUMERATOR_DISPLAY_STYLE_SHIFT_UP,
    /**
     * fractionDenominatorShiftDown
     */
    FRACTION_DENOMINATOR_SHIFT_DOWN,
    /**
     * fractionDenominatorDisplayStyleShiftDown
     */
    FRACTION_DENOMINATOR_DISPLAY_STYLE_SHIFT_DOWN,
    /**
     * fractionNumeratorGapMin
     */
    FRACTION_NUMERATOR_GAP_MIN,
    /**
     * fractionNumDisplayStyleGapMin
     */
    FRACTION_NUM_DISPLAY_STYLE_GAP_MIN,
    /**
     * fractionRuleThickness
     */
    FRACTION_RULE_THICKNESS,
    /**
     * fractionDenominatorGapMin
     */
    FRACTION_DENOMINATOR_GAP_MIN,
    /**
     * fractionDenomDisplayStyleGapMin
     */
    FRACTION_DENOM_DISPLAY_STYLE_GAP_MIN,
    /**
     * skewedFractionHorizontalGap
     */
    SKEWED_FRACTION_HORIZONTAL_GAP,
    /**
     * skewedFractionVerticalGap
     */
    SKEWED_FRACTION_VERTICAL_GAP,
    /**
     * overbarVerticalGap
     */
    OVERBAR_VERTICAL_GAP,
    /**
     * overbarRuleThickness
     */
    OVERBAR_RULE_THICKNESS,
    /**
     * overbarExtraAscender
     */
    OVERBAR_EXTRA_ASCENDER,
    /**
     * underbarVerticalGap
     */
    UNDERBAR_VERTICAL_GAP,
    /**
     * underbarRuleThickness
     */
    UNDERBAR_RULE_THICKNESS,
    /**
     * underbarExtraDescender
     */
    UNDERBAR_EXTRA_DESCENDER,
    /**
     * radicalVerticalGap
     */
    RADICAL_VERTICAL_GAP,
    /**
     * radicalDisplayStyleVerticalGap
     */
    RADICAL_DISPLAY_STYLE_VERTICAL_GAP,
    /**
     * radicalRuleThickness
     */
    RADICAL_RULE_THICKNESS,
    /**
     * radicalExtraAscender
     */
    RADICAL_EXTRA_ASCENDER,
    /**
     * radicalKernBeforeDegree
     */
    RADICAL_KERN_BEFORE_DEGREE,
    /**
     * radicalKernAfterDegree
     */
    RADICAL_KERN_AFTER_DEGREE,
    /**
     * radicalDegreeBottomRaisePercent
     */
    RADICAL_DEGREE_BOTTOM_RAISE_PERCENT,
  }
  /**
   * The math kerning-table types defined for the four corners
   * of a glyph.
   */
  enum ot_math_kern_t {
    /**
     * The top right corner of the glyph.
     */
    TOP_RIGHT,
    /**
     * The top left corner of the glyph.
     */
    TOP_LEFT,
    /**
     * The bottom right corner of the glyph.
     */
    BOTTOM_RIGHT,
    /**
     * The bottom left corner of the glyph.
     */
    BOTTOM_LEFT,
  }
  /**
   * Known metadata tags from https://docs.microsoft.com/en-us/typography/opentype/spec/meta
   */
  enum ot_meta_tag_t {
    /**
     * Design languages. Text, using only
     * Basic Latin (ASCII) characters. Indicates languages and/or scripts
     * for the user audiences that the font was primarily designed for.
     */
    DESIGN_LANGUAGES,
    /**
     * Supported languages. Text, using
     * only Basic Latin (ASCII) characters. Indicates languages and/or scripts
     * that the font is declared to be capable of supporting.
     */
    SUPPORTED_LANGUAGES,
  }
  /**
   * Metric tags corresponding to [MVAR Value
   * Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/mvar#value-tags)
   */
  enum ot_metrics_tag_t {
    /**
     * horizontal ascender.
     */
    HORIZONTAL_ASCENDER,
    /**
     * horizontal descender.
     */
    HORIZONTAL_DESCENDER,
    /**
     * horizontal line gap.
     */
    HORIZONTAL_LINE_GAP,
    /**
     * horizontal clipping ascent.
     */
    HORIZONTAL_CLIPPING_ASCENT,
    /**
     * horizontal clipping descent.
     */
    HORIZONTAL_CLIPPING_DESCENT,
    /**
     * vertical ascender.
     */
    VERTICAL_ASCENDER,
    /**
     * vertical descender.
     */
    VERTICAL_DESCENDER,
    /**
     * vertical line gap.
     */
    VERTICAL_LINE_GAP,
    /**
     * horizontal caret rise.
     */
    HORIZONTAL_CARET_RISE,
    /**
     * horizontal caret run.
     */
    HORIZONTAL_CARET_RUN,
    /**
     * horizontal caret offset.
     */
    HORIZONTAL_CARET_OFFSET,
    /**
     * vertical caret rise.
     */
    VERTICAL_CARET_RISE,
    /**
     * vertical caret run.
     */
    VERTICAL_CARET_RUN,
    /**
     * vertical caret offset.
     */
    VERTICAL_CARET_OFFSET,
    /**
     * x height.
     */
    X_HEIGHT,
    /**
     * cap height.
     */
    CAP_HEIGHT,
    /**
     * subscript em x size.
     */
    SUBSCRIPT_EM_X_SIZE,
    /**
     * subscript em y size.
     */
    SUBSCRIPT_EM_Y_SIZE,
    /**
     * subscript em x offset.
     */
    SUBSCRIPT_EM_X_OFFSET,
    /**
     * subscript em y offset.
     */
    SUBSCRIPT_EM_Y_OFFSET,
    /**
     * superscript em x size.
     */
    SUPERSCRIPT_EM_X_SIZE,
    /**
     * superscript em y size.
     */
    SUPERSCRIPT_EM_Y_SIZE,
    /**
     * superscript em x offset.
     */
    SUPERSCRIPT_EM_X_OFFSET,
    /**
     * superscript em y offset.
     */
    SUPERSCRIPT_EM_Y_OFFSET,
    /**
     * strikeout size.
     */
    STRIKEOUT_SIZE,
    /**
     * strikeout offset.
     */
    STRIKEOUT_OFFSET,
    /**
     * underline size.
     */
    UNDERLINE_SIZE,
    /**
     * underline offset.
     */
    UNDERLINE_OFFSET,
  }
  /**
   * An enum type representing the pre-defined name IDs.
   *
   * For more information on these fields, see the
   * [OpenType spec](https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids).
   */
  enum ot_name_id_predefined_t {
    /**
     * Copyright notice
     */
    COPYRIGHT,
    /**
     * Font Family name
     */
    FONT_FAMILY,
    /**
     * Font Subfamily name
     */
    FONT_SUBFAMILY,
    /**
     * Unique font identifier
     */
    UNIQUE_ID,
    /**
     * Full font name that reflects
     * all family and relevant subfamily descriptors
     */
    FULL_NAME,
    /**
     * Version string
     */
    VERSION_STRING,
    /**
     * PostScript name for the font
     */
    POSTSCRIPT_NAME,
    /**
     * Trademark
     */
    TRADEMARK,
    /**
     * Manufacturer Name
     */
    MANUFACTURER,
    /**
     * Designer
     */
    DESIGNER,
    /**
     * Description
     */
    DESCRIPTION,
    /**
     * URL of font vendor
     */
    VENDOR_URL,
    /**
     * URL of typeface designer
     */
    DESIGNER_URL,
    /**
     * License Description
     */
    LICENSE,
    /**
     * URL where additional licensing
     * information can be found
     */
    LICENSE_URL,
    /**
     * Typographic Family name
     */
    TYPOGRAPHIC_FAMILY,
    /**
     * Typographic Subfamily name
     */
    TYPOGRAPHIC_SUBFAMILY,
    /**
     * Compatible Full Name for MacOS
     */
    MAC_FULL_NAME,
    /**
     * Sample text
     */
    SAMPLE_TEXT,
    /**
     * PostScript CID findfont name
     */
    CID_FINDFONT_NAME,
    /**
     * WWS Family Name
     */
    WWS_FAMILY,
    /**
     * WWS Subfamily Name
     */
    WWS_SUBFAMILY,
    /**
     * Light Background Palette
     */
    LIGHT_BACKGROUND,
    /**
     * Dark Background Palette
     */
    DARK_BACKGROUND,
    /**
     * Variations PostScript Name Prefix
     */
    VARIATIONS_PS_PREFIX,
    /**
     * Value to represent a nonexistent name ID.
     */
    INVALID,
  }
  /**
   * The values of this enumeration describe the compositing modes
   * that can be used when combining temporary redirected drawing
   * with the backdrop.
   *
   * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
   * section for details.
   */
  enum paint_composite_mode_t {
    /**
     * clear destination layer (bounded)
     */
    CLEAR,
    /**
     * replace destination layer (bounded)
     */
    SRC,
    /**
     * ignore the source
     */
    DEST,
    /**
     * draw source layer on top of destination layer
     * (bounded)
     */
    SRC_OVER,
    /**
     * draw destination on top of source
     */
    DEST_OVER,
    /**
     * draw source where there was destination content
     * (unbounded)
     */
    SRC_IN,
    /**
     * leave destination only where there was
     * source content (unbounded)
     */
    DEST_IN,
    /**
     * draw source where there was no destination
     * content (unbounded)
     */
    SRC_OUT,
    /**
     * leave destination only where there was no
     * source content
     */
    DEST_OUT,
    /**
     * draw source on top of destination content and
     * only there
     */
    SRC_ATOP,
    /**
     * leave destination on top of source content
     * and only there (unbounded)
     */
    DEST_ATOP,
    /**
     * source and destination are shown where there is only
     * one of them
     */
    XOR,
    /**
     * source and destination layers are accumulated
     */
    PLUS,
    /**
     * source and destination are complemented and
     * multiplied. This causes the result to be at least as light as the lighter
     * inputs.
     */
    SCREEN,
    /**
     * multiplies or screens, depending on the
     * lightness of the destination color.
     */
    OVERLAY,
    /**
     * replaces the destination with the source if it
     * is darker, otherwise keeps the source.
     */
    DARKEN,
    /**
     * replaces the destination with the source if it
     * is lighter, otherwise keeps the source.
     */
    LIGHTEN,
    /**
     * brightens the destination color to reflect
     * the source color.
     */
    COLOR_DODGE,
    /**
     * darkens the destination color to reflect
     * the source color.
     */
    COLOR_BURN,
    /**
     * Multiplies or screens, dependent on source
     * color.
     */
    HARD_LIGHT,
    /**
     * Darkens or lightens, dependent on source
     * color.
     */
    SOFT_LIGHT,
    /**
     * Takes the difference of the source and
     * destination color.
     */
    DIFFERENCE,
    /**
     * Produces an effect similar to difference, but
     * with lower contrast.
     */
    EXCLUSION,
    /**
     * source and destination layers are multiplied.
     * This causes the result to be at least as dark as the darker inputs.
     */
    MULTIPLY,
    /**
     * Creates a color with the hue of the source
     * and the saturation and luminosity of the target.
     */
    HSL_HUE,
    /**
     * Creates a color with the saturation
     * of the source and the hue and luminosity of the target. Painting with
     * this mode onto a gray area produces no change.
     */
    HSL_SATURATION,
    /**
     * Creates a color with the hue and saturation
     * of the source and the luminosity of the target. This preserves the gray
     * levels of the target and is useful for coloring monochrome images or
     * tinting color images.
     */
    HSL_COLOR,
    /**
     * Creates a color with the luminosity of
     * the source and the hue and saturation of the target. This produces an
     * inverse effect to `HB_PAINT_COMPOSITE_MODE_HSL_COLOR`.
     */
    HSL_LUMINOSITY,
  }
  /**
   * The values of this enumeration determine how color values
   * outside the minimum and maximum defined offset on a #hb_color_line_t
   * are determined.
   *
   * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
   * section for details.
   */
  enum paint_extend_t {
    /**
     * Outside the defined interval,
     *   the color of the closest color stop is used.
     */
    PAD,
    /**
     * The color line is repeated over
     *   repeated multiples of the defined interval
     */
    REPEAT,
    /**
     * The color line is repeated over
     *      repeated intervals, as for the repeat mode.
     *      However, in each repeated interval, the ordering of
     *      color stops is the reverse of the adjacent interval.
     */
    REFLECT,
  }
  /**
   * Data type for scripts. Each #hb_script_t's value is an #hb_tag_t corresponding
   * to the four-letter values defined by [ISO 15924](https://unicode.org/iso15924/).
   *
   * See also the Script (sc) property of the Unicode Character Database.
   */
  enum script_t {
    /**
     * `Zyyy`
     */
    COMMON,
    /**
     * `Zinh`
     */
    INHERITED,
    /**
     * `Zzzz`
     */
    UNKNOWN,
    /**
     * `Arab`
     */
    ARABIC,
    /**
     * `Armn`
     */
    ARMENIAN,
    /**
     * `Beng`
     */
    BENGALI,
    /**
     * `Cyrl`
     */
    CYRILLIC,
    /**
     * `Deva`
     */
    DEVANAGARI,
    /**
     * `Geor`
     */
    GEORGIAN,
    /**
     * `Grek`
     */
    GREEK,
    /**
     * `Gujr`
     */
    GUJARATI,
    /**
     * `Guru`
     */
    GURMUKHI,
    /**
     * `Hang`
     */
    HANGUL,
    /**
     * `Hani`
     */
    HAN,
    /**
     * `Hebr`
     */
    HEBREW,
    /**
     * `Hira`
     */
    HIRAGANA,
    /**
     * `Knda`
     */
    KANNADA,
    /**
     * `Kana`
     */
    KATAKANA,
    /**
     * `Laoo`
     */
    LAO,
    /**
     * `Latn`
     */
    LATIN,
    /**
     * `Mlym`
     */
    MALAYALAM,
    /**
     * `Orya`
     */
    ORIYA,
    /**
     * `Taml`
     */
    TAMIL,
    /**
     * `Telu`
     */
    TELUGU,
    /**
     * `Thai`
     */
    THAI,
    /**
     * `Tibt`
     */
    TIBETAN,
    /**
     * `Bopo`
     */
    BOPOMOFO,
    /**
     * `Brai`
     */
    BRAILLE,
    /**
     * `Cans`
     */
    CANADIAN_SYLLABICS,
    /**
     * `Cher`
     */
    CHEROKEE,
    /**
     * `Ethi`
     */
    ETHIOPIC,
    /**
     * `Khmr`
     */
    KHMER,
    /**
     * `Mong`
     */
    MONGOLIAN,
    /**
     * `Mymr`
     */
    MYANMAR,
    /**
     * `Ogam`
     */
    OGHAM,
    /**
     * `Runr`
     */
    RUNIC,
    /**
     * `Sinh`
     */
    SINHALA,
    /**
     * `Syrc`
     */
    SYRIAC,
    /**
     * `Thaa`
     */
    THAANA,
    /**
     * `Yiii`
     */
    YI,
    /**
     * `Dsrt`
     */
    DESERET,
    /**
     * `Goth`
     */
    GOTHIC,
    /**
     * `Ital`
     */
    OLD_ITALIC,
    /**
     * `Buhd`
     */
    BUHID,
    /**
     * `Hano`
     */
    HANUNOO,
    /**
     * `Tglg`
     */
    TAGALOG,
    /**
     * `Tagb`
     */
    TAGBANWA,
    /**
     * `Cprt`
     */
    CYPRIOT,
    /**
     * `Limb`
     */
    LIMBU,
    /**
     * `Linb`
     */
    LINEAR_B,
    /**
     * `Osma`
     */
    OSMANYA,
    /**
     * `Shaw`
     */
    SHAVIAN,
    /**
     * `Tale`
     */
    TAI_LE,
    /**
     * `Ugar`
     */
    UGARITIC,
    /**
     * `Bugi`
     */
    BUGINESE,
    /**
     * `Copt`
     */
    COPTIC,
    /**
     * `Glag`
     */
    GLAGOLITIC,
    /**
     * `Khar`
     */
    KHAROSHTHI,
    /**
     * `Talu`
     */
    NEW_TAI_LUE,
    /**
     * `Xpeo`
     */
    OLD_PERSIAN,
    /**
     * `Sylo`
     */
    SYLOTI_NAGRI,
    /**
     * `Tfng`
     */
    TIFINAGH,
    /**
     * `Bali`
     */
    BALINESE,
    /**
     * `Xsux`
     */
    CUNEIFORM,
    /**
     * `Nkoo`
     */
    NKO,
    /**
     * `Phag`
     */
    PHAGS_PA,
    /**
     * `Phnx`
     */
    PHOENICIAN,
    /**
     * `Cari`
     */
    CARIAN,
    /**
     * `Cham`
     */
    CHAM,
    /**
     * `Kali`
     */
    KAYAH_LI,
    /**
     * `Lepc`
     */
    LEPCHA,
    /**
     * `Lyci`
     */
    LYCIAN,
    /**
     * `Lydi`
     */
    LYDIAN,
    /**
     * `Olck`
     */
    OL_CHIKI,
    /**
     * `Rjng`
     */
    REJANG,
    /**
     * `Saur`
     */
    SAURASHTRA,
    /**
     * `Sund`
     */
    SUNDANESE,
    /**
     * `Vaii`
     */
    VAI,
    /**
     * `Avst`
     */
    AVESTAN,
    /**
     * `Bamu`
     */
    BAMUM,
    /**
     * `Egyp`
     */
    EGYPTIAN_HIEROGLYPHS,
    /**
     * `Armi`
     */
    IMPERIAL_ARAMAIC,
    /**
     * `Phli`
     */
    INSCRIPTIONAL_PAHLAVI,
    /**
     * `Prti`
     */
    INSCRIPTIONAL_PARTHIAN,
    /**
     * `Java`
     */
    JAVANESE,
    /**
     * `Kthi`
     */
    KAITHI,
    /**
     * `Lisu`
     */
    LISU,
    /**
     * `Mtei`
     */
    MEETEI_MAYEK,
    /**
     * `Sarb`
     */
    OLD_SOUTH_ARABIAN,
    /**
     * `Orkh`
     */
    OLD_TURKIC,
    /**
     * `Samr`
     */
    SAMARITAN,
    /**
     * `Lana`
     */
    TAI_THAM,
    /**
     * `Tavt`
     */
    TAI_VIET,
    /**
     * `Batk`
     */
    BATAK,
    /**
     * `Brah`
     */
    BRAHMI,
    /**
     * `Mand`
     */
    MANDAIC,
    /**
     * `Cakm`
     */
    CHAKMA,
    /**
     * `Merc`
     */
    MEROITIC_CURSIVE,
    /**
     * `Mero`
     */
    MEROITIC_HIEROGLYPHS,
    /**
     * `Plrd`
     */
    MIAO,
    /**
     * `Shrd`
     */
    SHARADA,
    /**
     * `Sora`
     */
    SORA_SOMPENG,
    /**
     * `Takr`
     */
    TAKRI,
    /**
     * `Bass`, Since: 0.9.30
     */
    BASSA_VAH,
    /**
     * `Aghb`, Since: 0.9.30
     */
    CAUCASIAN_ALBANIAN,
    /**
     * `Dupl`, Since: 0.9.30
     */
    DUPLOYAN,
    /**
     * `Elba`, Since: 0.9.30
     */
    ELBASAN,
    /**
     * `Gran`, Since: 0.9.30
     */
    GRANTHA,
    /**
     * `Khoj`, Since: 0.9.30
     */
    KHOJKI,
    /**
     * `Sind`, Since: 0.9.30
     */
    KHUDAWADI,
    /**
     * `Lina`, Since: 0.9.30
     */
    LINEAR_A,
    /**
     * `Mahj`, Since: 0.9.30
     */
    MAHAJANI,
    /**
     * `Mani`, Since: 0.9.30
     */
    MANICHAEAN,
    /**
     * `Mend`, Since: 0.9.30
     */
    MENDE_KIKAKUI,
    /**
     * `Modi`, Since: 0.9.30
     */
    MODI,
    /**
     * `Mroo`, Since: 0.9.30
     */
    MRO,
    /**
     * `Nbat`, Since: 0.9.30
     */
    NABATAEAN,
    /**
     * `Narb`, Since: 0.9.30
     */
    OLD_NORTH_ARABIAN,
    /**
     * `Perm`, Since: 0.9.30
     */
    OLD_PERMIC,
    /**
     * `Hmng`, Since: 0.9.30
     */
    PAHAWH_HMONG,
    /**
     * `Palm`, Since: 0.9.30
     */
    PALMYRENE,
    /**
     * `Pauc`, Since: 0.9.30
     */
    PAU_CIN_HAU,
    /**
     * `Phlp`, Since: 0.9.30
     */
    PSALTER_PAHLAVI,
    /**
     * `Sidd`, Since: 0.9.30
     */
    SIDDHAM,
    /**
     * `Tirh`, Since: 0.9.30
     */
    TIRHUTA,
    /**
     * `Wara`, Since: 0.9.30
     */
    WARANG_CITI,
    /**
     * `Ahom`, Since: 0.9.30
     */
    AHOM,
    /**
     * `Hluw`, Since: 0.9.30
     */
    ANATOLIAN_HIEROGLYPHS,
    /**
     * `Hatr`, Since: 0.9.30
     */
    HATRAN,
    /**
     * `Mult`, Since: 0.9.30
     */
    MULTANI,
    /**
     * `Hung`, Since: 0.9.30
     */
    OLD_HUNGARIAN,
    /**
     * `Sgnw`, Since: 0.9.30
     */
    SIGNWRITING,
    /**
     * `Adlm`, Since: 1.3.0
     */
    ADLAM,
    /**
     * `Bhks`, Since: 1.3.0
     */
    BHAIKSUKI,
    /**
     * `Marc`, Since: 1.3.0
     */
    MARCHEN,
    /**
     * `Osge`, Since: 1.3.0
     */
    OSAGE,
    /**
     * `Tang`, Since: 1.3.0
     */
    TANGUT,
    /**
     * `Newa`, Since: 1.3.0
     */
    NEWA,
    /**
     * `Gonm`, Since: 1.6.0
     */
    MASARAM_GONDI,
    /**
     * `Nshu`, Since: 1.6.0
     */
    NUSHU,
    /**
     * `Soyo`, Since: 1.6.0
     */
    SOYOMBO,
    /**
     * `Zanb`, Since: 1.6.0
     */
    ZANABAZAR_SQUARE,
    /**
     * `Dogr`, Since: 1.8.0
     */
    DOGRA,
    /**
     * `Gong`, Since: 1.8.0
     */
    GUNJALA_GONDI,
    /**
     * `Rohg`, Since: 1.8.0
     */
    HANIFI_ROHINGYA,
    /**
     * `Maka`, Since: 1.8.0
     */
    MAKASAR,
    /**
     * `Medf`, Since: 1.8.0
     */
    MEDEFAIDRIN,
    /**
     * `Sogo`, Since: 1.8.0
     */
    OLD_SOGDIAN,
    /**
     * `Sogd`, Since: 1.8.0
     */
    SOGDIAN,
    /**
     * `Elym`, Since: 2.4.0
     */
    ELYMAIC,
    /**
     * `Nand`, Since: 2.4.0
     */
    NANDINAGARI,
    /**
     * `Hmnp`, Since: 2.4.0
     */
    NYIAKENG_PUACHUE_HMONG,
    /**
     * `Wcho`, Since: 2.4.0
     */
    WANCHO,
    /**
     * `Chrs`, Since: 2.6.7
     */
    CHORASMIAN,
    /**
     * `Diak`, Since: 2.6.7
     */
    DIVES_AKURU,
    /**
     * `Kits`, Since: 2.6.7
     */
    KHITAN_SMALL_SCRIPT,
    /**
     * `Yezi`, Since: 2.6.7
     */
    YEZIDI,
    /**
     * `Cpmn`, Since: 3.0.0
     */
    CYPRO_MINOAN,
    /**
     * `Ougr`, Since: 3.0.0
     */
    OLD_UYGHUR,
    /**
     * `Tnsa`, Since: 3.0.0
     */
    TANGSA,
    /**
     * `Toto`, Since: 3.0.0
     */
    TOTO,
    /**
     * `Vith`, Since: 3.0.0
     */
    VITHKUQI,
    /**
     * `Zmth`, Since: 3.4.0
     */
    MATH,
    /**
     * `Kawi`, Since: 5.2.0
     */
    KAWI,
    /**
     * `Nagm`, Since: 5.2.0
     */
    NAG_MUNDARI,
    /**
     * No script set
     */
    INVALID,
  }
  /**
   * Defined by [OpenType Design-Variation Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg).
   */
  enum style_tag_t {
    /**
     * Used to vary between non-italic and italic.
     * A value of 0 can be interpreted as "Roman" (non-italic); a value of 1 can
     * be interpreted as (fully) italic.
     */
    ITALIC,
    /**
     * Used to vary design to suit different text sizes.
     * Non-zero. Values can be interpreted as text size, in points.
     */
    OPTICAL_SIZE,
    /**
     * Used to vary between upright and slanted text. Values
     * must be greater than -90 and less than +90. Values can be interpreted as
     * the angle, in counter-clockwise degrees, of oblique slant from whatever the
     * designer considers to be upright for that font design. Typical right-leaning
     * Italic fonts have a negative slant angle (typically around -12)
     */
    SLANT_ANGLE,
    /**
     * same as `HB_STYLE_TAG_SLANT_ANGLE` expression as ratio.
     * Typical right-leaning Italic fonts have a positive slant ratio (typically around 0.2)
     */
    SLANT_RATIO,
    /**
     * Used to vary width of text from narrower to wider.
     * Non-zero. Values can be interpreted as a percentage of whatever the font
     * designer considers “normal width” for that font design.
     */
    WIDTH,
    /**
     * Used to vary stroke thicknesses or other design details
     * to give variation from lighter to blacker. Values can be interpreted in direct
     * comparison to values for usWeightClass in the OS/2 table,
     * or the CSS font-weight property.
     */
    WEIGHT,
  }
  /**
   * Data type for the Canonical_Combining_Class (ccc) property
   * from the Unicode Character Database.
   *
   * <note>Note: newer versions of Unicode may add new values.
   * Client programs should be ready to handle any value in the 0..254 range
   * being returned from hb_unicode_combining_class().</note>
   */
  enum unicode_combining_class_t {
    /**
     * Spacing and enclosing marks; also many vowel and consonant signs, even if nonspacing
     */
    NOT_REORDERED,
    /**
     * Marks which overlay a base letter or symbol
     */
    OVERLAY,
    /**
     * Diacritic nukta marks in Brahmi-derived scripts
     */
    NUKTA,
    /**
     * Hiragana/Katakana voicing marks
     */
    KANA_VOICING,
    /**
     * Viramas
     */
    VIRAMA,
    /**
     * [Hebrew]
     */
    CCC10,
    /**
     * [Hebrew]
     */
    CCC11,
    /**
     * [Hebrew]
     */
    CCC12,
    /**
     * [Hebrew]
     */
    CCC13,
    /**
     * [Hebrew]
     */
    CCC14,
    /**
     * [Hebrew]
     */
    CCC15,
    /**
     * [Hebrew]
     */
    CCC16,
    /**
     * [Hebrew]
     */
    CCC17,
    /**
     * [Hebrew]
     */
    CCC18,
    /**
     * [Hebrew]
     */
    CCC19,
    /**
     * [Hebrew]
     */
    CCC20,
    /**
     * [Hebrew]
     */
    CCC21,
    /**
     * [Hebrew]
     */
    CCC22,
    /**
     * [Hebrew]
     */
    CCC23,
    /**
     * [Hebrew]
     */
    CCC24,
    /**
     * [Hebrew]
     */
    CCC25,
    /**
     * [Hebrew]
     */
    CCC26,
    /**
     * [Arabic]
     */
    CCC27,
    /**
     * [Arabic]
     */
    CCC28,
    /**
     * [Arabic]
     */
    CCC29,
    /**
     * [Arabic]
     */
    CCC30,
    /**
     * [Arabic]
     */
    CCC31,
    /**
     * [Arabic]
     */
    CCC32,
    /**
     * [Arabic]
     */
    CCC33,
    /**
     * [Arabic]
     */
    CCC34,
    /**
     * [Arabic]
     */
    CCC35,
    /**
     * [Syriac]
     */
    CCC36,
    /**
     * [Telugu]
     */
    CCC84,
    /**
     * [Telugu]
     */
    CCC91,
    /**
     * [Thai]
     */
    CCC103,
    /**
     * [Thai]
     */
    CCC107,
    /**
     * [Lao]
     */
    CCC118,
    /**
     * [Lao]
     */
    CCC122,
    /**
     * [Tibetan]
     */
    CCC129,
    /**
     * [Tibetan]
     */
    CCC130,
    /**
     * [Tibetan] Since: 7.2.0
     */
    CCC132,
    /**
     * Marks attached at the bottom left
     */
    ATTACHED_BELOW_LEFT,
    /**
     * Marks attached directly below
     */
    ATTACHED_BELOW,
    /**
     * Marks attached directly above
     */
    ATTACHED_ABOVE,
    /**
     * Marks attached at the top right
     */
    ATTACHED_ABOVE_RIGHT,
    /**
     * Distinct marks at the bottom left
     */
    BELOW_LEFT,
    /**
     * Distinct marks directly below
     */
    BELOW,
    /**
     * Distinct marks at the bottom right
     */
    BELOW_RIGHT,
    /**
     * Distinct marks to the left
     */
    LEFT,
    /**
     * Distinct marks to the right
     */
    RIGHT,
    /**
     * Distinct marks at the top left
     */
    ABOVE_LEFT,
    /**
     * Distinct marks directly above
     */
    ABOVE,
    /**
     * Distinct marks at the top right
     */
    ABOVE_RIGHT,
    /**
     * Distinct marks subtending two bases
     */
    DOUBLE_BELOW,
    /**
     * Distinct marks extending above two bases
     */
    DOUBLE_ABOVE,
    /**
     * Greek iota subscript only
     */
    IOTA_SUBSCRIPT,
    /**
     * Invalid combining class
     */
    INVALID,
  }
  /**
   * Data type for the "General_Category" (gc) property from
   * the Unicode Character Database.
   */
  enum unicode_general_category_t {
    /**
     * [Cc]
     */
    CONTROL,
    /**
     * [Cf]
     */
    FORMAT,
    /**
     * [Cn]
     */
    UNASSIGNED,
    /**
     * [Co]
     */
    PRIVATE_USE,
    /**
     * [Cs]
     */
    SURROGATE,
    /**
     * [Ll]
     */
    LOWERCASE_LETTER,
    /**
     * [Lm]
     */
    MODIFIER_LETTER,
    /**
     * [Lo]
     */
    OTHER_LETTER,
    /**
     * [Lt]
     */
    TITLECASE_LETTER,
    /**
     * [Lu]
     */
    UPPERCASE_LETTER,
    /**
     * [Mc]
     */
    SPACING_MARK,
    /**
     * [Me]
     */
    ENCLOSING_MARK,
    /**
     * [Mn]
     */
    NON_SPACING_MARK,
    /**
     * [Nd]
     */
    DECIMAL_NUMBER,
    /**
     * [Nl]
     */
    LETTER_NUMBER,
    /**
     * [No]
     */
    OTHER_NUMBER,
    /**
     * [Pc]
     */
    CONNECT_PUNCTUATION,
    /**
     * [Pd]
     */
    DASH_PUNCTUATION,
    /**
     * [Pe]
     */
    CLOSE_PUNCTUATION,
    /**
     * [Pf]
     */
    FINAL_PUNCTUATION,
    /**
     * [Pi]
     */
    INITIAL_PUNCTUATION,
    /**
     * [Po]
     */
    OTHER_PUNCTUATION,
    /**
     * [Ps]
     */
    OPEN_PUNCTUATION,
    /**
     * [Sc]
     */
    CURRENCY_SYMBOL,
    /**
     * [Sk]
     */
    MODIFIER_SYMBOL,
    /**
     * [Sm]
     */
    MATH_SYMBOL,
    /**
     * [So]
     */
    OTHER_SYMBOL,
    /**
     * [Zl]
     */
    LINE_SEPARATOR,
    /**
     * [Zp]
     */
    PARAGRAPH_SEPARATOR,
    /**
     * [Zs]
     */
    SPACE_SEPARATOR,
  }
  /**
   * Flags from comparing two #hb_buffer_t's.
   *
   * Buffer with different #hb_buffer_content_type_t cannot be meaningfully
   * compared in any further detail.
   *
   * For buffers with differing length, the per-glyph comparison is not
   * attempted, though we do still scan reference buffer for dotted circle and
   * `.notdef` glyphs.
   *
   * If the buffers have the same length, we compare them glyph-by-glyph and
   * report which aspect(s) of the glyph info/position are different.
   * @bitfield
   */
  enum buffer_diff_flags_t {
    /**
     * equal buffers.
     */
    EQUAL,
    /**
     * buffers with different
     *     #hb_buffer_content_type_t.
     */
    CONTENT_TYPE_MISMATCH,
    /**
     * buffers with differing length.
     */
    LENGTH_MISMATCH,
    /**
     * `.notdef` glyph is present in the
     *     reference buffer.
     */
    NOTDEF_PRESENT,
    /**
     * dotted circle glyph is present
     *     in the reference buffer.
     */
    DOTTED_CIRCLE_PRESENT,
    /**
     * difference in #hb_glyph_info_t.codepoint
     */
    CODEPOINT_MISMATCH,
    /**
     * difference in #hb_glyph_info_t.cluster
     */
    CLUSTER_MISMATCH,
    /**
     * difference in #hb_glyph_flags_t.
     */
    GLYPH_FLAGS_MISMATCH,
    /**
     * difference in #hb_glyph_position_t.
     */
    POSITION_MISMATCH,
  }
  /**
   * Flags for #hb_buffer_t.
   * @bitfield
   */
  enum buffer_flags_t {
    /**
     * the default buffer flag.
     */
    DEFAULT,
    /**
     * flag indicating that special handling of the beginning
     *                      of text paragraph can be applied to this buffer. Should usually
     *                      be set, unless you are passing to the buffer only part
     *                      of the text without the full context.
     */
    BOT,
    /**
     * flag indicating that special handling of the end of text
     *                      paragraph can be applied to this buffer, similar to
     *                      `HB_BUFFER_FLAG_BOT`.
     */
    EOT,
    /**
     * flag indication that character with Default_Ignorable
     *                      Unicode property should use the corresponding glyph
     *                      from the font, instead of hiding them (done by
     *                      replacing them with the space glyph and zeroing the
     *                      advance width.)  This flag takes precedence over
     *                      `HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES`.
     */
    PRESERVE_DEFAULT_IGNORABLES,
    /**
     * flag indication that character with Default_Ignorable
     *                      Unicode property should be removed from glyph string
     *                      instead of hiding them (done by replacing them with the
     *                      space glyph and zeroing the advance width.)
     *                      `HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES` takes
     *                      precedence over this flag. Since: 1.8.0
     */
    REMOVE_DEFAULT_IGNORABLES,
    /**
     * flag indicating that a dotted circle should
     *                      not be inserted in the rendering of incorrect
     *                      character sequences (such at <0905 093E>). Since: 2.4.0
     */
    DO_NOT_INSERT_DOTTED_CIRCLE,
    /**
     * flag indicating that the hb_shape() call and its variants
     *                      should perform various verification processes on the results
     *                      of the shaping operation on the buffer.  If the verification
     *                      fails, then either a buffer message is sent, if a message
     *                      handler is installed on the buffer, or a message is written
     *                      to standard error.  In either case, the shaping result might
     *                      be modified to show the failed output. Since: 3.4.0
     */
    VERIFY,
    /**
     * flag indicating that the `HB_GLYPH_FLAG_UNSAFE_TO_CONCAT`
     *                      glyph-flag should be produced by the shaper. By default
     *                      it will not be produced since it incurs a cost. Since: 4.0.0
     */
    PRODUCE_UNSAFE_TO_CONCAT,
    /**
     * flag indicating that the `HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL`
     *                      glyph-flag should be produced by the shaper. By default
     *                      it will not be produced. Since: 5.1.0
     */
    PRODUCE_SAFE_TO_INSERT_TATWEEL,
    /**
     * All currently defined flags: Since: 4.4.0
     */
    DEFINED,
  }
  /**
   * Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs().
   * @bitfield
   */
  enum buffer_serialize_flags_t {
    /**
     * serialize glyph names, clusters and positions.
     */
    DEFAULT,
    /**
     * do not serialize glyph cluster.
     */
    NO_CLUSTERS,
    /**
     * do not serialize glyph position information.
     */
    NO_POSITIONS,
    /**
     * do no serialize glyph name.
     */
    NO_GLYPH_NAMES,
    /**
     * serialize glyph extents.
     */
    GLYPH_EXTENTS,
    /**
     * serialize glyph flags. Since: 1.5.0
     */
    GLYPH_FLAGS,
    /**
     * do not serialize glyph advances,
     *  glyph offsets will reflect absolute glyph positions. Since: 1.8.0
     */
    NO_ADVANCES,
    /**
     * All currently defined flags. Since: 4.4.0
     */
    DEFINED,
  }
  /**
   * Flags for #hb_glyph_info_t.
   * @bitfield
   */
  enum glyph_flags_t {
    /**
     * Indicates that if input text is broken at the
     * 				   beginning of the cluster this glyph is part of,
     * 				   then both sides need to be re-shaped, as the
     * 				   result might be different.
     * 				   On the flip side, it means that when this
     * 				   flag is not present, then it is safe to break
     * 				   the glyph-run at the beginning of this
     * 				   cluster, and the two sides will represent the
     * 				   exact same result one would get if breaking
     * 				   input text at the beginning of this cluster
     * 				   and shaping the two sides separately.
     * 				   This can be used to optimize paragraph
     * 				   layout, by avoiding re-shaping of each line
     * 				   after line-breaking.
     */
    UNSAFE_TO_BREAK,
    /**
     * Indicates that if input text is changed on one
     * 				   side of the beginning of the cluster this glyph
     * 				   is part of, then the shaping results for the
     * 				   other side might change.
     * 				   Note that the absence of this flag will NOT by
     * 				   itself mean that it IS safe to concat text.
     * 				   Only two pieces of text both of which clear of
     * 				   this flag can be concatenated safely.
     * 				   This can be used to optimize paragraph
     * 				   layout, by avoiding re-shaping of each line
     * 				   after line-breaking, by limiting the
     * 				   reshaping to a small piece around the
     * 				   breaking position only, even if the breaking
     * 				   position carries the
     * 				   #HB_GLYPH_FLAG_UNSAFE_TO_BREAK or when
     * 				   hyphenation or other text transformation
     * 				   happens at line-break position, in the following
     * 				   way:
     * 				   1. Iterate back from the line-break position
     * 				   until the first cluster start position that is
     * 				   NOT unsafe-to-concat, 2. shape the segment from
     * 				   there till the end of line, 3. check whether the
     * 				   resulting glyph-run also is clear of the
     * 				   unsafe-to-concat at its start-of-text position;
     * 				   if it is, just splice it into place and the line
     * 				   is shaped; If not, move on to a position further
     * 				   back that is clear of unsafe-to-concat and retry
     * 				   from there, and repeat.
     * 				   At the start of next line a similar algorithm can
     * 				   be implemented. That is: 1. Iterate forward from
     * 				   the line-break position until the first cluster
     * 				   start position that is NOT unsafe-to-concat, 2.
     * 				   shape the segment from beginning of the line to
     * 				   that position, 3. check whether the resulting
     * 				   glyph-run also is clear of the unsafe-to-concat
     * 				   at its end-of-text position; if it is, just splice
     * 				   it into place and the beginning is shaped; If not,
     * 				   move on to a position further forward that is clear
     * 				   of unsafe-to-concat and retry up to there, and repeat.
     * 				   A slight complication will arise in the
     * 				   implementation of the algorithm above,
     * 				   because while our buffer API has a way to
     * 				   return flags for position corresponding to
     * 				   start-of-text, there is currently no position
     * 				   corresponding to end-of-text.  This limitation
     * 				   can be alleviated by shaping more text than needed
     * 				   and looking for unsafe-to-concat flag within text
     * 				   clusters.
     * 				   The #HB_GLYPH_FLAG_UNSAFE_TO_BREAK flag will
     * 				   always imply this flag.
     * 			   To use this flag, you must enable the buffer flag
     * 			   `HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT` during
     * 			   shaping, otherwise the buffer flag will not be
     * 			   reliably produced.
     * 				   Since: 4.0.0
     */
    UNSAFE_TO_CONCAT,
    /**
     * In scripts that use elongation (Arabic,
     * 				   Mongolian, Syriac, etc.), this flag signifies
     * 				   that it is safe to insert a U+0640 TATWEEL
     * 				   character before this cluster for elongation.
     * 				   This flag does not determine the
     * 				   script-specific elongation places, but only
     * 				   when it is safe to do the elongation without
     * 				   interrupting text shaping.
     * 				   Since: 5.1.0
     */
    SAFE_TO_INSERT_TATWEEL,
    /**
     * All the currently defined flags.
     */
    DEFINED,
  }
  /**
   * Flags that describe the properties of color palette.
   * @bitfield
   */
  enum ot_color_palette_flags_t {
    /**
     * Default indicating that there is nothing special
     *   to note about a color palette.
     */
    DEFAULT,
    /**
     * Flag indicating that the color
     *   palette is appropriate to use when displaying the font on a light background such as white.
     */
    USABLE_WITH_LIGHT_BACKGROUND,
    /**
     * Flag indicating that the color
     *   palette is appropriate to use when displaying the font on a dark background such as black.
     */
    USABLE_WITH_DARK_BACKGROUND,
  }
  /**
   * Flags for math glyph parts.
   * @bitfield
   */
  enum ot_math_glyph_part_flags_t {
    /**
     * This is an extender glyph part that
     * can be repeated to reach the desired length.
     */
    EXTENDER,
  }
  /**
   * Flags for #hb_ot_var_axis_info_t.
   * @bitfield
   */
  enum ot_var_axis_flags_t {
    /**
     * The axis should not be exposed directly in user interfaces.
     */
    HIDDEN,
  }
  /**
   * Used when getting or setting AAT feature selectors. Indicates that
   * there is no selector index corresponding to the selector of interest.
   */
  const AAT_LAYOUT_NO_SELECTOR_INDEX: number
  /**
   * The default code point for replacing invalid characters in a given encoding.
   * Set to U+FFFD REPLACEMENT CHARACTER.
   */
  const BUFFER_REPLACEMENT_CODEPOINT_DEFAULT: number
  /**
   * Unused #hb_codepoint_t value.
   */
  const CODEPOINT_INVALID: codepoint_t
  /**
   * Special setting for #hb_feature_t.start to apply the feature from the start
   * of the buffer.
   */
  const FEATURE_GLOBAL_START: number
  /**
   * Constant signifying that a font does not have any
   * named-instance index set.  This is the default of
   * a font.
   */
  const FONT_NO_VAR_NAMED_INSTANCE: number
  /**
   * An unset #hb_language_t.
   */
  const LANGUAGE_INVALID: language_t
  /**
   * Special value for language index indicating default or unsupported language.
   */
  const OT_LAYOUT_DEFAULT_LANGUAGE_INDEX: number
  /**
   * Special value for feature index indicating unsupported feature.
   */
  const OT_LAYOUT_NO_FEATURE_INDEX: number
  /**
   * Special value for script index indicating unsupported script.
   */
  const OT_LAYOUT_NO_SCRIPT_INDEX: number
  /**
   * Special value for variations index indicating unsupported variation.
   */
  const OT_LAYOUT_NO_VARIATIONS_INDEX: number
  /**
   * Maximum number of OpenType tags that can correspond to a give #hb_language_t.
   */
  const OT_MAX_TAGS_PER_LANGUAGE: number
  /**
   * Maximum number of OpenType tags that can correspond to a give #hb_script_t.
   */
  const OT_MAX_TAGS_PER_SCRIPT: number
  /**
   * Do not use.
   */
  const OT_VAR_NO_AXIS_INDEX: number
  /**
   * [Tibetan]
   */
  const UNICODE_COMBINING_CLASS_CCC133: number
  /**
   * Maximum valid Unicode code point.
   */
  const UNICODE_MAX: number
  /**
   * See Unicode 6.1 for details on the maximum decomposition length.
   */
  const UNICODE_MAX_DECOMPOSITION_LEN: number
  const VERSION_MAJOR: number
  const VERSION_MICRO: number
  const VERSION_MINOR: number
  const VERSION_STRING: string
  /**
   * Fetches the name identifier of the specified feature type in the face's `name` table.
   * @param face #hb_face_t to work upon
   * @param featureType The #hb_aat_layout_feature_type_t of the requested feature type
   * @returns Name identifier of the requested feature type
   */
  function aatLayoutFeatureTypeGetNameId(
    face: face_t,
    featureType: aat_layout_feature_type_t
  ): ot_name_id_t
  /**
   * Fetches a list of the selectors available for the specified feature in the given face.
   *
   * If upon return, `default_index` is set to #HB_AAT_LAYOUT_NO_SELECTOR_INDEX, then
   * the feature type is non-exclusive.  Otherwise, `default_index` is the index of
   * the selector that is selected by default.
   * @param face #hb_face_t to work upon
   * @param featureType The #hb_aat_layout_feature_type_t of the requested feature type
   * @param startOffset offset of the first feature type to retrieve
   * @returns Number of all available feature selectors
   */
  function aatLayoutFeatureTypeGetSelectorInfos(
    face: face_t,
    featureType: aat_layout_feature_type_t,
    startOffset: number
  ): [
    /* returnType */ number,
    /* selectors */ aat_layout_feature_selector_info_t[],
    /* defaultIndex */ number,
  ]
  /**
   * Fetches a list of the AAT feature types included in the specified face.
   * @param face #hb_face_t to work upon
   * @param startOffset offset of the first feature type to retrieve
   * @returns Number of all available feature types.
   */
  function aatLayoutGetFeatureTypes(
    face: face_t,
    startOffset: number
  ): [/* returnType */ number, /* features */ aat_layout_feature_type_t[]]
  /**
   * Tests whether the specified face includes any positioning information
   * in the `kerx` table.
   *
   * <note>Note: does not examine the `GPOS` table.</note>
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function aatLayoutHasPositioning(face: face_t): bool_t
  /**
   * Tests whether the specified face includes any substitutions in the
   * `morx` or `mort` tables.
   *
   * <note>Note: does not examine the `GSUB` table.</note>
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function aatLayoutHasSubstitution(face: face_t): bool_t
  /**
   * Tests whether the specified face includes any tracking information
   * in the `trak` table.
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function aatLayoutHasTracking(face: face_t): bool_t
  /**
   * Makes a writable copy of `blob`.
   * @param blob A blob.
   * @returns The new blob, or nullptr if allocation failed
   */
  function blobCopyWritableOrFail(blob: blob_t): blob_t
  /**
   * Creates a new blob containing the data from the
   * specified binary font file.
   * @param fileName A font filename
   * @returns An #hb_blob_t pointer with the content of the file, or hb_blob_get_empty() if failed.
   */
  function blobCreateFromFile(fileName: string): blob_t
  /**
   * Creates a new blob containing the data from the
   * specified binary font file.
   * @param fileName A font filename
   * @returns An #hb_blob_t pointer with the content of the file, or `NULL` if failed.
   */
  function blobCreateFromFileOrFail(fileName: string): blob_t
  /**
   * Returns a blob that represents a range of bytes in `parent`.  The new
   * blob is always created with #HB_MEMORY_MODE_READONLY, meaning that it
   * will never modify data in the parent blob.  The parent data is not
   * expected to be modified, and will result in undefined behavior if it
   * is.
   *
   * Makes `parent` immutable.
   * @param parent Parent blob.
   * @param offset Start offset of sub-blob within `parent,` in bytes.
   * @param length Length of sub-blob.
   * @returns New blob, or the empty blob if something failed or if @length is zero or @offset is beyond the end of @parent's data.  Destroy with hb_blob_destroy().
   */
  function blobCreateSubBlob(
    parent: blob_t,
    offset: number,
    length: number
  ): blob_t
  /**
   * Fetches the data from a blob.
   * @param blob a blob.
   * @returns the byte data of @blob.
   */
  function blobGetData(blob: blob_t): string[] | null
  /**
   * Tries to make blob data writable (possibly copying it) and
   * return pointer to data.
   *
   * Fails if blob has been made immutable, or if memory allocation
   * fails.
   * @param blob a blob.
   * @returns Writable blob data, or `NULL` if failed.
   */
  function blobGetDataWritable(blob: blob_t): string[]
  /**
   * Returns the singleton empty blob.
   *
   * See TODO:link object types for more information.
   * @returns The empty blob.
   */
  function blobGetEmpty(): blob_t
  /**
   * Fetches the length of a blob's data.
   * @param blob a blob.
   * @returns the length of @blob data in bytes.
   */
  function blobGetLength(blob: blob_t): number
  /**
   * Tests whether a blob is immutable.
   * @param blob a blob.
   * @returns `true` if @blob is immutable, `false` otherwise
   */
  function blobIsImmutable(blob: blob_t): bool_t
  /**
   * Makes a blob immutable.
   * @param blob a blob
   */
  function blobMakeImmutable(blob: blob_t): void
  /**
   * Appends a character with the Unicode value of `codepoint` to `buffer,` and
   * gives it the initial cluster value of `cluster`. Clusters can be any thing
   * the client wants, they are usually used to refer to the index of the
   * character in the input text stream and are output in
   * #hb_glyph_info_t.cluster field.
   *
   * This function does not check the validity of `codepoint,` it is up to the
   * caller to ensure it is a valid Unicode code point.
   * @param buffer An #hb_buffer_t
   * @param codepoint A Unicode code point.
   * @param cluster The cluster value of `codepoint`.
   */
  function bufferAdd(
    buffer: buffer_t,
    codepoint: codepoint_t,
    cluster: number
  ): void
  /**
   * Appends characters from `text` array to `buffer`. The `item_offset` is the
   * position of the first character from `text` that will be appended, and
   * `item_length` is the number of character. When shaping part of a larger text
   * (e.g. a run of text from a paragraph), instead of passing just the substring
   * corresponding to the run, it is preferable to pass the whole
   * paragraph and specify the run start and length as `item_offset` and
   * `item_length,` respectively, to give HarfBuzz the full context to be able,
   * for example, to do cross-run Arabic shaping or properly handle combining
   * marks at stat of run.
   *
   * This function does not check the validity of `text,` it is up to the caller
   * to ensure it contains a valid Unicode scalar values.  In contrast,
   * hb_buffer_add_utf32() can be used that takes similar input but performs
   * sanity-check on the input.
   * @param buffer a #hb_buffer_t to append characters to.
   * @param text an array of Unicode code points to append.
   * @param itemOffset the offset of the first code point to add to the `buffer`.
   * @param itemLength the number of code points to add to the `buffer,` or -1 for the               end of `text` (assuming it is `NULL` terminated).
   */
  function bufferAddCodepoints(
    buffer: buffer_t,
    text: codepoint_t[],
    itemOffset: number,
    itemLength: number
  ): void
  /**
   * Similar to hb_buffer_add_codepoints(), but allows only access to first 256
   * Unicode code points that can fit in 8-bit strings.
   *
   * <note>Has nothing to do with non-Unicode Latin-1 encoding.</note>
   * @param buffer An #hb_buffer_t
   * @param text an array of UTF-8               characters to append
   * @param itemOffset the offset of the first character to add to the `buffer`
   * @param itemLength the number of characters to add to the `buffer,` or -1 for the               end of `text` (assuming it is `NULL` terminated)
   */
  function bufferAddLatin1(
    buffer: buffer_t,
    text: number[],
    itemOffset: number,
    itemLength: number
  ): void
  /**
   * See hb_buffer_add_codepoints().
   *
   * Replaces invalid UTF-16 characters with the `buffer` replacement code point,
   * see hb_buffer_set_replacement_codepoint().
   * @param buffer An #hb_buffer_t
   * @param text An array of UTF-16 characters to append
   * @param itemOffset The offset of the first character to add to the `buffer`
   * @param itemLength The number of characters to add to the `buffer,` or -1 for the               end of `text` (assuming it is `NULL` terminated)
   */
  function bufferAddUtf16(
    buffer: buffer_t,
    text: number[],
    itemOffset: number,
    itemLength: number
  ): void
  /**
   * See hb_buffer_add_codepoints().
   *
   * Replaces invalid UTF-32 characters with the `buffer` replacement code point,
   * see hb_buffer_set_replacement_codepoint().
   * @param buffer An #hb_buffer_t
   * @param text An array of UTF-32 characters to append
   * @param itemOffset The offset of the first character to add to the `buffer`
   * @param itemLength The number of characters to add to the `buffer,` or -1 for the               end of `text` (assuming it is `NULL` terminated)
   */
  function bufferAddUtf32(
    buffer: buffer_t,
    text: number[],
    itemOffset: number,
    itemLength: number
  ): void
  /**
   * See hb_buffer_add_codepoints().
   *
   * Replaces invalid UTF-8 characters with the `buffer` replacement code point,
   * see hb_buffer_set_replacement_codepoint().
   * @param buffer An #hb_buffer_t
   * @param text An array of UTF-8               characters to append.
   * @param itemOffset The offset of the first character to add to the `buffer`.
   * @param itemLength The number of characters to add to the `buffer,` or -1 for the               end of `text` (assuming it is `NULL` terminated).
   */
  function bufferAddUtf8(
    buffer: buffer_t,
    text: number[],
    itemOffset: number,
    itemLength: number
  ): void
  /**
   * Check if allocating memory for the buffer succeeded.
   * @param buffer An #hb_buffer_t
   * @returns `true` if @buffer memory allocation succeeded, `false` otherwise.
   */
  function bufferAllocationSuccessful(buffer: buffer_t): bool_t
  /**
   * Append (part of) contents of another buffer to this buffer.
   * @param buffer An #hb_buffer_t
   * @param source source #hb_buffer_t
   * @param start start index into source buffer to copy.  Use 0 to copy from start of buffer.
   * @param end end index into source buffer to copy.  Use `HB_FEATURE_GLOBAL_END` to copy to end of buffer.
   */
  function bufferAppend(
    buffer: buffer_t,
    source: buffer_t,
    start: number,
    end: number
  ): void
  /**
   * Similar to hb_buffer_reset(), but does not clear the Unicode functions and
   * the replacement code point.
   * @param buffer An #hb_buffer_t
   */
  function bufferClearContents(buffer: buffer_t): void
  /**
   * Creates a new #hb_buffer_t with all properties to defaults.
   * @returns A newly allocated #hb_buffer_t with a reference count of 1. The initial reference count should be released with hb_buffer_destroy() when you are done using the #hb_buffer_t. This function never returns `NULL`. If memory cannot be allocated, a special #hb_buffer_t object will be returned on which hb_buffer_allocation_successful() returns `false`.
   */
  function bufferCreate(): buffer_t
  /**
   * Creates a new #hb_buffer_t, similar to hb_buffer_create(). The only
   * difference is that the buffer is configured similarly to `src`.
   * @param src An #hb_buffer_t
   * @returns A newly allocated #hb_buffer_t, similar to hb_buffer_create().
   */
  function bufferCreateSimilar(src: buffer_t): buffer_t
  /**
   * Deserializes glyphs `buffer` from textual representation in the format
   * produced by hb_buffer_serialize_glyphs().
   * @param buffer an #hb_buffer_t buffer.
   * @param buf string to deserialize
   * @param font font for getting glyph IDs
   * @param format the #hb_buffer_serialize_format_t of the input `buf`
   * @returns `true` if parse was successful, `false` if an error occurred.
   */
  function bufferDeserializeGlyphs(
    buffer: buffer_t,
    buf: string[],
    font: font_t | null,
    format: buffer_serialize_format_t
  ): [/* returnType */ bool_t, /* endPtr */ string]
  /**
   * Deserializes Unicode `buffer` from textual representation in the format
   * produced by hb_buffer_serialize_unicode().
   * @param buffer an #hb_buffer_t buffer.
   * @param buf string to deserialize
   * @param format the #hb_buffer_serialize_format_t of the input `buf`
   * @returns `true` if parse was successful, `false` if an error occurred.
   */
  function bufferDeserializeUnicode(
    buffer: buffer_t,
    buf: string[],
    format: buffer_serialize_format_t
  ): [/* returnType */ bool_t, /* endPtr */ string]
  /**
   * If dottedcircle_glyph is (hb_codepoint_t) -1 then #HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT
   * and #HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT are never returned.  This should be used by most
   * callers if just comparing two buffers is needed.
   * @param buffer a buffer.
   * @param reference other buffer to compare to.
   * @param dottedcircleGlyph glyph id of U+25CC DOTTED CIRCLE, or (hb_codepoint_t) -1.
   * @param positionFuzz allowed absolute difference in position values.
   */
  function bufferDiff(
    buffer: buffer_t,
    reference: buffer_t,
    dottedcircleGlyph: codepoint_t,
    positionFuzz: number
  ): buffer_diff_flags_t
  /**
   * Fetches the cluster level of a buffer. The #hb_buffer_cluster_level_t
   * dictates one aspect of how HarfBuzz will treat non-base characters
   * during shaping.
   * @param buffer An #hb_buffer_t
   * @returns The cluster level of @buffer
   */
  function bufferGetClusterLevel(buffer: buffer_t): buffer_cluster_level_t
  /**
   * Fetches the type of `buffer` contents. Buffers are either empty, contain
   * characters (before shaping), or contain glyphs (the result of shaping).
   * @param buffer An #hb_buffer_t
   * @returns The type of @buffer contents
   */
  function bufferGetContentType(buffer: buffer_t): buffer_content_type_t
  /**
   * See hb_buffer_set_direction()
   * @param buffer An #hb_buffer_t
   * @returns The direction of the @buffer.
   */
  function bufferGetDirection(buffer: buffer_t): direction_t
  /**
   * Fetches an empty #hb_buffer_t.
   * @returns The empty buffer
   */
  function bufferGetEmpty(): buffer_t
  /**
   * Fetches the #hb_buffer_flags_t of `buffer`.
   * @param buffer An #hb_buffer_t
   * @returns The @buffer flags
   */
  function bufferGetFlags(buffer: buffer_t): buffer_flags_t
  /**
   * Returns `buffer` glyph information array.  Returned pointer
   * is valid as long as `buffer` contents are not modified.
   * @param buffer An #hb_buffer_t
   * @returns The @buffer glyph information array. The value valid as long as buffer has not been modified.
   */
  function bufferGetGlyphInfos(buffer: buffer_t): glyph_info_t[]
  /**
   * Returns `buffer` glyph position array.  Returned pointer
   * is valid as long as `buffer` contents are not modified.
   *
   * If buffer did not have positions before, the positions will be
   * initialized to zeros, unless this function is called from
   * within a buffer message callback (see hb_buffer_set_message_func()),
   * in which case `NULL` is returned.
   * @param buffer An #hb_buffer_t
   * @returns The @buffer glyph position array. The value valid as long as buffer has not been modified.
   */
  function bufferGetGlyphPositions(buffer: buffer_t): glyph_position_t[]
  /**
   * See hb_buffer_set_invisible_glyph().
   * @param buffer An #hb_buffer_t
   * @returns The @buffer invisible #hb_codepoint_t
   */
  function bufferGetInvisibleGlyph(buffer: buffer_t): codepoint_t
  /**
   * See hb_buffer_set_language().
   * @param buffer An #hb_buffer_t
   * @returns The #hb_language_t of the buffer. Must not be freed by the caller.
   */
  function bufferGetLanguage(buffer: buffer_t): language_t
  /**
   * Returns the number of items in the buffer.
   * @param buffer An #hb_buffer_t
   * @returns The @buffer length. The value valid as long as buffer has not been modified.
   */
  function bufferGetLength(buffer: buffer_t): number
  /**
   * See hb_buffer_set_not_found_glyph().
   * @param buffer An #hb_buffer_t
   * @returns The @buffer not-found #hb_codepoint_t
   */
  function bufferGetNotFoundGlyph(buffer: buffer_t): codepoint_t
  /**
   * Fetches the #hb_codepoint_t that replaces invalid entries for a given encoding
   * when adding text to `buffer`.
   * @param buffer An #hb_buffer_t
   * @returns The @buffer replacement #hb_codepoint_t
   */
  function bufferGetReplacementCodepoint(buffer: buffer_t): codepoint_t
  /**
   * Fetches the script of `buffer`.
   * @param buffer An #hb_buffer_t
   * @returns The #hb_script_t of the @buffer
   */
  function bufferGetScript(buffer: buffer_t): script_t
  /**
   * Sets `props` to the #hb_segment_properties_t of `buffer`.
   * @param buffer An #hb_buffer_t
   */
  function bufferGetSegmentProperties(
    buffer: buffer_t
  ): /* props */ segment_properties_t
  /**
   * Fetches the Unicode-functions structure of a buffer.
   * @param buffer An #hb_buffer_t
   * @returns The Unicode-functions structure
   */
  function bufferGetUnicodeFuncs(buffer: buffer_t): unicode_funcs_t
  /**
   * Sets unset buffer segment properties based on buffer Unicode
   * contents.  If buffer is not empty, it must have content type
   * #HB_BUFFER_CONTENT_TYPE_UNICODE.
   *
   * If buffer script is not set (ie. is #HB_SCRIPT_INVALID), it
   * will be set to the Unicode script of the first character in
   * the buffer that has a script other than #HB_SCRIPT_COMMON,
   * #HB_SCRIPT_INHERITED, and #HB_SCRIPT_UNKNOWN.
   *
   * Next, if buffer direction is not set (ie. is #HB_DIRECTION_INVALID),
   * it will be set to the natural horizontal direction of the
   * buffer script as returned by hb_script_get_horizontal_direction().
   * If hb_script_get_horizontal_direction() returns #HB_DIRECTION_INVALID,
   * then #HB_DIRECTION_LTR is used.
   *
   * Finally, if buffer language is not set (ie. is #HB_LANGUAGE_INVALID),
   * it will be set to the process's default language as returned by
   * hb_language_get_default().  This may change in the future by
   * taking buffer script into consideration when choosing a language.
   * Note that hb_language_get_default() is NOT threadsafe the first time
   * it is called.  See documentation for that function for details.
   * @param buffer An #hb_buffer_t
   */
  function bufferGuessSegmentProperties(buffer: buffer_t): void
  /**
   * Returns whether `buffer` has glyph position data.
   * A buffer gains position data when hb_buffer_get_glyph_positions() is called on it,
   * and cleared of position data when hb_buffer_clear_contents() is called.
   * @param buffer an #hb_buffer_t.
   * @returns `true` if the @buffer has position array, `false` otherwise.
   */
  function bufferHasPositions(buffer: buffer_t): bool_t
  /**
   * Reorders a glyph buffer to have canonical in-cluster glyph order / position.
   * The resulting clusters should behave identical to pre-reordering clusters.
   *
   * <note>This has nothing to do with Unicode normalization.</note>
   * @param buffer An #hb_buffer_t
   */
  function bufferNormalizeGlyphs(buffer: buffer_t): void
  /**
   * Pre allocates memory for `buffer` to fit at least `size` number of items.
   * @param buffer An #hb_buffer_t
   * @param size Number of items to pre allocate.
   * @returns `true` if @buffer memory allocation succeeded, `false` otherwise
   */
  function bufferPreAllocate(buffer: buffer_t, size: number): bool_t
  /**
   * Resets the buffer to its initial status, as if it was just newly created
   * with hb_buffer_create().
   * @param buffer An #hb_buffer_t
   */
  function bufferReset(buffer: buffer_t): void
  /**
   * Reverses buffer contents.
   * @param buffer An #hb_buffer_t
   */
  function bufferReverse(buffer: buffer_t): void
  /**
   * Reverses buffer clusters.  That is, the buffer contents are
   * reversed, then each cluster (consecutive items having the
   * same cluster number) are reversed again.
   * @param buffer An #hb_buffer_t
   */
  function bufferReverseClusters(buffer: buffer_t): void
  /**
   * Reverses buffer contents between `start` and `end`.
   * @param buffer An #hb_buffer_t
   * @param start start index
   * @param end end index
   */
  function bufferReverseRange(
    buffer: buffer_t,
    start: number,
    end: number
  ): void
  /**
   * Serializes `buffer` into a textual representation of its content, whether
   * Unicode codepoints or glyph identifiers and positioning information. This is
   * useful for showing the contents of the buffer, for example during debugging.
   * See the documentation of hb_buffer_serialize_unicode() and
   * hb_buffer_serialize_glyphs() for a description of the output format.
   * @param buffer an #hb_buffer_t buffer.
   * @param start the first item in `buffer` to serialize.
   * @param end the last item in `buffer` to serialize.
   * @param font the #hb_font_t used to shape this buffer, needed to        read glyph names and extents. If `NULL`, an empty font will be used.
   * @param format the #hb_buffer_serialize_format_t to use for formatting the output.
   * @param flags the #hb_buffer_serialize_flags_t that control what glyph properties         to serialize.
   * @returns The number of serialized items.
   */
  function bufferSerialize(
    buffer: buffer_t,
    start: number,
    end: number,
    font: font_t | null,
    format: buffer_serialize_format_t,
    flags: buffer_serialize_flags_t
  ): [/* returnType */ number, /* buf */ number[], /* bufConsumed */ number]
  /**
   * Parses a string into an #hb_buffer_serialize_format_t. Does not check if
   * `str` is a valid buffer serialization format, use
   * hb_buffer_serialize_list_formats() to get the list of supported formats.
   * @param str a string to parse
   * @returns The parsed #hb_buffer_serialize_format_t.
   */
  function bufferSerializeFormatFromString(
    str: number[]
  ): buffer_serialize_format_t
  /**
   * Converts `format` to the string corresponding it, or `NULL` if it is not a valid
   * #hb_buffer_serialize_format_t.
   * @param format an #hb_buffer_serialize_format_t to convert.
   * @returns A `NULL` terminated string corresponding to @format. Should not be freed.
   */
  function bufferSerializeFormatToString(
    format: buffer_serialize_format_t
  ): string
  /**
   * Serializes `buffer` into a textual representation of its glyph content,
   * useful for showing the contents of the buffer, for example during debugging.
   * There are currently two supported serialization formats:
   *
   * ## text
   * A human-readable, plain text format.
   * The serialized glyphs will look something like:
   *
   * ```
   * [uni0651=0`5`18,0+0|uni0628=0+1897]
   * ```
   *
   * - The serialized glyphs are delimited with `[` and `]`.
   * - Glyphs are separated with `|`
   * - Each glyph starts with glyph name, or glyph index if
   *   #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set. Then,
   *   - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, `=` then #hb_glyph_info_t.cluster.
   *   - If #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set, the #hb_glyph_position_t in the format:
   *     - If both #hb_glyph_position_t.x_offset and #hb_glyph_position_t.y_offset are not 0, ``x_offset,`y_offset`. Then,
   *     - `+x_advance`, then `,y_advance` if #hb_glyph_position_t.y_advance is not 0. Then,
   *   - If #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set, the #hb_glyph_extents_t in the format `<x_bearing,y_bearing,width,height>`
   *
   * ## json
   * A machine-readable, structured format.
   * The serialized glyphs will look something like:
   *
   * ```
   * [{"g":"uni0651","cl":0,"dx":518,"dy":0,"ax":0,"ay":0},
   * {"g":"uni0628","cl":0,"dx":0,"dy":0,"ax":1897,"ay":0}]
   * ```
   *
   * Each glyph is a JSON object, with the following properties:
   * - `g`: the glyph name or glyph index if
   *   #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set.
   * - `cl`: #hb_glyph_info_t.cluster if
   *   #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set.
   * - `dx`,`dy`,`ax`,`ay`: #hb_glyph_position_t.x_offset, #hb_glyph_position_t.y_offset,
   *    #hb_glyph_position_t.x_advance and #hb_glyph_position_t.y_advance
   *    respectively, if #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set.
   * - `xb`,`yb`,`w`,`h`: #hb_glyph_extents_t.x_bearing, #hb_glyph_extents_t.y_bearing,
   *    #hb_glyph_extents_t.width and #hb_glyph_extents_t.height respectively if
   *    #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set.
   * @param buffer an #hb_buffer_t buffer.
   * @param start the first item in `buffer` to serialize.
   * @param end the last item in `buffer` to serialize.
   * @param font the #hb_font_t used to shape this buffer, needed to        read glyph names and extents. If `NULL`, an empty font will be used.
   * @param format the #hb_buffer_serialize_format_t to use for formatting the output.
   * @param flags the #hb_buffer_serialize_flags_t that control what glyph properties         to serialize.
   * @returns The number of serialized items.
   */
  function bufferSerializeGlyphs(
    buffer: buffer_t,
    start: number,
    end: number,
    font: font_t | null,
    format: buffer_serialize_format_t,
    flags: buffer_serialize_flags_t
  ): [/* returnType */ number, /* buf */ number[], /* bufConsumed */ number]
  /**
   * Returns a list of supported buffer serialization formats.
   * @returns A string array of buffer serialization formats. Should not be freed.
   */
  function bufferSerializeListFormats(): string[]
  /**
   * Serializes `buffer` into a textual representation of its content,
   * when the buffer contains Unicode codepoints (i.e., before shaping). This is
   * useful for showing the contents of the buffer, for example during debugging.
   * There are currently two supported serialization formats:
   *
   * ## text
   * A human-readable, plain text format.
   * The serialized codepoints will look something like:
   *
   * ```
   *  <U+0651=0|U+0628=1>
   * ```
   *
   * - Glyphs are separated with `|`
   * - Unicode codepoints are expressed as zero-padded four (or more)
   *   digit hexadecimal numbers preceded by `U+`
   * - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, the cluster
   *   will be indicated with a `=` then #hb_glyph_info_t.cluster.
   *
   * ## json
   * A machine-readable, structured format.
   * The serialized codepoints will be a list of objects with the following
   * properties:
   * - `u`: the Unicode codepoint as a decimal integer
   * - `cl`: #hb_glyph_info_t.cluster if
   *   #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set.
   *
   * For example:
   *
   * ```
   * [{u:1617,cl:0},{u:1576,cl:1}]
   * ```
   * @param buffer an #hb_buffer_t buffer.
   * @param start the first item in `buffer` to serialize.
   * @param end the last item in `buffer` to serialize.
   * @param format the #hb_buffer_serialize_format_t to use for formatting the output.
   * @param flags the #hb_buffer_serialize_flags_t that control what glyph properties         to serialize.
   * @returns The number of serialized items.
   */
  function bufferSerializeUnicode(
    buffer: buffer_t,
    start: number,
    end: number,
    format: buffer_serialize_format_t,
    flags: buffer_serialize_flags_t
  ): [/* returnType */ number, /* buf */ number[], /* bufConsumed */ number]
  /**
   * Sets the cluster level of a buffer. The #hb_buffer_cluster_level_t
   * dictates one aspect of how HarfBuzz will treat non-base characters
   * during shaping.
   * @param buffer An #hb_buffer_t
   * @param clusterLevel The cluster level to set on the buffer
   */
  function bufferSetClusterLevel(
    buffer: buffer_t,
    clusterLevel: buffer_cluster_level_t
  ): void
  /**
   * Sets the type of `buffer` contents. Buffers are either empty, contain
   * characters (before shaping), or contain glyphs (the result of shaping).
   *
   * You rarely need to call this function, since a number of other
   * functions transition the content type for you. Namely:
   *
   * - A newly created buffer starts with content type
   *   %HB_BUFFER_CONTENT_TYPE_INVALID. Calling hb_buffer_reset(),
   *   hb_buffer_clear_contents(), as well as calling hb_buffer_set_length()
   *   with an argument of zero all set the buffer content type to invalid
   *   as well.
   *
   * - Calling hb_buffer_add_utf8(), hb_buffer_add_utf16(),
   *   hb_buffer_add_utf32(), hb_buffer_add_codepoints() and
   *   hb_buffer_add_latin1() expect that buffer is either empty and
   *   have a content type of invalid, or that buffer content type is
   *   %HB_BUFFER_CONTENT_TYPE_UNICODE, and they also set the content
   *   type to Unicode if they added anything to an empty buffer.
   *
   * - Finally hb_shape() and hb_shape_full() expect that the buffer
   *   is either empty and have content type of invalid, or that buffer
   *   content type is %HB_BUFFER_CONTENT_TYPE_UNICODE, and upon
   *   success they set the buffer content type to
   *   %HB_BUFFER_CONTENT_TYPE_GLYPHS.
   *
   * The above transitions are designed such that one can use a buffer
   * in a loop of "reset : add-text : shape" without needing to ever
   * modify the content type manually.
   * @param buffer An #hb_buffer_t
   * @param contentType The type of buffer contents to set
   */
  function bufferSetContentType(
    buffer: buffer_t,
    contentType: buffer_content_type_t
  ): void
  /**
   * Set the text flow direction of the buffer. No shaping can happen without
   * setting `buffer` direction, and it controls the visual direction for the
   * output glyphs; for RTL direction the glyphs will be reversed. Many layout
   * features depend on the proper setting of the direction, for example,
   * reversing RTL text before shaping, then shaping with LTR direction is not
   * the same as keeping the text in logical order and shaping with RTL
   * direction.
   * @param buffer An #hb_buffer_t
   * @param direction the #hb_direction_t of the `buffer`
   */
  function bufferSetDirection(buffer: buffer_t, direction: direction_t): void
  /**
   * Sets `buffer` flags to `flags`. See #hb_buffer_flags_t.
   * @param buffer An #hb_buffer_t
   * @param flags The buffer flags to set
   */
  function bufferSetFlags(buffer: buffer_t, flags: buffer_flags_t): void
  /**
   * Sets the #hb_codepoint_t that replaces invisible characters in
   * the shaping result.  If set to zero (default), the glyph for the
   * U+0020 SPACE character is used.  Otherwise, this value is used
   * verbatim.
   * @param buffer An #hb_buffer_t
   * @param invisible the invisible #hb_codepoint_t
   */
  function bufferSetInvisibleGlyph(
    buffer: buffer_t,
    invisible: codepoint_t
  ): void
  /**
   * Sets the language of `buffer` to `language`.
   *
   * Languages are crucial for selecting which OpenType feature to apply to the
   * buffer which can result in applying language-specific behaviour. Languages
   * are orthogonal to the scripts, and though they are related, they are
   * different concepts and should not be confused with each other.
   *
   * Use hb_language_from_string() to convert from BCP 47 language tags to
   * #hb_language_t.
   * @param buffer An #hb_buffer_t
   * @param language An hb_language_t to set
   */
  function bufferSetLanguage(buffer: buffer_t, language: language_t): void
  /**
   * Similar to hb_buffer_pre_allocate(), but clears any new items added at the
   * end.
   * @param buffer An #hb_buffer_t
   * @param length The new length of `buffer`
   * @returns `true` if @buffer memory allocation succeeded, `false` otherwise.
   */
  function bufferSetLength(buffer: buffer_t, length: number): bool_t
  /**
   * Sets the implementation function for #hb_buffer_message_func_t.
   * @param buffer An #hb_buffer_t
   * @param func Callback function
   */
  function bufferSetMessageFunc(
    buffer: buffer_t,
    func: buffer_message_func_t
  ): void
  /**
   * Sets the #hb_codepoint_t that replaces characters not found in
   * the font during shaping.
   *
   * The not-found glyph defaults to zero, sometimes known as the
   * ".notdef" glyph.  This API allows for differentiating the two.
   * @param buffer An #hb_buffer_t
   * @param notFound the not-found #hb_codepoint_t
   */
  function bufferSetNotFoundGlyph(buffer: buffer_t, notFound: codepoint_t): void
  /**
   * Sets the #hb_codepoint_t that replaces invalid entries for a given encoding
   * when adding text to `buffer`.
   *
   * Default is #HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT.
   * @param buffer An #hb_buffer_t
   * @param replacement the replacement #hb_codepoint_t
   */
  function bufferSetReplacementCodepoint(
    buffer: buffer_t,
    replacement: codepoint_t
  ): void
  /**
   * Sets the script of `buffer` to `script`.
   *
   * Script is crucial for choosing the proper shaping behaviour for scripts that
   * require it (e.g. Arabic) and the which OpenType features defined in the font
   * to be applied.
   *
   * You can pass one of the predefined #hb_script_t values, or use
   * hb_script_from_string() or hb_script_from_iso15924_tag() to get the
   * corresponding script from an ISO 15924 script tag.
   * @param buffer An #hb_buffer_t
   * @param script An #hb_script_t to set.
   */
  function bufferSetScript(buffer: buffer_t, script: script_t): void
  /**
   * Sets the segment properties of the buffer, a shortcut for calling
   * hb_buffer_set_direction(), hb_buffer_set_script() and
   * hb_buffer_set_language() individually.
   * @param buffer An #hb_buffer_t
   * @param props An #hb_segment_properties_t to use
   */
  function bufferSetSegmentProperties(
    buffer: buffer_t,
    props: segment_properties_t
  ): void
  /**
   * Sets the Unicode-functions structure of a buffer to
   * `unicode_funcs`.
   * @param buffer An #hb_buffer_t
   * @param unicodeFuncs The Unicode-functions structure
   */
  function bufferSetUnicodeFuncs(
    buffer: buffer_t,
    unicodeFuncs: unicode_funcs_t
  ): void
  /**
   * Fetches the alpha channel of the given `color`.
   * @param color an #hb_color_t we are interested in its channels.
   * @returns Alpha channel value
   */
  function colorGetAlpha(color: color_t): number
  /**
   * Fetches the blue channel of the given `color`.
   * @param color an #hb_color_t we are interested in its channels.
   * @returns Blue channel value
   */
  function colorGetBlue(color: color_t): number
  /**
   * Fetches the green channel of the given `color`.
   * @param color an #hb_color_t we are interested in its channels.
   * @returns Green channel value
   */
  function colorGetGreen(color: color_t): number
  /**
   * Fetches the red channel of the given `color`.
   * @param color an #hb_color_t we are interested in its channels.
   * @returns Red channel value
   */
  function colorGetRed(color: color_t): number
  /**
   * Fetches a list of color stops from the given color line object.
   *
   * Note that due to variations being applied, the returned color stops
   * may be out of order. It is the callers responsibility to ensure that
   * color stops are sorted by their offset before they are used.
   * @param colorLine a #hb_color_line_t object
   * @param start the index of the first color stop to return
   * @returns the total number of color stops in @color_line
   */
  function colorLineGetColorStops(
    colorLine: color_line_t,
    start: number
  ): [/* returnType */ number, /* colorStops */ color_stop_t[]]
  /**
   * Fetches the extend mode of the color line object.
   * @param colorLine a #hb_color_line_t object
   * @returns the extend mode of @color_line
   */
  function colorLineGetExtend(colorLine: color_line_t): paint_extend_t
  /**
   * Converts a string to an #hb_direction_t.
   *
   * Matching is loose and applies only to the first letter. For
   * examples, "LTR" and "left-to-right" will both return #HB_DIRECTION_LTR.
   *
   * Unmatched strings will return #HB_DIRECTION_INVALID.
   * @param str String to convert
   * @returns The #hb_direction_t matching @str
   */
  function directionFromString(str: number[]): direction_t
  /**
   * Converts an #hb_direction_t to a string.
   * @param direction The #hb_direction_t to convert
   * @returns The string corresponding to @direction
   */
  function directionToString(direction: direction_t): string
  /**
   * Perform a "close-path" draw operation.
   * @param dfuncs draw functions
   * @param drawData associated draw data passed by the caller
   * @param st current draw state
   */
  function drawClosePath(
    dfuncs: draw_funcs_t,
    drawData: any | null,
    st: draw_state_t
  ): void
  /**
   * Perform a "cubic-to" draw operation.
   * @param dfuncs draw functions
   * @param drawData associated draw data passed by the caller
   * @param st current draw state
   * @param control1X X component of first control point
   * @param control1Y Y component of first control point
   * @param control2X X component of second control point
   * @param control2Y Y component of second control point
   * @param toX X component of target point
   * @param toY Y component of target point
   */
  function drawCubicTo(
    dfuncs: draw_funcs_t,
    drawData: any | null,
    st: draw_state_t,
    control1X: number,
    control1Y: number,
    control2X: number,
    control2Y: number,
    toX: number,
    toY: number
  ): void
  /**
   * Creates a new draw callbacks object.
   * @returns A newly allocated #hb_draw_funcs_t with a reference count of 1. The initial reference count should be released with hb_draw_funcs_destroy when you are done using the #hb_draw_funcs_t. This function never returns `NULL`. If memory cannot be allocated, a special singleton #hb_draw_funcs_t object will be returned.
   */
  function drawFuncsCreate(): draw_funcs_t
  /**
   * Fetches the singleton empty draw-functions structure.
   * @returns The empty draw-functions structure
   */
  function drawFuncsGetEmpty(): draw_funcs_t
  /**
   * Checks whether `dfuncs` is immutable.
   * @param dfuncs draw functions
   * @returns `true` if @dfuncs is immutable, `false` otherwise
   */
  function drawFuncsIsImmutable(dfuncs: draw_funcs_t): bool_t
  /**
   * Makes `dfuncs` object immutable.
   * @param dfuncs draw functions
   */
  function drawFuncsMakeImmutable(dfuncs: draw_funcs_t): void
  /**
   * Sets close-path callback to the draw functions object.
   * @param dfuncs draw functions object
   * @param func close-path callback
   */
  function drawFuncsSetClosePathFunc(
    dfuncs: draw_funcs_t,
    func: draw_close_path_func_t
  ): void
  /**
   * Sets cubic-to callback to the draw functions object.
   * @param dfuncs draw functions
   * @param func cubic-to callback
   */
  function drawFuncsSetCubicToFunc(
    dfuncs: draw_funcs_t,
    func: draw_cubic_to_func_t
  ): void
  /**
   * Sets line-to callback to the draw functions object.
   * @param dfuncs draw functions object
   * @param func line-to callback
   */
  function drawFuncsSetLineToFunc(
    dfuncs: draw_funcs_t,
    func: draw_line_to_func_t
  ): void
  /**
   * Sets move-to callback to the draw functions object.
   * @param dfuncs draw functions object
   * @param func move-to callback
   */
  function drawFuncsSetMoveToFunc(
    dfuncs: draw_funcs_t,
    func: draw_move_to_func_t
  ): void
  /**
   * Sets quadratic-to callback to the draw functions object.
   * @param dfuncs draw functions object
   * @param func quadratic-to callback
   */
  function drawFuncsSetQuadraticToFunc(
    dfuncs: draw_funcs_t,
    func: draw_quadratic_to_func_t
  ): void
  /**
   * Perform a "line-to" draw operation.
   * @param dfuncs draw functions
   * @param drawData associated draw data passed by the caller
   * @param st current draw state
   * @param toX X component of target point
   * @param toY Y component of target point
   */
  function drawLineTo(
    dfuncs: draw_funcs_t,
    drawData: any | null,
    st: draw_state_t,
    toX: number,
    toY: number
  ): void
  /**
   * Perform a "move-to" draw operation.
   * @param dfuncs draw functions
   * @param drawData associated draw data passed by the caller
   * @param st current draw state
   * @param toX X component of target point
   * @param toY Y component of target point
   */
  function drawMoveTo(
    dfuncs: draw_funcs_t,
    drawData: any | null,
    st: draw_state_t,
    toX: number,
    toY: number
  ): void
  /**
   * Perform a "quadratic-to" draw operation.
   * @param dfuncs draw functions
   * @param drawData associated draw data passed by the caller
   * @param st current draw state
   * @param controlX X component of control point
   * @param controlY Y component of control point
   * @param toX X component of target point
   * @param toY Y component of target point
   */
  function drawQuadraticTo(
    dfuncs: draw_funcs_t,
    drawData: any | null,
    st: draw_state_t,
    controlX: number,
    controlY: number,
    toX: number,
    toY: number
  ): void
  /**
   * Add table for `tag` with data provided by `blob` to the face.  `face` must
   * be created using hb_face_builder_create().
   * @param face A face object created with hb_face_builder_create()
   * @param tag The #hb_tag_t of the table to add
   * @param blob The blob containing the table data to add
   */
  function faceBuilderAddTable(face: face_t, tag: tag_t, blob: blob_t): bool_t
  /**
   * Creates a #hb_face_t that can be used with hb_face_builder_add_table().
   * After tables are added to the face, it can be compiled to a binary
   * font file by calling hb_face_reference_blob().
   * @returns New face.
   */
  function faceBuilderCreate(): face_t
  /**
   * Set the ordering of tables for serialization. Any tables not
   * specified in the tags list will be ordered after the tables in
   * tags, ordered by the default sort ordering.
   * @param face A face object created with hb_face_builder_create()
   * @param tags ordered list of table tags terminated by   %HB_TAG_NONE
   */
  function faceBuilderSortTables(face: face_t, tags: tag_t[]): void
  /**
   * Collects the mapping from Unicode characters to nominal glyphs of the `face,`
   * and optionally all of the Unicode characters covered by `face`.
   * @param face A face object
   */
  function faceCollectNominalGlyphMapping(
    face: face_t
  ): [/* mapping */ map_t, /* unicodes */ set_t | null]
  /**
   * Collects all of the Unicode characters covered by `face` and adds
   * them to the #hb_set_t set `out`.
   * @param face A face object
   */
  function faceCollectUnicodes(face: face_t): /* out */ set_t
  /**
   * Collects all Unicode "Variation Selector" characters covered by `face` and adds
   * them to the #hb_set_t set `out`.
   * @param face A face object
   */
  function faceCollectVariationSelectors(face: face_t): /* out */ set_t
  /**
   * Collects all Unicode characters for `variation_selector` covered by `face` and adds
   * them to the #hb_set_t set `out`.
   * @param face A face object
   * @param variationSelector The Variation Selector to query
   */
  function faceCollectVariationUnicodes(
    face: face_t,
    variationSelector: codepoint_t
  ): /* out */ set_t
  /**
   * Fetches the number of faces in a blob.
   * @param blob a blob.
   * @returns Number of faces in @blob
   */
  function faceCount(blob: blob_t): number
  /**
   * Constructs a new face object from the specified blob and
   * a face index into that blob.
   *
   * The face index is used for blobs of file formats such as TTC and
   * DFont that can contain more than one face.  Face indices within
   * such collections are zero-based.
   *
   * <note>Note: If the blob font format is not a collection, `index`
   * is ignored.  Otherwise, only the lower 16-bits of `index` are used.
   * The unmodified `index` can be accessed via hb_face_get_index().</note>
   *
   * <note>Note: The high 16-bits of `index,` if non-zero, are used by
   * hb_font_create() to load named-instances in variable fonts.  See
   * hb_font_create() for details.</note>
   * @param blob #hb_blob_t to work upon
   * @param index The index of the face within `blob`
   * @returns The new face object
   */
  function faceCreate(blob: blob_t, index: number): face_t
  /**
   * Variant of hb_face_create(), built for those cases where it is more
   * convenient to provide data for individual tables instead of the whole font
   * data. With the caveat that hb_face_get_table_tags() does not currently work
   * with faces created this way.
   *
   * Creates a new face object from the specified `user_data` and `reference_table_func,`
   * with the `destroy` callback.
   * @param referenceTableFunc Table-referencing function
   * @returns The new face object
   */
  function faceCreateForTables(
    referenceTableFunc: reference_table_func_t
  ): face_t
  /**
   * Fetches the singleton empty face object.
   * @returns The empty face object
   */
  function faceGetEmpty(): face_t
  /**
   * Fetches the glyph-count value of the specified face object.
   * @param face A face object
   * @returns The glyph-count value of @face
   */
  function faceGetGlyphCount(face: face_t): number
  /**
   * Fetches the face-index corresponding to the given face.
   *
   * <note>Note: face indices within a collection are zero-based.</note>
   * @param face A face object
   * @returns The index of @face.
   */
  function faceGetIndex(face: face_t): number
  /**
   * Fetches a list of all table tags for a face, if possible. The list returned will
   * begin at the offset provided
   * @param face A face object
   * @param startOffset The index of first table tag to retrieve
   * @returns Total number of tables, or zero if it is not possible to list
   */
  function faceGetTableTags(
    face: face_t,
    startOffset: number
  ): [/* returnType */ number, /* tableTags */ tag_t[]]
  /**
   * Fetches the units-per-em (UPEM) value of the specified face object.
   *
   * Typical UPEM values for fonts are 1000, or 2048, but any value
   * in between 16 and 16,384 is allowed for OpenType fonts.
   * @param face A face object
   * @returns The upem value of @face
   */
  function faceGetUpem(face: face_t): number
  /**
   * Tests whether the given face object is immutable.
   * @param face A face object
   * @returns `true` is @face is immutable, `false` otherwise
   */
  function faceIsImmutable(face: face_t): bool_t
  /**
   * Makes the given face object immutable.
   * @param face A face object
   */
  function faceMakeImmutable(face: face_t): void
  /**
   * Fetches a pointer to the binary blob that contains the
   * specified face. Returns an empty blob if referencing face data is not
   * possible.
   * @param face A face object
   * @returns A pointer to the blob for @face
   */
  function faceReferenceBlob(face: face_t): blob_t
  /**
   * Fetches a reference to the specified table within
   * the specified face.
   * @param face A face object
   * @param tag The #hb_tag_t of the table to query
   * @returns A pointer to the @tag table within @face
   */
  function faceReferenceTable(face: face_t, tag: tag_t): blob_t
  /**
   * Sets the glyph count for a face object to the specified value.
   *
   * This API is used in rare circumstances.
   * @param face A face object
   * @param glyphCount The glyph-count value to assign
   */
  function faceSetGlyphCount(face: face_t, glyphCount: number): void
  /**
   * Assigns the specified face-index to `face`. Fails if the
   * face is immutable.
   *
   * <note>Note: changing the index has no effect on the face itself
   * This only changes the value returned by hb_face_get_index().</note>
   * @param face A face object
   * @param index The index to assign
   */
  function faceSetIndex(face: face_t, index: number): void
  /**
   * Sets the units-per-em (upem) for a face object to the specified value.
   *
   * This API is used in rare circumstances.
   * @param face A face object
   * @param upem The units-per-em value to assign
   */
  function faceSetUpem(face: face_t, upem: number): void
  /**
   * Parses a string into a #hb_feature_t.
   *
   * The format for specifying feature strings follows. All valid CSS
   * font-feature-settings values other than 'normal' and the global values are
   * also accepted, though not documented below. CSS string escapes are not
   * supported.
   *
   * The range indices refer to the positions between Unicode characters. The
   * position before the first character is always 0.
   *
   * The format is Python-esque.  Here is how it all works:
   *
   * <informaltable pgwide='1' align='left' frame='none'>
   * <tgroup cols='5'>
   * <thead>
   * <row><entry>Syntax</entry>    <entry>Value</entry> <entry>Start</entry> <entry>End</entry></row>
   * </thead>
   * <tbody>
   * <row><entry>Setting value:</entry></row>
   * <row><entry>kern</entry>      <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
   * <row><entry>+kern</entry>     <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
   * <row><entry>-kern</entry>     <entry>0</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature off</entry></row>
   * <row><entry>kern=0</entry>    <entry>0</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature off</entry></row>
   * <row><entry>kern=1</entry>    <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
   * <row><entry>aalt=2</entry>    <entry>2</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Choose 2nd alternate</entry></row>
   * <row><entry>Setting index:</entry></row>
   * <row><entry>kern[]</entry>    <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
   * <row><entry>kern[:]</entry>   <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
   * <row><entry>kern[5:]</entry>  <entry>1</entry>     <entry>5</entry>      <entry>∞</entry>   <entry>Turn feature on, partial</entry></row>
   * <row><entry>kern[:5]</entry>  <entry>1</entry>     <entry>0</entry>      <entry>5</entry>   <entry>Turn feature on, partial</entry></row>
   * <row><entry>kern[3:5]</entry> <entry>1</entry>     <entry>3</entry>      <entry>5</entry>   <entry>Turn feature on, range</entry></row>
   * <row><entry>kern[3]</entry>   <entry>1</entry>     <entry>3</entry>      <entry>3+1</entry> <entry>Turn feature on, single char</entry></row>
   * <row><entry>Mixing it all:</entry></row>
   * <row><entry>aalt[3:5]=2</entry> <entry>2</entry>   <entry>3</entry>      <entry>5</entry>   <entry>Turn 2nd alternate on for range</entry></row>
   * </tbody>
   * </tgroup>
   * </informaltable>
   * @param str a string to parse
   * @returns `true` if @str is successfully parsed, `false` otherwise
   */
  function featureFromString(
    str: number[]
  ): [/* returnType */ bool_t, /* feature */ feature_t]
  /**
   * Converts a #hb_feature_t into a `NULL`-terminated string in the format
   * understood by hb_feature_from_string(). The client in responsible for
   * allocating big enough size for `buf,` 128 bytes is more than enough.
   * @param feature an #hb_feature_t to convert
   */
  function featureToString(feature: feature_t): /* buf */ string[]
  /**
   * Adds the origin coordinates to an (X,Y) point coordinate, in
   * the specified glyph ID in the specified font.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @param direction The direction of the text segment
   * @param x Input = The original X coordinate     Output = The X coordinate plus the X-coordinate of the origin
   * @param y Input = The original Y coordinate     Output = The Y coordinate plus the Y-coordinate of the origin
   */
  function fontAddGlyphOriginForDirection(
    font: font_t,
    glyph: codepoint_t,
    direction: direction_t,
    x: position_t,
    y: position_t
  ): [/* x */ position_t, /* y */ position_t]
  /**
   * Notifies the `font` that underlying font data has changed.
   * This has the effect of increasing the serial as returned
   * by hb_font_get_serial(), which invalidates internal caches.
   * @param font #hb_font_t to work upon
   */
  function fontChanged(font: font_t): void
  /**
   * Constructs a new font object from the specified face.
   *
   * <note>Note: If `face'`s index value (as passed to hb_face_create()
   * has non-zero top 16-bits, those bits minus one are passed to
   * hb_font_set_var_named_instance(), effectively loading a named-instance
   * of a variable font, instead of the default-instance.  This allows
   * specifying which named-instance to load by default when creating the
   * face.</note>
   * @param face a face.
   * @returns The new font object
   */
  function fontCreate(face: face_t): font_t
  /**
   * Constructs a sub-font font object from the specified `parent` font,
   * replicating the parent's properties.
   * @param parent The parent font object
   * @returns The new sub-font font object
   */
  function fontCreateSubFont(parent: font_t): font_t
  /**
   * Draws the outline that corresponds to a glyph in the specified `font`.
   *
   * The outline is returned by way of calls to the callbacks of the `dfuncs`
   * objects, with `draw_data` passed to them.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID
   * @param dfuncs #hb_draw_funcs_t to draw to
   * @param drawData User data to pass to draw callbacks
   */
  function fontDrawGlyph(
    font: font_t,
    glyph: codepoint_t,
    dfuncs: draw_funcs_t,
    drawData: any | null
  ): void
  /**
   * Creates a new #hb_font_funcs_t structure of font functions.
   * @returns The font-functions structure
   */
  function fontFuncsCreate(): font_funcs_t
  /**
   * Fetches an empty font-functions structure.
   * @returns The font-functions structure
   */
  function fontFuncsGetEmpty(): font_funcs_t
  /**
   * Tests whether a font-functions structure is immutable.
   * @param ffuncs The font-functions structure
   * @returns `true` if @ffuncs is immutable, `false` otherwise
   */
  function fontFuncsIsImmutable(ffuncs: font_funcs_t): bool_t
  /**
   * Makes a font-functions structure immutable.
   * @param ffuncs The font-functions structure
   */
  function fontFuncsMakeImmutable(ffuncs: font_funcs_t): void
  /**
   * Sets the implementation function for #hb_font_draw_glyph_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetDrawGlyphFunc(
    ffuncs: font_funcs_t,
    func: font_draw_glyph_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_font_h_extents_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetFontHExtentsFunc(
    ffuncs: font_funcs_t,
    func: font_get_font_h_extents_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_font_v_extents_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetFontVExtentsFunc(
    ffuncs: font_funcs_t,
    func: font_get_font_v_extents_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_contour_point_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphContourPointFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_contour_point_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_extents_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphExtentsFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_extents_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_from_name_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphFromNameFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_from_name_func_t
  ): void
  /**
   * Deprecated.  Use hb_font_funcs_set_nominal_glyph_func() and
   * hb_font_funcs_set_variation_glyph_func() instead.
   * @param ffuncs The font-functions structure
   * @param func callback function
   */
  function fontFuncsSetGlyphFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_h_advance_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphHAdvanceFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_h_advance_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_h_advances_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphHAdvancesFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_h_advances_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_h_kerning_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphHKerningFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_h_kerning_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_h_origin_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphHOriginFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_h_origin_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_name_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphNameFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_name_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_shape_func_t,
   * which is the same as #hb_font_draw_glyph_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphShapeFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_shape_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_v_advance_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphVAdvanceFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_v_advance_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_v_advances_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphVAdvancesFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_v_advances_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_v_kerning_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphVKerningFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_v_kerning_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_glyph_v_origin_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetGlyphVOriginFunc(
    ffuncs: font_funcs_t,
    func: font_get_glyph_v_origin_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_nominal_glyph_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetNominalGlyphFunc(
    ffuncs: font_funcs_t,
    func: font_get_nominal_glyph_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_nominal_glyphs_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetNominalGlyphsFunc(
    ffuncs: font_funcs_t,
    func: font_get_nominal_glyphs_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_paint_glyph_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetPaintGlyphFunc(
    ffuncs: font_funcs_t,
    func: font_paint_glyph_func_t
  ): void
  /**
   * Sets the implementation function for #hb_font_get_variation_glyph_func_t.
   * @param ffuncs A font-function structure
   * @param func The callback function to assign
   */
  function fontFuncsSetVariationGlyphFunc(
    ffuncs: font_funcs_t,
    func: font_get_variation_glyph_func_t
  ): void
  /**
   * Fetches the empty font object.
   * @returns The empty font object
   */
  function fontGetEmpty(): font_t
  /**
   * Fetches the extents for a font in a text segment of the
   * specified direction.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param direction The direction of the text segment
   */
  function fontGetExtentsForDirection(
    font: font_t,
    direction: direction_t
  ): /* extents */ font_extents_t
  /**
   * Fetches the face associated with the specified font object.
   * @param font #hb_font_t to work upon
   * @returns The #hb_face_t value
   */
  function fontGetFace(font: font_t): face_t
  /**
   * Fetches the glyph ID for a Unicode code point in the specified
   * font, with an optional variation selector.
   *
   * If `variation_selector` is 0, calls hb_font_get_nominal_glyph();
   * otherwise calls hb_font_get_variation_glyph().
   * @param font #hb_font_t to work upon
   * @param unicode The Unicode code point to query
   * @param variationSelector A variation-selector code point
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyph(
    font: font_t,
    unicode: codepoint_t,
    variationSelector: codepoint_t
  ): [/* returnType */ bool_t, /* glyph */ codepoint_t]
  /**
   * Fetches the advance for a glyph ID from the specified font,
   * in a text segment of the specified direction.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @param direction The direction of the text segment
   */
  function fontGetGlyphAdvanceForDirection(
    font: font_t,
    glyph: codepoint_t,
    direction: direction_t
  ): [/* x */ position_t, /* y */ position_t]
  /**
   * Fetches the advances for a sequence of glyph IDs in the specified
   * font, in a text segment of the specified direction.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param direction The direction of the text segment
   * @param count The number of glyph IDs in the sequence queried
   * @param firstGlyph The first glyph ID to query
   * @param glyphStride The stride between successive glyph IDs
   */
  function fontGetGlyphAdvancesForDirection(
    font: font_t,
    direction: direction_t,
    count: number,
    firstGlyph: codepoint_t,
    glyphStride: number
  ): [/* firstAdvance */ position_t, /* advanceStride */ number]
  /**
   * Fetches the (x,y) coordinates of a specified contour-point index
   * in the specified glyph, within the specified font.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @param pointIndex The contour-point index to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyphContourPoint(
    font: font_t,
    glyph: codepoint_t,
    pointIndex: number
  ): [/* returnType */ bool_t, /* x */ position_t, /* y */ position_t]
  /**
   * Fetches the (X,Y) coordinates of a specified contour-point index
   * in the specified glyph ID in the specified font, with respect
   * to the origin in a text segment in the specified direction.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @param pointIndex The contour-point index to query
   * @param direction The direction of the text segment
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyphContourPointForOrigin(
    font: font_t,
    glyph: codepoint_t,
    pointIndex: number,
    direction: direction_t
  ): [/* returnType */ bool_t, /* x */ position_t, /* y */ position_t]
  /**
   * Fetches the #hb_glyph_extents_t data for a glyph ID
   * in the specified font.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyphExtents(
    font: font_t,
    glyph: codepoint_t
  ): [/* returnType */ bool_t, /* extents */ glyph_extents_t]
  /**
   * Fetches the #hb_glyph_extents_t data for a glyph ID
   * in the specified font, with respect to the origin in
   * a text segment in the specified direction.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @param direction The direction of the text segment
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyphExtentsForOrigin(
    font: font_t,
    glyph: codepoint_t,
    direction: direction_t
  ): [/* returnType */ bool_t, /* extents */ glyph_extents_t]
  /**
   * Fetches the glyph ID that corresponds to a name string in the specified `font`.
   *
   * <note>Note: `len` == -1 means the name string is null-terminated.</note>
   * @param font #hb_font_t to work upon
   * @param name The name string to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyphFromName(
    font: font_t,
    name: string[]
  ): [/* returnType */ bool_t, /* glyph */ codepoint_t]
  /**
   * Fetches the advance for a glyph ID in the specified font,
   * for horizontal text segments.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @returns The advance of @glyph within @font
   */
  function fontGetGlyphHAdvance(font: font_t, glyph: codepoint_t): position_t
  /**
   * Fetches the advances for a sequence of glyph IDs in the specified
   * font, for horizontal text segments.
   * @param font #hb_font_t to work upon
   * @param count The number of glyph IDs in the sequence queried
   * @param firstGlyph The first glyph ID to query
   * @param glyphStride The stride between successive glyph IDs
   * @param advanceStride The stride between successive advances
   */
  function fontGetGlyphHAdvances(
    font: font_t,
    count: number,
    firstGlyph: codepoint_t,
    glyphStride: number,
    advanceStride: number
  ): /* firstAdvance */ position_t
  /**
   * Fetches the kerning-adjustment value for a glyph-pair in
   * the specified font, for horizontal text segments.
   *
   * <note>It handles legacy kerning only (as returned by the corresponding
   * #hb_font_funcs_t function).</note>
   * @param font #hb_font_t to work upon
   * @param leftGlyph The glyph ID of the left glyph in the glyph pair
   * @param rightGlyph The glyph ID of the right glyph in the glyph pair
   * @returns The kerning adjustment value
   */
  function fontGetGlyphHKerning(
    font: font_t,
    leftGlyph: codepoint_t,
    rightGlyph: codepoint_t
  ): position_t
  /**
   * Fetches the (X,Y) coordinates of the origin for a glyph ID
   * in the specified font, for horizontal text segments.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyphHOrigin(
    font: font_t,
    glyph: codepoint_t
  ): [/* returnType */ bool_t, /* x */ position_t, /* y */ position_t]
  /**
   * Fetches the kerning-adjustment value for a glyph-pair in the specified font.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param firstGlyph The glyph ID of the first glyph in the glyph pair to query
   * @param secondGlyph The glyph ID of the second glyph in the glyph pair to query
   * @param direction The direction of the text segment
   */
  function fontGetGlyphKerningForDirection(
    font: font_t,
    firstGlyph: codepoint_t,
    secondGlyph: codepoint_t,
    direction: direction_t
  ): [/* x */ position_t, /* y */ position_t]
  /**
   * Fetches the glyph-name string for a glyph ID in the specified `font`.
   *
   * According to the OpenType specification, glyph names are limited to 63
   * characters and can only contain (a subset of) ASCII.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyphName(
    font: font_t,
    glyph: codepoint_t
  ): [/* returnType */ bool_t, /* name */ string[]]
  /**
   * Fetches the (X,Y) coordinates of the origin for a glyph in
   * the specified font.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @param direction The direction of the text segment
   */
  function fontGetGlyphOriginForDirection(
    font: font_t,
    glyph: codepoint_t,
    direction: direction_t
  ): [/* x */ position_t, /* y */ position_t]
  /**
   * Fetches the glyph shape that corresponds to a glyph in the specified `font`.
   * The shape is returned by way of calls to the callbacks of the `dfuncs`
   * objects, with `draw_data` passed to them.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID
   * @param dfuncs #hb_draw_funcs_t to draw to
   * @param drawData User data to pass to draw callbacks
   */
  function fontGetGlyphShape(
    font: font_t,
    glyph: codepoint_t,
    dfuncs: draw_funcs_t,
    drawData: any | null
  ): void
  /**
   * Fetches the advance for a glyph ID in the specified font,
   * for vertical text segments.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @returns The advance of @glyph within @font
   */
  function fontGetGlyphVAdvance(font: font_t, glyph: codepoint_t): position_t
  /**
   * Fetches the advances for a sequence of glyph IDs in the specified
   * font, for vertical text segments.
   * @param font #hb_font_t to work upon
   * @param count The number of glyph IDs in the sequence queried
   * @param firstGlyph The first glyph ID to query
   * @param glyphStride The stride between successive glyph IDs
   */
  function fontGetGlyphVAdvances(
    font: font_t,
    count: number,
    firstGlyph: codepoint_t,
    glyphStride: number
  ): [/* firstAdvance */ position_t, /* advanceStride */ number]
  /**
   * Fetches the kerning-adjustment value for a glyph-pair in
   * the specified font, for vertical text segments.
   *
   * <note>It handles legacy kerning only (as returned by the corresponding
   * #hb_font_funcs_t function).</note>
   * @param font #hb_font_t to work upon
   * @param topGlyph The glyph ID of the top glyph in the glyph pair
   * @param bottomGlyph The glyph ID of the bottom glyph in the glyph pair
   * @returns The kerning adjustment value
   */
  function fontGetGlyphVKerning(
    font: font_t,
    topGlyph: codepoint_t,
    bottomGlyph: codepoint_t
  ): position_t
  /**
   * Fetches the (X,Y) coordinates of the origin for a glyph ID
   * in the specified font, for vertical text segments.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetGlyphVOrigin(
    font: font_t,
    glyph: codepoint_t
  ): [/* returnType */ bool_t, /* x */ position_t, /* y */ position_t]
  /**
   * Fetches the extents for a specified font, for horizontal
   * text segments.
   * @param font #hb_font_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetHExtents(
    font: font_t
  ): [/* returnType */ bool_t, /* extents */ font_extents_t]
  /**
   * Fetches the nominal glyph ID for a Unicode code point in the
   * specified font.
   *
   * This version of the function should not be used to fetch glyph IDs
   * for code points modified by variation selectors. For variation-selector
   * support, user hb_font_get_variation_glyph() or use hb_font_get_glyph().
   * @param font #hb_font_t to work upon
   * @param unicode The Unicode code point to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetNominalGlyph(
    font: font_t,
    unicode: codepoint_t
  ): [/* returnType */ bool_t, /* glyph */ codepoint_t]
  /**
   * Fetches the nominal glyph IDs for a sequence of Unicode code points. Glyph
   * IDs must be returned in a #hb_codepoint_t output parameter. Stops at the
   * first unsupported glyph ID.
   * @param font #hb_font_t to work upon
   * @param count number of code points to query
   * @param firstUnicode The first Unicode code point to query
   * @param unicodeStride The stride between successive code points
   * @param glyphStride The stride between successive glyph IDs
   * @returns the number of code points processed
   */
  function fontGetNominalGlyphs(
    font: font_t,
    count: number,
    firstUnicode: codepoint_t,
    unicodeStride: number,
    glyphStride: number
  ): [/* returnType */ number, /* firstGlyph */ codepoint_t]
  /**
   * Fetches the parent font of `font`.
   * @param font #hb_font_t to work upon
   * @returns The parent font object
   */
  function fontGetParent(font: font_t): font_t
  /**
   * Fetches the horizontal and vertical points-per-em (ppem) of a font.
   * @param font #hb_font_t to work upon
   */
  function fontGetPpem(font: font_t): [/* xPpem */ number, /* yPpem */ number]
  /**
   * Fetches the "point size" of a font. Used in CoreText to
   * implement optical sizing.
   * @param font #hb_font_t to work upon
   * @returns Point size.  A value of zero means "not set."
   */
  function fontGetPtem(font: font_t): number
  /**
   * Fetches the horizontal and vertical scale of a font.
   * @param font #hb_font_t to work upon
   */
  function fontGetScale(
    font: font_t
  ): [/* xScale */ number, /* yScale */ number]
  /**
   * Returns the internal serial number of the font. The serial
   * number is increased every time a setting on the font is
   * changed, using a setter function.
   * @param font #hb_font_t to work upon
   * @returns serial number
   */
  function fontGetSerial(font: font_t): number
  /**
   * Fetches the "synthetic boldness" parameters of a font.
   * @param font #hb_font_t to work upon
   */
  function fontGetSyntheticBold(
    font: font_t
  ): [/* xEmbolden */ number, /* yEmbolden */ number, /* inPlace */ bool_t]
  /**
   * Fetches the "synthetic slant" of a font.
   * @param font #hb_font_t to work upon
   * @returns Synthetic slant.  By default is zero.
   */
  function fontGetSyntheticSlant(font: font_t): number
  /**
   * Fetches the extents for a specified font, for vertical
   * text segments.
   * @param font #hb_font_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetVExtents(
    font: font_t
  ): [/* returnType */ bool_t, /* extents */ font_extents_t]
  /**
   * Fetches the list of variation coordinates (in design-space units) currently
   * set on a font.
   *
   * Note that this returned array may only contain values for some
   * (or none) of the axes; omitted axes effectively have their default
   * values.
   *
   * Return value is valid as long as variation coordinates of the font
   * are not modified.
   * @param font #hb_font_t to work upon
   * @returns coordinates array
   */
  function fontGetVarCoordsDesign(
    font: font_t
  ): [/* returnType */ number, /* length */ number]
  /**
   * Fetches the list of normalized variation coordinates currently
   * set on a font.
   *
   * Note that this returned array may only contain values for some
   * (or none) of the axes; omitted axes effectively have zero values.
   *
   * Return value is valid as long as variation coordinates of the font
   * are not modified.
   * @param font #hb_font_t to work upon
   * @returns coordinates array
   */
  function fontGetVarCoordsNormalized(
    font: font_t
  ): [/* returnType */ number, /* length */ number]
  /**
   * Returns the currently-set named-instance index of the font.
   * @param font a font.
   * @returns Named-instance index or %HB_FONT_NO_VAR_NAMED_INSTANCE.
   */
  function fontGetVarNamedInstance(font: font_t): number
  /**
   * Fetches the glyph ID for a Unicode code point when followed by
   * by the specified variation-selector code point, in the specified
   * font.
   * @param font #hb_font_t to work upon
   * @param unicode The Unicode code point to query
   * @param variationSelector The  variation-selector code point to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGetVariationGlyph(
    font: font_t,
    unicode: codepoint_t,
    variationSelector: codepoint_t
  ): [/* returnType */ bool_t, /* glyph */ codepoint_t]
  /**
   * Fetches the glyph ID from `font` that matches the specified string.
   * Strings of the format `gidDDD` or `uniUUUU` are parsed automatically.
   *
   * <note>Note: `len` == -1 means the string is null-terminated.</note>
   * @param font #hb_font_t to work upon
   * @param s string to query
   * @returns `true` if data found, `false` otherwise
   */
  function fontGlyphFromString(
    font: font_t,
    s: number[]
  ): [/* returnType */ bool_t, /* glyph */ codepoint_t]
  /**
   * Fetches the name of the specified glyph ID in `font` and returns
   * it in string `s`.
   *
   * If the glyph ID has no name in `font,` a string of the form `gidDDD` is
   * generated, with `DDD` being the glyph ID.
   *
   * According to the OpenType specification, glyph names are limited to 63
   * characters and can only contain (a subset of) ASCII.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   */
  function fontGlyphToString(font: font_t, glyph: codepoint_t): /* s */ string[]
  /**
   * Tests whether a font object is immutable.
   * @param font #hb_font_t to work upon
   * @returns `true` if @font is immutable, `false` otherwise
   */
  function fontIsImmutable(font: font_t): bool_t
  /**
   * Makes `font` immutable.
   * @param font #hb_font_t to work upon
   */
  function fontMakeImmutable(font: font_t): void
  /**
   * Paints the glyph.
   *
   * The painting instructions are returned by way of calls to
   * the callbacks of the `funcs` object, with `paint_data` passed
   * to them.
   *
   * If the font has color palettes (see hb_ot_color_has_palettes()),
   * then `palette_index` selects the palette to use. If the font only
   * has one palette, this will be 0.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID
   * @param pfuncs #hb_paint_funcs_t to paint with
   * @param paintData User data to pass to paint callbacks
   * @param paletteIndex The index of the font's color palette to use
   * @param foreground The foreground color, unpremultipled
   */
  function fontPaintGlyph(
    font: font_t,
    glyph: codepoint_t,
    pfuncs: paint_funcs_t,
    paintData: any | null,
    paletteIndex: number,
    foreground: color_t
  ): void
  /**
   * Sets `face` as the font-face value of `font`.
   * @param font #hb_font_t to work upon
   * @param face The #hb_face_t to assign
   */
  function fontSetFace(font: font_t, face: face_t): void
  /**
   * Replaces the font-functions structure attached to a font, updating
   * the font's user-data with `font-data` and the `destroy` callback.
   * @param font #hb_font_t to work upon
   * @param klass The font-functions structure.
   */
  function fontSetFuncs(font: font_t, klass: font_funcs_t): void
  /**
   * Replaces the user data attached to a font, updating the font's
   * `destroy` callback.
   * @param font #hb_font_t to work upon
   * @param fontData Data to attach to `font`
   */
  function fontSetFuncsData(font: font_t, fontData: any | null): void
  /**
   * Sets the parent font of `font`.
   * @param font #hb_font_t to work upon
   * @param parent The parent font object to assign
   */
  function fontSetParent(font: font_t, parent: font_t): void
  /**
   * Sets the horizontal and vertical pixels-per-em (PPEM) of a font.
   *
   * These values are used for pixel-size-specific adjustment to
   * shaping and draw results, though for the most part they are
   * unused and can be left unset.
   * @param font #hb_font_t to work upon
   * @param xPpem Horizontal ppem value to assign
   * @param yPpem Vertical ppem value to assign
   */
  function fontSetPpem(font: font_t, xPpem: number, yPpem: number): void
  /**
   * Sets the "point size" of a font. Set to zero to unset.
   * Used in CoreText to implement optical sizing.
   *
   * <note>Note: There are 72 points in an inch.</note>
   * @param font #hb_font_t to work upon
   * @param ptem font size in points.
   */
  function fontSetPtem(font: font_t, ptem: number): void
  /**
   * Sets the horizontal and vertical scale of a font.
   *
   * The font scale is a number related to, but not the same as,
   * font size. Typically the client establishes a scale factor
   * to be used between the two. For example, 64, or 256, which
   * would be the fractional-precision part of the font scale.
   * This is necessary because #hb_position_t values are integer
   * types and you need to leave room for fractional values
   * in there.
   *
   * For example, to set the font size to 20, with 64
   * levels of fractional precision you would call
   * `hb_font_set_scale(font, 20 * 64, 20 * 64)`.
   *
   * In the example above, even what font size 20 means is up to
   * you. It might be 20 pixels, or 20 points, or 20 millimeters.
   * HarfBuzz does not care about that.  You can set the point
   * size of the font using hb_font_set_ptem(), and the pixel
   * size using hb_font_set_ppem().
   *
   * The choice of scale is yours but needs to be consistent between
   * what you set here, and what you expect out of #hb_position_t
   * as well has draw / paint API output values.
   *
   * Fonts default to a scale equal to the UPEM value of their face.
   * A font with this setting is sometimes called an "unscaled" font.
   * @param font #hb_font_t to work upon
   * @param xScale Horizontal scale value to assign
   * @param yScale Vertical scale value to assign
   */
  function fontSetScale(font: font_t, xScale: number, yScale: number): void
  /**
   * Sets the "synthetic boldness" of a font.
   *
   * Positive values for `x_embolden` / `y_embolden` make a font
   * bolder, negative values thinner. Typical values are in the
   * 0.01 to 0.05 range. The default value is zero.
   *
   * Synthetic boldness is applied by offsetting the contour
   * points of the glyph shape.
   *
   * Synthetic boldness is applied when rendering a glyph via
   * hb_font_draw_glyph().
   *
   * If `in_place` is `false`, then glyph advance-widths are also
   * adjusted, otherwise they are not.  The in-place mode is
   * useful for simulating [font grading](https://fonts.google.com/knowledge/glossary/grade).
   * @param font #hb_font_t to work upon
   * @param xEmbolden the amount to embolden horizontally
   * @param yEmbolden the amount to embolden vertically
   * @param inPlace whether to embolden glyphs in-place
   */
  function fontSetSyntheticBold(
    font: font_t,
    xEmbolden: number,
    yEmbolden: number,
    inPlace: bool_t
  ): void
  /**
   * Sets the "synthetic slant" of a font.  By default is zero.
   * Synthetic slant is the graphical skew applied to the font
   * at rendering time.
   *
   * HarfBuzz needs to know this value to adjust shaping results,
   * metrics, and style values to match the slanted rendering.
   *
   * <note>Note: The glyph shape fetched via the hb_font_draw_glyph()
   * function is slanted to reflect this value as well.</note>
   *
   * <note>Note: The slant value is a ratio.  For example, a
   * 20% slant would be represented as a 0.2 value.</note>
   * @param font #hb_font_t to work upon
   * @param slant synthetic slant value.
   */
  function fontSetSyntheticSlant(font: font_t, slant: number): void
  /**
   * Applies a list of variation coordinates (in design-space units)
   * to a font.
   *
   * Note that this overrides all existing variations set on `font`.
   * Axes not included in `coords` will be effectively set to their
   * default values.
   * @param font #hb_font_t to work upon
   * @param coords Array of variation coordinates to apply
   */
  function fontSetVarCoordsDesign(font: font_t, coords: number[]): void
  /**
   * Applies a list of variation coordinates (in normalized units)
   * to a font.
   *
   * Note that this overrides all existing variations set on `font`.
   * Axes not included in `coords` will be effectively set to their
   * default values.
   *
   * <note>Note: Coordinates should be normalized to 2.14.</note>
   * @param font #hb_font_t to work upon
   * @param coords Array of variation coordinates to apply
   */
  function fontSetVarCoordsNormalized(font: font_t, coords: number[]): void
  /**
   * Sets design coords of a font from a named-instance index.
   * @param font a font.
   * @param instanceIndex named instance index.
   */
  function fontSetVarNamedInstance(font: font_t, instanceIndex: number): void
  /**
   * Change the value of one variation axis on the font.
   *
   * Note: This function is expensive to be called repeatedly.
   *   If you want to set multiple variation axes at the same time,
   *   use hb_font_set_variations() instead.
   * @param font #hb_font_t to work upon
   * @param tag The #hb_tag_t tag of the variation-axis name
   * @param value The value of the variation axis
   */
  function fontSetVariation(font: font_t, tag: tag_t, value: number): void
  /**
   * Applies a list of font-variation settings to a font.
   *
   * Note that this overrides all existing variations set on `font`.
   * Axes not included in `variations` will be effectively set to their
   * default values.
   * @param font #hb_font_t to work upon
   * @param variations Array of variation settings to apply
   */
  function fontSetVariations(font: font_t, variations: variation_t[]): void
  /**
   * Subtracts the origin coordinates from an (X,Y) point coordinate,
   * in the specified glyph ID in the specified font.
   *
   * Calls the appropriate direction-specific variant (horizontal
   * or vertical) depending on the value of `direction`.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph ID to query
   * @param direction The direction of the text segment
   * @param x Input = The original X coordinate     Output = The X coordinate minus the X-coordinate of the origin
   * @param y Input = The original Y coordinate     Output = The Y coordinate minus the Y-coordinate of the origin
   */
  function fontSubtractGlyphOriginForDirection(
    font: font_t,
    glyph: codepoint_t,
    direction: direction_t,
    x: position_t,
    y: position_t
  ): [/* x */ position_t, /* y */ position_t]
  /**
   * Creates an #hb_face_t face object from the specified FT_Face.
   *
   * Note that this is using the FT_Face object just to get at the underlying
   * font data, and fonts created from the returned #hb_face_t will use the native
   * HarfBuzz font implementation, unless you call hb_ft_font_set_funcs() on them.
   *
   * This variant of the function does not provide any life-cycle management.
   *
   * Most client programs should use hb_ft_face_create_referenced()
   * (or, perhaps, hb_ft_face_create_cached()) instead.
   *
   * If you know you have valid reasons not to use hb_ft_face_create_referenced(),
   * then it is the client program's responsibility to destroy `ft_face`
   * after the #hb_face_t face object has been destroyed.
   * @param ftFace FT_Face to work upon
   * @returns the new #hb_face_t face object
   */
  function ftFaceCreate(ftFace: freetype2.Face): face_t
  /**
   * Creates an #hb_face_t face object from the specified FT_Face.
   *
   * Note that this is using the FT_Face object just to get at the underlying
   * font data, and fonts created from the returned #hb_face_t will use the native
   * HarfBuzz font implementation, unless you call hb_ft_font_set_funcs() on them.
   *
   * This variant of the function caches the newly created #hb_face_t
   * face object, using the `generic` pointer of `ft_face`. Subsequent function
   * calls that are passed the same `ft_face` parameter will have the same
   * #hb_face_t returned to them, and that #hb_face_t will be correctly
   * reference counted.
   *
   * However, client programs are still responsible for destroying
   * `ft_face` after the last #hb_face_t face object has been destroyed.
   * @param ftFace FT_Face to work upon
   * @returns the new #hb_face_t face object
   */
  function ftFaceCreateCached(ftFace: freetype2.Face): face_t
  /**
   * Creates an #hb_face_t face object from the specified FT_Face.
   *
   * Note that this is using the FT_Face object just to get at the underlying
   * font data, and fonts created from the returned #hb_face_t will use the native
   * HarfBuzz font implementation, unless you call hb_ft_font_set_funcs() on them.
   *
   * This is the preferred variant of the hb_ft_face_create*
   * function family, because it calls FT_Reference_Face() on `ft_face,`
   * ensuring that `ft_face` remains alive as long as the resulting
   * #hb_face_t face object remains alive. Also calls FT_Done_Face()
   * when the #hb_face_t face object is destroyed.
   *
   * Use this version unless you know you have good reasons not to.
   * @param ftFace FT_Face to work upon
   * @returns the new #hb_face_t face object
   */
  function ftFaceCreateReferenced(ftFace: freetype2.Face): face_t
  /**
   * Refreshes the state of `font` when the underlying FT_Face has changed.
   * This function should be called after changing the size or
   * variation-axis settings on the FT_Face.
   * @param font #hb_font_t to work upon
   */
  function ftFontChanged(font: font_t): void
  /**
   * Creates an #hb_font_t font object from the specified FT_Face.
   *
   * <note>Note: You must set the face size on `ft_face` before calling
   * hb_ft_font_create() on it. HarfBuzz assumes size is always set and will
   * access `size` member of FT_Face unconditionally.</note>
   *
   * This variant of the function does not provide any life-cycle management.
   *
   * Most client programs should use hb_ft_font_create_referenced()
   * instead.
   *
   * If you know you have valid reasons not to use hb_ft_font_create_referenced(),
   * then it is the client program's responsibility to destroy `ft_face`
   * after the #hb_font_t font object has been destroyed.
   *
   * HarfBuzz will use the `destroy` callback on the #hb_font_t font object
   * if it is supplied when you use this function. However, even if `destroy`
   * is provided, it is the client program's responsibility to destroy `ft_face,`
   * and it is the client program's responsibility to ensure that `ft_face` is
   * destroyed only after the #hb_font_t font object has been destroyed.
   * @param ftFace FT_Face to work upon
   * @returns the new #hb_font_t font object
   */
  function ftFontCreate(ftFace: freetype2.Face): font_t
  /**
   * Creates an #hb_font_t font object from the specified FT_Face.
   *
   * <note>Note: You must set the face size on `ft_face` before calling
   * hb_ft_font_create_referenced() on it. HarfBuzz assumes size is always set
   * and will access `size` member of FT_Face unconditionally.</note>
   *
   * This is the preferred variant of the hb_ft_font_create*
   * function family, because it calls FT_Reference_Face() on `ft_face,`
   * ensuring that `ft_face` remains alive as long as the resulting
   * #hb_font_t font object remains alive.
   *
   * Use this version unless you know you have good reasons not to.
   * @param ftFace FT_Face to work upon
   * @returns the new #hb_font_t font object
   */
  function ftFontCreateReferenced(ftFace: freetype2.Face): font_t
  /**
   * Fetches the FT_Load_Glyph load flags of the specified #hb_font_t.
   *
   * For more information, see
   * <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_load_xxx>
   *
   * This function works with #hb_font_t objects created by
   * hb_ft_font_create() or hb_ft_font_create_referenced().
   * @param font #hb_font_t to work upon
   * @returns FT_Load_Glyph flags found, or 0
   */
  function ftFontGetLoadFlags(font: font_t): number
  /**
   * Configures the font-functions structure of the specified
   * #hb_font_t font object to use FreeType font functions.
   *
   * In particular, you can use this function to configure an
   * existing #hb_face_t face object for use with FreeType font
   * functions even if that #hb_face_t face object was initially
   * created with hb_face_create(), and therefore was not
   * initially configured to use FreeType font functions.
   *
   * An #hb_font_t object created with hb_ft_font_create()
   * is preconfigured for FreeType font functions and does not
   * require this function to be used.
   *
   * Note that if you modify the underlying #hb_font_t after
   * calling this function, you need to call hb_ft_hb_font_changed()
   * to update the underlying FT_Face.
   *
   * <note>Note: Internally, this function creates an FT_Face.
   * </note>
   * @param font #hb_font_t to work upon
   */
  function ftFontSetFuncs(font: font_t): void
  /**
   * Sets the FT_Load_Glyph load flags for the specified #hb_font_t.
   *
   * For more information, see
   * <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_load_xxx>
   *
   * This function works with #hb_font_t objects created by
   * hb_ft_font_create() or hb_ft_font_create_referenced().
   * @param font #hb_font_t to work upon
   * @param loadFlags The FreeType load flags to set
   */
  function ftFontSetLoadFlags(font: font_t, loadFlags: number): void
  /**
   * Refreshes the state of the underlying FT_Face of `font` when the hb_font_t
   * `font` has changed.
   * This function should be called after changing the size or
   * variation-axis settings on the `font`.
   * This call is fast if nothing has changed on `font`.
   * @param font #hb_font_t to work upon
   * @returns true if changed, false otherwise
   */
  function ftHbFontChanged(font: font_t): bool_t
  /**
   * Creates an #hb_blob_t blob from the specified
   * GBytes data structure.
   * @param gbytes the GBytes structure to work upon
   * @returns the new #hb_blob_t blob object
   */
  function glibBlobCreate(gbytes: any): blob_t
  /**
   * Fetches a Unicode-functions structure that is populated
   * with the appropriate GLib function for each method.
   * @returns a pointer to the #hb_unicode_funcs_t Unicode-functions structure
   */
  function glibGetUnicodeFuncs(): unicode_funcs_t
  /**
   * Fetches the GUnicodeScript identifier that corresponds to the
   * specified #hb_script_t script.
   * @param script The #hb_script_t to query
   * @returns the GUnicodeScript identifier found
   */
  function glibScriptFromScript(script: script_t): GLib.UnicodeScript
  /**
   * Fetches the #hb_script_t script that corresponds to the
   * specified GUnicodeScript identifier.
   * @param script The GUnicodeScript identifier to query
   * @returns the #hb_script_t script found
   */
  function glibScriptToScript(script: GLib.UnicodeScript): script_t
  /**
   * Returns glyph flags encoded within a #hb_glyph_info_t.
   * @param info a #hb_glyph_info_t
   * @returns The #hb_glyph_flags_t encoded within @info
   */
  function glyphInfoGetGlyphFlags(info: glyph_info_t): glyph_flags_t
  /**
   * Converts `str` representing a BCP 47 language tag to the corresponding
   * #hb_language_t.
   * @param str a string representing       a BCP 47 language tag
   * @returns The #hb_language_t corresponding to the BCP 47 language tag.
   */
  function languageFromString(str: number[]): language_t
  /**
   * Fetch the default language from current locale.
   *
   * <note>Note that the first time this function is called, it calls
   * "setlocale (LC_CTYPE, nullptr)" to fetch current locale.  The underlying
   * setlocale function is, in many implementations, NOT threadsafe.  To avoid
   * problems, call this function once before multiple threads can call it.
   * This function is only used from hb_buffer_guess_segment_properties() by
   * HarfBuzz itself.</note>
   * @returns The default language of the locale as an #hb_language_t
   */
  function languageGetDefault(): language_t
  /**
   * Check whether a second language tag is the same or a more
   * specific version of the provided language tag.  For example,
   * "fa_IR.utf8" is a more specific tag for "fa" or for "fa_IR".
   * @param language The #hb_language_t to work on
   * @param specific Another #hb_language_t
   * @returns `true` if languages match, `false` otherwise.
   */
  function languageMatches(language: language_t, specific: language_t): bool_t
  /**
   * Converts an #hb_language_t to a string.
   * @param language The #hb_language_t to convert
   * @returns A `NULL`-terminated string representing the @language. Must not be freed by the caller.
   */
  function languageToString(language: language_t): string
  /**
   * Tests whether memory allocation for a set was successful.
   * @param map A map
   * @returns `true` if allocation succeeded, `false` otherwise
   */
  function mapAllocationSuccessful(map: map_t): bool_t
  /**
   * Clears out the contents of `map`.
   * @param map A map
   */
  function mapClear(map: map_t): void
  /**
   * Allocate a copy of `map`.
   * @param map A map
   * @returns Newly-allocated map.
   */
  function mapCopy(map: map_t): map_t
  /**
   * Creates a new, initially empty map.
   * @returns The new #hb_map_t
   */
  function mapCreate(): map_t
  /**
   * Removes `key` and its stored value from `map`.
   * @param map A map
   * @param key The key to delete
   */
  function mapDel(map: map_t, key: codepoint_t): void
  /**
   * Fetches the value stored for `key` in `map`.
   * @param map A map
   * @param key The key to query
   */
  function mapGet(map: map_t, key: codepoint_t): codepoint_t
  /**
   * Fetches the singleton empty #hb_map_t.
   * @returns The empty #hb_map_t
   */
  function mapGetEmpty(): map_t
  /**
   * Returns the number of key-value pairs in the map.
   * @param map A map
   * @returns The population of @map
   */
  function mapGetPopulation(map: map_t): number
  /**
   * Tests whether `key` is an element of `map`.
   * @param map A map
   * @param key The key to query
   * @returns `true` if @key is found in @map, `false` otherwise
   */
  function mapHas(map: map_t, key: codepoint_t): bool_t
  /**
   * Creates a hash representing `map`.
   * @param map A map
   * @returns A hash of @map.
   */
  function mapHash(map: map_t): number
  /**
   * Tests whether `map` is empty (contains no elements).
   * @param map A map
   * @returns `true` if @map is empty
   */
  function mapIsEmpty(map: map_t): bool_t
  /**
   * Tests whether `map` and `other` are equal (contain the same
   * elements).
   * @param map A map
   * @param other Another map
   * @returns `true` if the two maps are equal, `false` otherwise.
   */
  function mapIsEqual(map: map_t, other: map_t): bool_t
  /**
   * Add the keys of `map` to `keys`.
   * @param map A map
   * @param keys A set
   */
  function mapKeys(map: map_t, keys: set_t): void
  /**
   * Fetches the next key/value pair in `map`.
   *
   * Set `idx` to -1 to get started.
   *
   * If the map is modified during iteration, the behavior is undefined.
   *
   * The order in which the key/values are returned is undefined.
   * @param map A map
   * @param idx Iterator internal state
   * @returns `true` if there was a next value, `false` otherwise
   */
  function mapNext(
    map: map_t,
    idx: number
  ): [
    /* returnType */ bool_t,
    /* idx */ number,
    /* key */ codepoint_t,
    /* value */ codepoint_t,
  ]
  /**
   * Stores `key:``value` in the map.
   * @param map A map
   * @param key The key to store in the map
   * @param value The value to store for `key`
   */
  function mapSet(map: map_t, key: codepoint_t, value: codepoint_t): void
  /**
   * Add the contents of `other` to `map`.
   * @param map A map
   * @param other Another map
   */
  function mapUpdate(map: map_t, other: map_t): void
  /**
   * Add the values of `map` to `values`.
   * @param map A map
   * @param values A set
   */
  function mapValues(map: map_t, values: set_t): void
  /**
   * Fetches a list of all color layers for the specified glyph index in the specified
   * face. The list returned will begin at the offset provided.
   * @param face #hb_face_t to work upon
   * @param glyph The glyph index to query
   * @param startOffset offset of the first layer to retrieve
   * @returns Total number of layers available for the glyph index queried
   */
  function otColorGlyphGetLayers(
    face: face_t,
    glyph: codepoint_t,
    startOffset: number
  ): [/* returnType */ number, /* layers */ ot_color_layer_t[] | null]
  /**
   * Tests where a face includes COLRv1 paint
   * data for `glyph`.
   * @param face #hb_face_t to work upon
   * @param glyph The glyph index to query
   * @returns `true` if data found, `false` otherwise
   */
  function otColorGlyphHasPaint(face: face_t, glyph: codepoint_t): bool_t
  /**
   * Fetches the PNG image for a glyph. This function takes a font object, not a face object,
   * as input. To get an optimally sized PNG blob, the PPEM values must be set on the `font`
   * object. If PPEM is unset, the blob returned will be the largest PNG available.
   *
   * If the glyph has no PNG image, the singleton empty blob is returned.
   * @param font #hb_font_t to work upon
   * @param glyph a glyph index
   * @returns An #hb_blob_t containing the PNG image for the glyph, if available
   */
  function otColorGlyphReferencePng(font: font_t, glyph: codepoint_t): blob_t
  /**
   * Fetches the SVG document for a glyph. The blob may be either plain text or gzip-encoded.
   *
   * If the glyph has no SVG document, the singleton empty blob is returned.
   * @param face #hb_face_t to work upon
   * @param glyph a svg glyph index
   * @returns An #hb_blob_t containing the SVG document of the glyph, if available
   */
  function otColorGlyphReferenceSvg(face: face_t, glyph: codepoint_t): blob_t
  /**
   * Tests whether a face includes a `COLR` table
   * with data according to COLRv0.
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function otColorHasLayers(face: face_t): bool_t
  /**
   * Tests where a face includes a `COLR` table
   * with data according to COLRv1.
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function otColorHasPaint(face: face_t): bool_t
  /**
   * Tests whether a face includes a `CPAL` color-palette table.
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function otColorHasPalettes(face: face_t): bool_t
  /**
   * Tests whether a face has PNG glyph images (either in `CBDT` or `sbix` tables).
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function otColorHasPng(face: face_t): bool_t
  /**
   * Tests whether a face includes any `SVG` glyph images.
   * @param face #hb_face_t to work upon.
   * @returns `true` if data found, `false` otherwise.
   */
  function otColorHasSvg(face: face_t): bool_t
  /**
   * Fetches the `name` table Name ID that provides display names for
   * the specified color in a face's `CPAL` color palette.
   *
   * Display names can be generic (e.g., "Background") or specific
   * (e.g., "Eye color").
   * @param face #hb_face_t to work upon
   * @param colorIndex The index of the color
   * @returns the Name ID found for the color.
   */
  function otColorPaletteColorGetNameId(
    face: face_t,
    colorIndex: number
  ): ot_name_id_t
  /**
   * Fetches a list of the colors in a color palette.
   *
   * After calling this function, `colors` will be filled with the palette
   * colors. If `colors` is NULL, the function will just return the number
   * of total colors without storing any actual colors; this can be used
   * for allocating a buffer of suitable size before calling
   * hb_ot_color_palette_get_colors() a second time.
   *
   * The RGBA values in the palette are unpremultiplied. See the
   * OpenType spec [CPAL](https://learn.microsoft.com/en-us/typography/opentype/spec/cpal)
   * section for details.
   * @param face #hb_face_t to work upon
   * @param paletteIndex the index of the color palette to query
   * @param startOffset offset of the first color to retrieve
   * @returns the total number of colors in the palette
   */
  function otColorPaletteGetColors(
    face: face_t,
    paletteIndex: number,
    startOffset: number
  ): [/* returnType */ number, /* colors */ color_t[] | null]
  /**
   * Fetches the number of color palettes in a face.
   * @param face #hb_face_t to work upon
   * @returns the number of palettes found
   */
  function otColorPaletteGetCount(face: face_t): number
  /**
   * Fetches the flags defined for a color palette.
   * @param face #hb_face_t to work upon
   * @param paletteIndex The index of the color palette
   * @returns the #hb_ot_color_palette_flags_t of the requested color palette
   */
  function otColorPaletteGetFlags(
    face: face_t,
    paletteIndex: number
  ): ot_color_palette_flags_t
  /**
   * Fetches the `name` table Name ID that provides display names for
   * a `CPAL` color palette.
   *
   * Palette display names can be generic (e.g., "Default") or provide
   * specific, themed names (e.g., "Spring", "Summer", "Fall", and "Winter").
   * @param face #hb_face_t to work upon
   * @param paletteIndex The index of the color palette
   * @returns the Named ID found for the palette. If the requested palette has no name the result is #HB_OT_NAME_ID_INVALID.
   */
  function otColorPaletteGetNameId(
    face: face_t,
    paletteIndex: number
  ): ot_name_id_t
  /**
   * Sets the font functions to use when working with `font`.
   * @param font #hb_font_t to work upon
   */
  function otFontSetFuncs(font: font_t): void
  /**
   * Fetches a list of all feature indexes in the specified face's GSUB table
   * or GPOS table, underneath the specified scripts, languages, and features.
   * If no list of scripts is provided, all scripts will be queried. If no list
   * of languages is provided, all languages will be queried. If no list of
   * features is provided, all features will be queried.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scripts The array of scripts to collect features for,   terminated by %HB_TAG_NONE
   * @param languages The array of languages to collect features for,   terminated by %HB_TAG_NONE
   * @param features The array of features to collect,   terminated by %HB_TAG_NONE
   */
  function otLayoutCollectFeatures(
    face: face_t,
    tableTag: tag_t,
    scripts: tag_t[] | null,
    languages: tag_t[] | null,
    features: tag_t[] | null
  ): /* featureIndexes */ set_t
  /**
   * Fetches the mapping from feature tags to feature indexes for
   * the specified script and language.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageIndex The index of the requested language tag
   */
  function otLayoutCollectFeaturesMap(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageIndex: number
  ): /* featureMap */ map_t
  /**
   * Fetches a list of all feature-lookup indexes in the specified face's GSUB
   * table or GPOS table, underneath the specified scripts, languages, and
   * features. If no list of scripts is provided, all scripts will be queried.
   * If no list of languages is provided, all languages will be queried. If no
   * list of features is provided, all features will be queried.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scripts The array of scripts to collect lookups for,   terminated by %HB_TAG_NONE
   * @param languages The array of languages to collect lookups for,   terminated by %HB_TAG_NONE
   * @param features The array of features to collect lookups for,   terminated by %HB_TAG_NONE
   */
  function otLayoutCollectLookups(
    face: face_t,
    tableTag: tag_t,
    scripts: tag_t[] | null,
    languages: tag_t[] | null,
    features: tag_t[] | null
  ): /* lookupIndexes */ set_t
  /**
   * Fetches a list of the characters defined as having a variant under the specified
   * "Character Variant" ("cvXX") feature tag.
   * @param face #hb_face_t to work upon
   * @param tableTag table tag to query, "GSUB" or "GPOS".
   * @param featureIndex index of feature to query.
   * @param startOffset offset of the first character to retrieve
   * @returns Number of total sample characters in the cvXX feature.
   */
  function otLayoutFeatureGetCharacters(
    face: face_t,
    tableTag: tag_t,
    featureIndex: number,
    startOffset: number
  ): [/* returnType */ number, /* characters */ codepoint_t[]]
  /**
   * Fetches a list of all lookups enumerated for the specified feature, in
   * the specified face's GSUB table or GPOS table. The list returned will
   * begin at the offset provided.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param featureIndex The index of the requested feature
   * @param startOffset offset of the first lookup to retrieve
   * @returns Total number of lookups.
   */
  function otLayoutFeatureGetLookups(
    face: face_t,
    tableTag: tag_t,
    featureIndex: number,
    startOffset: number
  ): [/* returnType */ number, /* lookupIndexes */ number[]]
  /**
   * Fetches name indices from feature parameters for "Stylistic Set" ('ssXX') or
   * "Character Variant" ('cvXX') features.
   * @param face #hb_face_t to work upon
   * @param tableTag table tag to query, "GSUB" or "GPOS".
   * @param featureIndex index of feature to query.
   * @returns `true` if data found, `false` otherwise
   */
  function otLayoutFeatureGetNameIds(
    face: face_t,
    tableTag: tag_t,
    featureIndex: number
  ): [
    /* returnType */ bool_t,
    /* labelId */ ot_name_id_t,
    /* tooltipId */ ot_name_id_t,
    /* sampleId */ ot_name_id_t,
    /* numNamedParameters */ number,
    /* firstParamId */ ot_name_id_t,
  ]
  /**
   * Fetches a list of all lookups enumerated for the specified feature, in
   * the specified face's GSUB table or GPOS table, enabled at the specified
   * variations index. The list returned will begin at the offset provided.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param featureIndex The index of the feature to query
   * @param variationsIndex The index of the feature variation to query
   * @param startOffset offset of the first lookup to retrieve
   * @returns Total number of lookups.
   */
  function otLayoutFeatureWithVariationsGetLookups(
    face: face_t,
    tableTag: tag_t,
    featureIndex: number,
    variationsIndex: number,
    startOffset: number
  ): [/* returnType */ number, /* lookupIndexes */ number[]]
  /**
   * Fetches a list of all attachment points for the specified glyph in the GDEF
   * table of the face. The list returned will begin at the offset provided.
   *
   * Useful if the client program wishes to cache the list.
   * @param face The #hb_face_t to work on
   * @param glyph The #hb_codepoint_t code point to query
   * @param startOffset offset of the first attachment point to retrieve
   * @returns Total number of attachment points for @glyph.
   */
  function otLayoutGetAttachPoints(
    face: face_t,
    glyph: codepoint_t,
    startOffset: number
  ): [/* returnType */ number, /* pointArray */ number[]]
  /**
   * Fetches a baseline value from the face.
   * @param font a font
   * @param baselineTag a baseline tag
   * @param direction text direction.
   * @param scriptTag script tag.
   * @param languageTag language tag, currently unused.
   * @returns `true` if found baseline value in the font.
   */
  function otLayoutGetBaseline(
    font: font_t,
    baselineTag: ot_layout_baseline_tag_t,
    direction: direction_t,
    scriptTag: tag_t,
    languageTag: tag_t
  ): [/* returnType */ bool_t, /* coord */ position_t | null]
  /**
   * Fetches a baseline value from the face.
   *
   * This function is like hb_ot_layout_get_baseline() but takes
   * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
   * @param font a font
   * @param baselineTag a baseline tag
   * @param direction text direction.
   * @param script script.
   * @param language language, currently unused.
   * @returns `true` if found baseline value in the font.
   */
  function otLayoutGetBaseline2(
    font: font_t,
    baselineTag: ot_layout_baseline_tag_t,
    direction: direction_t,
    script: script_t,
    language: language_t | null
  ): [/* returnType */ bool_t, /* coord */ position_t | null]
  /**
   * Fetches a baseline value from the face, and synthesizes
   * it if the font does not have it.
   * @param font a font
   * @param baselineTag a baseline tag
   * @param direction text direction.
   * @param scriptTag script tag.
   * @param languageTag language tag, currently unused.
   */
  function otLayoutGetBaselineWithFallback(
    font: font_t,
    baselineTag: ot_layout_baseline_tag_t,
    direction: direction_t,
    scriptTag: tag_t,
    languageTag: tag_t
  ): /* coord */ position_t
  /**
   * Fetches a baseline value from the face, and synthesizes
   * it if the font does not have it.
   *
   * This function is like hb_ot_layout_get_baseline_with_fallback() but takes
   * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
   * @param font a font
   * @param baselineTag a baseline tag
   * @param direction text direction.
   * @param script script.
   * @param language language, currently unused.
   */
  function otLayoutGetBaselineWithFallback2(
    font: font_t,
    baselineTag: ot_layout_baseline_tag_t,
    direction: direction_t,
    script: script_t,
    language: language_t | null
  ): /* coord */ position_t
  /**
   * Fetches script/language-specific font extents.  These values are
   * looked up in the `BASE` table's `MinMax` records.
   *
   * If no such extents are found, the default extents for the font are
   * fetched. As such, the return value of this function can for the
   * most part be ignored.  Note that the per-script/language extents
   * do not have a line-gap value, and the line-gap is set to zero in
   * that case.
   * @param font a font
   * @param direction text direction.
   * @param scriptTag script tag.
   * @param languageTag language tag.
   * @returns `true` if found script/language-specific font extents.
   */
  function otLayoutGetFontExtents(
    font: font_t,
    direction: direction_t,
    scriptTag: tag_t,
    languageTag: tag_t
  ): [/* returnType */ bool_t, /* extents */ font_extents_t | null]
  /**
   * Fetches script/language-specific font extents.  These values are
   * looked up in the `BASE` table's `MinMax` records.
   *
   * If no such extents are found, the default extents for the font are
   * fetched. As such, the return value of this function can for the
   * most part be ignored.  Note that the per-script/language extents
   * do not have a line-gap value, and the line-gap is set to zero in
   * that case.
   *
   * This function is like hb_ot_layout_get_font_extents() but takes
   * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
   * @param font a font
   * @param direction text direction.
   * @param script script.
   * @param language language.
   * @returns `true` if found script/language-specific font extents.
   */
  function otLayoutGetFontExtents2(
    font: font_t,
    direction: direction_t,
    script: script_t,
    language: language_t | null
  ): [/* returnType */ bool_t, /* extents */ font_extents_t | null]
  /**
   * Fetches the GDEF class of the requested glyph in the specified face.
   * @param face The #hb_face_t to work on
   * @param glyph The #hb_codepoint_t code point to query
   * @returns The #hb_ot_layout_glyph_class_t glyph class of the given code point in the GDEF table of the face.
   */
  function otLayoutGetGlyphClass(
    face: face_t,
    glyph: codepoint_t
  ): ot_layout_glyph_class_t
  /**
   * Retrieves the set of all glyphs from the face that belong to the requested
   * glyph class in the face's GDEF table.
   * @param face The #hb_face_t to work on
   * @param klass The #hb_ot_layout_glyph_class_t GDEF class to retrieve
   */
  function otLayoutGetGlyphsInClass(
    face: face_t,
    klass: ot_layout_glyph_class_t
  ): /* glyphs */ set_t
  /**
   * Fetches the dominant horizontal baseline tag used by `script`.
   * @param script a script tag.
   * @returns dominant baseline tag for the @script.
   */
  function otLayoutGetHorizontalBaselineTagForScript(
    script: script_t
  ): ot_layout_baseline_tag_t
  /**
   * Fetches a list of the caret positions defined for a ligature glyph in the GDEF
   * table of the font. The list returned will begin at the offset provided.
   *
   * Note that a ligature that is formed from n characters will have n-1
   * caret positions. The first character is not represented in the array,
   * since its caret position is the glyph position.
   *
   * The positions returned by this function are 'unshaped', and will have to
   * be fixed up for kerning that may be applied to the ligature glyph.
   * @param font The #hb_font_t to work on
   * @param direction The #hb_direction_t text direction to use
   * @param glyph The #hb_codepoint_t code point to query
   * @param startOffset offset of the first caret position to retrieve
   * @returns Total number of ligature caret positions for @glyph.
   */
  function otLayoutGetLigatureCarets(
    font: font_t,
    direction: direction_t,
    glyph: codepoint_t,
    startOffset: number
  ): [/* returnType */ number, /* caretArray */ position_t[]]
  /**
   * Fetches optical-size feature data (i.e., the `size` feature from GPOS). Note that
   * the subfamily_id and the subfamily name string (accessible via the subfamily_name_id)
   * as used here are defined as pertaining only to fonts within a font family that differ
   * specifically in their respective size ranges; other ways to differentiate fonts within
   * a subfamily are not covered by the `size` feature.
   *
   * For more information on this distinction, see the [`size` feature documentation](
   * https://docs.microsoft.com/en-us/typography/opentype/spec/features_pt#tag-size).
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function otLayoutGetSizeParams(
    face: face_t
  ): [
    /* returnType */ bool_t,
    /* designSize */ number,
    /* subfamilyId */ number,
    /* subfamilyNameId */ ot_name_id_t,
    /* rangeStart */ number,
    /* rangeEnd */ number,
  ]
  /**
   * Tests whether a face has any glyph classes defined in its GDEF table.
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function otLayoutHasGlyphClasses(face: face_t): bool_t
  /**
   * Tests whether the specified face includes any GPOS positioning.
   * @param face #hb_face_t to work upon
   * @returns `true` if the face has GPOS data, `false` otherwise
   */
  function otLayoutHasPositioning(face: face_t): bool_t
  /**
   * Tests whether the specified face includes any GSUB substitutions.
   * @param face #hb_face_t to work upon
   * @returns `true` if data found, `false` otherwise
   */
  function otLayoutHasSubstitution(face: face_t): bool_t
  /**
   * Fetches the index of a given feature tag in the specified face's GSUB table
   * or GPOS table, underneath the specified script and language.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageIndex The index of the requested language tag
   * @param featureTag #hb_tag_t of the feature tag requested
   * @returns `true` if the feature is found, `false` otherwise
   */
  function otLayoutLanguageFindFeature(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageIndex: number,
    featureTag: tag_t
  ): [/* returnType */ bool_t, /* featureIndex */ number]
  /**
   * Fetches a list of all features in the specified face's GSUB table
   * or GPOS table, underneath the specified script and language. The list
   * returned will begin at the offset provided.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageIndex The index of the requested language tag
   * @param startOffset offset of the first feature tag to retrieve
   * @returns Total number of features.
   */
  function otLayoutLanguageGetFeatureIndexes(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageIndex: number,
    startOffset: number
  ): [/* returnType */ number, /* featureIndexes */ number[]]
  /**
   * Fetches a list of all features in the specified face's GSUB table
   * or GPOS table, underneath the specified script and language. The list
   * returned will begin at the offset provided.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageIndex The index of the requested language tag
   * @param startOffset offset of the first feature tag to retrieve
   * @returns Total number of feature tags.
   */
  function otLayoutLanguageGetFeatureTags(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageIndex: number,
    startOffset: number
  ): [/* returnType */ number, /* featureTags */ tag_t[]]
  /**
   * Fetches the tag of a requested feature index in the given face's GSUB or GPOS table,
   * underneath the specified script and language.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageIndex The index of the requested language tag
   * @returns `true` if the feature is found, `false` otherwise
   */
  function otLayoutLanguageGetRequiredFeature(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageIndex: number
  ): [
    /* returnType */ bool_t,
    /* featureIndex */ number,
    /* featureTag */ tag_t,
  ]
  /**
   * Fetches the index of a requested feature in the given face's GSUB or GPOS table,
   * underneath the specified script and language.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageIndex The index of the requested language tag
   * @returns `true` if the feature is found, `false` otherwise
   */
  function otLayoutLanguageGetRequiredFeatureIndex(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageIndex: number
  ): [/* returnType */ bool_t, /* featureIndex */ number]
  /**
   * Fetches a list of all glyphs affected by the specified lookup in the
   * specified face's GSUB table or GPOS table.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param lookupIndex The index of the feature lookup to query
   */
  function otLayoutLookupCollectGlyphs(
    face: face_t,
    tableTag: tag_t,
    lookupIndex: number
  ): [
    /* glyphsBefore */ set_t,
    /* glyphsInput */ set_t,
    /* glyphsAfter */ set_t,
    /* glyphsOutput */ set_t,
  ]
  /**
   * Fetches alternates of a glyph from a given GSUB lookup index.
   * @param face a face.
   * @param lookupIndex index of the feature lookup to query.
   * @param glyph a glyph id.
   * @param startOffset starting offset.
   * @returns Total number of alternates found in the specific lookup index for the given glyph id.
   */
  function otLayoutLookupGetGlyphAlternates(
    face: face_t,
    lookupIndex: number,
    glyph: codepoint_t,
    startOffset: number
  ): [/* returnType */ number, /* alternateGlyphs */ codepoint_t[]]
  /**
   * Fetches the optical bound of a glyph positioned at the margin of text.
   * The direction identifies which edge of the glyph to query.
   * @param font a font.
   * @param lookupIndex index of the feature lookup to query.
   * @param direction edge of the glyph to query.
   * @param glyph a glyph id.
   * @returns Adjustment value. Negative values mean the glyph will stick out of the margin.
   */
  function otLayoutLookupGetOpticalBound(
    font: font_t,
    lookupIndex: number,
    direction: direction_t,
    glyph: codepoint_t
  ): position_t
  /**
   * Compute the transitive closure of glyphs needed for a
   * specified lookup.
   * @param face #hb_face_t to work upon
   * @param lookupIndex index of the feature lookup to query
   */
  function otLayoutLookupSubstituteClosure(
    face: face_t,
    lookupIndex: number
  ): /* glyphs */ set_t
  /**
   * Tests whether a specified lookup in the specified face would
   * trigger a substitution on the given glyph sequence.
   * @param face #hb_face_t to work upon
   * @param lookupIndex The index of the lookup to query
   * @param glyphs The sequence of glyphs to query for substitution
   * @param glyphsLength The length of the glyph sequence
   * @param zeroContext #hb_bool_t indicating whether pre-/post-context are disallowed in substitutions
   * @returns `true` if a substitution would be triggered, `false` otherwise
   */
  function otLayoutLookupWouldSubstitute(
    face: face_t,
    lookupIndex: number,
    glyphs: codepoint_t,
    glyphsLength: number,
    zeroContext: bool_t
  ): bool_t
  /**
   * Compute the transitive closure of glyphs needed for all of the
   * provided lookups.
   * @param face #hb_face_t to work upon
   * @param lookups The set of lookups to query
   */
  function otLayoutLookupsSubstituteClosure(
    face: face_t,
    lookups: set_t
  ): /* glyphs */ set_t
  /**
   * Fetches the index of a given language tag in the specified face's GSUB table
   * or GPOS table, underneath the specified script tag.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageTag The #hb_tag_t of the requested language
   * @param languageIndex The index of the requested language
   * @returns `true` if the language tag is found, `false` otherwise
   */
  function otLayoutScriptFindLanguage(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageTag: tag_t,
    languageIndex: number
  ): bool_t
  /**
   * Fetches a list of language tags in the given face's GSUB or GPOS table, underneath
   * the specified script index. The list returned will begin at the offset provided.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param startOffset offset of the first language tag to retrieve
   * @returns Total number of language tags.
   */
  function otLayoutScriptGetLanguageTags(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    startOffset: number
  ): [/* returnType */ number, /* languageTags */ tag_t[]]
  /**
   * Fetches the index of the first language tag fom `language_tags` that is present
   * in the specified face's GSUB or GPOS table, underneath the specified script
   * index.
   *
   * If none of the given language tags is found, `false` is returned and
   * `language_index` is set to the default language index.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageCount The number of languages in the specified script
   * @param languageTags The array of language tags
   * @returns `true` if one of the given language tags is found, `false` otherwise
   */
  function otLayoutScriptSelectLanguage(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageCount: number,
    languageTags: tag_t
  ): [/* returnType */ bool_t, /* languageIndex */ number]
  /**
   * Fetches the index of the first language tag fom `language_tags` that is present
   * in the specified face's GSUB or GPOS table, underneath the specified script
   * index.
   *
   * If none of the given language tags is found, `false` is returned and
   * `language_index` is set to #HB_OT_LAYOUT_DEFAULT_LANGUAGE_INDEX and
   * `chosen_language` is set to #HB_TAG_NONE.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptIndex The index of the requested script tag
   * @param languageCount The number of languages in the specified script
   * @param languageTags The array of language tags
   * @returns `true` if one of the given language tags is found, `false` otherwise
   */
  function otLayoutScriptSelectLanguage2(
    face: face_t,
    tableTag: tag_t,
    scriptIndex: number,
    languageCount: number,
    languageTags: tag_t
  ): [
    /* returnType */ bool_t,
    /* languageIndex */ number,
    /* chosenLanguage */ tag_t,
  ]
  /**
   * Deprecated since 2.0.0
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptTags Array of #hb_tag_t script tags
   */
  function otLayoutTableChooseScript(
    face: face_t,
    tableTag: tag_t,
    scriptTags: tag_t
  ): [
    /* returnType */ bool_t,
    /* scriptIndex */ number,
    /* chosenScript */ tag_t,
  ]
  /**
   * Fetches a list of feature variations in the specified face's GSUB table
   * or GPOS table, at the specified variation coordinates.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param coords The variation coordinates to query
   * @param numCoords The number of variation coordinates
   * @returns `true` if feature variations were found, `false` otherwise.
   */
  function otLayoutTableFindFeatureVariations(
    face: face_t,
    tableTag: tag_t,
    coords: number,
    numCoords: number
  ): [/* returnType */ bool_t, /* variationsIndex */ number]
  /**
   * Fetches the index if a given script tag in the specified face's GSUB table
   * or GPOS table.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptTag #hb_tag_t of the script tag requested
   * @returns `true` if the script is found, `false` otherwise
   */
  function otLayoutTableFindScript(
    face: face_t,
    tableTag: tag_t,
    scriptTag: tag_t
  ): [/* returnType */ bool_t, /* scriptIndex */ number]
  /**
   * Fetches a list of all feature tags in the given face's GSUB or GPOS table.
   * Note that there might be duplicate feature tags, belonging to different
   * script/language-system pairs of the table.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param startOffset offset of the first feature tag to retrieve
   * @returns Total number of feature tags.
   */
  function otLayoutTableGetFeatureTags(
    face: face_t,
    tableTag: tag_t,
    startOffset: number
  ): [/* returnType */ number, /* featureTags */ tag_t[]]
  /**
   * Fetches the total number of lookups enumerated in the specified
   * face's GSUB table or GPOS table.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @returns Total number of lookups.
   */
  function otLayoutTableGetLookupCount(face: face_t, tableTag: tag_t): number
  /**
   * Fetches a list of all scripts enumerated in the specified face's GSUB table
   * or GPOS table. The list returned will begin at the offset provided.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param startOffset offset of the first script tag to retrieve
   * @returns Total number of script tags.
   */
  function otLayoutTableGetScriptTags(
    face: face_t,
    tableTag: tag_t,
    startOffset: number
  ): [/* returnType */ number, /* scriptTags */ tag_t[]]
  /**
   * Selects an OpenType script for `table_tag` from the `script_tags` array.
   *
   * If the table does not have any of the requested scripts, then `DFLT`,
   * `dflt`, and `latn` tags are tried in that order. If the table still does not
   * have any of these scripts, `script_index` is set to
   * #HB_OT_LAYOUT_NO_SCRIPT_INDEX and `chosen_script` is set to #HB_TAG_NONE.
   * @param face #hb_face_t to work upon
   * @param tableTag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
   * @param scriptCount Number of script tags in the array
   * @param scriptTags Array of #hb_tag_t script tags
   * @returns `true` if one of the requested scripts is selected, `false` if a fallback script is selected or if no scripts are selected.
   */
  function otLayoutTableSelectScript(
    face: face_t,
    tableTag: tag_t,
    scriptCount: number,
    scriptTags: tag_t
  ): [
    /* returnType */ bool_t,
    /* scriptIndex */ number,
    /* chosenScript */ tag_t,
  ]
  /**
   * Fetches the specified math constant. For most constants, the value returned
   * is an #hb_position_t.
   *
   * However, if the requested constant is #HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN,
   * #HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN or
   * #HB_OT_MATH_CONSTANT_RADICAL_DEGREE_BOTTOM_RAISE_PERCENT, then the return value is
   * an integer between 0 and 100 representing that percentage.
   * @param font #hb_font_t to work upon
   * @param constant #hb_ot_math_constant_t the constant to retrieve
   * @returns the requested constant or zero
   */
  function otMathGetConstant(
    font: font_t,
    constant: ot_math_constant_t
  ): position_t
  /**
   * Fetches the GlyphAssembly for the specified font, glyph index, and direction.
   * Returned are a list of #hb_ot_math_glyph_part_t glyph parts that can be
   * used to draw the glyph and an italics-correction value (if one is defined
   * in the font).
   *
   * <note>The `direction` parameter is only used to select between horizontal
   * or vertical directions for the construction. Even though all #hb_direction_t
   * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
   * considered.</note>
   * @param font #hb_font_t to work upon
   * @param glyph The index of the glyph to stretch
   * @param direction direction of the stretching (horizontal or vertical)
   * @param startOffset offset of the first glyph part to retrieve
   * @returns the total number of parts in the glyph assembly
   */
  function otMathGetGlyphAssembly(
    font: font_t,
    glyph: codepoint_t,
    direction: direction_t,
    startOffset: number
  ): [
    /* returnType */ number,
    /* parts */ ot_math_glyph_part_t[],
    /* italicsCorrection */ position_t,
  ]
  /**
   * Fetches an italics-correction value (if one exists) for the specified
   * glyph index.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph index from which to retrieve the value
   * @returns the italics correction of the glyph or zero
   */
  function otMathGetGlyphItalicsCorrection(
    font: font_t,
    glyph: codepoint_t
  ): position_t
  /**
   * Fetches the math kerning (cut-ins) value for the specified font, glyph index, and
   * `kern`.
   *
   * If the MathKern table is found, the function examines it to find a height
   * value that is greater or equal to `correction_height`. If such a height
   * value is found, corresponding kerning value from the table is returned. If
   * no such height value is found, the last kerning value is returned.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph index from which to retrieve the value
   * @param kern The #hb_ot_math_kern_t from which to retrieve the value
   * @param correctionHeight the correction height to use to determine the kerning.
   * @returns requested kerning value or zero
   */
  function otMathGetGlyphKerning(
    font: font_t,
    glyph: codepoint_t,
    kern: ot_math_kern_t,
    correctionHeight: position_t
  ): position_t
  /**
   * Fetches the raw MathKern (cut-in) data for the specified font, glyph index,
   * and `kern`. The corresponding list of kern values and correction heights is
   * returned as a list of #hb_ot_math_kern_entry_t structs.
   *
   * See also #hb_ot_math_get_glyph_kerning, which handles selecting the
   * appropriate kern value for a given correction height.
   *
   * <note>For a glyph with `n` defined kern values (where `n` > 0), there are only
   * `n−`1 defined correction heights, as each correction height defines a boundary
   * past which the next kern value should be selected. Therefore, only the
   * #hb_ot_math_kern_entry_t.kern_value of the uppermost #hb_ot_math_kern_entry_t
   * actually comes from the font; its corresponding
   * #hb_ot_math_kern_entry_t.max_correction_height is always set to
   * <code>INT32_MAX</code>.</note>
   * @param font #hb_font_t to work upon
   * @param glyph The glyph index from which to retrieve the kernings
   * @param kern The #hb_ot_math_kern_t from which to retrieve the kernings
   * @param startOffset offset of the first kern entry to retrieve
   * @returns the total number of kern values available or zero
   */
  function otMathGetGlyphKernings(
    font: font_t,
    glyph: codepoint_t,
    kern: ot_math_kern_t,
    startOffset: number
  ): [/* returnType */ number, /* kernEntries */ ot_math_kern_entry_t[]]
  /**
   * Fetches a top-accent-attachment value (if one exists) for the specified
   * glyph index.
   *
   * For any glyph that does not have a top-accent-attachment value - that is,
   * a glyph not covered by the `MathTopAccentAttachment` table (or, when
   * `font` has no `MathTopAccentAttachment` table or no `MATH` table, any
   * glyph) - the function synthesizes a value, returning the position at
   * one-half the glyph's advance width.
   * @param font #hb_font_t to work upon
   * @param glyph The glyph index from which to retrieve the value
   * @returns the top accent attachment of the glyph or 0.5 * the advance               width of @glyph
   */
  function otMathGetGlyphTopAccentAttachment(
    font: font_t,
    glyph: codepoint_t
  ): position_t
  /**
   * Fetches the MathGlyphConstruction for the specified font, glyph index, and
   * direction. The corresponding list of size variants is returned as a list of
   * #hb_ot_math_glyph_variant_t structs.
   *
   * <note>The `direction` parameter is only used to select between horizontal
   * or vertical directions for the construction. Even though all #hb_direction_t
   * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
   * considered.</note>
   * @param font #hb_font_t to work upon
   * @param glyph The index of the glyph to stretch
   * @param direction The direction of the stretching (horizontal or vertical)
   * @param startOffset offset of the first variant to retrieve
   * @returns the total number of size variants available or zero
   */
  function otMathGetGlyphVariants(
    font: font_t,
    glyph: codepoint_t,
    direction: direction_t,
    startOffset: number
  ): [/* returnType */ number, /* variants */ ot_math_glyph_variant_t[]]
  /**
   * Fetches the MathVariants table for the specified font and returns the
   * minimum overlap of connecting glyphs that are required to draw a glyph
   * assembly in the specified direction.
   *
   * <note>The `direction` parameter is only used to select between horizontal
   * or vertical directions for the construction. Even though all #hb_direction_t
   * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
   * considered.</note>
   * @param font #hb_font_t to work upon
   * @param direction direction of the stretching (horizontal or vertical)
   * @returns requested minimum connector overlap or zero
   */
  function otMathGetMinConnectorOverlap(
    font: font_t,
    direction: direction_t
  ): position_t
  /**
   * Tests whether a face has a `MATH` table.
   * @param face #hb_face_t to test
   * @returns `true` if the table is found, `false` otherwise
   */
  function otMathHasData(face: face_t): bool_t
  /**
   * Tests whether the given glyph index is an extended shape in the face.
   * @param face #hb_face_t to work upon
   * @param glyph The glyph index to test
   * @returns `true` if the glyph is an extended shape, `false` otherwise
   */
  function otMathIsGlyphExtendedShape(face: face_t, glyph: codepoint_t): bool_t
  /**
   * Fetches all available feature types.
   * @param face a face object
   * @param startOffset iteration's start offset
   * @returns Number of all available feature types.
   */
  function otMetaGetEntryTags(
    face: face_t,
    startOffset: number
  ): [/* returnType */ number, /* entries */ ot_meta_tag_t[]]
  /**
   * It fetches metadata entry of a given tag from a font.
   * @param face a #hb_face_t object.
   * @param metaTag tag of metadata you like to have.
   * @returns A blob containing the blob.
   */
  function otMetaReferenceEntry(face: face_t, metaTag: ot_meta_tag_t): blob_t
  /**
   * Fetches metrics value corresponding to `metrics_tag` from `font`.
   * @param font an #hb_font_t object.
   * @param metricsTag tag of metrics value you like to fetch.
   * @returns Whether found the requested metrics in the font.
   */
  function otMetricsGetPosition(
    font: font_t,
    metricsTag: ot_metrics_tag_t
  ): [/* returnType */ bool_t, /* position */ position_t]
  /**
   * Fetches metrics value corresponding to `metrics_tag` from `font,`
   * and synthesizes a value if it the value is missing in the font.
   * @param font an #hb_font_t object.
   * @param metricsTag tag of metrics value you like to fetch.
   */
  function otMetricsGetPositionWithFallback(
    font: font_t,
    metricsTag: ot_metrics_tag_t
  ): /* position */ position_t
  /**
   * Fetches metrics value corresponding to `metrics_tag` from `font` with the
   * current font variation settings applied.
   * @param font an #hb_font_t object.
   * @param metricsTag tag of metrics value you like to fetch.
   * @returns The requested metric value.
   */
  function otMetricsGetVariation(
    font: font_t,
    metricsTag: ot_metrics_tag_t
  ): number
  /**
   * Fetches horizontal metrics value corresponding to `metrics_tag` from `font`
   * with the current font variation settings applied.
   * @param font an #hb_font_t object.
   * @param metricsTag tag of metrics value you like to fetch.
   * @returns The requested metric value.
   */
  function otMetricsGetXVariation(
    font: font_t,
    metricsTag: ot_metrics_tag_t
  ): position_t
  /**
   * Fetches vertical metrics value corresponding to `metrics_tag` from `font` with
   * the current font variation settings applied.
   * @param font an #hb_font_t object.
   * @param metricsTag tag of metrics value you like to fetch.
   * @returns The requested metric value.
   */
  function otMetricsGetYVariation(
    font: font_t,
    metricsTag: ot_metrics_tag_t
  ): position_t
  /**
   * Fetches a font name from the OpenType 'name' table.
   * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
   * Returns string in UTF-16 encoding. A NUL terminator is always written
   * for convenience, and isn't included in the output `text_size`.
   * @param face font face.
   * @param nameId OpenType name identifier to fetch.
   * @param language language to fetch the name for.
   * @returns full length of the requested string, or 0 if not found.
   */
  function otNameGetUtf16(
    face: face_t,
    nameId: ot_name_id_t,
    language: language_t
  ): [/* returnType */ number, /* text */ number[]]
  /**
   * Fetches a font name from the OpenType 'name' table.
   * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
   * Returns string in UTF-32 encoding. A NUL terminator is always written
   * for convenience, and isn't included in the output `text_size`.
   * @param face font face.
   * @param nameId OpenType name identifier to fetch.
   * @param language language to fetch the name for.
   * @returns full length of the requested string, or 0 if not found.
   */
  function otNameGetUtf32(
    face: face_t,
    nameId: ot_name_id_t,
    language: language_t
  ): [/* returnType */ number, /* text */ number[]]
  /**
   * Fetches a font name from the OpenType 'name' table.
   * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
   * Returns string in UTF-8 encoding. A NUL terminator is always written
   * for convenience, and isn't included in the output `text_size`.
   * @param face font face.
   * @param nameId OpenType name identifier to fetch.
   * @param language language to fetch the name for.
   * @returns full length of the requested string, or 0 if not found.
   */
  function otNameGetUtf8(
    face: face_t,
    nameId: ot_name_id_t,
    language: language_t
  ): [/* returnType */ number, /* text */ string[]]
  /**
   * Enumerates all available name IDs and language combinations. Returned
   * array is owned by the `face` and should not be modified.  It can be
   * used as long as `face` is alive.
   * @param face font face.
   * @returns Array of available name entries.
   */
  function otNameListNames(face: face_t): ot_name_entry_t[]
  /**
   * Computes the transitive closure of glyphs needed for a specified
   * input buffer under the given font and feature list. The closure is
   * computed as a set, not as a list.
   * @param font #hb_font_t to work upon
   * @param buffer The input buffer to compute from
   * @param features The features enabled on the buffer
   */
  function otShapeGlyphsClosure(
    font: font_t,
    buffer: buffer_t,
    features: feature_t[]
  ): /* glyphs */ set_t
  /**
   * Computes the complete set of GSUB or GPOS lookups that are applicable
   * under a given `shape_plan`.
   * @param shapePlan #hb_shape_plan_t to query
   * @param tableTag GSUB or GPOS
   */
  function otShapePlanCollectLookups(
    shapePlan: shape_plan_t,
    tableTag: tag_t
  ): /* lookupIndexes */ set_t
  /**
   * Converts an #hb_language_t to an #hb_tag_t.
   * @param language an #hb_language_t to convert.
   */
  function otTagFromLanguage(language: language_t): tag_t
  /**
   * Converts a language tag to an #hb_language_t.
   * @param tag an language tag
   * @returns The #hb_language_t corresponding to @tag.
   */
  function otTagToLanguage(tag: tag_t): language_t | null
  /**
   * Converts a script tag to an #hb_script_t.
   * @param tag a script tag
   * @returns The #hb_script_t corresponding to @tag.
   */
  function otTagToScript(tag: tag_t): script_t
  /**
   * Converts an #hb_script_t to script tags.
   * @param script an #hb_script_t to convert.
   */
  function otTagsFromScript(
    script: script_t
  ): [/* scriptTag1 */ tag_t, /* scriptTag2 */ tag_t]
  /**
   * Converts an #hb_script_t and an #hb_language_t to script and language tags.
   * @param script an #hb_script_t to convert.
   * @param language an #hb_language_t to convert.
   * @param scriptCount maximum number of script tags to retrieve (IN) and actual number of script tags retrieved (OUT)
   * @param languageCount maximum number of language tags to retrieve (IN) and actual number of language tags retrieved (OUT)
   */
  function otTagsFromScriptAndLanguage(
    script: script_t,
    language: language_t | null,
    scriptCount?: number,
    languageCount?: number
  ): [
    /* scriptCount */ number,
    /* scriptTags */ tag_t,
    /* languageCount */ number,
    /* languageTags */ tag_t,
  ]
  /**
   * Converts a script tag and a language tag to an #hb_script_t and an
   * #hb_language_t.
   * @param scriptTag a script tag
   * @param languageTag a language tag
   */
  function otTagsToScriptAndLanguage(
    scriptTag: tag_t,
    languageTag: tag_t
  ): [/* script */ script_t, /* language */ language_t]
  /**
   * Fetches the variation-axis information corresponding to the specified axis tag
   * in the specified face.
   * @param face #hb_face_t to work upon
   * @param axisTag The #hb_tag_t of the variation axis to query
   * @param axisIndex The index of the variation axis
   */
  function otVarFindAxis(
    face: face_t,
    axisTag: tag_t,
    axisIndex: number
  ): [/* returnType */ bool_t, /* axisInfo */ ot_var_axis_t]
  /**
   * Fetches the variation-axis information corresponding to the specified axis tag
   * in the specified face.
   * @param face #hb_face_t to work upon
   * @param axisTag The #hb_tag_t of the variation axis to query
   * @returns `true` if data found, `false` otherwise
   */
  function otVarFindAxisInfo(
    face: face_t,
    axisTag: tag_t
  ): [/* returnType */ bool_t, /* axisInfo */ ot_var_axis_info_t]
  /**
   * Fetches a list of all variation axes in the specified face. The list returned will begin
   * at the offset provided.
   * @param face #hb_face_t to work upon
   * @param startOffset offset of the first lookup to retrieve
   */
  function otVarGetAxes(
    face: face_t,
    startOffset: number
  ): [/* returnType */ number, /* axesArray */ ot_var_axis_t[]]
  /**
   * Fetches the number of OpenType variation axes included in the face.
   * @param face The #hb_face_t to work on
   * @returns the number of variation axes defined
   */
  function otVarGetAxisCount(face: face_t): number
  /**
   * Fetches a list of all variation axes in the specified face. The list returned will begin
   * at the offset provided.
   * @param face #hb_face_t to work upon
   * @param startOffset offset of the first lookup to retrieve
   * @returns the number of variation axes in the face
   */
  function otVarGetAxisInfos(
    face: face_t,
    startOffset: number
  ): [/* returnType */ number, /* axesArray */ ot_var_axis_info_t[]]
  /**
   * Fetches the number of named instances included in the face.
   * @param face The #hb_face_t to work on
   * @returns the number of named instances defined
   */
  function otVarGetNamedInstanceCount(face: face_t): number
  /**
   * Tests whether a face includes any OpenType variation data in the `fvar` table.
   * @param face The #hb_face_t to work on
   * @returns `true` if data found, `false` otherwise
   */
  function otVarHasData(face: face_t): bool_t
  /**
   * Fetches the design-space coordinates corresponding to the given
   * named instance in the face.
   * @param face The #hb_face_t to work on
   * @param instanceIndex The index of the named instance to query
   * @returns the number of variation axes in the face
   */
  function otVarNamedInstanceGetDesignCoords(
    face: face_t,
    instanceIndex: number
  ): [/* returnType */ number, /* coords */ number[]]
  /**
   * Fetches the `name` table Name ID that provides display names for
   * the "PostScript name" defined for the given named instance in the face.
   * @param face The #hb_face_t to work on
   * @param instanceIndex The index of the named instance to query
   * @returns the Name ID found for the PostScript name
   */
  function otVarNamedInstanceGetPostscriptNameId(
    face: face_t,
    instanceIndex: number
  ): ot_name_id_t
  /**
   * Fetches the `name` table Name ID that provides display names for
   * the "Subfamily name" defined for the given named instance in the face.
   * @param face The #hb_face_t to work on
   * @param instanceIndex The index of the named instance to query
   * @returns the Name ID found for the Subfamily name
   */
  function otVarNamedInstanceGetSubfamilyNameId(
    face: face_t,
    instanceIndex: number
  ): ot_name_id_t
  /**
   * Normalizes the given design-space coordinates. The minimum and maximum
   * values for the axis are mapped to the interval [-1,1], with the default
   * axis value mapped to 0.
   *
   * The normalized values have 14 bits of fixed-point sub-integer precision as per
   * OpenType specification.
   *
   * Any additional scaling defined in the face's `avar` table is also
   * applied, as described at https://docs.microsoft.com/en-us/typography/opentype/spec/avar
   * @param face The #hb_face_t to work on
   * @param coordsLength The length of the coordinate array
   * @param designCoords The design-space coordinates to normalize
   */
  function otVarNormalizeCoords(
    face: face_t,
    coordsLength: number,
    designCoords: number
  ): /* normalizedCoords */ number
  /**
   * Normalizes all of the coordinates in the given list of variation axes.
   * @param face The #hb_face_t to work on
   * @param variations The array of variations to normalize
   * @param variationsLength The number of variations to normalize
   */
  function otVarNormalizeVariations(
    face: face_t,
    variations: variation_t,
    variationsLength: number
  ): /* coords */ number[]
  /**
   * Perform a "color" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param isForeground whether the color is the foreground
   * @param color The color to use
   */
  function paintColor(
    funcs: paint_funcs_t,
    paintData: any | null,
    isForeground: bool_t,
    color: color_t
  ): void
  /**
   * Perform a "color-glyph" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param glyph the glyph ID
   * @param font the font
   */
  function paintColorGlyph(
    funcs: paint_funcs_t,
    paintData: any | null,
    glyph: codepoint_t,
    font: font_t
  ): bool_t
  /**
   * Gets the custom palette color for `color_index`.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param colorIndex color index
   * @returns `true` if found, `false` otherwise
   */
  function paintCustomPaletteColor(
    funcs: paint_funcs_t,
    paintData: any | null,
    colorIndex: number
  ): [/* returnType */ bool_t, /* color */ color_t]
  /**
   * Creates a new #hb_paint_funcs_t structure of paint functions.
   *
   * The initial reference count of 1 should be released with hb_paint_funcs_destroy()
   * when you are done using the #hb_paint_funcs_t. This function never returns
   * `NULL`. If memory cannot be allocated, a special singleton #hb_paint_funcs_t
   * object will be returned.
   * @returns the paint-functions structure
   */
  function paintFuncsCreate(): paint_funcs_t
  /**
   * Fetches the singleton empty paint-functions structure.
   * @returns The empty paint-functions structure
   */
  function paintFuncsGetEmpty(): paint_funcs_t
  /**
   * Tests whether a paint-functions structure is immutable.
   * @param funcs The paint-functions structure
   * @returns `true` if @funcs is immutable, `false` otherwise
   */
  function paintFuncsIsImmutable(funcs: paint_funcs_t): bool_t
  /**
   * Makes a paint-functions structure immutable.
   *
   * After this call, all attempts to set one of the callbacks
   * on `funcs` will fail.
   * @param funcs The paint-functions structure
   */
  function paintFuncsMakeImmutable(funcs: paint_funcs_t): void
  /**
   * Sets the paint-color callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The paint-color callback
   */
  function paintFuncsSetColorFunc(
    funcs: paint_funcs_t,
    func: paint_color_func_t
  ): void
  /**
   * Sets the color-glyph callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The color-glyph callback
   */
  function paintFuncsSetColorGlyphFunc(
    funcs: paint_funcs_t,
    func: paint_color_glyph_func_t
  ): void
  /**
   * Sets the custom-palette-color callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The custom-palette-color callback
   */
  function paintFuncsSetCustomPaletteColorFunc(
    funcs: paint_funcs_t,
    func: paint_custom_palette_color_func_t
  ): void
  /**
   * Sets the paint-image callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The paint-image callback
   */
  function paintFuncsSetImageFunc(
    funcs: paint_funcs_t,
    func: paint_image_func_t
  ): void
  /**
   * Sets the linear-gradient callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The linear-gradient callback
   */
  function paintFuncsSetLinearGradientFunc(
    funcs: paint_funcs_t,
    func: paint_linear_gradient_func_t
  ): void
  /**
   * Sets the pop-clip callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The pop-clip callback
   */
  function paintFuncsSetPopClipFunc(
    funcs: paint_funcs_t,
    func: paint_pop_clip_func_t
  ): void
  /**
   * Sets the pop-group callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The pop-group callback
   */
  function paintFuncsSetPopGroupFunc(
    funcs: paint_funcs_t,
    func: paint_pop_group_func_t
  ): void
  /**
   * Sets the pop-transform callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The pop-transform callback
   */
  function paintFuncsSetPopTransformFunc(
    funcs: paint_funcs_t,
    func: paint_pop_transform_func_t
  ): void
  /**
   * Sets the push-clip-glyph callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The push-clip-glyph callback
   */
  function paintFuncsSetPushClipGlyphFunc(
    funcs: paint_funcs_t,
    func: paint_push_clip_glyph_func_t
  ): void
  /**
   * Sets the push-clip-rect callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The push-clip-rectangle callback
   */
  function paintFuncsSetPushClipRectangleFunc(
    funcs: paint_funcs_t,
    func: paint_push_clip_rectangle_func_t
  ): void
  /**
   * Sets the push-group callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The push-group callback
   */
  function paintFuncsSetPushGroupFunc(
    funcs: paint_funcs_t,
    func: paint_push_group_func_t
  ): void
  /**
   * Sets the push-transform callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The push-transform callback
   */
  function paintFuncsSetPushTransformFunc(
    funcs: paint_funcs_t,
    func: paint_push_transform_func_t
  ): void
  /**
   * Sets the radial-gradient callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The radial-gradient callback
   */
  function paintFuncsSetRadialGradientFunc(
    funcs: paint_funcs_t,
    func: paint_radial_gradient_func_t
  ): void
  /**
   * Sets the sweep-gradient callback on the paint functions struct.
   * @param funcs A paint functions struct
   * @param func The sweep-gradient callback
   */
  function paintFuncsSetSweepGradientFunc(
    funcs: paint_funcs_t,
    func: paint_sweep_gradient_func_t
  ): void
  /**
   * Perform a "image" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param image image data
   * @param width width of the raster image in pixels, or 0
   * @param height height of the raster image in pixels, or 0
   * @param format the image format as a tag
   * @param slant the synthetic slant ratio to be applied to the image during rendering
   * @param extents the extents of the glyph
   */
  function paintImage(
    funcs: paint_funcs_t,
    paintData: any | null,
    image: blob_t,
    width: number,
    height: number,
    format: tag_t,
    slant: number,
    extents: glyph_extents_t | null
  ): void
  /**
   * Perform a "linear-gradient" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param colorLine Color information for the gradient
   * @param x0 X coordinate of the first point
   * @param y0 Y coordinate of the first point
   * @param x1 X coordinate of the second point
   * @param y1 Y coordinate of the second point
   * @param x2 X coordinate of the third point
   * @param y2 Y coordinate of the third point
   */
  function paintLinearGradient(
    funcs: paint_funcs_t,
    paintData: any | null,
    colorLine: color_line_t,
    x0: number,
    y0: number,
    x1: number,
    y1: number,
    x2: number,
    y2: number
  ): void
  /**
   * Perform a "pop-clip" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   */
  function paintPopClip(funcs: paint_funcs_t, paintData: any | null): void
  /**
   * Perform a "pop-group" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param mode the compositing mode to use
   */
  function paintPopGroup(
    funcs: paint_funcs_t,
    paintData: any | null,
    mode: paint_composite_mode_t
  ): void
  /**
   * Perform a "pop-transform" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   */
  function paintPopTransform(funcs: paint_funcs_t, paintData: any | null): void
  /**
   * Perform a "push-clip-glyph" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param glyph the glyph ID
   * @param font the font
   */
  function paintPushClipGlyph(
    funcs: paint_funcs_t,
    paintData: any | null,
    glyph: codepoint_t,
    font: font_t
  ): void
  /**
   * Perform a "push-clip-rect" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param xmin min X for the rectangle
   * @param ymin min Y for the rectangle
   * @param xmax max X for the rectangle
   * @param ymax max Y for the rectangle
   */
  function paintPushClipRectangle(
    funcs: paint_funcs_t,
    paintData: any | null,
    xmin: number,
    ymin: number,
    xmax: number,
    ymax: number
  ): void
  /**
   * Perform a "push-group" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   */
  function paintPushGroup(funcs: paint_funcs_t, paintData: any | null): void
  /**
   * Perform a "push-transform" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param xx xx component of the transform matrix
   * @param yx yx component of the transform matrix
   * @param xy xy component of the transform matrix
   * @param yy yy component of the transform matrix
   * @param dx dx component of the transform matrix
   * @param dy dy component of the transform matrix
   */
  function paintPushTransform(
    funcs: paint_funcs_t,
    paintData: any | null,
    xx: number,
    yx: number,
    xy: number,
    yy: number,
    dx: number,
    dy: number
  ): void
  /**
   * Perform a "radial-gradient" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param colorLine Color information for the gradient
   * @param x0 X coordinate of the first circle's center
   * @param y0 Y coordinate of the first circle's center
   * @param r0 radius of the first circle
   * @param x1 X coordinate of the second circle's center
   * @param y1 Y coordinate of the second circle's center
   * @param r1 radius of the second circle
   */
  function paintRadialGradient(
    funcs: paint_funcs_t,
    paintData: any | null,
    colorLine: color_line_t,
    x0: number,
    y0: number,
    r0: number,
    x1: number,
    y1: number,
    r1: number
  ): void
  /**
   * Perform a "sweep-gradient" paint operation.
   * @param funcs paint functions
   * @param paintData associated data passed by the caller
   * @param colorLine Color information for the gradient
   * @param x0 X coordinate of the circle's center
   * @param y0 Y coordinate of the circle's center
   * @param startAngle the start angle
   * @param endAngle the end angle
   */
  function paintSweepGradient(
    funcs: paint_funcs_t,
    paintData: any | null,
    colorLine: color_line_t,
    x0: number,
    y0: number,
    startAngle: number,
    endAngle: number
  ): void
  /**
   * Converts an ISO 15924 script tag to a corresponding #hb_script_t.
   * @param tag an #hb_tag_t representing an ISO 15924 tag.
   * @returns An #hb_script_t corresponding to the ISO 15924 tag.
   */
  function scriptFromIso15924Tag(tag: tag_t): script_t
  /**
   * Converts a string `str` representing an ISO 15924 script tag to a
   * corresponding #hb_script_t. Shorthand for hb_tag_from_string() then
   * hb_script_from_iso15924_tag().
   * @param str a string representing an       ISO 15924 tag.
   * @returns An #hb_script_t corresponding to the ISO 15924 tag.
   */
  function scriptFromString(str: number[]): script_t
  /**
   * Fetches the #hb_direction_t of a script when it is
   * set horizontally. All right-to-left scripts will return
   * #HB_DIRECTION_RTL. All left-to-right scripts will return
   * #HB_DIRECTION_LTR.  Scripts that can be written either
   * horizontally or vertically will return #HB_DIRECTION_INVALID.
   * Unknown scripts will return #HB_DIRECTION_LTR.
   * @param script The #hb_script_t to query
   * @returns The horizontal #hb_direction_t of @script
   */
  function scriptGetHorizontalDirection(script: script_t): direction_t
  /**
   * Converts an #hb_script_t to a corresponding ISO 15924 script tag.
   * @param script an #hb_script_t to convert.
   * @returns An #hb_tag_t representing an ISO 15924 script tag.
   */
  function scriptToIso15924Tag(script: script_t): tag_t
  /**
   * Checks the equality of two #hb_segment_properties_t's.
   * @param a first #hb_segment_properties_t to compare.
   * @param b second #hb_segment_properties_t to compare.
   * @returns `true` if all properties of @a equal those of @b, `false` otherwise.
   */
  function segmentPropertiesEqual(
    a: segment_properties_t,
    b: segment_properties_t
  ): bool_t
  /**
   * Creates a hash representing `p`.
   * @param p #hb_segment_properties_t to hash.
   * @returns A hash of @p.
   */
  function segmentPropertiesHash(p: segment_properties_t): number
  /**
   * Fills in missing fields of `p` from `src` in a considered manner.
   *
   * First, if `p` does not have direction set, direction is copied from `src`.
   *
   * Next, if `p` and `src` have the same direction (which can be unset), if `p`
   * does not have script set, script is copied from `src`.
   *
   * Finally, if `p` and `src` have the same direction and script (which either
   * can be unset), if `p` does not have language set, language is copied from
   * `src`.
   * @param p #hb_segment_properties_t to fill in.
   * @param src #hb_segment_properties_t to fill in from.
   */
  function segmentPropertiesOverlay(
    p: segment_properties_t,
    src: segment_properties_t
  ): void
  /**
   * Adds `codepoint` to `set`.
   * @param set A set
   * @param codepoint The element to add to `set`
   */
  function setAdd(set: set_t, codepoint: codepoint_t): void
  /**
   * Adds all of the elements from `first` to `last`
   * (inclusive) to `set`.
   * @param set A set
   * @param first The first element to add to `set`
   * @param last The final element to add to `set`
   */
  function setAddRange(set: set_t, first: codepoint_t, last: codepoint_t): void
  /**
   * Adds `num_codepoints` codepoints to a set at once.
   * The codepoints array must be in increasing order,
   * with size at least `num_codepoints`.
   * @param set A set
   * @param sortedCodepoints Array of codepoints to add
   */
  function setAddSortedArray(set: set_t, sortedCodepoints: codepoint_t[]): void
  /**
   * Tests whether memory allocation for a set was successful.
   * @param set A set
   * @returns `true` if allocation succeeded, `false` otherwise
   */
  function setAllocationSuccessful(set: set_t): bool_t
  /**
   * Clears out the contents of a set.
   * @param set A set
   */
  function setClear(set: set_t): void
  /**
   * Allocate a copy of `set`.
   * @param set A set
   * @returns Newly-allocated set.
   */
  function setCopy(set: set_t): set_t
  /**
   * Creates a new, initially empty set.
   * @returns The new #hb_set_t
   */
  function setCreate(): set_t
  /**
   * Removes `codepoint` from `set`.
   * @param set A set
   * @param codepoint Removes `codepoint` from `set`
   */
  function setDel(set: set_t, codepoint: codepoint_t): void
  /**
   * Removes all of the elements from `first` to `last`
   * (inclusive) from `set`.
   *
   * If `last` is #HB_SET_VALUE_INVALID, then all values
   * greater than or equal to `first` are removed.
   * @param set A set
   * @param first The first element to remove from `set`
   * @param last The final element to remove from `set`
   */
  function setDelRange(set: set_t, first: codepoint_t, last: codepoint_t): void
  /**
   * Fetches the singleton empty #hb_set_t.
   * @returns The empty #hb_set_t
   */
  function setGetEmpty(): set_t
  /**
   * Finds the largest element in the set.
   * @param set A set
   * @returns maximum of @set, or #HB_SET_VALUE_INVALID if @set is empty.
   */
  function setGetMax(set: set_t): codepoint_t
  /**
   * Finds the smallest element in the set.
   * @param set A set
   * @returns minimum of @set, or #HB_SET_VALUE_INVALID if @set is empty.
   */
  function setGetMin(set: set_t): codepoint_t
  /**
   * Returns the number of elements in the set.
   * @param set A set
   * @returns The population of @set
   */
  function setGetPopulation(set: set_t): number
  /**
   * Tests whether `codepoint` belongs to `set`.
   * @param set A set
   * @param codepoint The element to query
   * @returns `true` if @codepoint is in @set, `false` otherwise
   */
  function setHas(set: set_t, codepoint: codepoint_t): bool_t
  /**
   * Creates a hash representing `set`.
   * @param set A set
   * @returns A hash of @set.
   */
  function setHash(set: set_t): number
  /**
   * Makes `set` the intersection of `set` and `other`.
   * @param set A set
   * @param other Another set
   */
  function setIntersect(set: set_t, other: set_t): void
  /**
   * Inverts the contents of `set`.
   * @param set A set
   */
  function setInvert(set: set_t): void
  /**
   * Tests whether a set is empty (contains no elements).
   * @param set a set.
   * @returns `true` if @set is empty
   */
  function setIsEmpty(set: set_t): bool_t
  /**
   * Tests whether `set` and `other` are equal (contain the same
   * elements).
   * @param set A set
   * @param other Another set
   * @returns `true` if the two sets are equal, `false` otherwise.
   */
  function setIsEqual(set: set_t, other: set_t): bool_t
  /**
   * Returns whether the set is inverted.
   * @param set A set
   * @returns `true` if the set is inverted, `false` otherwise
   */
  function setIsInverted(set: set_t): bool_t
  /**
   * Tests whether `set` is a subset of `larger_set`.
   * @param set A set
   * @param largerSet Another set
   * @returns `true` if the @set is a subset of (or equal to) @larger_set, `false` otherwise.
   */
  function setIsSubset(set: set_t, largerSet: set_t): bool_t
  /**
   * Fetches the next element in `set` that is greater than current value of `codepoint`.
   *
   * Set `codepoint` to #HB_SET_VALUE_INVALID to get started.
   * @param set A set
   * @param codepoint Input = Code point to query             Output = Code point retrieved
   * @returns `true` if there was a next value, `false` otherwise
   */
  function setNext(
    set: set_t,
    codepoint: codepoint_t
  ): [/* returnType */ bool_t, /* codepoint */ codepoint_t]
  /**
   * Finds the next element in `set` that is greater than `codepoint`. Writes out
   * codepoints to `out,` until either the set runs out of elements, or `size`
   * codepoints are written, whichever comes first.
   * @param set A set
   * @param codepoint Outputting codepoints starting after this one.             Use #HB_SET_VALUE_INVALID to get started.
   * @param out An array of codepoints to write to.
   * @returns the number of values written.
   */
  function setNextMany(
    set: set_t,
    codepoint: codepoint_t,
    out: codepoint_t[]
  ): number
  /**
   * Fetches the next consecutive range of elements in `set` that
   * are greater than current value of `last`.
   *
   * Set `last` to #HB_SET_VALUE_INVALID to get started.
   * @param set A set
   * @param last Input = The current last code point in the range         Output = The last code point in the range
   * @returns `true` if there was a next range, `false` otherwise
   */
  function setNextRange(
    set: set_t,
    last: codepoint_t
  ): [/* returnType */ bool_t, /* first */ codepoint_t, /* last */ codepoint_t]
  /**
   * Fetches the previous element in `set` that is lower than current value of `codepoint`.
   *
   * Set `codepoint` to #HB_SET_VALUE_INVALID to get started.
   * @param set A set
   * @param codepoint Input = Code point to query             Output = Code point retrieved
   * @returns `true` if there was a previous value, `false` otherwise
   */
  function setPrevious(
    set: set_t,
    codepoint: codepoint_t
  ): [/* returnType */ bool_t, /* codepoint */ codepoint_t]
  /**
   * Fetches the previous consecutive range of elements in `set` that
   * are greater than current value of `last`.
   *
   * Set `first` to #HB_SET_VALUE_INVALID to get started.
   * @param set A set
   * @param first Input = The current first code point in the range         Output = The first code point in the range
   * @returns `true` if there was a previous range, `false` otherwise
   */
  function setPreviousRange(
    set: set_t,
    first: codepoint_t
  ): [/* returnType */ bool_t, /* first */ codepoint_t, /* last */ codepoint_t]
  /**
   * Makes the contents of `set` equal to the contents of `other`.
   * @param set A set
   * @param other Another set
   */
  function setSet(set: set_t, other: set_t): void
  /**
   * Subtracts the contents of `other` from `set`.
   * @param set A set
   * @param other Another set
   */
  function setSubtract(set: set_t, other: set_t): void
  /**
   * Makes `set` the symmetric difference of `set`
   * and `other`.
   * @param set A set
   * @param other Another set
   */
  function setSymmetricDifference(set: set_t, other: set_t): void
  /**
   * Makes `set` the union of `set` and `other`.
   * @param set A set
   * @param other Another set
   */
  function setUnion(set: set_t, other: set_t): void
  /**
   * Shapes `buffer` using `font` turning its Unicode characters content to
   * positioned glyphs. If `features` is not `NULL`, it will be used to control the
   * features applied during shaping. If two `features` have the same tag but
   * overlapping ranges the value of the feature with the higher index takes
   * precedence.
   * @param font an #hb_font_t to use for shaping
   * @param buffer an #hb_buffer_t to shape
   * @param features an array of user    specified #hb_feature_t or `NULL`
   */
  function shape(
    font: font_t,
    buffer: buffer_t,
    features: feature_t[] | null
  ): void
  /**
   * See hb_shape() for details. If `shaper_list` is not `NULL`, the specified
   * shapers will be used in the given order, otherwise the default shapers list
   * will be used.
   * @param font an #hb_font_t to use for shaping
   * @param buffer an #hb_buffer_t to shape
   * @param features an array of user    specified #hb_feature_t or `NULL`
   * @param shaperList a `NULL`-terminated    array of shapers to use or `NULL`
   * @returns false if all shapers failed, true otherwise
   */
  function shapeFull(
    font: font_t,
    buffer: buffer_t,
    features: feature_t[] | null,
    shaperList: string[] | null
  ): bool_t
  /**
   * See hb_shape_full() for basic details. If `shaper_list` is not `NULL`, the specified
   * shapers will be used in the given order, otherwise the default shapers list
   * will be used.
   *
   * In addition, justify the shaping results such that the shaping results reach
   * the target advance width/height, depending on the buffer direction.
   *
   * If the advance of the buffer shaped with hb_shape_full() is already known,
   * put that in *advance. Otherwise set *advance to zero.
   *
   * This API is currently experimental and will probably change in the future.
   * @param font a mutable #hb_font_t to use for shaping
   * @param buffer an #hb_buffer_t to shape
   * @param features an array of user    specified #hb_feature_t or `NULL`
   * @param shaperList a `NULL`-terminated    array of shapers to use or `NULL`
   * @param minTargetAdvance Minimum advance width/height to aim for.
   * @param maxTargetAdvance Maximum advance width/height to aim for.
   * @param advance Input/output advance width/height of the buffer.
   * @returns false if all shapers failed, true otherwise XSince: EXPERIMENTAL
   */
  function shapeJustify(
    font: font_t,
    buffer: buffer_t,
    features: feature_t[] | null,
    shaperList: string[] | null,
    minTargetAdvance: number,
    maxTargetAdvance: number,
    advance: number
  ): [
    /* returnType */ bool_t,
    /* advance */ number,
    /* varTag */ tag_t,
    /* varValue */ number,
  ]
  /**
   * Retrieves the list of shapers supported by HarfBuzz.
   * @returns an array of    constant strings
   */
  function shapeListShapers(): string[]
  /**
   * Constructs a shaping plan for a combination of `face,` `user_features,` `props,`
   * and `shaper_list`.
   * @param face #hb_face_t to use
   * @param props The #hb_segment_properties_t of the segment
   * @param userFeatures The list of user-selected features
   * @param shaperList List of shapers to try
   * @returns The shaping plan
   */
  function shapePlanCreate(
    face: face_t,
    props: segment_properties_t,
    userFeatures: feature_t[],
    shaperList: string[]
  ): shape_plan_t
  /**
   * The variable-font version of #hb_shape_plan_create.
   * Constructs a shaping plan for a combination of `face,` `user_features,` `props,`
   * and `shaper_list,` plus the variation-space coordinates `coords`.
   * @param face #hb_face_t to use
   * @param props The #hb_segment_properties_t of the segment
   * @param userFeatures The list of user-selected features
   * @param coords The list of variation-space coordinates
   * @param shaperList List of shapers to try
   * @returns The shaping plan
   */
  function shapePlanCreate2(
    face: face_t,
    props: segment_properties_t,
    userFeatures: feature_t[],
    coords: number[],
    shaperList: string[]
  ): shape_plan_t
  /**
   * Creates a cached shaping plan suitable for reuse, for a combination
   * of `face,` `user_features,` `props,` and `shaper_list`.
   * @param face #hb_face_t to use
   * @param props The #hb_segment_properties_t of the segment
   * @param userFeatures The list of user-selected features
   * @param shaperList List of shapers to try
   * @returns The shaping plan
   */
  function shapePlanCreateCached(
    face: face_t,
    props: segment_properties_t,
    userFeatures: feature_t[],
    shaperList: string[]
  ): shape_plan_t
  /**
   * The variable-font version of #hb_shape_plan_create_cached.
   * Creates a cached shaping plan suitable for reuse, for a combination
   * of `face,` `user_features,` `props,` and `shaper_list,` plus the
   * variation-space coordinates `coords`.
   * @param face #hb_face_t to use
   * @param props The #hb_segment_properties_t of the segment
   * @param userFeatures The list of user-selected features
   * @param coords The list of variation-space coordinates
   * @param shaperList List of shapers to try
   * @returns The shaping plan
   */
  function shapePlanCreateCached2(
    face: face_t,
    props: segment_properties_t,
    userFeatures: feature_t[],
    coords: number[],
    shaperList: string[]
  ): shape_plan_t
  /**
   * Executes the given shaping plan on the specified buffer, using
   * the given `font` and `features`.
   * @param shapePlan A shaping plan
   * @param font The #hb_font_t to use
   * @param buffer The #hb_buffer_t to work upon
   * @param features Features to enable
   * @returns `true` if success, `false` otherwise.
   */
  function shapePlanExecute(
    shapePlan: shape_plan_t,
    font: font_t,
    buffer: buffer_t,
    features: feature_t[]
  ): bool_t
  /**
   * Fetches the singleton empty shaping plan.
   * @returns The empty shaping plan
   */
  function shapePlanGetEmpty(): shape_plan_t
  /**
   * Fetches the shaper from a given shaping plan.
   * @param shapePlan A shaping plan
   * @returns The shaper
   */
  function shapePlanGetShaper(shapePlan: shape_plan_t): string
  /**
   * Searches variation axes of a #hb_font_t object for a specific axis first,
   * if not set, then tries to get default style values from different
   * tables of the font.
   * @param font a #hb_font_t object.
   * @param styleTag a style tag.
   * @returns Corresponding axis or default value to a style tag.
   */
  function styleGetValue(font: font_t, styleTag: style_tag_t): number
  /**
   * Converts a string into an #hb_tag_t. Valid tags
   * are four characters. Shorter input strings will be
   * padded with spaces. Longer input strings will be
   * truncated.
   * @param str String to convert
   * @returns The #hb_tag_t corresponding to @str
   */
  function tagFromString(str: number[]): tag_t
  /**
   * Converts an #hb_tag_t to a string and returns it in `buf`.
   * Strings will be four characters long.
   * @param tag #hb_tag_t to convert
   */
  function tagToString(tag: tag_t): /* buf */ number[]
  /**
   * Retrieves the Canonical Combining Class (ccc) property
   * of code point `unicode`.
   * @param ufuncs The Unicode-functions structure
   * @param unicode The code point to query
   * @returns The #hb_unicode_combining_class_t of @unicode
   */
  function unicodeCombiningClass(
    ufuncs: unicode_funcs_t,
    unicode: codepoint_t
  ): unicode_combining_class_t
  /**
   * Fetches the composition of a sequence of two Unicode
   * code points.
   *
   * Calls the composition function of the specified
   * Unicode-functions structure `ufuncs`.
   * @param ufuncs The Unicode-functions structure
   * @param a The first Unicode code point to compose
   * @param b The second Unicode code point to compose
   * @returns `true` if @a and @b composed, `false` otherwise
   */
  function unicodeCompose(
    ufuncs: unicode_funcs_t,
    a: codepoint_t,
    b: codepoint_t
  ): [/* returnType */ bool_t, /* ab */ codepoint_t]
  /**
   * Fetches the decomposition of a Unicode code point.
   *
   * Calls the decomposition function of the specified
   * Unicode-functions structure `ufuncs`.
   * @param ufuncs The Unicode-functions structure
   * @param ab Unicode code point to decompose
   * @returns `true` if @ab was decomposed, `false` otherwise
   */
  function unicodeDecompose(
    ufuncs: unicode_funcs_t,
    ab: codepoint_t
  ): [/* returnType */ bool_t, /* a */ codepoint_t, /* b */ codepoint_t]
  /**
   * Fetches the compatibility decomposition of a Unicode
   * code point. Deprecated.
   * @param ufuncs The Unicode-functions structure
   * @param u Code point to decompose
   * @returns length of @decomposed.
   */
  function unicodeDecomposeCompatibility(
    ufuncs: unicode_funcs_t,
    u: codepoint_t
  ): [/* returnType */ number, /* decomposed */ codepoint_t]
  /**
   * Don't use. Not used by HarfBuzz.
   * @param ufuncs a Unicode-function structure
   * @param unicode The code point to query
   */
  function unicodeEastasianWidth(
    ufuncs: unicode_funcs_t,
    unicode: codepoint_t
  ): number
  /**
   * Creates a new #hb_unicode_funcs_t structure of Unicode functions.
   * @param parent Parent Unicode-functions structure
   * @returns The Unicode-functions structure
   */
  function unicodeFuncsCreate(parent: unicode_funcs_t | null): unicode_funcs_t
  /**
   * Fetches a pointer to the default Unicode-functions structure that is used
   * when no functions are explicitly set on #hb_buffer_t.
   * @returns a pointer to the #hb_unicode_funcs_t Unicode-functions structure
   */
  function unicodeFuncsGetDefault(): unicode_funcs_t
  /**
   * Fetches the singleton empty Unicode-functions structure.
   * @returns The empty Unicode-functions structure
   */
  function unicodeFuncsGetEmpty(): unicode_funcs_t
  /**
   * Fetches the parent of the Unicode-functions structure
   * `ufuncs`.
   * @param ufuncs The Unicode-functions structure
   * @returns The parent Unicode-functions structure
   */
  function unicodeFuncsGetParent(ufuncs: unicode_funcs_t): unicode_funcs_t
  /**
   * Tests whether the specified Unicode-functions structure
   * is immutable.
   * @param ufuncs The Unicode-functions structure
   * @returns `true` if @ufuncs is immutable, `false` otherwise
   */
  function unicodeFuncsIsImmutable(ufuncs: unicode_funcs_t): bool_t
  /**
   * Makes the specified Unicode-functions structure
   * immutable.
   * @param ufuncs The Unicode-functions structure
   */
  function unicodeFuncsMakeImmutable(ufuncs: unicode_funcs_t): void
  /**
   * Sets the implementation function for #hb_unicode_combining_class_func_t.
   * @param ufuncs A Unicode-functions structure
   * @param func The callback function to assign
   */
  function unicodeFuncsSetCombiningClassFunc(
    ufuncs: unicode_funcs_t,
    func: unicode_combining_class_func_t
  ): void
  /**
   * Sets the implementation function for #hb_unicode_compose_func_t.
   * @param ufuncs A Unicode-functions structure
   * @param func The callback function to assign
   */
  function unicodeFuncsSetComposeFunc(
    ufuncs: unicode_funcs_t,
    func: unicode_compose_func_t
  ): void
  /**
   * Sets the implementation function for #hb_unicode_decompose_compatibility_func_t.
   * @param ufuncs A Unicode-functions structure
   * @param func The callback function to assign
   */
  function unicodeFuncsSetDecomposeCompatibilityFunc(
    ufuncs: unicode_funcs_t,
    func: unicode_decompose_compatibility_func_t
  ): void
  /**
   * Sets the implementation function for #hb_unicode_decompose_func_t.
   * @param ufuncs A Unicode-functions structure
   * @param func The callback function to assign
   */
  function unicodeFuncsSetDecomposeFunc(
    ufuncs: unicode_funcs_t,
    func: unicode_decompose_func_t
  ): void
  /**
   * Sets the implementation function for #hb_unicode_eastasian_width_func_t.
   * @param ufuncs a Unicode-function structure
   * @param func The callback function to assign
   */
  function unicodeFuncsSetEastasianWidthFunc(
    ufuncs: unicode_funcs_t,
    func: unicode_eastasian_width_func_t
  ): void
  /**
   * Sets the implementation function for #hb_unicode_general_category_func_t.
   * @param ufuncs A Unicode-functions structure
   * @param func The callback function to assign
   */
  function unicodeFuncsSetGeneralCategoryFunc(
    ufuncs: unicode_funcs_t,
    func: unicode_general_category_func_t
  ): void
  /**
   * Sets the implementation function for #hb_unicode_mirroring_func_t.
   * @param ufuncs A Unicode-functions structure
   * @param func The callback function to assign
   */
  function unicodeFuncsSetMirroringFunc(
    ufuncs: unicode_funcs_t,
    func: unicode_mirroring_func_t
  ): void
  /**
   * Sets the implementation function for #hb_unicode_script_func_t.
   * @param ufuncs A Unicode-functions structure
   * @param func The callback function to assign
   */
  function unicodeFuncsSetScriptFunc(
    ufuncs: unicode_funcs_t,
    func: unicode_script_func_t
  ): void
  /**
   * Retrieves the General Category (gc) property
   * of code point `unicode`.
   * @param ufuncs The Unicode-functions structure
   * @param unicode The code point to query
   * @returns The #hb_unicode_general_category_t of @unicode
   */
  function unicodeGeneralCategory(
    ufuncs: unicode_funcs_t,
    unicode: codepoint_t
  ): unicode_general_category_t
  /**
   * Retrieves the Bi-directional Mirroring Glyph code
   * point defined for code point `unicode`.
   * @param ufuncs The Unicode-functions structure
   * @param unicode The code point to query
   * @returns The #hb_codepoint_t of the Mirroring Glyph for @unicode
   */
  function unicodeMirroring(
    ufuncs: unicode_funcs_t,
    unicode: codepoint_t
  ): codepoint_t
  /**
   * Retrieves the #hb_script_t script to which code
   * point `unicode` belongs.
   * @param ufuncs The Unicode-functions structure
   * @param unicode The code point to query
   * @returns The #hb_script_t of @unicode
   */
  function unicodeScript(
    ufuncs: unicode_funcs_t,
    unicode: codepoint_t
  ): script_t
  /**
   * Parses a string into a #hb_variation_t.
   *
   * The format for specifying variation settings follows. All valid CSS
   * font-variation-settings values other than 'normal' and 'inherited' are also
   * accepted, though, not documented below.
   *
   * The format is a tag, optionally followed by an equals sign, followed by a
   * number. For example `wght=500`, or `slnt=-7.5`.
   * @param str a string to parse
   * @returns `true` if @str is successfully parsed, `false` otherwise
   */
  function variationFromString(
    str: number[]
  ): [/* returnType */ bool_t, /* variation */ variation_t]
  /**
   * Converts an #hb_variation_t into a `NULL`-terminated string in the format
   * understood by hb_variation_from_string(). The client in responsible for
   * allocating big enough size for `buf,` 128 bytes is more than enough.
   * @param variation an #hb_variation_t to convert
   */
  function variationToString(variation: variation_t): /* buf */ string[]
  /**
   * A callback method for #hb_buffer_t. The method gets called with the
   * #hb_buffer_t it was set on, the #hb_font_t the buffer is shaped with and a
   * message describing what step of the shaping process will be performed.
   * Returning `false` from this method will skip this shaping step and move to
   * the next one.
   * @callback
   * @param buffer An #hb_buffer_t to work upon
   * @param font The #hb_font_t the `buffer` is shaped with
   * @param message `NULL`-terminated message passed to the function
   * @returns `true` to perform the shaping step, `false` to skip it.
   */
  interface buffer_message_func_t {
    (buffer: buffer_t, font: font_t, message: string): bool_t
  }
  /**
   * A virtual method for the #hb_color_line_t to fetch color stops.
   * @callback
   * @param colorLine a #hb_color_line_t object
   * @param colorLineData the data accompanying `color_line`
   * @param start the index of the first color stop to return
   * @returns the total number of color stops in @color_line
   */
  interface color_line_get_color_stops_func_t {
    (colorLine: color_line_t, colorLineData: any | null, start: number): number
  }
  /**
   * A virtual method for the `hb_color_line_t` to fetches the extend mode.
   * @callback
   * @param colorLine a #hb_color_line_t object
   * @param colorLineData the data accompanying `color_line`
   * @returns the extend mode of @color_line
   */
  interface color_line_get_extend_func_t {
    (colorLine: color_line_t, colorLineData: any | null): paint_extend_t
  }
  /**
   * A virtual method for destroy user-data callbacks.
   * @callback
   */
  interface destroy_func_t {
    (): void
  }
  /**
   * A virtual method for the #hb_draw_funcs_t to perform a "close-path" draw
   * operation.
   * @callback
   * @param dfuncs draw functions object
   * @param drawData The data accompanying the draw functions in hb_font_draw_glyph()
   * @param st current draw state
   */
  interface draw_close_path_func_t {
    (dfuncs: draw_funcs_t, drawData: any | null, st: draw_state_t): void
  }
  /**
   * A virtual method for the #hb_draw_funcs_t to perform a "cubic-to" draw
   * operation.
   * @callback
   * @param dfuncs draw functions object
   * @param drawData The data accompanying the draw functions in hb_font_draw_glyph()
   * @param st current draw state
   * @param control1X X component of first control point
   * @param control1Y Y component of first control point
   * @param control2X X component of second control point
   * @param control2Y Y component of second control point
   * @param toX X component of target point
   * @param toY Y component of target point
   */
  interface draw_cubic_to_func_t {
    (
      dfuncs: draw_funcs_t,
      drawData: any | null,
      st: draw_state_t,
      control1X: number,
      control1Y: number,
      control2X: number,
      control2Y: number,
      toX: number,
      toY: number
    ): void
  }
  /**
   * A virtual method for the #hb_draw_funcs_t to perform a "line-to" draw
   * operation.
   * @callback
   * @param dfuncs draw functions object
   * @param drawData The data accompanying the draw functions in hb_font_draw_glyph()
   * @param st current draw state
   * @param toX X component of target point
   * @param toY Y component of target point
   */
  interface draw_line_to_func_t {
    (
      dfuncs: draw_funcs_t,
      drawData: any | null,
      st: draw_state_t,
      toX: number,
      toY: number
    ): void
  }
  /**
   * A virtual method for the #hb_draw_funcs_t to perform a "move-to" draw
   * operation.
   * @callback
   * @param dfuncs draw functions object
   * @param drawData The data accompanying the draw functions in hb_font_draw_glyph()
   * @param st current draw state
   * @param toX X component of target point
   * @param toY Y component of target point
   */
  interface draw_move_to_func_t {
    (
      dfuncs: draw_funcs_t,
      drawData: any | null,
      st: draw_state_t,
      toX: number,
      toY: number
    ): void
  }
  /**
   * A virtual method for the #hb_draw_funcs_t to perform a "quadratic-to" draw
   * operation.
   * @callback
   * @param dfuncs draw functions object
   * @param drawData The data accompanying the draw functions in hb_font_draw_glyph()
   * @param st current draw state
   * @param controlX X component of control point
   * @param controlY Y component of control point
   * @param toX X component of target point
   * @param toY Y component of target point
   */
  interface draw_quadratic_to_func_t {
    (
      dfuncs: draw_funcs_t,
      drawData: any | null,
      st: draw_state_t,
      controlX: number,
      controlY: number,
      toX: number,
      toY: number
    ): void
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param glyph The glyph ID to query
   * @param drawFuncs The draw functions to send the shape data to
   * @param drawData The data accompanying the draw functions
   */
  interface font_draw_glyph_func_t {
    (
      font: font_t,
      fontData: any | null,
      glyph: codepoint_t,
      drawFuncs: draw_funcs_t,
      drawData: any | null
    ): void
  }
  /**
   * This method should retrieve the extents for a font.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   */
  interface font_get_font_extents_func_t {
    (font: font_t, fontData: any | null): bool_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the advance for a specified glyph. The
   * method must return an #hb_position_t.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param glyph The glyph ID to query
   * @returns The advance of @glyph within @font
   */
  interface font_get_glyph_advance_func_t {
    (font: font_t, fontData: any | null, glyph: codepoint_t): position_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the advances for a sequence of glyphs.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param count The number of glyph IDs in the sequence queried
   * @param firstGlyph The first glyph ID to query
   * @param glyphStride The stride between successive glyph IDs
   * @param advanceStride The stride between successive advances
   */
  interface font_get_glyph_advances_func_t {
    (
      font: font_t,
      fontData: any | null,
      count: number,
      firstGlyph: codepoint_t,
      glyphStride: number,
      advanceStride: number
    ): void
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the (X,Y) coordinates (in font units) for a
   * specified contour point in a glyph. Each coordinate must be returned as
   * an #hb_position_t output parameter.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param glyph The glyph ID to query
   * @param pointIndex The contour-point index to query
   * @returns `true` if data found, `false` otherwise
   */
  interface font_get_glyph_contour_point_func_t {
    (
      font: font_t,
      fontData: any | null,
      glyph: codepoint_t,
      pointIndex: number
    ): bool_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the extents for a specified glyph. Extents must be
   * returned in an #hb_glyph_extents output parameter.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param glyph The glyph ID to query
   * @returns `true` if data found, `false` otherwise
   */
  interface font_get_glyph_extents_func_t {
    (font: font_t, fontData: any | null, glyph: codepoint_t): bool_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the glyph ID that corresponds to a glyph-name
   * string.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param name The name string to query
   * @returns `true` if data found, `false` otherwise
   */
  interface font_get_glyph_from_name_func_t {
    (font: font_t, fontData: any | null, name: string[]): bool_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the glyph ID for a specified Unicode code point
   * font, with an optional variation selector.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param unicode The Unicode code point to query
   * @param variationSelector The  variation-selector code point to query
   * @returns `true` if data found, `false` otherwise
   */
  interface font_get_glyph_func_t {
    (
      font: font_t,
      fontData: any | null,
      unicode: codepoint_t,
      variationSelector: codepoint_t
    ): bool_t
  }
  /**
   * This method should retrieve the kerning-adjustment value for a glyph-pair in
   * the specified font, for horizontal text segments.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param firstGlyph The glyph ID of the first glyph in the glyph pair
   * @param secondGlyph The glyph ID of the second glyph in the glyph pair
   */
  interface font_get_glyph_kerning_func_t {
    (
      font: font_t,
      fontData: any | null,
      firstGlyph: codepoint_t,
      secondGlyph: codepoint_t
    ): position_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the glyph name that corresponds to a
   * glyph ID. The name should be returned in a string output parameter.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param glyph The glyph ID to query
   * @returns `true` if data found, `false` otherwise
   */
  interface font_get_glyph_name_func_t {
    (font: font_t, fontData: any | null, glyph: codepoint_t): bool_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the (X,Y) coordinates (in font units) of the
   * origin for a glyph. Each coordinate must be returned in an #hb_position_t
   * output parameter.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param glyph The glyph ID to query
   * @returns `true` if data found, `false` otherwise
   */
  interface font_get_glyph_origin_func_t {
    (font: font_t, fontData: any | null, glyph: codepoint_t): bool_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param glyph The glyph ID to query
   * @param drawFuncs The draw functions to send the shape data to
   * @param drawData The data accompanying the draw functions
   */
  interface font_get_glyph_shape_func_t {
    (
      font: font_t,
      fontData: any | null,
      glyph: codepoint_t,
      drawFuncs: draw_funcs_t,
      drawData: any | null
    ): void
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the nominal glyph ID for a specified Unicode code
   * point. Glyph IDs must be returned in a #hb_codepoint_t output parameter.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param unicode The Unicode code point to query
   * @returns `true` if data found, `false` otherwise
   */
  interface font_get_nominal_glyph_func_t {
    (font: font_t, fontData: any | null, unicode: codepoint_t): bool_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the nominal glyph IDs for a sequence of
   * Unicode code points. Glyph IDs must be returned in a #hb_codepoint_t
   * output parameter.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param count number of code points to query
   * @param firstUnicode The first Unicode code point to query
   * @param unicodeStride The stride between successive code points
   * @param glyphStride The stride between successive glyph IDs
   * @returns the number of code points processed
   */
  interface font_get_nominal_glyphs_func_t {
    (
      font: font_t,
      fontData: any | null,
      count: number,
      firstUnicode: codepoint_t,
      unicodeStride: number,
      glyphStride: number
    ): number
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   *
   * This method should retrieve the glyph ID for a specified Unicode code point
   * followed by a specified Variation Selector code point. Glyph IDs must be
   * returned in a #hb_codepoint_t output parameter.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param unicode The Unicode code point to query
   * @param variationSelector The  variation-selector code point to query
   * @returns `true` if data found, `false` otherwise
   */
  interface font_get_variation_glyph_func_t {
    (
      font: font_t,
      fontData: any | null,
      unicode: codepoint_t,
      variationSelector: codepoint_t
    ): bool_t
  }
  /**
   * A virtual method for the #hb_font_funcs_t of an #hb_font_t object.
   * @callback
   * @param font #hb_font_t to work upon
   * @param fontData `font` user data pointer
   * @param glyph The glyph ID to query
   * @param paintFuncs The paint functions to use
   * @param paintData The data accompanying the paint functions
   * @param paletteIndex The color palette to use
   * @param foreground The foreground color
   */
  interface font_paint_glyph_func_t {
    (
      font: font_t,
      fontData: any | null,
      glyph: codepoint_t,
      paintFuncs: paint_funcs_t,
      paintData: any | null,
      paletteIndex: number,
      foreground: color_t
    ): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to paint a
   * color everywhere within the current clip.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param isForeground whether the color is the foreground
   * @param color The color to use, unpremultiplied
   */
  interface paint_color_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      isForeground: bool_t,
      color: color_t
    ): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to render a color glyph by glyph index.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param glyph the glyph ID
   * @param font the font
   * @returns %true if the glyph was painted, %false otherwise.
   */
  interface paint_color_glyph_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      glyph: codepoint_t,
      font: font_t
    ): bool_t
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to fetch a color from the custom
   * color palette.
   *
   * Custom palette colors override the colors from the fonts selected color
   * palette. It is not necessary to override all palette entries; for entries
   * that should be taken from the font palette, return `false`.
   *
   * This function might get called multiple times, but the custom palette is
   * expected to remain unchanged for duration of a hb_font_paint_glyph() call.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param colorIndex the color index
   * @returns `true` if found, `false` otherwise
   */
  interface paint_custom_palette_color_func_t {
    (funcs: paint_funcs_t, paintData: any | null, colorIndex: number): bool_t
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to paint a glyph image.
   *
   * This method is called for glyphs with image blobs in the CBDT,
   * sbix or SVG tables. The `format` identifies the kind of data that
   * is contained in `image`. Possible values include #HB_PAINT_IMAGE_FORMAT_PNG,
   * #HB_PAINT_IMAGE_FORMAT_SVG and #HB_PAINT_IMAGE_FORMAT_BGRA.
   *
   * The image dimensions and glyph extents are provided if available,
   * and should be used to size and position the image.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param image the image data
   * @param width width of the raster image in pixels, or 0
   * @param height height of the raster image in pixels, or 0
   * @param format the image format as a tag
   * @param slant the synthetic slant ratio to be applied to the image during rendering
   * @param extents glyph extents for desired rendering
   * @returns Whether the operation was successful.
   */
  interface paint_image_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      image: blob_t,
      width: number,
      height: number,
      format: tag_t,
      slant: number,
      extents: glyph_extents_t | null
    ): bool_t
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to paint a linear
   * gradient everywhere within the current clip.
   *
   * The `color_line` object contains information about the colors of the gradients.
   * It is only valid for the duration of the callback, you cannot keep it around.
   *
   * The coordinates of the points are interpreted according
   * to the current transform.
   *
   * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
   * section for details on how the points define the direction
   * of the gradient, and how to interpret the `color_line`.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param colorLine Color information for the gradient
   * @param x0 X coordinate of the first point
   * @param y0 Y coordinate of the first point
   * @param x1 X coordinate of the second point
   * @param y1 Y coordinate of the second point
   * @param x2 X coordinate of the third point
   * @param y2 Y coordinate of the third point
   */
  interface paint_linear_gradient_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      colorLine: color_line_t,
      x0: number,
      y0: number,
      x1: number,
      y1: number,
      x2: number,
      y2: number
    ): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to undo
   * the effect of a prior call to the #hb_paint_funcs_push_clip_glyph_func_t
   * or #hb_paint_funcs_push_clip_rectangle_func_t vfuncs.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   */
  interface paint_pop_clip_func_t {
    (funcs: paint_funcs_t, paintData: any | null): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to undo
   * the effect of a prior call to the #hb_paint_funcs_push_group_func_t
   * vfunc.
   *
   * This call stops the redirection to the intermediate surface,
   * and then composites it on the previous surface, using the
   * compositing mode passed to this call.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param mode the compositing mode to use
   */
  interface paint_pop_group_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      mode: paint_composite_mode_t
    ): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to undo
   * the effect of a prior call to the #hb_paint_funcs_push_transform_func_t
   * vfunc.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   */
  interface paint_pop_transform_func_t {
    (funcs: paint_funcs_t, paintData: any | null): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to clip
   * subsequent paint calls to the outline of a glyph.
   *
   * The coordinates of the glyph outline are interpreted according
   * to the current transform.
   *
   * This clip is applied in addition to the current clip,
   * and remains in effect until a matching call to
   * the #hb_paint_funcs_pop_clip_func_t vfunc.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param glyph the glyph ID
   * @param font the font
   */
  interface paint_push_clip_glyph_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      glyph: codepoint_t,
      font: font_t
    ): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to clip
   * subsequent paint calls to a rectangle.
   *
   * The coordinates of the rectangle are interpreted according
   * to the current transform.
   *
   * This clip is applied in addition to the current clip,
   * and remains in effect until a matching call to
   * the #hb_paint_funcs_pop_clip_func_t vfunc.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param xmin min X for the rectangle
   * @param ymin min Y for the rectangle
   * @param xmax max X for the rectangle
   * @param ymax max Y for the rectangle
   */
  interface paint_push_clip_rectangle_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      xmin: number,
      ymin: number,
      xmax: number,
      ymax: number
    ): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to use
   * an intermediate surface for subsequent paint calls.
   *
   * The drawing will be redirected to an intermediate surface
   * until a matching call to the #hb_paint_funcs_pop_group_func_t
   * vfunc.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   */
  interface paint_push_group_func_t {
    (funcs: paint_funcs_t, paintData: any | null): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to apply
   * a transform to subsequent paint calls.
   *
   * This transform is applied after the current transform,
   * and remains in effect until a matching call to
   * the #hb_paint_funcs_pop_transform_func_t vfunc.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param xx xx component of the transform matrix
   * @param yx yx component of the transform matrix
   * @param xy xy component of the transform matrix
   * @param yy yy component of the transform matrix
   * @param dx dx component of the transform matrix
   * @param dy dy component of the transform matrix
   */
  interface paint_push_transform_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      xx: number,
      yx: number,
      xy: number,
      yy: number,
      dx: number,
      dy: number
    ): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to paint a radial
   * gradient everywhere within the current clip.
   *
   * The `color_line` object contains information about the colors of the gradients.
   * It is only valid for the duration of the callback, you cannot keep it around.
   *
   * The coordinates of the points are interpreted according
   * to the current transform.
   *
   * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
   * section for details on how the points define the direction
   * of the gradient, and how to interpret the `color_line`.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param colorLine Color information for the gradient
   * @param x0 X coordinate of the first circle's center
   * @param y0 Y coordinate of the first circle's center
   * @param r0 radius of the first circle
   * @param x1 X coordinate of the second circle's center
   * @param y1 Y coordinate of the second circle's center
   * @param r1 radius of the second circle
   */
  interface paint_radial_gradient_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      colorLine: color_line_t,
      x0: number,
      y0: number,
      r0: number,
      x1: number,
      y1: number,
      r1: number
    ): void
  }
  /**
   * A virtual method for the #hb_paint_funcs_t to paint a sweep
   * gradient everywhere within the current clip.
   *
   * The `color_line` object contains information about the colors of the gradients.
   * It is only valid for the duration of the callback, you cannot keep it around.
   *
   * The coordinates of the points are interpreted according
   * to the current transform.
   *
   * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
   * section for details on how the points define the direction
   * of the gradient, and how to interpret the `color_line`.
   * @callback
   * @param funcs paint functions object
   * @param paintData The data accompanying the paint functions in hb_font_paint_glyph()
   * @param colorLine Color information for the gradient
   * @param x0 X coordinate of the circle's center
   * @param y0 Y coordinate of the circle's center
   * @param startAngle the start angle, in radians
   * @param endAngle the end angle, in radians
   */
  interface paint_sweep_gradient_func_t {
    (
      funcs: paint_funcs_t,
      paintData: any | null,
      colorLine: color_line_t,
      x0: number,
      y0: number,
      startAngle: number,
      endAngle: number
    ): void
  }
  /**
   * Callback function for hb_face_create_for_tables().
   * @callback
   * @param face an #hb_face_t to reference table for
   * @param tag the tag of the table to reference
   * @returns A pointer to the @tag table within @face
   */
  interface reference_table_func_t {
    (face: face_t, tag: tag_t): blob_t
  }
  /**
   * A virtual method for the #hb_unicode_funcs_t structure.
   *
   * This method should retrieve the Canonical Combining Class (ccc)
   * property for a specified Unicode code point.
   * @callback
   * @param ufuncs A Unicode-functions structure
   * @param unicode The code point to query
   * @returns The #hb_unicode_combining_class_t of @unicode
   */
  interface unicode_combining_class_func_t {
    (ufuncs: unicode_funcs_t, unicode: codepoint_t): unicode_combining_class_t
  }
  /**
   * A virtual method for the #hb_unicode_funcs_t structure.
   *
   * This method should compose a sequence of two input Unicode code
   * points by canonical equivalence, returning the composed code
   * point in a #hb_codepoint_t output parameter (if successful).
   * The method must return an #hb_bool_t indicating the success
   * of the composition.
   * @callback
   * @param ufuncs A Unicode-functions structure
   * @param a The first code point to compose
   * @param b The second code point to compose
   * @returns `true` is @a,@b composed, `false` otherwise
   */
  interface unicode_compose_func_t {
    (ufuncs: unicode_funcs_t, a: codepoint_t, b: codepoint_t): bool_t
  }
  /**
   * Fully decompose `u` to its Unicode compatibility decomposition. The codepoints of the decomposition will be written to `decomposed`.
   * The complete length of the decomposition will be returned.
   *
   * If `u` has no compatibility decomposition, zero should be returned.
   *
   * The Unicode standard guarantees that a buffer of length #HB_UNICODE_MAX_DECOMPOSITION_LEN codepoints will always be sufficient for any
   * compatibility decomposition plus an terminating value of 0.  Consequently, `decompose` must be allocated by the caller to be at least this length.  Implementations
   * of this function type must ensure that they do not write past the provided array.
   * @callback
   * @param ufuncs a Unicode function structure
   * @param u codepoint to decompose
   * @param decomposed address of codepoint array (of length #HB_UNICODE_MAX_DECOMPOSITION_LEN) to write decomposition into
   * @returns number of codepoints in the full compatibility decomposition of @u, or 0 if no decomposition available.
   */
  interface unicode_decompose_compatibility_func_t {
    (ufuncs: unicode_funcs_t, u: codepoint_t, decomposed: codepoint_t): number
  }
  /**
   * A virtual method for the #hb_unicode_funcs_t structure.
   *
   * This method should decompose an input Unicode code point,
   * returning the two decomposed code points in #hb_codepoint_t
   * output parameters (if successful). The method must return an
   * #hb_bool_t indicating the success of the composition.
   * @callback
   * @param ufuncs A Unicode-functions structure
   * @param ab The code point to decompose
   * @returns `true` if @ab decomposed, `false` otherwise
   */
  interface unicode_decompose_func_t {
    (ufuncs: unicode_funcs_t, ab: codepoint_t): bool_t
  }
  /**
   * A virtual method for the #hb_unicode_funcs_t structure.
   * @callback
   * @param ufuncs A Unicode-functions structure
   * @param unicode The code point to query
   */
  interface unicode_eastasian_width_func_t {
    (ufuncs: unicode_funcs_t, unicode: codepoint_t): number
  }
  /**
   * A virtual method for the #hb_unicode_funcs_t structure.
   *
   * This method should retrieve the General Category property for
   * a specified Unicode code point.
   * @callback
   * @param ufuncs A Unicode-functions structure
   * @param unicode The code point to query
   * @returns The #hb_unicode_general_category_t of @unicode
   */
  interface unicode_general_category_func_t {
    (ufuncs: unicode_funcs_t, unicode: codepoint_t): unicode_general_category_t
  }
  /**
   * A virtual method for the #hb_unicode_funcs_t structure.
   *
   * This method should retrieve the Bi-Directional Mirroring Glyph
   * code point for a specified Unicode code point.
   *
   * <note>Note: If a code point does not have a specified
   * Bi-Directional Mirroring Glyph defined, the method should
   * return the original code point.</note>
   * @callback
   * @param ufuncs A Unicode-functions structure
   * @param unicode The code point to query
   * @returns The #hb_codepoint_t of the Mirroring Glyph for @unicode
   */
  interface unicode_mirroring_func_t {
    (ufuncs: unicode_funcs_t, unicode: codepoint_t): codepoint_t
  }
  /**
   * A virtual method for the #hb_unicode_funcs_t structure.
   *
   * This method should retrieve the Script property for a
   * specified Unicode code point.
   * @callback
   * @param ufuncs A Unicode-functions structure
   * @param unicode The code point to query
   * @returns The #hb_script_t of @unicode
   */
  interface unicode_script_func_t {
    (ufuncs: unicode_funcs_t, unicode: codepoint_t): script_t
  }
  interface aat_layout_feature_selector_info_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.aat_layout_feature_selector_info_t

    /**
     * The selector's name identifier
     * @field
     */
    nameId: ot_name_id_t
    /**
     * The value to turn the selector on
     * @field
     */
    enable: aat_layout_feature_selector_t
    /**
     * The value to turn the selector off
     * @field
     */
    disable: aat_layout_feature_selector_t
  }

  /**
   * Structure representing a setting for an #hb_aat_layout_feature_type_t.
   * @record
   */
  class aat_layout_feature_selector_info_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.aat_layout_feature_selector_info_t

    static name: string
  }

  interface blob_t {}

  /**
   * Data type for blobs. A blob wraps a chunk of binary
   * data and facilitates its lifecycle management between
   * a client program and HarfBuzz.
   * @record
   */
  class blob_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.blob_t

    static name: string
  }

  interface buffer_t {}

  /**
   * The main structure holding the input text and its properties before shaping,
   * and output glyphs and their information after shaping.
   * @record
   */
  class buffer_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.buffer_t

    static name: string
  }

  interface color_line_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.color_line_t

    data: any
    getColorStops: color_line_get_color_stops_func_t
    getColorStopsUserData: any
    getExtend: color_line_get_extend_func_t
    getExtendUserData: any
    reserved0: any
    reserved1: any
    reserved2: any
    reserved3: any
    reserved5: any
    reserved6: any
    reserved7: any
    reserved8: any
  }

  /**
   * A struct containing color information for a gradient.
   * @record
   */
  class color_line_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.color_line_t

    static name: string
  }

  interface color_stop_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.color_stop_t

    /**
     * the offset of the color stop
     * @field
     */
    offset: number
    /**
     * whether the color is the foreground
     * @field
     */
    isForeground: bool_t
    /**
     * the color, unpremultiplied
     * @field
     */
    color: color_t
  }

  /**
   * Information about a color stop on a color line.
   *
   * Color lines typically have offsets ranging between 0 and 1,
   * but that is not required.
   *
   * Note: despite `color` being unpremultiplied here, interpolation in
   * gradients shall happen in premultiplied space. See the OpenType spec
   * [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
   * section for details.
   * @record
   */
  class color_stop_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.color_stop_t

    static name: string
  }

  interface draw_funcs_t {}

  /**
   * Glyph draw callbacks.
   *
   * #hb_draw_move_to_func_t, #hb_draw_line_to_func_t and
   * #hb_draw_cubic_to_func_t calls are necessary to be defined but we translate
   * #hb_draw_quadratic_to_func_t calls to #hb_draw_cubic_to_func_t if the
   * callback isn't defined.
   * @record
   */
  class draw_funcs_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.draw_funcs_t

    static name: string
  }

  interface draw_state_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.draw_state_t

    /**
     * Whether there is an open path
     * @field
     */
    pathOpen: bool_t
    /**
     * X component of the start of current path
     * @field
     */
    pathStartX: number
    /**
     * Y component of the start of current path
     * @field
     */
    pathStartY: number
    /**
     * X component of current point
     * @field
     */
    currentX: number
    /**
     * Y component of current point
     * @field
     */
    currentY: number
  }

  /**
   * Current drawing state.
   * @record
   */
  class draw_state_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.draw_state_t

    static name: string
  }

  interface face_t {}

  /**
   * Data type for holding font faces.
   * @record
   */
  class face_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.face_t

    static name: string
  }

  interface feature_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.feature_t

    /**
     * The #hb_tag_t tag of the feature
     * @field
     */
    tag: tag_t
    /**
     * The value of the feature. 0 disables the feature, non-zero (usually
     * 1) enables the feature.  For features implemented as lookup type 3 (like
     * 'salt') the `value` is a one based index into the alternates.
     * @field
     */
    value: number
    /**
     * the cluster to start applying this feature setting (inclusive).
     * @field
     */
    start: number
    /**
     * the cluster to end applying this feature setting (exclusive).
     * @field
     */
    end: number

    // Owm methods of HarfBuzz-0.0.HarfBuzz.feature_t

    /**
     * Converts a #hb_feature_t into a `NULL`-terminated string in the format
     * understood by hb_feature_from_string(). The client in responsible for
     * allocating big enough size for `buf,` 128 bytes is more than enough.
     */
    string(): /* buf */ string[]
  }

  /**
   * The #hb_feature_t is the structure that holds information about requested
   * feature application. The feature will be applied with the given value to all
   * glyphs which are in clusters between `start` (inclusive) and `end` (exclusive).
   * Setting start to #HB_FEATURE_GLOBAL_START and end to #HB_FEATURE_GLOBAL_END
   * specifies that the feature always applies to the entire buffer.
   * @record
   */
  class feature_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.feature_t

    static name: string
  }

  interface font_extents_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.font_extents_t

    /**
     * The height of typographic ascenders.
     * @field
     */
    ascender: position_t
    /**
     * The depth of typographic descenders.
     * @field
     */
    descender: position_t
    /**
     * The suggested line-spacing gap.
     * @field
     */
    lineGap: position_t
  }

  /**
   * Font-wide extent values, measured in font units.
   *
   * Note that typically `ascender` is positive and `descender`
   * negative, in coordinate systems that grow up.
   * @record
   */
  class font_extents_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.font_extents_t

    static name: string
  }

  interface font_funcs_t {}

  /**
   * Data type containing a set of virtual methods used for
   * working on #hb_font_t font objects.
   *
   * HarfBuzz provides a lightweight default function for each of
   * the methods in #hb_font_funcs_t. Client programs can implement
   * their own replacements for the individual font functions, as
   * needed, and replace the default by calling the setter for a
   * method.
   * @record
   */
  class font_funcs_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.font_funcs_t

    static name: string
  }

  interface font_t {}

  /**
   * Data type for holding fonts.
   * @record
   */
  class font_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.font_t

    static name: string
  }

  interface glyph_extents_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.glyph_extents_t

    /**
     * Distance from the x-origin to the left extremum of the glyph.
     * @field
     */
    xBearing: position_t
    /**
     * Distance from the top extremum of the glyph to the y-origin.
     * @field
     */
    yBearing: position_t
    /**
     * Distance from the left extremum of the glyph to the right extremum.
     * @field
     */
    width: position_t
    /**
     * Distance from the top extremum of the glyph to the bottom extremum.
     * @field
     */
    height: position_t
  }

  /**
   * Glyph extent values, measured in font units.
   *
   * Note that `height` is negative, in coordinate systems that grow up.
   * @record
   */
  class glyph_extents_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.glyph_extents_t

    static name: string
  }

  interface glyph_info_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.glyph_info_t

    /**
     * either a Unicode code point (before shaping) or a glyph index
     *             (after shaping).
     * @field
     */
    codepoint: codepoint_t
    /**
     * the index of the character in the original text that corresponds
     *           to this #hb_glyph_info_t, or whatever the client passes to
     *           hb_buffer_add(). More than one #hb_glyph_info_t can have the same
     *           `cluster` value, if they resulted from the same character (e.g. one
     *           to many glyph substitution), and when more than one character gets
     *           merged in the same glyph (e.g. many to one glyph substitution) the
     *           #hb_glyph_info_t will have the smallest cluster value of them.
     *           By default some characters are merged into the same cluster
     *           (e.g. combining marks have the same cluster as their bases)
     *           even if they are separate glyphs, hb_buffer_set_cluster_level()
     *           allow selecting more fine-grained cluster handling.
     * @field
     */
    cluster: number
  }

  /**
   * The #hb_glyph_info_t is the structure that holds information about the
   * glyphs and their relation to input text.
   * @record
   */
  class glyph_info_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.glyph_info_t

    static name: string
  }

  interface glyph_position_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.glyph_position_t

    /**
     * how much the line advances after drawing this glyph when setting
     *             text in horizontal direction.
     * @field
     */
    xAdvance: position_t
    /**
     * how much the line advances after drawing this glyph when setting
     *             text in vertical direction.
     * @field
     */
    yAdvance: position_t
    /**
     * how much the glyph moves on the X-axis before drawing it, this
     *            should not affect how much the line advances.
     * @field
     */
    xOffset: position_t
    /**
     * how much the glyph moves on the Y-axis before drawing it, this
     *            should not affect how much the line advances.
     * @field
     */
    yOffset: position_t
  }

  /**
   * The #hb_glyph_position_t is the structure that holds the positions of the
   * glyph in both horizontal and vertical directions. All positions in
   * #hb_glyph_position_t are relative to the current point.
   * @record
   */
  class glyph_position_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.glyph_position_t

    static name: string
  }

  interface language_t {
    // Owm methods of HarfBuzz-0.0.HarfBuzz.language_t

    /**
     * Converts an #hb_language_t to a string.
     * @returns A `NULL`-terminated string representing the @language. Must not be freed by the caller.
     */
    string(): string
  }

  /**
   * Data type for languages. Each #hb_language_t corresponds to a BCP 47
   * language tag.
   * @record
   */
  class language_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.language_t

    static name: string
  }

  interface map_t {}

  /**
   * Data type for holding integer-to-integer hash maps.
   * @record
   */
  class map_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.map_t

    static name: string
  }

  interface ot_color_layer_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.ot_color_layer_t

    /**
     * the glyph ID of the layer
     * @field
     */
    glyph: codepoint_t
    /**
     * the palette color index of the layer
     * @field
     */
    colorIndex: number
  }

  /**
   * Pairs of glyph and color index.
   *
   * A color index of 0xFFFF does not refer to a palette
   * color, but indicates that the foreground color should
   * be used.
   * @record
   */
  class ot_color_layer_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.ot_color_layer_t

    static name: string
  }

  interface ot_math_glyph_part_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.ot_math_glyph_part_t

    /**
     * The glyph index of the variant part
     * @field
     */
    glyph: codepoint_t
    /**
     * The length of the connector on the starting side of the variant part
     * @field
     */
    startConnectorLength: position_t
    /**
     * The length of the connector on the ending side of the variant part
     * @field
     */
    endConnectorLength: position_t
    /**
     * The total advance of the part
     * @field
     */
    fullAdvance: position_t
    /**
     * #hb_ot_math_glyph_part_flags_t flags for the part
     * @field
     */
    flags: ot_math_glyph_part_flags_t
  }

  /**
   * Data type to hold information for a "part" component of a math-variant glyph.
   * Large variants for stretchable math glyphs (such as parentheses) can be constructed
   * on the fly from parts.
   * @record
   */
  class ot_math_glyph_part_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.ot_math_glyph_part_t

    static name: string
  }

  interface ot_math_glyph_variant_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.ot_math_glyph_variant_t

    /**
     * The glyph index of the variant
     * @field
     */
    glyph: codepoint_t
    /**
     * The advance width of the variant
     * @field
     */
    advance: position_t
  }

  /**
   * Data type to hold math-variant information for a glyph.
   * @record
   */
  class ot_math_glyph_variant_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.ot_math_glyph_variant_t

    static name: string
  }

  interface ot_math_kern_entry_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.ot_math_kern_entry_t

    /**
     * The maximum height at which this entry should be used
     * @field
     */
    maxCorrectionHeight: position_t
    /**
     * The kern value of the entry
     * @field
     */
    kernValue: position_t
  }

  /**
   * Data type to hold math kerning (cut-in) information for a glyph.
   * @record
   */
  class ot_math_kern_entry_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.ot_math_kern_entry_t

    static name: string
  }

  interface ot_name_entry_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.ot_name_entry_t

    /**
     * name ID
     * @field
     */
    nameId: ot_name_id_t
    /**
     * language
     * @field
     */
    language: language_t
  }

  /**
   * Structure representing a name ID in a particular language.
   * @record
   */
  class ot_name_entry_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.ot_name_entry_t

    static name: string
  }

  interface ot_var_axis_info_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.ot_var_axis_info_t

    /**
     * Index of the axis in the variation-axis array
     * @field
     */
    axisIndex: number
    /**
     * The #hb_tag_t tag identifying the design variation of the axis
     * @field
     */
    tag: tag_t
    /**
     * The `name` table Name ID that provides display names for the axis
     * @field
     */
    nameId: ot_name_id_t
    /**
     * The #hb_ot_var_axis_flags_t flags for the axis
     * @field
     */
    flags: ot_var_axis_flags_t
    /**
     * The minimum value on the variation axis that the font covers
     * @field
     */
    minValue: number
    /**
     * The position on the variation axis corresponding to the font's defaults
     * @field
     */
    defaultValue: number
    /**
     * The maximum value on the variation axis that the font covers
     * @field
     */
    maxValue: number
  }

  /**
   * Data type for holding variation-axis values.
   *
   * The minimum, default, and maximum values are in un-normalized, user scales.
   *
   * <note>Note: at present, the only flag defined for `flags` is
   * #HB_OT_VAR_AXIS_FLAG_HIDDEN.</note>
   * @record
   */
  class ot_var_axis_info_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.ot_var_axis_info_t

    static name: string
  }

  interface ot_var_axis_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.ot_var_axis_t

    /**
     * axis tag
     * @field
     */
    tag: tag_t
    /**
     * axis name identifier
     * @field
     */
    nameId: ot_name_id_t
    /**
     * minimum value of the axis
     * @field
     */
    minValue: number
    /**
     * default value of the axis
     * @field
     */
    defaultValue: number
    /**
     * maximum value of the axis
     * @field
     */
    maxValue: number
  }

  /**
   * Use #hb_ot_var_axis_info_t instead.
   * @record
   */
  class ot_var_axis_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.ot_var_axis_t

    static name: string
  }

  interface paint_funcs_t {}

  /**
   * Glyph paint callbacks.
   *
   * The callbacks assume that the caller maintains a stack
   * of current transforms, clips and intermediate surfaces,
   * as evidenced by the pairs of push/pop callbacks. The
   * push/pop calls will be properly nested, so it is fine
   * to store the different kinds of object on a single stack.
   *
   * Not all callbacks are required for all kinds of glyphs.
   * For rendering COLRv0 or non-color outline glyphs, the
   * gradient callbacks are not needed, and the composite
   * callback only needs to handle simple alpha compositing
   * (#HB_PAINT_COMPOSITE_MODE_SRC_OVER).
   *
   * The paint-image callback is only needed for glyphs
   * with image blobs in the CBDT, sbix or SVG tables.
   *
   * The custom-palette-color callback is only necessary if
   * you want to override colors from the font palette with
   * custom colors.
   * @record
   */
  class paint_funcs_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.paint_funcs_t

    static name: string
  }

  interface segment_properties_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.segment_properties_t

    /**
     * the #hb_direction_t of the buffer, see hb_buffer_set_direction().
     * @field
     */
    direction: direction_t
    /**
     * the #hb_script_t of the buffer, see hb_buffer_set_script().
     * @field
     */
    script: script_t
    /**
     * the #hb_language_t of the buffer, see hb_buffer_set_language().
     * @field
     */
    language: language_t
  }

  /**
   * The structure that holds various text properties of an #hb_buffer_t. Can be
   * set and retrieved using hb_buffer_set_segment_properties() and
   * hb_buffer_get_segment_properties(), respectively.
   * @record
   */
  class segment_properties_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.segment_properties_t

    static name: string
  }

  interface set_t {}

  /**
   * Data type for holding a set of integers. #hb_set_t's are
   * used to gather and contain glyph IDs, Unicode code
   * points, and various other collections of discrete
   * values.
   * @record
   */
  class set_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.set_t

    static name: string
  }

  interface shape_plan_t {}

  /**
   * Data type for holding a shaping plan.
   *
   * Shape plans contain information about how HarfBuzz will shape a
   * particular text segment, based on the segment's properties and the
   * capabilities in the font face in use.
   *
   * Shape plans can be queried about how shaping will perform, given a set
   * of specific input parameters (script, language, direction, features,
   * etc.).
   * @record
   */
  class shape_plan_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.shape_plan_t

    static name: string
  }

  interface unicode_funcs_t {}

  /**
   * Data type containing a set of virtual methods used for
   * accessing various Unicode character properties.
   *
   * HarfBuzz provides a default function for each of the
   * methods in #hb_unicode_funcs_t. Client programs can implement
   * their own replacements for the individual Unicode functions, as
   * needed, and replace the default by calling the setter for a
   * method.
   * @record
   */
  class unicode_funcs_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.unicode_funcs_t

    static name: string
  }

  interface user_data_key_t {}

  /**
   * Data structure for holding user-data keys.
   * @record
   */
  class user_data_key_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.user_data_key_t

    static name: string
  }

  interface variation_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.variation_t

    /**
     * The #hb_tag_t tag of the variation-axis name
     * @field
     */
    tag: tag_t
    /**
     * The value of the variation axis
     * @field
     */
    value: number

    // Owm methods of HarfBuzz-0.0.HarfBuzz.variation_t

    /**
     * Converts an #hb_variation_t into a `NULL`-terminated string in the format
     * understood by hb_variation_from_string(). The client in responsible for
     * allocating big enough size for `buf,` 128 bytes is more than enough.
     */
    string(): /* buf */ string[]
  }

  /**
   * Data type for holding variation data. Registered OpenType
   * variation-axis tags are listed in
   * [OpenType Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg).
   * @record
   */
  class variation_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.variation_t

    static name: string
  }

  interface var_int_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.var_int_t

    u32: number
    i32: number
    u16: number[]
    i16: number[]
    u8: number[]
    i8: number[]
  }

  class var_int_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.var_int_t

    static name: string
  }

  interface var_num_t {
    // Own fields of HarfBuzz-0.0.HarfBuzz.var_num_t

    f: number
    u32: number
    i32: number
    u16: number[]
    i16: number[]
    u8: number[]
    i8: number[]
  }

  class var_num_t {
    // Own properties of HarfBuzz-0.0.HarfBuzz.var_num_t

    static name: string
  }

  type bool_t = number
  type codepoint_t = number
  type color_t = number
  type font_get_font_h_extents_func_t = font_get_font_extents_func_t
  type font_get_font_v_extents_func_t = font_get_font_extents_func_t
  type font_get_glyph_h_advance_func_t = font_get_glyph_advance_func_t
  type font_get_glyph_h_advances_func_t = font_get_glyph_advances_func_t
  type font_get_glyph_h_kerning_func_t = font_get_glyph_kerning_func_t
  type font_get_glyph_h_origin_func_t = font_get_glyph_origin_func_t
  type font_get_glyph_v_advance_func_t = font_get_glyph_advance_func_t
  type font_get_glyph_v_advances_func_t = font_get_glyph_advances_func_t
  type font_get_glyph_v_kerning_func_t = font_get_glyph_kerning_func_t
  type font_get_glyph_v_origin_func_t = font_get_glyph_origin_func_t
  type mask_t = number
  type ot_name_id_t = number
  type position_t = number
  type tag_t = number
}

type Gio20 = typeof Gio

declare global {
  interface NodeGtkGi {
    require(ns: "Gio", ver?: "2.0"): Gio20
  }
}

type GModule20 = typeof GModule

declare global {
  interface NodeGtkGi {
    require(ns: "GModule", ver?: "2.0"): GModule20
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace GModule {
  /**
   * Errors returned by g_module_open_full().
   */
  enum ModuleError {
    /**
     * there was an error loading or opening a module file
     */
    FAILED,
    /**
     * a module returned an error from its `g_module_check_init()` function
     */
    CHECK_FAILED,
  }
  /**
   * Flags passed to g_module_open().
   * Note that these flags are not supported on all platforms.
   * @bitfield
   */
  enum ModuleFlags {
    /**
     * specifies that symbols are only resolved when
     *     needed. The default action is to bind all symbols when the module
     *     is loaded.
     */
    LAZY,
    /**
     * specifies that symbols in the module should
     *     not be added to the global name space. The default action on most
     *     platforms is to place symbols in the module in the global name space,
     *     which may cause conflicts with existing symbols.
     */
    LOCAL,
    /**
     * mask for all flags.
     */
    MASK,
  }
  const MODULE_IMPL_AR: number
  const MODULE_IMPL_DL: number
  const MODULE_IMPL_NONE: number
  const MODULE_IMPL_WIN32: number
  /**
   * A portable way to build the filename of a module. The platform-specific
   * prefix and suffix are added to the filename, if needed, and the result
   * is added to the directory, using the correct separator character.
   *
   * The directory should specify the directory where the module can be found.
   * It can be %NULL or an empty string to indicate that the module is in a
   * standard platform-specific directory, though this is not recommended
   * since the wrong module may be found.
   *
   * For example, calling g_module_build_path() on a Linux system with a
   * `directory` of `/lib` and a `module_name` of "mylibrary" will return
   * `/lib/libmylibrary.so`. On a Windows system, using `\Windows` as the
   * directory it will return `\Windows\mylibrary.dll`.
   * @param directory the directory where the module is. This can be     %NULL or the empty string to indicate that the standard platform-specific     directories will be used, though that is not recommended
   * @param moduleName the name of the module
   * @returns the complete path of the module, including the standard library     prefix and suffix. This should be freed when no longer needed
   */
  function moduleBuildPath(
    directory: string | null,
    moduleName: string
  ): string | null
  /**
   * Gets a string describing the last module error.
   * @returns a string describing the last module error
   */
  function moduleError(): string
  function moduleErrorQuark(): GLib.Quark
  /**
   * Checks if modules are supported on the current platform.
   * @returns %TRUE if modules are supported
   */
  function moduleSupported(): boolean
  /**
   * Specifies the type of the module initialization function.
   * If a module contains a function named g_module_check_init() it is called
   * automatically when the module is loaded. It is passed the #GModule structure
   * and should return %NULL on success or a string describing the initialization
   * error.
   * @callback
   * @param module the #GModule corresponding to the module which has just been loaded
   * @returns %NULL on success, or a string describing the initialization error
   */
  interface ModuleCheckInit {
    (module: Module): string
  }
  /**
   * Specifies the type of the module function called when it is unloaded.
   * If a module contains a function named g_module_unload() it is called
   * automatically when the module is unloaded.
   * It is passed the #GModule structure.
   * @callback
   * @param module the #GModule about to be unloaded
   */
  interface ModuleUnload {
    (module: Module): void
  }
  interface Module {
    // Owm methods of GModule-2.0.GModule.Module

    /**
     * Closes a module.
     * @returns %TRUE on success
     */
    close(): boolean
    /**
     * Ensures that a module will never be unloaded.
     * Any future g_module_close() calls on the module will be ignored.
     */
    makeResident(): void
    /**
     * Returns the filename that the module was opened with.
     *
     * If `module` refers to the application itself, "main" is returned.
     * @returns the filename of the module
     */
    name(): string
    /**
     * Gets a symbol pointer from a module, such as one exported
     * by %G_MODULE_EXPORT. Note that a valid symbol can be %NULL.
     * @param symbolName the name of the symbol to find
     * @returns %TRUE on success
     */
    symbol(
      symbolName: string
    ): [/* returnType */ boolean, /* symbol */ any | null]
  }

  /**
   * The #GModule struct is an opaque data structure to represent a
   * [dynamically-loaded module][glib-Dynamic-Loading-of-Modules].
   * It should only be accessed via the following functions.
   * @record
   */
  class Module {
    // Own properties of GModule-2.0.GModule.Module

    static name: string

    // Constructors of GModule-2.0.GModule.Module

    /**
     * A portable way to build the filename of a module. The platform-specific
     * prefix and suffix are added to the filename, if needed, and the result
     * is added to the directory, using the correct separator character.
     *
     * The directory should specify the directory where the module can be found.
     * It can be %NULL or an empty string to indicate that the module is in a
     * standard platform-specific directory, though this is not recommended
     * since the wrong module may be found.
     *
     * For example, calling g_module_build_path() on a Linux system with a
     * `directory` of `/lib` and a `module_name` of "mylibrary" will return
     * `/lib/libmylibrary.so`. On a Windows system, using `\Windows` as the
     * directory it will return `\Windows\mylibrary.dll`.
     * @param directory the directory where the module is. This can be     %NULL or the empty string to indicate that the standard platform-specific     directories will be used, though that is not recommended
     * @param moduleName the name of the module
     * @returns the complete path of the module, including the standard library     prefix and suffix. This should be freed when no longer needed
     */
    static buildPath(
      directory: string | null,
      moduleName: string
    ): string | null
    /**
     * Gets a string describing the last module error.
     * @returns a string describing the last module error
     */
    static error(): string
    static errorQuark(): GLib.Quark
    /**
     * Checks if modules are supported on the current platform.
     * @returns %TRUE if modules are supported
     */
    static supported(): boolean
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace Gio {
  /**
   * An enumeration for well-known message buses.
   */
  enum BusType {
    /**
     * An alias for the message bus that activated the process, if any.
     */
    STARTER,
    /**
     * Not a message bus.
     */
    NONE,
    /**
     * The system-wide message bus.
     */
    SYSTEM,
    /**
     * The login session message bus.
     */
    SESSION,
  }
  /**
   * Results returned from g_converter_convert().
   */
  enum ConverterResult {
    /**
     * There was an error during conversion.
     */
    ERROR,
    /**
     * Some data was consumed or produced
     */
    CONVERTED,
    /**
     * The conversion is finished
     */
    FINISHED,
    /**
     * Flushing is finished
     */
    FLUSHED,
  }
  /**
   * Enumeration describing different kinds of native credential types.
   */
  enum CredentialsType {
    /**
     * Indicates an invalid native credential type.
     */
    INVALID,
    /**
     * The native credentials type is a `struct ucred`.
     */
    LINUX_UCRED,
    /**
     * The native credentials type is a `struct cmsgcred`.
     */
    FREEBSD_CMSGCRED,
    /**
     * The native credentials type is a `struct sockpeercred`. Added in 2.30.
     */
    OPENBSD_SOCKPEERCRED,
    /**
     * The native credentials type is a `ucred_t`. Added in 2.40.
     */
    SOLARIS_UCRED,
    /**
     * The native credentials type is a `struct unpcbid`. Added in 2.42.
     */
    NETBSD_UNPCBID,
    /**
     * The native credentials type is a `struct xucred`. Added in 2.66.
     */
    APPLE_XUCRED,
    /**
     * The native credentials type is a PID `DWORD`. Added in 2.72.
     */
    WIN32_PID,
  }
  /**
   * Error codes for the %G_DBUS_ERROR error domain.
   */
  enum DBusError {
    /**
     * A generic error; "something went wrong" - see the error message for
     * more.
     */
    FAILED,
    /**
     * There was not enough memory to complete an operation.
     */
    NO_MEMORY,
    /**
     * The bus doesn't know how to launch a service to supply the bus name
     * you wanted.
     */
    SERVICE_UNKNOWN,
    /**
     * The bus name you referenced doesn't exist (i.e. no application owns
     * it).
     */
    NAME_HAS_NO_OWNER,
    /**
     * No reply to a message expecting one, usually means a timeout occurred.
     */
    NO_REPLY,
    /**
     * Something went wrong reading or writing to a socket, for example.
     */
    IO_ERROR,
    /**
     * A D-Bus bus address was malformed.
     */
    BAD_ADDRESS,
    /**
     * Requested operation isn't supported (like ENOSYS on UNIX).
     */
    NOT_SUPPORTED,
    /**
     * Some limited resource is exhausted.
     */
    LIMITS_EXCEEDED,
    /**
     * Security restrictions don't allow doing what you're trying to do.
     */
    ACCESS_DENIED,
    /**
     * Authentication didn't work.
     */
    AUTH_FAILED,
    /**
     * Unable to connect to server (probably caused by ECONNREFUSED on a
     * socket).
     */
    NO_SERVER,
    /**
     * Certain timeout errors, possibly ETIMEDOUT on a socket.  Note that
     * %G_DBUS_ERROR_NO_REPLY is used for message reply timeouts. Warning:
     * this is confusingly-named given that %G_DBUS_ERROR_TIMED_OUT also
     * exists. We can't fix it for compatibility reasons so just be
     * careful.
     */
    TIMEOUT,
    /**
     * No network access (probably ENETUNREACH on a socket).
     */
    NO_NETWORK,
    /**
     * Can't bind a socket since its address is in use (i.e. EADDRINUSE).
     */
    ADDRESS_IN_USE,
    /**
     * The connection is disconnected and you're trying to use it.
     */
    DISCONNECTED,
    /**
     * Invalid arguments passed to a method call.
     */
    INVALID_ARGS,
    /**
     * Missing file.
     */
    FILE_NOT_FOUND,
    /**
     * Existing file and the operation you're using does not silently overwrite.
     */
    FILE_EXISTS,
    /**
     * Method name you invoked isn't known by the object you invoked it on.
     */
    UNKNOWN_METHOD,
    /**
     * Certain timeout errors, e.g. while starting a service. Warning: this is
     * confusingly-named given that %G_DBUS_ERROR_TIMEOUT also exists. We
     * can't fix it for compatibility reasons so just be careful.
     */
    TIMED_OUT,
    /**
     * Tried to remove or modify a match rule that didn't exist.
     */
    MATCH_RULE_NOT_FOUND,
    /**
     * The match rule isn't syntactically valid.
     */
    MATCH_RULE_INVALID,
    /**
     * While starting a new process, the exec() call failed.
     */
    SPAWN_EXEC_FAILED,
    /**
     * While starting a new process, the fork() call failed.
     */
    SPAWN_FORK_FAILED,
    /**
     * While starting a new process, the child exited with a status code.
     */
    SPAWN_CHILD_EXITED,
    /**
     * While starting a new process, the child exited on a signal.
     */
    SPAWN_CHILD_SIGNALED,
    /**
     * While starting a new process, something went wrong.
     */
    SPAWN_FAILED,
    /**
     * We failed to setup the environment correctly.
     */
    SPAWN_SETUP_FAILED,
    /**
     * We failed to setup the config parser correctly.
     */
    SPAWN_CONFIG_INVALID,
    /**
     * Bus name was not valid.
     */
    SPAWN_SERVICE_INVALID,
    /**
     * Service file not found in system-services directory.
     */
    SPAWN_SERVICE_NOT_FOUND,
    /**
     * Permissions are incorrect on the setuid helper.
     */
    SPAWN_PERMISSIONS_INVALID,
    /**
     * Service file invalid (Name, User or Exec missing).
     */
    SPAWN_FILE_INVALID,
    /**
     * Tried to get a UNIX process ID and it wasn't available.
     */
    SPAWN_NO_MEMORY,
    /**
     * Tried to get a UNIX process ID and it wasn't available.
     */
    UNIX_PROCESS_ID_UNKNOWN,
    /**
     * A type signature is not valid.
     */
    INVALID_SIGNATURE,
    /**
     * A file contains invalid syntax or is otherwise broken.
     */
    INVALID_FILE_CONTENT,
    /**
     * Asked for SELinux security context and it wasn't available.
     */
    SELINUX_SECURITY_CONTEXT_UNKNOWN,
    /**
     * Asked for ADT audit data and it wasn't available.
     */
    ADT_AUDIT_DATA_UNKNOWN,
    /**
     * There's already an object with the requested object path.
     */
    OBJECT_PATH_IN_USE,
    /**
     * Object you invoked a method on isn't known. Since 2.42
     */
    UNKNOWN_OBJECT,
    /**
     * Interface you invoked a method on isn't known by the object. Since 2.42
     */
    UNKNOWN_INTERFACE,
    /**
     * Property you tried to access isn't known by the object. Since 2.42
     */
    UNKNOWN_PROPERTY,
    /**
     * Property you tried to set is read-only. Since 2.42
     */
    PROPERTY_READ_ONLY,
  }
  /**
   * Enumeration used to describe the byte order of a D-Bus message.
   */
  enum DBusMessageByteOrder {
    /**
     * The byte order is big endian.
     */
    BIG_ENDIAN,
    /**
     * The byte order is little endian.
     */
    LITTLE_ENDIAN,
  }
  /**
   * Header fields used in #GDBusMessage.
   */
  enum DBusMessageHeaderField {
    /**
     * Not a valid header field.
     */
    INVALID,
    /**
     * The object path.
     */
    PATH,
    /**
     * The interface name.
     */
    INTERFACE,
    /**
     * The method or signal name.
     */
    MEMBER,
    /**
     * The name of the error that occurred.
     */
    ERROR_NAME,
    /**
     * The serial number the message is a reply to.
     */
    REPLY_SERIAL,
    /**
     * The name the message is intended for.
     */
    DESTINATION,
    /**
     * Unique name of the sender of the message (filled in by the bus).
     */
    SENDER,
    /**
     * The signature of the message body.
     */
    SIGNATURE,
    /**
     * The number of UNIX file descriptors that accompany the message.
     */
    NUM_UNIX_FDS,
  }
  /**
   * Message types used in #GDBusMessage.
   */
  enum DBusMessageType {
    /**
     * Message is of invalid type.
     */
    INVALID,
    /**
     * Method call.
     */
    METHOD_CALL,
    /**
     * Method reply.
     */
    METHOD_RETURN,
    /**
     * Error reply.
     */
    ERROR,
    /**
     * Signal emission.
     */
    SIGNAL,
  }
  /**
   * #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
   * across various machine architectures.
   */
  enum DataStreamByteOrder {
    /**
     * Selects Big Endian byte order.
     */
    BIG_ENDIAN,
    /**
     * Selects Little Endian byte order.
     */
    LITTLE_ENDIAN,
    /**
     * Selects endianness based on host machine's architecture.
     */
    HOST_ENDIAN,
  }
  /**
   * #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
   */
  enum DataStreamNewlineType {
    /**
     * Selects "LF" line endings, common on most modern UNIX platforms.
     */
    LF,
    /**
     * Selects "CR" line endings.
     */
    CR,
    /**
     * Selects "CR, LF" line ending, common on Microsoft Windows.
     */
    CR_LF,
    /**
     * Automatically try to handle any line ending type.
     */
    ANY,
  }
  /**
   * Enumeration describing how a drive can be started/stopped.
   */
  enum DriveStartStopType {
    /**
     * Unknown or drive doesn't support
     *    start/stop.
     */
    UNKNOWN,
    /**
     * The stop method will physically
     *    shut down the drive and e.g. power down the port the drive is
     *    attached to.
     */
    SHUTDOWN,
    /**
     * The start/stop methods are used
     *    for connecting/disconnect to the drive over the network.
     */
    NETWORK,
    /**
     * The start/stop methods will
     *    assemble/disassemble a virtual drive from several physical
     *    drives.
     */
    MULTIDISK,
    /**
     * The start/stop methods will
     *    unlock/lock the disk (for example using the ATA <quote>SECURITY
     *    UNLOCK DEVICE</quote> command)
     */
    PASSWORD,
  }
  /**
   * GEmblemOrigin is used to add information about the origin of the emblem
   * to #GEmblem.
   */
  enum EmblemOrigin {
    /**
     * Emblem of unknown origin
     */
    UNKNOWN,
    /**
     * Emblem adds device-specific information
     */
    DEVICE,
    /**
     * Emblem depicts live metadata, such as "readonly"
     */
    LIVEMETADATA,
    /**
     * Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
     */
    TAG,
  }
  /**
   * Used by g_file_set_attributes_from_info() when setting file attributes.
   */
  enum FileAttributeStatus {
    /**
     * Attribute value is unset (empty).
     */
    UNSET,
    /**
     * Attribute value is set.
     */
    SET,
    /**
     * Indicates an error in setting the value.
     */
    ERROR_SETTING,
  }
  /**
   * The data types for file attributes.
   */
  enum FileAttributeType {
    /**
     * indicates an invalid or uninitialized type.
     */
    INVALID,
    /**
     * a null terminated UTF8 string.
     */
    STRING,
    /**
     * a zero terminated string of non-zero bytes.
     */
    BYTE_STRING,
    /**
     * a boolean value.
     */
    BOOLEAN,
    /**
     * an unsigned 4-byte/32-bit integer.
     */
    UINT32,
    /**
     * a signed 4-byte/32-bit integer.
     */
    INT32,
    /**
     * an unsigned 8-byte/64-bit integer.
     */
    UINT64,
    /**
     * a signed 8-byte/64-bit integer.
     */
    INT64,
    /**
     * a #GObject.
     */
    OBJECT,
    /**
     * a %NULL terminated char **. Since 2.22
     */
    STRINGV,
  }
  /**
   * Specifies what type of event a monitor event is.
   */
  enum FileMonitorEvent {
    /**
     * a file changed.
     */
    CHANGED,
    /**
     * a hint that this was probably the last change in a set of changes.
     */
    CHANGES_DONE_HINT,
    /**
     * a file was deleted.
     */
    DELETED,
    /**
     * a file was created.
     */
    CREATED,
    /**
     * a file attribute was changed.
     */
    ATTRIBUTE_CHANGED,
    /**
     * the file location will soon be unmounted.
     */
    PRE_UNMOUNT,
    /**
     * the file location was unmounted.
     */
    UNMOUNTED,
    /**
     * the file was moved -- only sent if the
     *   (deprecated) %G_FILE_MONITOR_SEND_MOVED flag is set
     */
    MOVED,
    /**
     * the file was renamed within the
     *   current directory -- only sent if the %G_FILE_MONITOR_WATCH_MOVES
     *   flag is set.  Since: 2.46.
     */
    RENAMED,
    /**
     * the file was moved into the
     *   monitored directory from another location -- only sent if the
     *   %G_FILE_MONITOR_WATCH_MOVES flag is set.  Since: 2.46.
     */
    MOVED_IN,
    /**
     * the file was moved out of the
     *   monitored directory to another location -- only sent if the
     *   %G_FILE_MONITOR_WATCH_MOVES flag is set.  Since: 2.46
     */
    MOVED_OUT,
  }
  /**
   * Indicates the file's on-disk type.
   *
   * On Windows systems a file will never have %G_FILE_TYPE_SYMBOLIC_LINK type;
   * use #GFileInfo and %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK to determine
   * whether a file is a symlink or not. This is due to the fact that NTFS does
   * not have a single filesystem object type for symbolic links - it has
   * files that symlink to files, and directories that symlink to directories.
   * #GFileType enumeration cannot precisely represent this important distinction,
   * which is why all Windows symlinks will continue to be reported as
   * %G_FILE_TYPE_REGULAR or %G_FILE_TYPE_DIRECTORY.
   */
  enum FileType {
    /**
     * File's type is unknown.
     */
    UNKNOWN,
    /**
     * File handle represents a regular file.
     */
    REGULAR,
    /**
     * File handle represents a directory.
     */
    DIRECTORY,
    /**
     * File handle represents a symbolic link
     *    (Unix systems).
     */
    SYMBOLIC_LINK,
    /**
     * File is a "special" file, such as a socket, fifo,
     *    block device, or character device.
     */
    SPECIAL,
    /**
     * File is a shortcut (Windows systems).
     */
    SHORTCUT,
    /**
     * File is a mountable location.
     */
    MOUNTABLE,
  }
  /**
   * Indicates a hint from the file system whether files should be
   * previewed in a file manager. Returned as the value of the key
   * %G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
   */
  enum FilesystemPreviewType {
    /**
     * Only preview files if user has explicitly requested it.
     */
    IF_ALWAYS,
    /**
     * Preview files if user has requested preview of "local" files.
     */
    IF_LOCAL,
    /**
     * Never preview files.
     */
    NEVER,
  }
  /**
   * Error codes returned by GIO functions.
   *
   * Note that this domain may be extended in future GLib releases. In
   * general, new error codes either only apply to new APIs, or else
   * replace %G_IO_ERROR_FAILED in cases that were not explicitly
   * distinguished before. You should therefore avoid writing code like
   *
   * ```c
   * if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
   *   {
   *     // Assume that this is EPRINTERONFIRE
   *     ...
   *   }
   * ```
   *
   * but should instead treat all unrecognized error codes the same as
   * %G_IO_ERROR_FAILED.
   *
   * See also #GPollableReturn for a cheaper way of returning
   * %G_IO_ERROR_WOULD_BLOCK to callers without allocating a #GError.
   */
  enum IOErrorEnum {
    /**
     * Generic error condition for when an operation fails
     *     and no more specific #GIOErrorEnum value is defined.
     */
    FAILED,
    /**
     * File not found.
     */
    NOT_FOUND,
    /**
     * File already exists.
     */
    EXISTS,
    /**
     * File is a directory.
     */
    IS_DIRECTORY,
    /**
     * File is not a directory.
     */
    NOT_DIRECTORY,
    /**
     * File is a directory that isn't empty.
     */
    NOT_EMPTY,
    /**
     * File is not a regular file.
     */
    NOT_REGULAR_FILE,
    /**
     * File is not a symbolic link.
     */
    NOT_SYMBOLIC_LINK,
    /**
     * File cannot be mounted.
     */
    NOT_MOUNTABLE_FILE,
    /**
     * Filename is too many characters.
     */
    FILENAME_TOO_LONG,
    /**
     * Filename is invalid or contains invalid characters.
     */
    INVALID_FILENAME,
    /**
     * File contains too many symbolic links.
     */
    TOO_MANY_LINKS,
    /**
     * No space left on drive.
     */
    NO_SPACE,
    /**
     * Invalid argument.
     */
    INVALID_ARGUMENT,
    /**
     * Permission denied.
     */
    PERMISSION_DENIED,
    /**
     * Operation (or one of its parameters) not supported
     */
    NOT_SUPPORTED,
    /**
     * File isn't mounted.
     */
    NOT_MOUNTED,
    /**
     * File is already mounted.
     */
    ALREADY_MOUNTED,
    /**
     * File was closed.
     */
    CLOSED,
    /**
     * Operation was cancelled. See #GCancellable.
     */
    CANCELLED,
    /**
     * Operations are still pending.
     */
    PENDING,
    /**
     * File is read only.
     */
    READ_ONLY,
    /**
     * Backup couldn't be created.
     */
    CANT_CREATE_BACKUP,
    /**
     * File's Entity Tag was incorrect.
     */
    WRONG_ETAG,
    /**
     * Operation timed out.
     */
    TIMED_OUT,
    /**
     * Operation would be recursive.
     */
    WOULD_RECURSE,
    /**
     * File is busy.
     */
    BUSY,
    /**
     * Operation would block.
     */
    WOULD_BLOCK,
    /**
     * Host couldn't be found (remote operations).
     */
    HOST_NOT_FOUND,
    /**
     * Operation would merge files.
     */
    WOULD_MERGE,
    /**
     * Operation failed and a helper program has
     *     already interacted with the user. Do not display any error dialog.
     */
    FAILED_HANDLED,
    /**
     * The current process has too many files
     *     open and can't open any more. Duplicate descriptors do count toward
     *     this limit. Since 2.20
     */
    TOO_MANY_OPEN_FILES,
    /**
     * The object has not been initialized. Since 2.22
     */
    NOT_INITIALIZED,
    /**
     * The requested address is already in use. Since 2.22
     */
    ADDRESS_IN_USE,
    /**
     * Need more input to finish operation. Since 2.24
     */
    PARTIAL_INPUT,
    /**
     * The input data was invalid. Since 2.24
     */
    INVALID_DATA,
    /**
     * A remote object generated an error that
     *     doesn't correspond to a locally registered #GError error
     *     domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
     *     error name and g_dbus_error_strip_remote_error() to fix up the
     *     message so it matches what was received on the wire. Since 2.26.
     */
    DBUS_ERROR,
    /**
     * Host unreachable. Since 2.26
     */
    HOST_UNREACHABLE,
    /**
     * Network unreachable. Since 2.26
     */
    NETWORK_UNREACHABLE,
    /**
     * Connection refused. Since 2.26
     */
    CONNECTION_REFUSED,
    /**
     * Connection to proxy server failed. Since 2.26
     */
    PROXY_FAILED,
    /**
     * Proxy authentication failed. Since 2.26
     */
    PROXY_AUTH_FAILED,
    /**
     * Proxy server needs authentication. Since 2.26
     */
    PROXY_NEED_AUTH,
    /**
     * Proxy connection is not allowed by ruleset.
     *     Since 2.26
     */
    PROXY_NOT_ALLOWED,
    /**
     * Broken pipe. Since 2.36
     */
    BROKEN_PIPE,
    /**
     * Connection closed by peer. Note that this
     *     is the same code as %G_IO_ERROR_BROKEN_PIPE; before 2.44 some
     *     "connection closed" errors returned %G_IO_ERROR_BROKEN_PIPE, but others
     *     returned %G_IO_ERROR_FAILED. Now they should all return the same
     *     value, which has this more logical name. Since 2.44.
     */
    CONNECTION_CLOSED,
    /**
     * Transport endpoint is not connected. Since 2.44
     */
    NOT_CONNECTED,
    /**
     * Message too large. Since 2.48.
     */
    MESSAGE_TOO_LARGE,
    /**
     * No such device found. Since 2.74
     */
    NO_SUCH_DEVICE,
    /**
     * Destination address unset. Since 2.80
     */
    DESTINATION_UNSET,
  }
  /**
   * Flags for use with g_io_module_scope_new().
   */
  enum IOModuleScopeFlags {
    /**
     * No module scan flags
     */
    NONE,
    /**
     * When using this scope to load or
     *     scan modules, automatically block a modules which has the same base
     *     basename as previously loaded module.
     */
    BLOCK_DUPLICATES,
  }
  /**
   * Memory availability warning levels.
   *
   * Note that because new values might be added, it is recommended that applications check
   * #GMemoryMonitorWarningLevel as ranges, for example:
   *
   * ```c
   * if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
   *   drop_caches ();
   * ```
   *
   */
  enum MemoryMonitorWarningLevel {
    /**
     * Memory on the device is low, processes
     *   should free up unneeded resources (for example, in-memory caches) so they can
     *   be used elsewhere.
     */
    LOW,
    /**
     * Same as `G_MEMORY_MONITOR_WARNING_LEVEL_LOW`
     *   but the device has even less free memory, so processes should try harder to free
     *   up unneeded resources. If your process does not need to stay running, it is a
     *   good time for it to quit.
     */
    MEDIUM,
    /**
     * The system will soon start terminating
     *   processes to reclaim memory, including background processes.
     */
    CRITICAL,
  }
  /**
   * #GMountOperationResult is returned as a result when a request for
   * information is send by the mounting operation.
   */
  enum MountOperationResult {
    /**
     * The request was fulfilled and the
     *     user specified data is now available
     */
    HANDLED,
    /**
     * The user requested the mount operation
     *     to be aborted
     */
    ABORTED,
    /**
     * The request was unhandled (i.e. not
     *     implemented)
     */
    UNHANDLED,
  }
  /**
   * The host's network connectivity state, as reported by #GNetworkMonitor.
   */
  enum NetworkConnectivity {
    /**
     * The host is not configured with a
     *   route to the Internet; it may or may not be connected to a local
     *   network.
     */
    LOCAL,
    /**
     * The host is connected to a network, but
     *   does not appear to be able to reach the full Internet, perhaps
     *   due to upstream network problems.
     */
    LIMITED,
    /**
     * The host is behind a captive portal and
     *   cannot reach the full Internet.
     */
    PORTAL,
    /**
     * The host is connected to a network, and
     *   appears to be able to reach the full Internet.
     */
    FULL,
  }
  /**
   * Priority levels for #GNotifications.
   */
  enum NotificationPriority {
    /**
     * the default priority, to be used for the
     *   majority of notifications (for example email messages, software updates,
     *   completed download/sync operations)
     */
    NORMAL,
    /**
     * for notifications that do not require
     *   immediate attention - typically used for contextual background
     *   information, such as contact birthdays or local weather
     */
    LOW,
    /**
     * for events that require more attention,
     *   usually because responses are time-sensitive (for example chat and SMS
     *   messages or alarms)
     */
    HIGH,
    /**
     * for urgent notifications, or notifications
     *   that require a response in a short space of time (for example phone calls
     *   or emergency warnings)
     */
    URGENT,
  }
  /**
   * #GPasswordSave is used to indicate the lifespan of a saved password.
   *
   * #Gvfs stores passwords in the Gnome keyring when this flag allows it
   * to, and later retrieves it again from there.
   */
  enum PasswordSave {
    /**
     * never save a password.
     */
    NEVER,
    /**
     * save a password for the session.
     */
    FOR_SESSION,
    /**
     * save a password permanently.
     */
    PERMANENTLY,
  }
  /**
   * Return value for various IO operations that signal errors via the
   * return value and not necessarily via a #GError.
   *
   * This enum exists to be able to return errors to callers without having to
   * allocate a #GError. Allocating #GErrors can be quite expensive for
   * regularly happening errors like %G_IO_ERROR_WOULD_BLOCK.
   *
   * In case of %G_POLLABLE_RETURN_FAILED a #GError should be set for the
   * operation to give details about the error that happened.
   */
  enum PollableReturn {
    /**
     * Generic error condition for when an operation fails.
     */
    FAILED,
    /**
     * The operation was successfully finished.
     */
    OK,
    /**
     * The operation would block.
     */
    WOULD_BLOCK,
  }
  /**
   * An error code used with %G_RESOLVER_ERROR in a #GError returned
   * from a #GResolver routine.
   */
  enum ResolverError {
    /**
     * the requested name/address/service was not
     *     found
     */
    NOT_FOUND,
    /**
     * the requested information could not
     *     be looked up due to a network error or similar problem
     */
    TEMPORARY_FAILURE,
    /**
     * unknown error
     */
    INTERNAL,
  }
  /**
   * The type of record that g_resolver_lookup_records() or
   * g_resolver_lookup_records_async() should retrieve. The records are returned
   * as lists of #GVariant tuples. Each record type has different values in
   * the variant tuples returned.
   *
   * %G_RESOLVER_RECORD_SRV records are returned as variants with the signature
   * `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the
   * weight, a `guint16` with the port, and a string of the hostname.
   *
   * %G_RESOLVER_RECORD_MX records are returned as variants with the signature
   * `(qs)`, representing a `guint16` with the preference, and a string containing
   * the mail exchanger hostname.
   *
   * %G_RESOLVER_RECORD_TXT records are returned as variants with the signature
   * `(as)`, representing an array of the strings in the text record. Note: Most TXT
   * records only contain a single string, but
   * [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a
   * record to contain multiple strings. The RFC which defines the interpretation
   * of a specific TXT record will likely require concatenation of multiple
   * strings if they are present, as with
   * [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3).
   *
   * %G_RESOLVER_RECORD_SOA records are returned as variants with the signature
   * `(ssuuuuu)`, representing a string containing the primary name server, a
   * string containing the administrator, the serial as a `guint32`, the refresh
   * interval as a `guint32`, the retry interval as a `guint32`, the expire timeout
   * as a `guint32`, and the TTL as a `guint32`.
   *
   * %G_RESOLVER_RECORD_NS records are returned as variants with the signature
   * `(s)`, representing a string of the hostname of the name server.
   */
  enum ResolverRecordType {
    /**
     * look up DNS SRV records for a domain
     */
    SRV,
    /**
     * look up DNS MX records for a domain
     */
    MX,
    /**
     * look up DNS TXT records for a name
     */
    TXT,
    /**
     * look up DNS SOA records for a zone
     */
    SOA,
    /**
     * look up DNS NS records for a domain
     */
    NS,
  }
  /**
   * An error code used with %G_RESOURCE_ERROR in a #GError returned
   * from a #GResource routine.
   */
  enum ResourceError {
    /**
     * no file was found at the requested path
     */
    NOT_FOUND,
    /**
     * unknown error
     */
    INTERNAL,
  }
  /**
   * Describes an event occurring on a #GSocketClient. See the
   * #GSocketClient::event signal for more details.
   *
   * Additional values may be added to this type in the future.
   */
  enum SocketClientEvent {
    /**
     * The client is doing a DNS lookup.
     */
    RESOLVING,
    /**
     * The client has completed a DNS lookup.
     */
    RESOLVED,
    /**
     * The client is connecting to a remote
     *   host (either a proxy or the destination server).
     */
    CONNECTING,
    /**
     * The client has connected to a remote
     *   host.
     */
    CONNECTED,
    /**
     * The client is negotiating
     *   with a proxy to connect to the destination server.
     */
    PROXY_NEGOTIATING,
    /**
     * The client has negotiated
     *   with the proxy server.
     */
    PROXY_NEGOTIATED,
    /**
     * The client is performing a
     *   TLS handshake.
     */
    TLS_HANDSHAKING,
    /**
     * The client has performed a
     *   TLS handshake.
     */
    TLS_HANDSHAKED,
    /**
     * The client is done with a particular
     *   #GSocketConnectable.
     */
    COMPLETE,
  }
  /**
   * The protocol family of a #GSocketAddress. (These values are
   * identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX,
   * if available.)
   */
  enum SocketFamily {
    /**
     * no address family
     */
    INVALID,
    /**
     * the UNIX domain family
     */
    UNIX,
    /**
     * the IPv4 family
     */
    IPV4,
    /**
     * the IPv6 family
     */
    IPV6,
  }
  /**
   * Describes an event occurring on a #GSocketListener. See the
   * #GSocketListener::event signal for more details.
   *
   * Additional values may be added to this type in the future.
   */
  enum SocketListenerEvent {
    /**
     * The listener is about to bind a socket.
     */
    BINDING,
    /**
     * The listener has bound a socket.
     */
    BOUND,
    /**
     * The listener is about to start
     *    listening on this socket.
     */
    LISTENING,
    /**
     * The listener is now listening on
     *   this socket.
     */
    LISTENED,
  }
  /**
   * A protocol identifier is specified when creating a #GSocket, which is a
   * family/type specific identifier, where 0 means the default protocol for
   * the particular family/type.
   *
   * This enum contains a set of commonly available and used protocols. You
   * can also pass any other identifiers handled by the platform in order to
   * use protocols not listed here.
   */
  enum SocketProtocol {
    /**
     * The protocol type is unknown
     */
    UNKNOWN,
    /**
     * The default protocol for the family/type
     */
    DEFAULT,
    /**
     * TCP over IP
     */
    TCP,
    /**
     * UDP over IP
     */
    UDP,
    /**
     * SCTP over IP
     */
    SCTP,
  }
  /**
   * Flags used when creating a #GSocket. Some protocols may not implement
   * all the socket types.
   */
  enum SocketType {
    /**
     * Type unknown or wrong
     */
    INVALID,
    /**
     * Reliable connection-based byte streams (e.g. TCP).
     */
    STREAM,
    /**
     * Connectionless, unreliable datagram passing.
     *     (e.g. UDP)
     */
    DATAGRAM,
    /**
     * Reliable connection-based passing of datagrams
     *     of fixed maximum length (e.g. SCTP).
     */
    SEQPACKET,
  }
  /**
   * The client authentication mode for a #GTlsServerConnection.
   */
  enum TlsAuthenticationMode {
    /**
     * client authentication not required
     */
    NONE,
    /**
     * client authentication is requested
     */
    REQUESTED,
    /**
     * client authentication is required
     */
    REQUIRED,
  }
  /**
   * Flags for g_tls_interaction_request_certificate(),
   * g_tls_interaction_request_certificate_async(), and
   * g_tls_interaction_invoke_request_certificate().
   */
  enum TlsCertificateRequestFlags {
    /**
     * No flags
     */
    NONE,
  }
  /**
   * An error code used with %G_TLS_CHANNEL_BINDING_ERROR in a #GError to
   * indicate a TLS channel binding retrieval error.
   */
  enum TlsChannelBindingError {
    /**
     * Either entire binding
     *    retrieval facility or specific binding type is not implemented in the
     *    TLS backend.
     */
    NOT_IMPLEMENTED,
    /**
     * The handshake is not yet
     *    complete on the connection which is a strong requirement for any existing
     *    binding type.
     */
    INVALID_STATE,
    /**
     * Handshake is complete but
     *    binding data is not available. That normally indicates the TLS
     *    implementation failed to provide the binding data. For example, some
     *    implementations do not provide a peer certificate for resumed connections.
     */
    NOT_AVAILABLE,
    /**
     * Binding type is not supported
     *    on the current connection. This error could be triggered when requesting
     *    `tls-server-end-point` binding data for a certificate which has no hash
     *    function or uses multiple hash functions.
     */
    NOT_SUPPORTED,
    /**
     * Any other backend error
     *    preventing binding data retrieval.
     */
    GENERAL_ERROR,
  }
  /**
   * The type of TLS channel binding data to retrieve from #GTlsConnection
   * or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The
   * [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5)
   * binding type is not currently implemented.
   */
  enum TlsChannelBindingType {
    /**
     * [`tls-unique`](https://tools.ietf.org/html/rfc5929#section-3) binding
     *    type
     */
    UNIQUE,
    /**
     * [`tls-server-end-point`](https://tools.ietf.org/html/rfc5929#section-4)
     *    binding type
     */
    SERVER_END_POINT,
    /**
     * [`tls-exporter`](https://www.rfc-editor.org/rfc/rfc9266.html) binding
     *    type. Since: 2.74
     */
    EXPORTER,
  }
  /**
   * Flags for g_tls_database_lookup_certificate_for_handle(),
   * g_tls_database_lookup_certificate_issuer(),
   * and g_tls_database_lookup_certificates_issued_by().
   */
  enum TlsDatabaseLookupFlags {
    /**
     * No lookup flags
     */
    NONE,
    /**
     * Restrict lookup to certificates that have
     *     a private key.
     */
    KEYPAIR,
  }
  /**
   * An error code used with %G_TLS_ERROR in a #GError returned from a
   * TLS-related routine.
   */
  enum TlsError {
    /**
     * No TLS provider is available
     */
    UNAVAILABLE,
    /**
     * Miscellaneous TLS error
     */
    MISC,
    /**
     * The certificate presented could not
     *   be parsed or failed validation.
     */
    BAD_CERTIFICATE,
    /**
     * The TLS handshake failed because the
     *   peer does not seem to be a TLS server.
     */
    NOT_TLS,
    /**
     * The TLS handshake failed because the
     *   peer's certificate was not acceptable.
     */
    HANDSHAKE,
    /**
     * The TLS handshake failed because
     *   the server requested a client-side certificate, but none was
     *   provided. See g_tls_connection_set_certificate().
     */
    CERTIFICATE_REQUIRED,
    /**
     * The TLS connection was closed without proper
     *   notice, which may indicate an attack. See
     *   g_tls_connection_set_require_close_notify().
     */
    EOF,
    /**
     * The TLS handshake failed
     *   because the client sent the fallback SCSV, indicating a protocol
     *   downgrade attack. Since: 2.60
     */
    INAPPROPRIATE_FALLBACK,
    /**
     * The certificate failed
     *   to load because a password was incorrect. Since: 2.72
     */
    BAD_CERTIFICATE_PASSWORD,
  }
  /**
   * #GTlsInteractionResult is returned by various functions in #GTlsInteraction
   * when finishing an interaction request.
   */
  enum TlsInteractionResult {
    /**
     * The interaction was unhandled (i.e. not
     *     implemented).
     */
    UNHANDLED,
    /**
     * The interaction completed, and resulting data
     *     is available.
     */
    HANDLED,
    /**
     * The interaction has failed, or was cancelled.
     *     and the operation should be aborted.
     */
    FAILED,
  }
  /**
   * The TLS or DTLS protocol version used by a #GTlsConnection or
   * #GDtlsConnection. The integer values of these versions are sequential
   * to ensure newer known protocol versions compare greater than older
   * known versions. Any known DTLS protocol version will compare greater
   * than any SSL or TLS protocol version. The protocol version may be
   * %G_TLS_PROTOCOL_VERSION_UNKNOWN if the TLS backend supports a newer
   * protocol version that GLib does not yet know about. This means that
   * it's possible for an unknown DTLS protocol version to compare less
   * than the TLS protocol versions.
   */
  enum TlsProtocolVersion {
    /**
     * No protocol version or unknown protocol version
     */
    UNKNOWN,
    /**
     * SSL 3.0, which is insecure and should not be used
     */
    SSL_3_0,
    /**
     * TLS 1.0, which is insecure and should not be used
     */
    TLS_1_0,
    /**
     * TLS 1.1, which is insecure and should not be used
     */
    TLS_1_1,
    /**
     * TLS 1.2, defined by [RFC 5246](https://datatracker.ietf.org/doc/html/rfc5246)
     */
    TLS_1_2,
    /**
     * TLS 1.3, defined by [RFC 8446](https://datatracker.ietf.org/doc/html/rfc8446)
     */
    TLS_1_3,
    /**
     * DTLS 1.0, which is insecure and should not be used
     */
    DTLS_1_0,
    /**
     * DTLS 1.2, defined by [RFC 6347](https://datatracker.ietf.org/doc/html/rfc6347)
     */
    DTLS_1_2,
  }
  /**
   * When to allow rehandshaking. See
   * g_tls_connection_set_rehandshake_mode().
   */
  enum TlsRehandshakeMode {
    /**
     * Never allow rehandshaking
     */
    NEVER,
    /**
     * Allow safe rehandshaking only
     */
    SAFELY,
    /**
     * Allow unsafe rehandshaking
     */
    UNSAFELY,
  }
  /**
   * The type of name used by a #GUnixSocketAddress.
   * %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain
   * socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS
   * indicates a socket not bound to any name (eg, a client-side socket,
   * or a socket created with socketpair()).
   *
   * For abstract sockets, there are two incompatible ways of naming
   * them; the man pages suggest using the entire `struct sockaddr_un`
   * as the name, padding the unused parts of the %sun_path field with
   * zeroes; this corresponds to %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED.
   * However, many programs instead just use a portion of %sun_path, and
   * pass an appropriate smaller length to bind() or connect(). This is
   * %G_UNIX_SOCKET_ADDRESS_ABSTRACT.
   */
  enum UnixSocketAddressType {
    /**
     * invalid
     */
    INVALID,
    /**
     * anonymous
     */
    ANONYMOUS,
    /**
     * a filesystem path
     */
    PATH,
    /**
     * an abstract name
     */
    ABSTRACT,
    /**
     * an abstract name, 0-padded
     *   to the full length of a unix socket name
     */
    ABSTRACT_PADDED,
  }
  /**
   * Used to select the type of data format to use for #GZlibDecompressor
   * and #GZlibCompressor.
   */
  enum ZlibCompressorFormat {
    /**
     * deflate compression with zlib header
     */
    ZLIB,
    /**
     * gzip file format
     */
    GZIP,
    /**
     * deflate compression with no header
     */
    RAW,
  }
  /**
   * Flags used when creating a #GAppInfo.
   * @bitfield
   */
  enum AppInfoCreateFlags {
    /**
     * No flags.
     */
    NONE,
    /**
     * Application opens in a terminal window.
     */
    NEEDS_TERMINAL,
    /**
     * Application supports URI arguments.
     */
    SUPPORTS_URIS,
    /**
     * Application supports startup notification. Since 2.26
     */
    SUPPORTS_STARTUP_NOTIFICATION,
  }
  /**
   * Flags used to define the behaviour of a #GApplication.
   * @bitfield
   */
  enum ApplicationFlags {
    /**
     * Default. Deprecated in 2.74, use
     *   %G_APPLICATION_DEFAULT_FLAGS instead
     */
    FLAGS_NONE,
    /**
     * Default flags. Since: 2.74
     */
    DEFAULT_FLAGS,
    /**
     * Run as a service. In this mode, registration
     *      fails if the service is already running, and the application
     *      will initially wait up to 10 seconds for an initial activation
     *      message to arrive.
     */
    IS_SERVICE,
    /**
     * Don't try to become the primary instance.
     */
    IS_LAUNCHER,
    /**
     * This application handles opening files (in
     *     the primary instance). Note that this flag only affects the default
     *     implementation of local_command_line(), and has no effect if
     *     %G_APPLICATION_HANDLES_COMMAND_LINE is given.
     *     See g_application_run() for details.
     */
    HANDLES_OPEN,
    /**
     * This application handles command line
     *     arguments (in the primary instance). Note that this flag only affect
     *     the default implementation of local_command_line().
     *     See g_application_run() for details.
     */
    HANDLES_COMMAND_LINE,
    /**
     * Send the environment of the
     *     launching process to the primary instance. Set this flag if your
     *     application is expected to behave differently depending on certain
     *     environment variables. For instance, an editor might be expected
     *     to use the `GIT_COMMITTER_NAME` environment variable
     *     when editing a git commit message. The environment is available
     *     to the #GApplication::command-line signal handler, via
     *     g_application_command_line_getenv().
     */
    SEND_ENVIRONMENT,
    /**
     * Make no attempts to do any of the typical
     *     single-instance application negotiation, even if the application
     *     ID is given.  The application neither attempts to become the
     *     owner of the application ID nor does it check if an existing
     *     owner already exists.  Everything occurs in the local process.
     *     Since: 2.30.
     */
    NON_UNIQUE,
    /**
     * Allow users to override the
     *     application ID from the command line with `--gapplication-app-id`.
     *     Since: 2.48
     */
    CAN_OVERRIDE_APP_ID,
    /**
     * Allow another instance to take over
     *     the bus name. Since: 2.60
     */
    ALLOW_REPLACEMENT,
    /**
     * Take over from another instance. This flag is
     *     usually set by passing `--gapplication-replace` on the commandline.
     *     Since: 2.60
     */
    REPLACE,
  }
  /**
   * #GAskPasswordFlags are used to request specific information from the
   * user, or to notify the user of their choices in an authentication
   * situation.
   * @bitfield
   */
  enum AskPasswordFlags {
    /**
     * operation requires a password.
     */
    NEED_PASSWORD,
    /**
     * operation requires a username.
     */
    NEED_USERNAME,
    /**
     * operation requires a domain.
     */
    NEED_DOMAIN,
    /**
     * operation supports saving settings.
     */
    SAVING_SUPPORTED,
    /**
     * operation supports anonymous users.
     */
    ANONYMOUS_SUPPORTED,
    /**
     * operation takes TCRYPT parameters (Since: 2.58)
     */
    TCRYPT,
  }
  /**
   * Flags used in g_bus_own_name().
   * @bitfield
   */
  enum BusNameOwnerFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Allow another message bus connection to claim the name.
     */
    ALLOW_REPLACEMENT,
    /**
     * If another message bus connection owns the name and have
     * specified %G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, then take the name from the other connection.
     */
    REPLACE,
    /**
     * If another message bus connection owns the name, immediately
     * return an error from g_bus_own_name() rather than entering the waiting queue for that name. (Since 2.54)
     */
    DO_NOT_QUEUE,
  }
  /**
   * Flags used in g_bus_watch_name().
   * @bitfield
   */
  enum BusNameWatcherFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * If no-one owns the name when
     * beginning to watch the name, ask the bus to launch an owner for the
     * name.
     */
    AUTO_START,
  }
  /**
   * Flags used when calling a g_converter_convert().
   * @bitfield
   */
  enum ConverterFlags {
    /**
     * No flags.
     */
    NONE,
    /**
     * At end of input data
     */
    INPUT_AT_END,
    /**
     * Flush data
     */
    FLUSH,
  }
  /**
   * Flags used in g_dbus_connection_call() and similar APIs.
   * @bitfield
   */
  enum DBusCallFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * The bus must not launch
     * an owner for the destination name in response to this method
     * invocation.
     */
    NO_AUTO_START,
    /**
     * the caller is prepared to
     * wait for interactive authorization. Since 2.46.
     */
    ALLOW_INTERACTIVE_AUTHORIZATION,
  }
  /**
   * Capabilities negotiated with the remote peer.
   * @bitfield
   */
  enum DBusCapabilityFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * The connection
     * supports exchanging UNIX file descriptors with the remote peer.
     */
    UNIX_FD_PASSING,
  }
  /**
   * Flags used when creating a new #GDBusConnection.
   * @bitfield
   */
  enum DBusConnectionFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Perform authentication against server.
     */
    AUTHENTICATION_CLIENT,
    /**
     * Perform authentication against client.
     */
    AUTHENTICATION_SERVER,
    /**
     * When
     * authenticating as a server, allow the anonymous authentication
     * method.
     */
    AUTHENTICATION_ALLOW_ANONYMOUS,
    /**
     * Pass this flag if connecting to a peer that is a
     * message bus. This means that the Hello() method will be invoked as part of the connection setup.
     */
    MESSAGE_BUS_CONNECTION,
    /**
     * If set, processing of D-Bus messages is
     * delayed until g_dbus_connection_start_message_processing() is called.
     */
    DELAY_MESSAGE_PROCESSING,
    /**
     * When authenticating
     * as a server, require the UID of the peer to be the same as the UID of the server. (Since: 2.68)
     */
    AUTHENTICATION_REQUIRE_SAME_USER,
    /**
     * When authenticating, try to use
     *  protocols that work across a Linux user namespace boundary, even if this
     *  reduces interoperability with older D-Bus implementations. This currently
     *  affects client-side `EXTERNAL` authentication, for which this flag makes
     *  connections to a server in another user namespace succeed, but causes
     *  a deadlock when connecting to a GDBus server older than 2.73.3. Since: 2.74
     */
    CROSS_NAMESPACE,
  }
  /**
   * Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
   * @bitfield
   */
  enum DBusInterfaceSkeletonFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Each method invocation is handled in
     *   a thread dedicated to the invocation. This means that the method implementation can use blocking IO
     *   without blocking any other part of the process. It also means that the method implementation must
     *   use locking to access data structures used by other threads.
     */
    HANDLE_METHOD_INVOCATIONS_IN_THREAD,
  }
  /**
   * Message flags used in #GDBusMessage.
   * @bitfield
   */
  enum DBusMessageFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * A reply is not expected.
     */
    NO_REPLY_EXPECTED,
    /**
     * The bus must not launch an
     * owner for the destination name in response to this message.
     */
    NO_AUTO_START,
    /**
     * If set on a method
     * call, this flag means that the caller is prepared to wait for interactive
     * authorization. Since 2.46.
     */
    ALLOW_INTERACTIVE_AUTHORIZATION,
  }
  /**
   * Flags used when constructing a #GDBusObjectManagerClient.
   * @bitfield
   */
  enum DBusObjectManagerClientFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * If not set and the
     *   manager is for a well-known name, then request the bus to launch
     *   an owner for the name if no-one owns the name. This flag can only
     *   be used in managers for well-known names.
     */
    DO_NOT_AUTO_START,
  }
  /**
   * Flags describing the access control of a D-Bus property.
   * @bitfield
   */
  enum DBusPropertyInfoFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Property is readable.
     */
    READABLE,
    /**
     * Property is writable.
     */
    WRITABLE,
  }
  /**
   * Flags used when constructing an instance of a #GDBusProxy derived class.
   * @bitfield
   */
  enum DBusProxyFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Don't load properties.
     */
    DO_NOT_LOAD_PROPERTIES,
    /**
     * Don't connect to signals on the remote object.
     */
    DO_NOT_CONNECT_SIGNALS,
    /**
     * If the proxy is for a well-known name,
     * do not ask the bus to launch an owner during proxy initialization or a method call.
     * This flag is only meaningful in proxies for well-known names.
     */
    DO_NOT_AUTO_START,
    /**
     * If set, the property value for any __invalidated property__ will be (asynchronously) retrieved upon receiving the [`PropertiesChanged`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties) D-Bus signal and the property will not cause emission of the #GDBusProxy::g-properties-changed signal. When the value is received the #GDBusProxy::g-properties-changed signal is emitted for the property along with the retrieved value. Since 2.32.
     */
    GET_INVALIDATED_PROPERTIES,
    /**
     * If the proxy is for a well-known name,
     * do not ask the bus to launch an owner during proxy initialization, but allow it to be
     * autostarted by a method call. This flag is only meaningful in proxies for well-known names,
     * and only if %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is not also specified.
     */
    DO_NOT_AUTO_START_AT_CONSTRUCTION,
    /**
     * Don't actually send the AddMatch D-Bus
     *    call for this signal subscription. This gives you more control
     *    over which match rules you add (but you must add them manually). (Since: 2.72)
     */
    NO_MATCH_RULE,
  }
  /**
   * Flags used when sending #GDBusMessages on a #GDBusConnection.
   * @bitfield
   */
  enum DBusSendMessageFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Do not automatically
     * assign a serial number from the #GDBusConnection object when
     * sending a message.
     */
    PRESERVE_SERIAL,
  }
  /**
   * Flags used when creating a #GDBusServer.
   * @bitfield
   */
  enum DBusServerFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * All #GDBusServer::new-connection
     * signals will run in separated dedicated threads (see signal for
     * details).
     */
    RUN_IN_THREAD,
    /**
     * Allow the anonymous
     * authentication method.
     */
    AUTHENTICATION_ALLOW_ANONYMOUS,
    /**
     * Require the UID of the
     * peer to be the same as the UID of the server when authenticating. (Since: 2.68)
     */
    AUTHENTICATION_REQUIRE_SAME_USER,
  }
  /**
   * Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
   * @bitfield
   */
  enum DBusSignalFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Don't actually send the AddMatch
     * D-Bus call for this signal subscription.  This gives you more control
     * over which match rules you add (but you must add them manually).
     */
    NO_MATCH_RULE,
    /**
     * Match first arguments that
     * contain a bus or interface name with the given namespace.
     */
    MATCH_ARG0_NAMESPACE,
    /**
     * Match first arguments that
     * contain an object path that is either equivalent to the given path,
     * or one of the paths is a subpath of the other.
     */
    MATCH_ARG0_PATH,
  }
  /**
   * Flags passed to g_dbus_connection_register_subtree().
   * @bitfield
   */
  enum DBusSubtreeFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Method calls to objects not in the enumerated range
     *                                                       will still be dispatched. This is useful if you want
     *                                                       to dynamically spawn objects in the subtree.
     */
    DISPATCH_TO_UNENUMERATED_NODES,
  }
  /**
   * Flags used when starting a drive.
   * @bitfield
   */
  enum DriveStartFlags {
    /**
     * No flags set.
     */
    NONE,
  }
  /**
   * Flags specifying the behaviour of an attribute.
   * @bitfield
   */
  enum FileAttributeInfoFlags {
    /**
     * no flags set.
     */
    NONE,
    /**
     * copy the attribute values when the file is copied.
     */
    COPY_WITH_FILE,
    /**
     * copy the attribute values when the file is moved.
     */
    COPY_WHEN_MOVED,
  }
  /**
   * Flags used when copying or moving files.
   * @bitfield
   */
  enum FileCopyFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Overwrite any existing files
     */
    OVERWRITE,
    /**
     * Make a backup of any existing files.
     */
    BACKUP,
    /**
     * Don't follow symlinks.
     */
    NOFOLLOW_SYMLINKS,
    /**
     * Copy all file metadata instead of just default set used for copy (see #GFileInfo).
     */
    ALL_METADATA,
    /**
     * Don't use copy and delete fallback if native move not supported.
     */
    NO_FALLBACK_FOR_MOVE,
    /**
     * Leaves target file with default perms, instead of setting the source file perms.
     */
    TARGET_DEFAULT_PERMS,
    /**
     * Use default modification
     *     timestamps instead of copying them from the source file. Since 2.80
     */
    TARGET_DEFAULT_MODIFIED_TIME,
  }
  /**
   * Flags used when an operation may create a file.
   * @bitfield
   */
  enum FileCreateFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Create a file that can only be
     *    accessed by the current user.
     */
    PRIVATE,
    /**
     * Replace the destination
     *    as if it didn't exist before. Don't try to keep any old
     *    permissions, replace instead of following links. This
     *    is generally useful if you're doing a "copy over"
     *    rather than a "save new version of" replace operation.
     *    You can think of it as "unlink destination" before
     *    writing to it, although the implementation may not
     *    be exactly like that. This flag can only be used with
     *    g_file_replace() and its variants, including g_file_replace_contents().
     *    Since 2.20
     */
    REPLACE_DESTINATION,
  }
  /**
   * Flags that can be used with g_file_measure_disk_usage().
   * @bitfield
   */
  enum FileMeasureFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Report any error encountered
     *   while traversing the directory tree.  Normally errors are only
     *   reported for the toplevel file.
     */
    REPORT_ANY_ERROR,
    /**
     * Tally usage based on apparent file
     *   sizes.  Normally, the block-size is used, if available, as this is a
     *   more accurate representation of disk space used.
     *   Compare with `du --apparent-size`.
     *   Since GLib 2.78. and similarly to `du` since GNU Coreutils 9.2, this will
     *   ignore the sizes of file types other than regular files and links, as the
     *   sizes of other file types are not specified in a standard way.
     */
    APPARENT_SIZE,
    /**
     * Do not cross mount point boundaries.
     *   Compare with `du -x`.
     */
    NO_XDEV,
  }
  /**
   * Flags used to set what a #GFileMonitor will watch for.
   * @bitfield
   */
  enum FileMonitorFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Watch for mount events.
     */
    WATCH_MOUNTS,
    /**
     * Pair DELETED and CREATED events caused
     *   by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED
     *   event instead (NB: not supported on all backends; the default
     *   behaviour -without specifying this flag- is to send single DELETED
     *   and CREATED events).  Deprecated since 2.46: use
     *   %G_FILE_MONITOR_WATCH_MOVES instead.
     */
    SEND_MOVED,
    /**
     * Watch for changes to the file made
     *   via another hard link. Since 2.36.
     */
    WATCH_HARD_LINKS,
    /**
     * Watch for rename operations on a
     *   monitored directory.  This causes %G_FILE_MONITOR_EVENT_RENAMED,
     *   %G_FILE_MONITOR_EVENT_MOVED_IN and %G_FILE_MONITOR_EVENT_MOVED_OUT
     *   events to be emitted when possible.  Since: 2.46.
     */
    WATCH_MOVES,
  }
  /**
   * Flags used when querying a #GFileInfo.
   * @bitfield
   */
  enum FileQueryInfoFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Don't follow symlinks.
     */
    NOFOLLOW_SYMLINKS,
  }
  /**
   * GIOStreamSpliceFlags determine how streams should be spliced.
   * @bitfield
   */
  enum IOStreamSpliceFlags {
    /**
     * Do not close either stream.
     */
    NONE,
    /**
     * Close the first stream after
     *     the splice.
     */
    CLOSE_STREAM1,
    /**
     * Close the second stream after
     *     the splice.
     */
    CLOSE_STREAM2,
    /**
     * Wait for both splice operations to finish
     *     before calling the callback.
     */
    WAIT_FOR_BOTH,
  }
  /**
   * Flags used when mounting a mount.
   * @bitfield
   */
  enum MountMountFlags {
    /**
     * No flags set.
     */
    NONE,
  }
  /**
   * Flags used when an unmounting a mount.
   * @bitfield
   */
  enum MountUnmountFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * Unmount even if there are outstanding
     *  file operations on the mount.
     */
    FORCE,
  }
  /**
   * GOutputStreamSpliceFlags determine how streams should be spliced.
   * @bitfield
   */
  enum OutputStreamSpliceFlags {
    /**
     * Do not close either stream.
     */
    NONE,
    /**
     * Close the source stream after
     *     the splice.
     */
    CLOSE_SOURCE,
    /**
     * Close the target stream after
     *     the splice.
     */
    CLOSE_TARGET,
  }
  /**
   * Flags to modify lookup behavior.
   * @bitfield
   */
  enum ResolverNameLookupFlags {
    /**
     * default behavior (same as g_resolver_lookup_by_name())
     */
    DEFAULT,
    /**
     * only resolve ipv4 addresses
     */
    IPV4_ONLY,
    /**
     * only resolve ipv6 addresses
     */
    IPV6_ONLY,
  }
  /**
   * GResourceFlags give information about a particular file inside a resource
   * bundle.
   * @bitfield
   */
  enum ResourceFlags {
    /**
     * No flags set.
     */
    NONE,
    /**
     * The file is compressed.
     */
    COMPRESSED,
  }
  /**
   * GResourceLookupFlags determine how resource path lookups are handled.
   * @bitfield
   */
  enum ResourceLookupFlags {
    /**
     * No flags set.
     */
    NONE,
  }
  /**
   * Flags used when creating a binding. These flags determine in which
   * direction the binding works. The default is to synchronize in both
   * directions.
   * @bitfield
   */
  enum SettingsBindFlags {
    /**
     * Equivalent to `G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET`
     */
    DEFAULT,
    /**
     * Update the #GObject property when the setting changes.
     *     It is an error to use this flag if the property is not writable.
     */
    GET,
    /**
     * Update the setting when the #GObject property changes.
     *     It is an error to use this flag if the property is not readable.
     */
    SET,
    /**
     * Do not try to bind a "sensitivity" property to the writability of the setting
     */
    NO_SENSITIVITY,
    /**
     * When set in addition to %G_SETTINGS_BIND_GET, set the #GObject property
     *     value initially from the setting, but do not listen for changes of the setting
     */
    GET_NO_CHANGES,
    /**
     * When passed to g_settings_bind(), uses a pair of mapping functions that invert
     *     the boolean value when mapping between the setting and the property.  The setting and property must both
     *     be booleans.  You cannot pass this flag to g_settings_bind_with_mapping().
     */
    INVERT_BOOLEAN,
  }
  /**
   * Flags used in g_socket_receive_message() and g_socket_send_message().
   * The flags listed in the enum are some commonly available flags, but the
   * values used for them are the same as on the platform, and any other flags
   * are passed in/out as is. So to use a platform specific flag, just include
   * the right system header and pass in the flag.
   * @bitfield
   */
  enum SocketMsgFlags {
    /**
     * No flags.
     */
    NONE,
    /**
     * Request to send/receive out of band data.
     */
    OOB,
    /**
     * Read data from the socket without removing it from
     *     the queue.
     */
    PEEK,
    /**
     * Don't use a gateway to send out the packet,
     *     only send to hosts on directly connected networks.
     */
    DONTROUTE,
  }
  /**
   * Flags to define the behaviour of a #GSubprocess.
   *
   * Note that the default for stdin is to redirect from `/dev/null`.  For
   * stdout and stderr the default are for them to inherit the
   * corresponding descriptor from the calling process.
   *
   * Note that it is a programmer error to mix 'incompatible' flags.  For
   * example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
   * %G_SUBPROCESS_FLAGS_STDOUT_SILENCE.
   * @bitfield
   */
  enum SubprocessFlags {
    /**
     * No flags.
     */
    NONE,
    /**
     * create a pipe for the stdin of the
     *   spawned process that can be accessed with
     *   g_subprocess_get_stdin_pipe().
     */
    STDIN_PIPE,
    /**
     * stdin is inherited from the
     *   calling process.
     */
    STDIN_INHERIT,
    /**
     * create a pipe for the stdout of the
     *   spawned process that can be accessed with
     *   g_subprocess_get_stdout_pipe().
     */
    STDOUT_PIPE,
    /**
     * silence the stdout of the spawned
     *   process (ie: redirect to `/dev/null`).
     */
    STDOUT_SILENCE,
    /**
     * create a pipe for the stderr of the
     *   spawned process that can be accessed with
     *   g_subprocess_get_stderr_pipe().
     */
    STDERR_PIPE,
    /**
     * silence the stderr of the spawned
     *   process (ie: redirect to `/dev/null`).
     */
    STDERR_SILENCE,
    /**
     * merge the stderr of the spawned
     *   process with whatever the stdout happens to be.  This is a good way
     *   of directing both streams to a common log file, for example.
     */
    STDERR_MERGE,
    /**
     * spawned processes will inherit the
     *   file descriptors of their parent, unless those descriptors have
     *   been explicitly marked as close-on-exec.  This flag has no effect
     *   over the "standard" file descriptors (stdin, stdout, stderr).
     */
    INHERIT_FDS,
    /**
     * if path searching is
     *   needed when spawning the subprocess, use the `PATH` in the launcher
     *   environment. (Since: 2.72)
     */
    SEARCH_PATH_FROM_ENVP,
  }
  /**
   * Flags to define future #GTestDBus behaviour.
   * @bitfield
   */
  enum TestDBusFlags {
    /**
     * No flags.
     */
    NONE,
  }
  /**
   * A set of flags describing TLS certification validation. This can be
   * used to describe why a particular certificate was rejected (for
   * example, in #GTlsConnection::accept-certificate).
   *
   * GLib guarantees that if certificate verification fails, at least one
   * flag will be set, but it does not guarantee that all possible flags
   * will be set. Accordingly, you may not safely decide to ignore any
   * particular type of error. For example, it would be incorrect to mask
   * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
   * because this could potentially be the only error flag set even if
   * other problems exist with the certificate.
   * @bitfield
   */
  enum TlsCertificateFlags {
    /**
     * No flags set. Since: 2.74
     */
    NO_FLAGS,
    /**
     * The signing certificate authority is
     *   not known.
     */
    UNKNOWN_CA,
    /**
     * The certificate does not match the
     *   expected identity of the site that it was retrieved from.
     */
    BAD_IDENTITY,
    /**
     * The certificate's activation time
     *   is still in the future
     */
    NOT_ACTIVATED,
    /**
     * The certificate has expired
     */
    EXPIRED,
    /**
     * The certificate has been revoked
     *   according to the #GTlsConnection's certificate revocation list.
     */
    REVOKED,
    /**
     * The certificate's algorithm is
     *   considered insecure.
     */
    INSECURE,
    /**
     * Some other error occurred validating
     *   the certificate
     */
    GENERIC_ERROR,
    /**
     * the combination of all of the above
     *   flags
     */
    VALIDATE_ALL,
  }
  /**
   * Flags for g_tls_database_verify_chain().
   * @bitfield
   */
  enum TlsDatabaseVerifyFlags {
    /**
     * No verification flags
     */
    NONE,
  }
  /**
   * Various flags for the password.
   * @bitfield
   */
  enum TlsPasswordFlags {
    /**
     * No flags
     */
    NONE,
    /**
     * The password was wrong, and the user should retry.
     */
    RETRY,
    /**
     * Hint to the user that the password has been
     *    wrong many times, and the user may not have many chances left.
     */
    MANY_TRIES,
    /**
     * Hint to the user that this is the last try to get
     *    this password right.
     */
    FINAL_TRY,
    /**
     * For PKCS #11, the user PIN is required.
     *    Since: 2.70.
     */
    PKCS11_USER,
    /**
     * For PKCS #11, the security officer
     *    PIN is required. Since: 2.70.
     */
    PKCS11_SECURITY_OFFICER,
    /**
     * For PKCS #11, the context-specific
     *    PIN is required. Since: 2.70.
     */
    PKCS11_CONTEXT_SPECIFIC,
  }
  /**
   * The value returned by handlers of the signals generated by
   * the `gdbus-codegen` tool to indicate that a method call has been
   * handled by an implementation. It is equal to %TRUE, but using
   * this macro is sometimes more readable.
   *
   * In code that needs to be backwards-compatible with older GLib,
   * use %TRUE instead, often written like this:
   *
   *
   * ```
   *   g_dbus_method_invocation_return_error (invocation, ...);
   *   return TRUE;    // handled
   * ```
   *
   */
  const DBUS_METHOD_INVOCATION_HANDLED: boolean
  /**
   * The value returned by handlers of the signals generated by
   * the `gdbus-codegen` tool to indicate that a method call has not been
   * handled by an implementation. It is equal to %FALSE, but using
   * this macro is sometimes more readable.
   *
   * In code that needs to be backwards-compatible with older GLib,
   * use %FALSE instead.
   */
  const DBUS_METHOD_INVOCATION_UNHANDLED: boolean
  /**
   * Extension point for debug control functionality.
   * See [Extending GIO][extending-gio].
   */
  const DEBUG_CONTROLLER_EXTENSION_POINT_NAME: string
  /**
   * Extension point for default handler to URI association. See
   * [Extending GIO][extending-gio].
   */
  const DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME: string
  /**
   * The string used to obtain a Unix device path with g_drive_get_identifier().
   */
  const DRIVE_IDENTIFIER_KIND_UNIX_DEVICE: string
  /**
   * A key in the "access" namespace for checking deletion privileges.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   *
   * This attribute will be %TRUE if the user is able to delete the file.
   */
  const FILE_ATTRIBUTE_ACCESS_CAN_DELETE: string
  /**
   * A key in the "access" namespace for getting execution privileges.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   *
   * This attribute will be %TRUE if the user is able to execute the file.
   */
  const FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE: string
  /**
   * A key in the "access" namespace for getting read privileges.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   *
   * This attribute will be %TRUE if the user is able to read the file.
   */
  const FILE_ATTRIBUTE_ACCESS_CAN_READ: string
  /**
   * A key in the "access" namespace for checking renaming privileges.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   *
   * This attribute will be %TRUE if the user is able to rename the file.
   */
  const FILE_ATTRIBUTE_ACCESS_CAN_RENAME: string
  /**
   * A key in the "access" namespace for checking trashing privileges.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   *
   * This attribute will be %TRUE if the user is able to move the file to
   * the trash.
   */
  const FILE_ATTRIBUTE_ACCESS_CAN_TRASH: string
  /**
   * A key in the "access" namespace for getting write privileges.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   *
   * This attribute will be %TRUE if the user is able to write to the file.
   */
  const FILE_ATTRIBUTE_ACCESS_CAN_WRITE: string
  /**
   * A key in the "dos" namespace for checking if the file's archive flag
   * is set.
   *
   * This attribute is %TRUE if the archive flag is set.
   *
   * This attribute is only available for DOS file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_DOS_IS_ARCHIVE: string
  /**
   * A key in the "dos" namespace for checking if the file is a NTFS mount point
   * (a volume mount or a junction point).
   *
   * This attribute is %TRUE if file is a reparse point of type
   * [IO_REPARSE_TAG_MOUNT_POINT](https://msdn.microsoft.com/en-us/library/dd541667.aspx).
   *
   * This attribute is only available for DOS file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT: string
  /**
   * A key in the "dos" namespace for checking if the file's backup flag
   * is set.
   *
   * This attribute is %TRUE if the backup flag is set.
   *
   * This attribute is only available for DOS file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_DOS_IS_SYSTEM: string
  /**
   * A key in the "dos" namespace for getting the file NTFS reparse tag.
   *
   * This value is 0 for files that are not reparse points.
   *
   * See the [Reparse Tags](https://msdn.microsoft.com/en-us/library/dd541667.aspx)
   * page for possible reparse tag values.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG: string
  /**
   * A key in the "etag" namespace for getting the value of the file's
   * entity tag.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_ETAG_VALUE: string
  /**
   * A key in the "filesystem" namespace for getting the number of bytes
   * of free space left on the file system.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
   */
  const FILE_ATTRIBUTE_FILESYSTEM_FREE: string
  /**
   * A key in the "filesystem" namespace for checking if the file system
   * is read only.
   *
   * Is set to %TRUE if the file system is read only.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_FILESYSTEM_READONLY: string
  /**
   * A key in the "filesystem" namespace for checking if the file system
   * is remote.
   *
   * Is set to %TRUE if the file system is remote.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_FILESYSTEM_REMOTE: string
  /**
   * A key in the "filesystem" namespace for getting the total size (in
   * bytes) of the file system, used in g_file_query_filesystem_info().
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
   */
  const FILE_ATTRIBUTE_FILESYSTEM_SIZE: string
  /**
   * A key in the "filesystem" namespace for getting the file system's type.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_FILESYSTEM_TYPE: string
  /**
   * A key in the "filesystem" namespace for getting the number of bytes
   * used by data on the file system.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
   */
  const FILE_ATTRIBUTE_FILESYSTEM_USED: string
  /**
   * A key in the "filesystem" namespace for hinting a file manager
   * application whether it should preview (e.g. thumbnail) files on the
   * file system.
   *
   * The value for this key contain a #GFilesystemPreviewType.
   */
  const FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW: string
  /**
   * A key in the "gvfs" namespace that gets the name of the current
   * GVFS backend in use.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_GVFS_BACKEND: string
  /**
   * A key in the "id" namespace for getting a file identifier.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   *
   * An example use would be during listing files, to avoid recursive
   * directory scanning.
   */
  const FILE_ATTRIBUTE_ID_FILE: string
  /**
   * A key in the "id" namespace for getting the file system identifier.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   *
   * An example use would be during drag and drop to see if the source
   * and target are on the same filesystem (default to move) or not (default
   * to copy).
   */
  const FILE_ATTRIBUTE_ID_FILESYSTEM: string
  /**
   * A key in the "mountable" namespace for checking if a file (of
   * type G_FILE_TYPE_MOUNTABLE) can be ejected.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT: string
  /**
   * A key in the "mountable" namespace for checking if a file (of
   * type G_FILE_TYPE_MOUNTABLE) is mountable.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT: string
  /**
   * A key in the "mountable" namespace for checking if a file (of
   * type G_FILE_TYPE_MOUNTABLE) can be polled.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL: string
  /**
   * A key in the "mountable" namespace for checking if a file (of
   * type G_FILE_TYPE_MOUNTABLE) can be started.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_CAN_START: string
  /**
   * A key in the "mountable" namespace for checking if a file (of
   * type G_FILE_TYPE_MOUNTABLE) can be started degraded.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED: string
  /**
   * A key in the "mountable" namespace for checking if a file (of
   * type G_FILE_TYPE_MOUNTABLE) can be stopped.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP: string
  /**
   * A key in the "mountable" namespace for checking if a file (of
   * type G_FILE_TYPE_MOUNTABLE)  is unmountable.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT: string
  /**
   * A key in the "mountable" namespace for getting the HAL UDI for the mountable
   * file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI: string
  /**
   * A key in the "mountable" namespace for checking if a file (of
   * type G_FILE_TYPE_MOUNTABLE) is automatically polled for media.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC: string
  /**
   * A key in the "mountable" namespace for getting the #GDriveStartStopType.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE: string
  /**
   * A key in the "mountable" namespace for getting the unix device.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE: string
  /**
   * A key in the "mountable" namespace for getting the unix device file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE: string
  /**
   * A key in the "owner" namespace for getting the file owner's group.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_OWNER_GROUP: string
  /**
   * A key in the "owner" namespace for getting the user name of the
   * file's owner.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_OWNER_USER: string
  /**
   * A key in the "owner" namespace for getting the real name of the
   * user that owns the file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_OWNER_USER_REAL: string
  /**
   * A key in the "preview" namespace for getting a #GIcon that can be
   * used to get preview of the file.
   *
   * For example, it may be a low resolution thumbnail without metadata.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
   *
   * The value for this key should contain a #GIcon.
   */
  const FILE_ATTRIBUTE_PREVIEW_ICON: string
  /**
   * A key in the "recent" namespace for getting time, when the metadata for the
   * file in `recent:///` was last changed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT64.
   */
  const FILE_ATTRIBUTE_RECENT_MODIFIED: string
  /**
   * A key in the "selinux" namespace for getting the file's SELinux
   * context.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   *
   * Note that this attribute is only available if GLib has been built
   * with SELinux support.
   */
  const FILE_ATTRIBUTE_SELINUX_CONTEXT: string
  /**
   * A key in the "standard" namespace for getting the amount of disk space
   * that is consumed by the file (in bytes).
   *
   * This will generally be larger than the file size (due to block size
   * overhead) but can occasionally be smaller (for example, for sparse files).
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
   */
  const FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE: string
  /**
   * A key in the "standard" namespace for getting the content type of the file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   *
   * The value for this key should contain a valid content type.
   */
  const FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE: string
  /**
   * A key in the "standard" namespace for getting the copy name of the file.
   *
   * The copy name is an optional version of the name. If available it's always
   * in UTF8, and corresponds directly to the original filename (only transcoded to
   * UTF8). This is useful if you want to copy the file to another filesystem that
   * might have a different encoding. If the filename is not a valid string in the
   * encoding selected for the filesystem it is in then the copy name will not be set.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_STANDARD_COPY_NAME: string
  /**
   * A key in the "standard" namespace for getting the description of the file.
   *
   * The description is a utf8 string that describes the file, generally containing
   * the filename, but can also contain further information. Example descriptions
   * could be "filename (on hostname)" for a remote file or "filename (in trash)"
   * for a file in the trash. This is useful for instance as the window title
   * when displaying a directory or for a bookmarks menu.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_STANDARD_DESCRIPTION: string
  /**
   * A key in the "standard" namespace for getting the display name of the file.
   *
   * A display name is guaranteed to be in UTF-8 and can thus be displayed in
   * the UI. It is guaranteed to be set on every file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME: string
  /**
   * A key in the "standard" namespace for edit name of the file.
   *
   * An edit name is similar to the display name, but it is meant to be
   * used when you want to rename the file in the UI. The display name
   * might contain information you don't want in the new filename (such as
   * "(invalid unicode)" if the filename was in an invalid encoding).
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_STANDARD_EDIT_NAME: string
  /**
   * A key in the "standard" namespace for getting the fast content type.
   *
   * The fast content type isn't as reliable as the regular one, as it
   * only uses the filename to guess it, but it is faster to calculate than the
   * regular content type.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE: string
  /**
   * A key in the "standard" namespace for getting the icon for the file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
   *
   * The value for this key should contain a #GIcon.
   */
  const FILE_ATTRIBUTE_STANDARD_ICON: string
  /**
   * A key in the "standard" namespace for checking if a file is a backup file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_STANDARD_IS_BACKUP: string
  /**
   * A key in the "standard" namespace for checking if a file is hidden.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_STANDARD_IS_HIDDEN: string
  /**
   * A key in the "standard" namespace for checking if the file is a symlink.
   * Typically the actual type is something else, if we followed the symlink
   * to get the type.
   *
   * On Windows NTFS mountpoints are considered to be symlinks as well.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_STANDARD_IS_SYMLINK: string
  /**
   * A key in the "standard" namespace for checking if a file is virtual.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL: string
  /**
   * A key in the "standard" namespace for checking if a file is
   * volatile. This is meant for opaque, non-POSIX-like backends to
   * indicate that the URI is not persistent. Applications should look
   * at %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET for the persistent URI.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_STANDARD_IS_VOLATILE: string
  /**
   * A key in the "standard" namespace for getting the name of the file.
   *
   * The name is the on-disk filename which may not be in any known encoding,
   * and can thus not be generally displayed as is. It is guaranteed to be set on
   * every file.
   *
   * Use %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME if you need to display the
   * name in a user interface.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
   */
  const FILE_ATTRIBUTE_STANDARD_NAME: string
  /**
   * A key in the "standard" namespace for getting the file's size (in bytes).
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
   */
  const FILE_ATTRIBUTE_STANDARD_SIZE: string
  /**
   * A key in the "standard" namespace for setting the sort order of a file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT32.
   *
   * An example use would be in file managers, which would use this key
   * to set the order files are displayed. Files with smaller sort order
   * should be sorted first, and files without sort order as if sort order
   * was zero.
   */
  const FILE_ATTRIBUTE_STANDARD_SORT_ORDER: string
  /**
   * A key in the "standard" namespace for getting the symbolic icon for the file.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
   *
   * The value for this key should contain a #GIcon.
   */
  const FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON: string
  /**
   * A key in the "standard" namespace for getting the symlink target, if the file
   * is a symlink.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
   */
  const FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET: string
  /**
   * A key in the "standard" namespace for getting the target URI for the file, in
   * the case of %G_FILE_TYPE_SHORTCUT or %G_FILE_TYPE_MOUNTABLE files.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_STANDARD_TARGET_URI: string
  /**
   * A key in the "standard" namespace for storing file types.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   *
   * The value for this key should contain a #GFileType.
   */
  const FILE_ATTRIBUTE_STANDARD_TYPE: string
  /**
   * A key in the "thumbnail" namespace for checking if thumbnailing failed.
   *
   * This attribute is %TRUE if thumbnailing failed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAILING_FAILED: string
  /**
   * A key in the "thumbnail" namespace for checking if thumbnailing failed
   * for the large image.
   *
   * This attribute is %TRUE if thumbnailing failed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAILING_FAILED_LARGE: string
  /**
   * A key in the "thumbnail" namespace for checking if thumbnailing failed
   * for the normal image.
   *
   * This attribute is %TRUE if thumbnailing failed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAILING_FAILED_NORMAL: string
  /**
   * A key in the "thumbnail" namespace for checking if thumbnailing failed
   * for the x-large image.
   *
   * This attribute is %TRUE if thumbnailing failed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAILING_FAILED_XLARGE: string
  /**
   * A key in the "thumbnail" namespace for checking if thumbnailing failed
   * for the xx-large image.
   *
   * This attribute is %TRUE if thumbnailing failed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAILING_FAILED_XXLARGE: string
  /**
   * A key in the "thumbnail" namespace for checking whether the thumbnail is outdated.
   *
   * This attribute is %TRUE if the thumbnail is up-to-date with the file it represents,
   * and %FALSE if the file has been modified since the thumbnail was generated.
   *
   * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED is %TRUE and this attribute is %FALSE,
   * it indicates that thumbnailing may be attempted again and may succeed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID: string
  /**
   * A key in the "thumbnail" namespace for checking whether the large
   * thumbnail is outdated.
   *
   * This attribute is %TRUE if the large thumbnail is up-to-date with the file
   * it represents, and %FALSE if the file has been modified since the thumbnail
   * was generated.
   *
   * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED_LARGE is %TRUE and this attribute
   * is %FALSE, it indicates that thumbnailing may be attempted again and may
   * succeed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_LARGE: string
  /**
   * A key in the "thumbnail" namespace for checking whether the normal
   * thumbnail is outdated.
   *
   * This attribute is %TRUE if the normal thumbnail is up-to-date with the file
   * it represents, and %FALSE if the file has been modified since the thumbnail
   * was generated.
   *
   * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED_NORMAL is %TRUE and this attribute
   * is %FALSE, it indicates that thumbnailing may be attempted again and may
   * succeed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_NORMAL: string
  /**
   * A key in the "thumbnail" namespace for checking whether the x-large
   * thumbnail is outdated.
   *
   * This attribute is %TRUE if the x-large thumbnail is up-to-date with the file
   * it represents, and %FALSE if the file has been modified since the thumbnail
   * was generated.
   *
   * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED_XLARGE is %TRUE and this attribute
   * is %FALSE, it indicates that thumbnailing may be attempted again and may
   * succeed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_XLARGE: string
  /**
   * A key in the "thumbnail" namespace for checking whether the xx-large
   * thumbnail is outdated.
   *
   * This attribute is %TRUE if the x-large thumbnail is up-to-date with the file
   * it represents, and %FALSE if the file has been modified since the thumbnail
   * was generated.
   *
   * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED_XXLARGE is %TRUE and this attribute
   * is %FALSE, it indicates that thumbnailing may be attempted again and may
   * succeed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_XXLARGE: string
  /**
   * A key in the "thumbnail" namespace for getting the path to the thumbnail
   * image with the biggest size available.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_PATH: string
  /**
   * A key in the "thumbnail" namespace for getting the path to the large
   * thumbnail image.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_PATH_LARGE: string
  /**
   * A key in the "thumbnail" namespace for getting the path to the normal
   * thumbnail image.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_PATH_NORMAL: string
  /**
   * A key in the "thumbnail" namespace for getting the path to the x-large
   * thumbnail image.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_PATH_XLARGE: string
  /**
   * A key in the "thumbnail" namespace for getting the path to the xx-large
   * thumbnail image.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
   */
  const FILE_ATTRIBUTE_THUMBNAIL_PATH_XXLARGE: string
  /**
   * A key in the "time" namespace for getting the time the file was last
   * accessed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64, and
   * contains the time since the file was last accessed, in seconds since the
   * UNIX epoch.
   */
  const FILE_ATTRIBUTE_TIME_ACCESS: string
  /**
   * A key in the "time" namespace for getting the nanoseconds of the time
   * the file was last accessed. This should be used in conjunction with
   * #G_FILE_ATTRIBUTE_TIME_ACCESS. Corresponding #GFileAttributeType is
   * %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TIME_ACCESS_NSEC: string
  /**
   * A key in the "time" namespace for getting the microseconds of the time
   * the file was last accessed.
   *
   * This should be used in conjunction with %G_FILE_ATTRIBUTE_TIME_ACCESS.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TIME_ACCESS_USEC: string
  /**
   * A key in the "time" namespace for getting the time the file was last
   * changed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
   * and contains the time since the file was last changed, in seconds since
   * the UNIX epoch.
   *
   * This corresponds to the traditional UNIX ctime.
   */
  const FILE_ATTRIBUTE_TIME_CHANGED: string
  /**
   * A key in the "time" namespace for getting the nanoseconds of the time
   * the file was last changed. This should be used in conjunction with
   * #G_FILE_ATTRIBUTE_TIME_CHANGED. Corresponding #GFileAttributeType is
   * %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TIME_CHANGED_NSEC: string
  /**
   * A key in the "time" namespace for getting the microseconds of the time
   * the file was last changed.
   *
   * This should be used in conjunction with %G_FILE_ATTRIBUTE_TIME_CHANGED.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TIME_CHANGED_USEC: string
  /**
   * A key in the "time" namespace for getting the time the file was created.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
   * and contains the time since the file was created, in seconds since the UNIX
   * epoch.
   *
   * This may correspond to Linux `stx_btime`, FreeBSD `st_birthtim`, NetBSD
   * `st_birthtime` or NTFS `ctime`.
   */
  const FILE_ATTRIBUTE_TIME_CREATED: string
  /**
   * A key in the "time" namespace for getting the nanoseconds of the time
   * the file was created. This should be used in conjunction with
   * #G_FILE_ATTRIBUTE_TIME_CREATED. Corresponding #GFileAttributeType is
   * %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TIME_CREATED_NSEC: string
  /**
   * A key in the "time" namespace for getting the microseconds of the time
   * the file was created.
   *
   * This should be used in conjunction with %G_FILE_ATTRIBUTE_TIME_CREATED.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TIME_CREATED_USEC: string
  /**
   * A key in the "time" namespace for getting the time the file was last
   * modified.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64, and
   * contains the time since the file was modified, in seconds since the UNIX
   * epoch.
   */
  const FILE_ATTRIBUTE_TIME_MODIFIED: string
  /**
   * A key in the "time" namespace for getting the nanoseconds of the time
   * the file was last modified. This should be used in conjunction with
   * #G_FILE_ATTRIBUTE_TIME_MODIFIED. Corresponding #GFileAttributeType is
   * %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TIME_MODIFIED_NSEC: string
  /**
   * A key in the "time" namespace for getting the microseconds of the time
   * the file was last modified.
   *
   * This should be used in conjunction with %G_FILE_ATTRIBUTE_TIME_MODIFIED.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TIME_MODIFIED_USEC: string
  /**
   * A key in the "trash" namespace for getting the deletion date and time
   * of a file inside the `trash:///` folder.
   *
   * The format of the returned string is `YYYY-MM-DDThh:mm:ss`.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
   */
  const FILE_ATTRIBUTE_TRASH_DELETION_DATE: string
  /**
   * A key in the "trash" namespace for getting the number of (toplevel) items
   * that are present in the `trash:///` folder.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_TRASH_ITEM_COUNT: string
  /**
   * A key in the "trash" namespace for getting the original path of a file
   * inside the `trash:///` folder before it was trashed.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
   */
  const FILE_ATTRIBUTE_TRASH_ORIG_PATH: string
  /**
   * A key in the "unix" namespace for getting the number of blocks allocated
   * for the file.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
   */
  const FILE_ATTRIBUTE_UNIX_BLOCKS: string
  /**
   * A key in the "unix" namespace for getting the block size for the file
   * system.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_UNIX_BLOCK_SIZE: string
  /**
   * A key in the "unix" namespace for getting the device id of the device the
   * file is located on (see stat() documentation).
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_UNIX_DEVICE: string
  /**
   * A key in the "unix" namespace for getting the group ID for the file.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_UNIX_GID: string
  /**
   * A key in the "unix" namespace for getting the inode of the file.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
   */
  const FILE_ATTRIBUTE_UNIX_INODE: string
  /**
   * A key in the "unix" namespace for checking if the file represents a
   * UNIX mount point.
   *
   * This attribute is %TRUE if the file is a UNIX mount point.
   *
   * Since 2.58, `/` is considered to be a mount point.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
   */
  const FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT: string
  /**
   * A key in the "unix" namespace for getting the mode of the file
   * (e.g. whether the file is a regular file, symlink, etc).
   *
   * See the documentation for `lstat()`: this attribute is equivalent to
   * the `st_mode` member of `struct stat`, and includes both the file type
   * and permissions.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_UNIX_MODE: string
  /**
   * A key in the "unix" namespace for getting the number of hard links
   * for a file.
   *
   * See the documentation for `lstat()`.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_UNIX_NLINK: string
  /**
   * A key in the "unix" namespace for getting the device ID for the file
   * (if it is a special file).
   *
   * See the documentation for `lstat()`.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_UNIX_RDEV: string
  /**
   * A key in the "unix" namespace for getting the user ID for the file.
   *
   * This attribute is only available for UNIX file systems.
   *
   * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
   */
  const FILE_ATTRIBUTE_UNIX_UID: string
  /**
   * Extension point for memory usage monitoring functionality.
   * See [Extending GIO][extending-gio].
   */
  const MEMORY_MONITOR_EXTENSION_POINT_NAME: string
  /**
   * The menu item attribute which holds the action name of the item.  Action
   * names are namespaced with an identifier for the action group in which the
   * action resides. For example, "win." for window-specific actions and "app."
   * for application-wide actions.
   *
   * See also g_menu_model_get_item_attribute() and g_menu_item_set_attribute().
   */
  const MENU_ATTRIBUTE_ACTION: string
  /**
   * The menu item attribute that holds the namespace for all action names in
   * menus that are linked from this item.
   */
  const MENU_ATTRIBUTE_ACTION_NAMESPACE: string
  /**
   * The menu item attribute which holds the icon of the item.
   *
   * The icon is stored in the format returned by g_icon_serialize().
   *
   * This attribute is intended only to represent 'noun' icons such as
   * favicons for a webpage, or application icons.  It should not be used
   * for 'verbs' (ie: stock icons).
   */
  const MENU_ATTRIBUTE_ICON: string
  /**
   * The menu item attribute which holds the label of the item.
   */
  const MENU_ATTRIBUTE_LABEL: string
  /**
   * The menu item attribute which holds the target with which the item's action
   * will be activated.
   *
   * See also g_menu_item_set_action_and_target()
   */
  const MENU_ATTRIBUTE_TARGET: string
  /**
   * The maximum number of entries in a menu section supported by
   * g_dbus_connection_export_menu_model().
   *
   * The exact value of the limit may change in future GLib versions.
   */
  const MENU_EXPORTER_MAX_SECTION_SIZE: number
  /**
   * The name of the link that associates a menu item with a section.  The linked
   * menu will usually be shown in place of the menu item, using the item's label
   * as a header.
   *
   * See also g_menu_item_set_link().
   */
  const MENU_LINK_SECTION: string
  /**
   * The name of the link that associates a menu item with a submenu.
   *
   * See also g_menu_item_set_link().
   */
  const MENU_LINK_SUBMENU: string
  const NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME: string
  /**
   * Extension point for network status monitoring functionality.
   * See [Extending GIO][extending-gio].
   */
  const NETWORK_MONITOR_EXTENSION_POINT_NAME: string
  /**
   * Extension point for power profile usage monitoring functionality.
   * See [Extending GIO][extending-gio].
   */
  const POWER_PROFILE_MONITOR_EXTENSION_POINT_NAME: string
  /**
   * Extension point for proxy functionality.
   * See [Extending GIO][extending-gio].
   */
  const PROXY_EXTENSION_POINT_NAME: string
  /**
   * Extension point for proxy resolving functionality.
   * See [Extending GIO][extending-gio].
   */
  const PROXY_RESOLVER_EXTENSION_POINT_NAME: string
  /**
   * Extension point for #GSettingsBackend functionality.
   */
  const SETTINGS_BACKEND_EXTENSION_POINT_NAME: string
  /**
   * Extension point for TLS functionality via #GTlsBackend.
   * See [Extending GIO][extending-gio].
   */
  const TLS_BACKEND_EXTENSION_POINT_NAME: string
  /**
   * The purpose used to verify the client certificate in a TLS connection.
   * Used by TLS servers.
   */
  const TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT: string
  /**
   * The purpose used to verify the server certificate in a TLS connection. This
   * is the most common purpose in use. Used by TLS clients.
   */
  const TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER: string
  /**
   * Extension point for #GVfs functionality.
   * See [Extending GIO][extending-gio].
   */
  const VFS_EXTENSION_POINT_NAME: string
  /**
   * The string used to obtain the volume class with g_volume_get_identifier().
   *
   * Known volume classes include `device`, `network`, and `loop`. Other
   * classes may be added in the future.
   *
   * This is intended to be used by applications to classify #GVolume
   * instances into different sections - for example a file manager or
   * file chooser can use this information to show `network` volumes under
   * a "Network" heading and `device` volumes under a "Devices" heading.
   */
  const VOLUME_IDENTIFIER_KIND_CLASS: string
  /**
   * The string used to obtain a Hal UDI with g_volume_get_identifier().
   */
  const VOLUME_IDENTIFIER_KIND_HAL_UDI: string
  /**
   * The string used to obtain a filesystem label with g_volume_get_identifier().
   */
  const VOLUME_IDENTIFIER_KIND_LABEL: string
  /**
   * The string used to obtain a NFS mount with g_volume_get_identifier().
   */
  const VOLUME_IDENTIFIER_KIND_NFS_MOUNT: string
  /**
   * The string used to obtain a Unix device path with g_volume_get_identifier().
   */
  const VOLUME_IDENTIFIER_KIND_UNIX_DEVICE: string
  /**
   * The string used to obtain a UUID with g_volume_get_identifier().
   */
  const VOLUME_IDENTIFIER_KIND_UUID: string
  /**
   * Extension point for volume monitor functionality.
   * See [Extending GIO][extending-gio].
   */
  const VOLUME_MONITOR_EXTENSION_POINT_NAME: string
  /**
   * Checks if `action_name` is valid.
   *
   * `action_name` is valid if it consists only of alphanumeric characters,
   * plus '-' and '.'.  The empty string is not a valid action name.
   *
   * It is an error to call this function with a non-utf8 `action_name`.
   * `action_name` must not be %NULL.
   * @param actionName a potential action name
   * @returns %TRUE if @action_name is valid
   */
  function actionNameIsValid(actionName: string): boolean
  /**
   * Parses a detailed action name into its separate name and target
   * components.
   *
   * Detailed action names can have three formats.
   *
   * The first format is used to represent an action name with no target
   * value and consists of just an action name containing no whitespace
   * nor the characters `:`, `(` or `)`.  For example: `app.action`.
   *
   * The second format is used to represent an action with a target value
   * that is a non-empty string consisting only of alphanumerics, plus `-`
   * and `.`.  In that case, the action name and target value are
   * separated by a double colon (`::`).  For example:
   * `app.action::target`.
   *
   * The third format is used to represent an action with any type of
   * target value, including strings.  The target value follows the action
   * name, surrounded in parens.  For example: `app.action(42)`.  The
   * target value is parsed using g_variant_parse().  If a tuple-typed
   * value is desired, it must be specified in the same way, resulting in
   * two sets of parens, for example: `app.action((1,2,3))`.  A string
   * target can be specified this way as well: `app.action('target')`.
   * For strings, this third format must be used if target value is
   * empty or contains characters other than alphanumerics, `-` and `.`.
   *
   * If this function returns %TRUE, a non-%NULL value is guaranteed to be returned
   * in `action_name` (if a pointer is passed in). A %NULL value may still be
   * returned in `target_value,` as the `detailed_name` may not contain a target.
   *
   * If returned, the #GVariant in `target_value` is guaranteed to not be floating.
   * @param detailedName a detailed action name
   * @returns %TRUE if successful, else %FALSE with @error set
   */
  function actionParseDetailedName(
    detailedName: string
  ): [
    /* returnType */ boolean,
    /* actionName */ string,
    /* targetValue */ GLib.Variant | null,
  ]
  /**
   * Formats a detailed action name from `action_name` and `target_value`.
   *
   * It is an error to call this function with an invalid action name.
   *
   * This function is the opposite of g_action_parse_detailed_name().
   * It will produce a string that can be parsed back to the `action_name`
   * and `target_value` by that function.
   *
   * See that function for the types of strings that will be printed by
   * this function.
   * @param actionName a valid action name
   * @param targetValue a #GVariant target value, or %NULL
   * @returns a detailed format string
   */
  function actionPrintDetailedName(
    actionName: string,
    targetValue: GLib.Variant | null
  ): string | null
  /**
   * Creates a new #GAppInfo from the given information.
   *
   * Note that for `commandline,` the quoting rules of the Exec key of the
   * [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
   * are applied. For example, if the `commandline` contains
   * percent-encoded URIs, the percent-character must be doubled in order to prevent it from
   * being swallowed by Exec key unquoting. See the specification for exact quoting rules.
   * @param commandline the commandline to use
   * @param applicationName the application name, or %NULL to use `commandline`
   * @param flags flags that can specify details of the created #GAppInfo
   * @returns new #GAppInfo for given command.
   */
  function appInfoCreateFromCommandline(
    commandline: string,
    applicationName: string | null,
    flags: AppInfoCreateFlags
  ): AppInfo
  /**
   * Gets a list of all of the applications currently registered
   * on this system.
   *
   * For desktop files, this includes applications that have
   * `NoDisplay=true` set or are excluded from display by means
   * of `OnlyShowIn` or `NotShowIn`. See g_app_info_should_show().
   * The returned list does not include applications which have
   * the `Hidden` key set.
   * @returns a newly allocated #GList of references to #GAppInfos.
   */
  function appInfoGetAll(): AppInfo[]
  /**
   * Gets a list of all #GAppInfos for a given content type,
   * including the recommended and fallback #GAppInfos. See
   * g_app_info_get_recommended_for_type() and
   * g_app_info_get_fallback_for_type().
   * @param contentType the content type to find a #GAppInfo for
   * @returns #GList of #GAppInfos     for given @content_type or %NULL on error.
   */
  function appInfoGetAllForType(contentType: string): AppInfo[]
  /**
   * Gets the default #GAppInfo for a given content type.
   * @param contentType the content type to find a #GAppInfo for
   * @param mustSupportUris if %TRUE, the #GAppInfo is expected to     support URIs
   * @returns #GAppInfo for given @content_type or     %NULL on error.
   */
  function appInfoGetDefaultForType(
    contentType: string,
    mustSupportUris: boolean
  ): AppInfo | null
  /**
   * Asynchronously gets the default #GAppInfo for a given content type.
   * @param contentType the content type to find a #GAppInfo for
   * @param mustSupportUris if %TRUE, the #GAppInfo is expected to     support URIs
   * @param cancellable optional #GCancellable object, %NULL to ignore
   * @param callback a #GAsyncReadyCallback to call when the request is done
   */
  function appInfoGetDefaultForTypeAsync(
    contentType: string,
    mustSupportUris: boolean,
    cancellable: Cancellable | null,
    callback: AsyncReadyCallback | null
  ): void
  /**
   * Finishes a default #GAppInfo lookup started by
   * g_app_info_get_default_for_type_async().
   *
   * If no #GAppInfo is found, then `error` will be set to %G_IO_ERROR_NOT_FOUND.
   * @param result a #GAsyncResult
   * @returns #GAppInfo for given @content_type or     %NULL on error.
   */
  function appInfoGetDefaultForTypeFinish(result: AsyncResult): AppInfo
  /**
   * Gets the default application for handling URIs with
   * the given URI scheme. A URI scheme is the initial part
   * of the URI, up to but not including the ':', e.g. "http",
   * "ftp" or "sip".
   * @param uriScheme a string containing a URI scheme.
   * @returns #GAppInfo for given @uri_scheme or     %NULL on error.
   */
  function appInfoGetDefaultForUriScheme(uriScheme: string): AppInfo | null
  /**
   * Asynchronously gets the default application for handling URIs with
   * the given URI scheme. A URI scheme is the initial part
   * of the URI, up to but not including the ':', e.g. "http",
   * "ftp" or "sip".
   * @param uriScheme a string containing a URI scheme.
   * @param cancellable optional #GCancellable object, %NULL to ignore
   * @param callback a #GAsyncReadyCallback to call when the request is done
   */
  function appInfoGetDefaultForUriSchemeAsync(
    uriScheme: string,
    cancellable: Cancellable | null,
    callback: AsyncReadyCallback | null
  ): void
  /**
   * Finishes a default #GAppInfo lookup started by
   * g_app_info_get_default_for_uri_scheme_async().
   *
   * If no #GAppInfo is found, then `error` will be set to %G_IO_ERROR_NOT_FOUND.
   * @param result a #GAsyncResult
   * @returns #GAppInfo for given @uri_scheme or     %NULL on error.
   */
  function appInfoGetDefaultForUriSchemeFinish(result: AsyncResult): AppInfo
  /**
   * Gets a list of fallback #GAppInfos for a given content type, i.e.
   * those applications which claim to support the given content type
   * by MIME type subclassing and not directly.
   * @param contentType the content type to find a #GAppInfo for
   * @returns #GList of #GAppInfos     for given @content_type or %NULL on error.
   */
  function appInfoGetFallbackForType(contentType: string): AppInfo[]
  /**
   * Gets a list of recommended #GAppInfos for a given content type, i.e.
   * those applications which claim to support the given content type exactly,
   * and not by MIME type subclassing.
   * Note that the first application of the list is the last used one, i.e.
   * the last one for which g_app_info_set_as_last_used_for_type() has been
   * called.
   * @param contentType the content type to find a #GAppInfo for
   * @returns #GList of #GAppInfos     for given @content_type or %NULL on error.
   */
  function appInfoGetRecommendedForType(contentType: string): AppInfo[]
  /**
   * Utility function that launches the default application
   * registered to handle the specified uri. Synchronous I/O
   * is done on the uri to detect the type of the file if
   * required.
   *
   * The D-Bus–activated applications don't have to be started if your application
   * terminates too soon after this function. To prevent this, use
   * g_app_info_launch_default_for_uri_async() instead.
   * @param uri the uri to show
   * @param context an optional #GAppLaunchContext
   * @returns %TRUE on success, %FALSE on error.
   */
  function appInfoLaunchDefaultForUri(
    uri: string,
    context: AppLaunchContext | null
  ): boolean
  /**
   * Async version of g_app_info_launch_default_for_uri().
   *
   * This version is useful if you are interested in receiving
   * error information in the case where the application is
   * sandboxed and the portal may present an application chooser
   * dialog to the user.
   *
   * This is also useful if you want to be sure that the D-Bus–activated
   * applications are really started before termination and if you are interested
   * in receiving error information from their activation.
   * @param uri the uri to show
   * @param context an optional #GAppLaunchContext
   * @param cancellable a #GCancellable
   * @param callback a #GAsyncReadyCallback to call when the request is done
   */
  function appInfoLaunchDefaultForUriAsync(
    uri: string,
    context: AppLaunchContext | null,
    cancellable: Cancellable | null,
    callback: AsyncReadyCallback | null
  ): void
  /**
   * Finishes an asynchronous launch-default-for-uri operation.
   * @param result a #GAsyncResult
   * @returns %TRUE if the launch was successful, %FALSE if @error is set
   */
  function appInfoLaunchDefaultForUriFinish(result: AsyncResult): boolean
  /**
   * Removes all changes to the type associations done by
   * g_app_info_set_as_default_for_type(),
   * g_app_info_set_as_default_for_extension(),
   * g_app_info_add_supports_type() or
   * g_app_info_remove_supports_type().
   * @param contentType a content type
   */
  function appInfoResetTypeAssociations(contentType: string): void
  /**
   * Helper function for constructing #GAsyncInitable object. This is
   * similar to g_object_newv() but also initializes the object asynchronously.
   *
   * When the initialization is finished, `callback` will be called. You can
   * then call g_async_initable_new_finish() to get the new object and check
   * for any errors.
   * @param objectType a #GType supporting #GAsyncInitable.
   * @param nParameters the number of parameters in `parameters`
   * @param parameters the parameters to use to construct the object
   * @param ioPriority the [I/O priority][io-priority] of the operation
   * @param cancellable optional #GCancellable object, %NULL to ignore.
   * @param callback a #GAsyncReadyCallback to call when the initialization is     finished
   */
  function asyncInitableNewvAsync(
    objectType: GObject.GType,
    nParameters: number,
    parameters: GObject.Parameter,
    ioPriority: number,
    cancellable: Cancellable | null,
    callback: AsyncReadyCallback | null
  ): void
  /**
   * Asynchronously connects to the message bus specified by `bus_type`.
   *
   * When the operation is finished, `callback` will be invoked. You can
   * then call g_bus_get_finish() to get the result of the operation.
   *
   * This is an asynchronous failable function. See g_bus_get_sync() for
   * the synchronous version.
   * @param busType a #GBusType
   * @param cancellable a #GCancellable or %NULL
   * @param callback a #GAsyncReadyCallback to call when the request is satisfied
   */
  function busGet(
    busType: BusType,
    cancellable: Cancellable | null,
    callback: AsyncReadyCallback | null
  ): void
  /**
   * Finishes an operation started with g_bus_get().
   *
   * The returned object is a singleton, that is, shared with other
   * callers of g_bus_get() and g_bus_get_sync() for `bus_type`. In the
   * event that you need a private message bus connection, use
   * g_dbus_address_get_for_bus_sync() and
   * g_dbus_connection_new_for_address() with
   * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
   * G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
   *
   * Note that the returned #GDBusConnection object will (usually) have
   * the #GDBusConnection:exit-on-close property set to %TRUE.
   * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed     to g_bus_get()
   * @returns a #GDBusConnection or %NULL if @error is set.     Free with g_object_unref().
   */
  function busGetFinish(res: AsyncResult): DBusConnection
  /**
   * Synchronously connects to the message bus specified by `bus_type`.
   * Note that the returned object may shared with other callers,
   * e.g. if two separate parts of a process calls this function with
   * the same `bus_type,` they will share the same object.
   *
   * This is a synchronous failable function. See g_bus_get() and
   * g_bus_get_finish() for the asynchronous version.
   *
   * The returned object is a singleton, that is, shared with other
   * callers of g_bus_get() and g_bus_get_sync() for `bus_type`. In the
   * event that you need a private message bus connection, use
   * g_dbus_address_get_for_bus_sync() and
   * g_dbus_connection_new_for_address() with
   * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
   * G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
   *
   * Note that the returned #GDBusConnection object will (usually) have
   * the #GDBusConnection:exit-on-close property set to %TRUE.
   * @param busType a #GBusType
   * @param cancellable a #GCancellable or %NULL
   * @returns a #GDBusConnection or %NULL if @error is set.     Free with g_object_unref().
   */
  function busGetSync(
    busType: BusType,
    cancellable: Cancellable | null
  ): DBusConnection
  /**
   * Version of g_bus_own_name_on_connection() using closures instead of
   * callbacks for easier binding in other languages.
   * @param connection a #GDBusConnection
   * @param name the well-known name to own
   * @param flags a set of flags from the #GBusNameOwnerFlags enumeration
   * @param nameAcquiredClosure #GClosure to invoke when `name` is     acquired or %NULL
   * @param nameLostClosure #GClosure to invoke when `name` is lost     or %NULL
   * @returns an identifier (never 0) that can be used with     g_bus_unown_name() to stop owning the name.
   */
  function busOwnNameOnConnection(
    connection: DBusConnection,
    name: string,
    flags: BusNameOwnerFlags,
    nameAcquiredClosure: GObject.TClosure | null,
    nameLostClosure: GObject.TClosure | null
  ): number
  /**
   * Version of g_bus_own_name() using closures instead of callbacks for
   * easier binding in other languages.
   * @param busType the type of bus to own a name on
   * @param name the well-known name to own
   * @param flags a set of flags from the #GBusNameOwnerFlags enumeration
   * @param busAcquiredClosure #GClosure to invoke when connected to     the bus of type `bus_type` or %NULL
   * @param nameAcquiredClosure #GClosure to invoke when `name` is     acquired or %NULL
   * @param nameLostClosure #GClosure to invoke when `name` is lost or     %NULL
   * @returns an identifier (never 0) that can be used with     g_bus_unown_name() to stop owning the name.
   */
  function busOwnName(
    busType: BusType,
    name: string,
    flags: BusNameOwnerFlags,
    busAcquiredClosure: GObject.TClosure | null,
    nameAcquiredClosure: GObject.TClosure | null,
    nameLostClosure: GObject.TClosure | null
  ): number
  /**
   * Stops owning a name.
   *
   * Note that there may still be D-Bus traffic to process (relating to owning
   * and unowning the name) in the current thread-default #GMainContext after
   * this function has returned. You should continue to iterate the #GMainContext
   * until the #GDestroyNotify function passed to g_bus_own_name() is called, in
   * order to avoid memory leaks through callbacks queued on the #GMainContext
   * after it’s stopped being iterated.
   * @param ownerId an identifier obtained from g_bus_own_name()
   */
  function busUnownName(ownerId: number): void
  /**
   * Stops watching a name.
   *
   * Note that there may still be D-Bus traffic to process (relating to watching
   * and unwatching the name) in the current thread-default #GMainContext after
   * this function has returned. You should continue to iterate the #GMainContext
   * until the #GDestroyNotify function passed to g_bus_watch_name() is called, in
   * order to avoid memory leaks through callbacks queued on the #GMainContext
   * after it’s stopped being iterated.
   * @param watcherId An identifier obtained from g_bus_watch_name()
   */
  function busUnwatchName(watcherId: number): void
  /**
   * Version of g_bus_watch_name_on_connection() using closures instead of callbacks for
   * easier binding in other languages.
   * @param connection A #GDBusConnection.
   * @param name The name (well-known or unique) to watch.
   * @param flags Flags from the #GBusNameWatcherFlags enumeration.
   * @param nameAppearedClosure #GClosure to invoke when `name` is known to exist or %NULL.
   * @param nameVanishedClosure #GClosure to invoke when `name` is known to not exist or %NULL.
   * @returns An identifier (never 0) that can be used with g_bus_unwatch_name() to stop watching the name.
   */
  function busWatchNameOnConnection(
    connection: DBusConnection,
    name: string,
    flags: BusNameWatcherFlags,
    nameAppearedClosure: GObject.TClosure | null,
    nameVanishedClosure: GObject.TClosure | null
  ): number
  /**
   * Version of g_bus_watch_name() using closures instead of callbacks for
   * easier binding in other languages.
   * @param busType The type of bus to watch a name on.
   * @param name The name (well-known or unique) to watch.
   * @param flags Flags from the #GBusNameWatcherFlags enumeration.
   * @param nameAppearedClosure #GClosure to invoke when `name` is known to exist or %NULL.
   * @param nameVanishedClosure #GClosure to invoke when `name` is known to not exist or %NULL.
   * @returns An identifier (never 0) that can be used with g_bus_unwatch_name() to stop watching the name.
   */
  function busWatchName(
    busType: BusType,
    name: string,
    flags: BusNameWatcherFlags,
    nameAppearedClosure: GObject.TClosure | null,
    nameVanishedClosure: GObject.TClosure | null
  ): number
  /**
   * Checks if a content type can be executable. Note that for instance
   * things like text files can be executables (i.e. scripts and batch files).
   * @param type a content type string
   * @returns %TRUE if the file type corresponds to a type that     can be executable, %FALSE otherwise.
   */
  function contentTypeCanBeExecutable(type: string): boolean
  /**
   * Compares two content types for equality.
   * @param type1 a content type string
   * @param type2 a content type string
   * @returns %TRUE if the two strings are identical or equivalent,     %FALSE otherwise.
   */
  function contentTypeEquals(type1: string, type2: string): boolean
  /**
   * Tries to find a content type based on the mime type name.
   * @param mimeType a mime type string
   * @returns Newly allocated string with content type or     %NULL. Free with g_free()
   */
  function contentTypeFromMimeType(mimeType: string): string | null
  /**
   * Gets the human readable description of the content type.
   * @param type a content type string
   * @returns a short description of the content type @type. Free the     returned string with g_free()
   */
  function contentTypeGetDescription(type: string): string | null
  /**
   * Gets the generic icon name for a content type.
   *
   * See the
   * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
   * specification for more on the generic icon name.
   * @param type a content type string
   * @returns the registered generic icon name for the given @type,     or %NULL if unknown. Free with g_free()
   */
  function contentTypeGetGenericIconName(type: string): string | null
  /**
   * Gets the icon for a content type.
   * @param type a content type string
   * @returns #GIcon corresponding to the content type. Free the returned     object with g_object_unref()
   */
  function contentTypeGetIcon(type: string): Icon
  /**
   * Get the list of directories which MIME data is loaded from. See
   * g_content_type_set_mime_dirs() for details.
   * @returns %NULL-terminated list of    directories to load MIME data from, including any `mime/` subdirectory,    and with the first directory to try listed first
   */
  function contentTypeGetMimeDirs(): string[]
  /**
   * Gets the mime type for the content type, if one is registered.
   * @param type a content type string
   * @returns the registered mime type for the     given @type, or %NULL if unknown; free with g_free().
   */
  function contentTypeGetMimeType(type: string): string | null
  /**
   * Gets the symbolic icon for a content type.
   * @param type a content type string
   * @returns symbolic #GIcon corresponding to the content type.     Free the returned object with g_object_unref()
   */
  function contentTypeGetSymbolicIcon(type: string): Icon
  /**
   * Guesses the content type based on example data. If the function is
   * uncertain, `result_uncertain` will be set to %TRUE. Either `filename`
   * or `data` may be %NULL, in which case the guess will be based solely
   * on the other argument.
   * @param filename a path, or %NULL
   * @param data a stream of data, or %NULL
   * @returns a string indicating a guessed content type for the     given data. Free with g_free()
   */
  function contentTypeGuess(
    filename: string | null,
    data: number[] | null
  ): [/* returnType */ string | null, /* resultUncertain */ boolean]
  /**
   * Tries to guess the type of the tree with root `root,` by
   * looking at the files it contains. The result is an array
   * of content types, with the best guess coming first.
   *
   * The types returned all have the form x-content/foo, e.g.
   * x-content/audio-cdda (for audio CDs) or x-content/image-dcf
   * (for a camera memory card). See the
   * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
   * specification for more on x-content types.
   *
   * This function is useful in the implementation of
   * g_mount_guess_content_type().
   * @param root the root of the tree to guess a type for
   * @returns an %NULL-terminated     array of zero or more content types. Free with g_strfreev()
   */
  function contentTypeGuessForTree(root: File): string[]
  /**
   * Determines if `type` is a subset of `supertype`.
   * @param type a content type string
   * @param supertype a content type string
   * @returns %TRUE if @type is a kind of @supertype,     %FALSE otherwise.
   */
  function contentTypeIsA(type: string, supertype: string): boolean
  /**
   * Determines if `type` is a subset of `mime_type`.
   * Convenience wrapper around g_content_type_is_a().
   * @param type a content type string
   * @param mimeType a mime type string
   * @returns %TRUE if @type is a kind of @mime_type,     %FALSE otherwise.
   */
  function contentTypeIsMimeType(type: string, mimeType: string): boolean
  /**
   * Checks if the content type is the generic "unknown" type.
   * On UNIX this is the "application/octet-stream" mimetype,
   * while on win32 it is "*" and on OSX it is a dynamic type
   * or octet-stream.
   * @param type a content type string
   * @returns %TRUE if the type is the unknown type.
   */
  function contentTypeIsUnknown(type: string): boolean
  /**
   * Set the list of directories used by GIO to load the MIME database.
   * If `dirs` is %NULL, the directories used are the default:
   *
   *  - the `mime` subdirectory of the directory in `$XDG_DATA_HOME`
   *  - the `mime` subdirectory of every directory in `$XDG_DATA_DIRS`
   *
   * This function is intended to be used when writing tests that depend on
   * information stored in the MIME database, in order to control the data.
   *
   * Typically, in case your tests use %G_TEST_OPTION_ISOLATE_DIRS, but they
   * depend on the system’s MIME database, you should call this function
   * with `dirs` set to %NULL before calling g_test_init(), for instance:
   *
   *
   * ```c
   *   // Load MIME data from the system
   *   g_content_type_set_mime_dirs (NULL);
   *   // Isolate the environment
   *   g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
   *
   *   …
   *
   *   return g_test_run ();
   * ```
   *
   * @param dirs %NULL-terminated list of    directories to load MIME data from, including any `mime/` subdirectory,    and with the first directory to try listed first
   */
  function contentTypeSetMimeDirs(dirs: string[] | null): void
  /**
   * Gets a list of strings containing all the registered content types
   * known to the system. The list and its data should be freed using
   * `g_list_free_full (list, g_free)`.
   * @returns list of the registered     content types
   */
  function contentTypesGetRegistered(): string[]
  /**
   * Escape `string` so it can appear in a D-Bus address as the value
   * part of a key-value pair.
   *
   * For instance, if `string` is `/run/bus-for-:0`,
   * this function would return `/run/bus-for-%3A0`,
   * which could be used in a D-Bus address like
   * `unix:nonce-tcp:host=127.0.0.1,port=42,noncefile=/run/bus-for-%3A0`.
   * @param string an unescaped string to be included in a D-Bus address     as the value in a key-value pair
   * @returns a copy of @string with all     non-optionally-escaped bytes escaped
   */
  function dbusAddressEscapeValue(string: string): string | null
  /**
   * Synchronously looks up the D-Bus address for the well-known message
   * bus instance specified by `bus_type`. This may involve using various
   * platform specific mechanisms.
   *
   * The returned address will be in the
   * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
   * @param busType a #GBusType
   * @param cancellable a #GCancellable or %NULL
   * @returns a valid D-Bus address string for @bus_type or     %NULL if @error is set
   */
  function dbusAddressGetForBusSync(
    busType: BusType,
    cancellable: Cancellable | null
  ): string | null
  /**
   * Asynchronously connects to an endpoint specified by `address` and
   * sets up the connection so it is in a state to run the client-side
   * of the D-Bus authentication conversation. `address` must be in the
   * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
   *
   * When the operation is finished, `callback` will be invoked. You can
   * then call g_dbus_address_get_stream_finish() to get the result of
   * the operation.
   *
   * This is an asynchronous failable function. See
   * g_dbus_address_get_stream_sync() for the synchronous version.
   * @param address A valid D-Bus address.
   * @param cancellable A #GCancellable or %NULL.
   * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
   */
  function dbusAddressGetStream(
    address: string,
    cancellable: Cancellable | null,
    callback: AsyncReadyCallback | null
  ): void
  /**
   * Finishes an operation started with g_dbus_address_get_stream().
   *
   * A server is not required to set a GUID, so `out_guid` may be set to %NULL
   * even on success.
   * @param res A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream().
   * @returns A #GIOStream or %NULL if @error is set.
   */
  function dbusAddressGetStreamFinish(
    res: AsyncResult
  ): [/* returnType */ IOStream, /* outGuid */ string | null]
  /**
   * Synchronously connects to an endpoint specified by `address` and
   * sets up the connection so it is in a state to run the client-side
   * of the D-Bus authentication conversation. `address` must be in the
   * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
   *
   * A server is not required to set a GUID, so `out_guid` may be set to %NULL
   * even on success.
   *
   * This is a synchronous failable function. See
   * g_dbus_address_get_stream() for the asynchronous version.
   * @param address A valid D-Bus address.
   * @param cancellable A #GCancellable or %NULL.
   * @returns A #GIOStream or %NULL if @error is set.
   */
  function dbusAddressGetStreamSync(
    address: string,
    cancellable: Cancellable | null
  ): [/* returnType */ IOStream, /* outGuid */ string | null]
  /**
   * Looks up the value of an annotation.
   *
   * The cost of this function is O(n) in number of annotations.
   * @param annotations A %NULL-terminated array of annotations or %NULL.
   * @param name The name of the annotation to look up.
   * @returns The value or %NULL if not found. Do not free, it is owned by @annotations.
   */
  function dbusAnnotationInfoLookup(
    annotations: DBusAnnotationInfo[] | null,
    name: string
  ): string | null
  /**
   * Creates a D-Bus error name to use for `error`. If `error` matches
   * a registered error (cf. g_dbus_error_register_error()), the corresponding
   * D-Bus error name will be returned.
   *
   * Otherwise the a name of the form
   * `org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE`
   * will be used. This allows other GDBus applications to map the error
   * on the wire back to a #GError using g_dbus_error_new_for_dbus_error().
   *
   * This function is typically only used in object mappings to put a
   * #GError on the wire. Regular applications should not use it.
   * @param error A #GError.
   * @returns A D-Bus error name (never %NULL).     Free with g_free().
   */
  function dbusErrorEncodeGerror(error: GLib.Error): string | null
  /**
   * Gets the D-Bus error name used for `error,` if any.
   *
   * This function is guaranteed to return a D-Bus error name for all
   * #GErrors returned from functions handling remote method calls
   * (e.g. g_dbus_connection_call_finish()) unless
   * g_dbus_error_strip_remote_error() has been used on `error`.
   * @param error a #GError
   * @returns an allocated string or %NULL if the     D-Bus error name could not be found. Free with g_free().
   */
  function dbusErrorGetRemoteError(error: GLib.Error): string | null
  /**
   * Checks if `error` represents an error received via D-Bus from a remote peer. If so,
   * use g_dbus_error_get_remote_error() to get the name of the error.
   * @param error A #GError.
   * @returns %TRUE if @error represents an error from a remote peer, %FALSE otherwise.
   */
  function dbusErrorIsRemoteError(error: GLib.Error): boolean
  /**
   * Creates a #GError based on the contents of `dbus_error_name` and
   * `dbus_error_message`.
   *
   * Errors registered with g_dbus_error_register_error() will be looked
   * up using `dbus_error_name` and if a match is found, the error domain
   * and code is used. Applications can use g_dbus_error_get_remote_error()
   * to recover `dbus_error_name`.
   *
   * If a match against a registered error is not found and the D-Bus
   * error name is in a form as returned by g_dbus_error_encode_gerror()
   * the error domain and code encoded in the name is used to
   * create the #GError. Also, `dbus_error_name` is added to the error message
   * such that it can be recovered with g_dbus_error_get_remote_error().
   *
   * Otherwise, a #GError with the error code %G_IO_ERROR_DBUS_ERROR
   * in the %G_IO_ERROR error domain is returned. Also, `dbus_error_name` is
   * added to the error message such that it can be recovered with
   * g_dbus_error_get_remote_error().
   *
   * In all three cases, `dbus_error_name` can always be recovered from the
   * returned #GError using the g_dbus_error_get_remote_error() function
   * (unless g_dbus_error_strip_remote_error() hasn't been used on the returned error).
   *
   * This function is typically only used in object mappings to prepare
   * #GError instances for applications. Regular applications should not use
   * it.
   * @param dbusErrorName D-Bus error name.
   * @param dbusErrorMessage D-Bus error message.
   * @returns An allocated #GError. Free with g_error_free().
   */
  function dbusErrorNewForDbusError(
    dbusErrorName: string,
    dbusErrorMessage: string
  ): GLib.Error
  function dbusErrorQuark(): GLib.Quark
  /**
   * Creates an association to map between `dbus_error_name` and
   * #GErrors specified by `error_domain` and `error_code`.
   *
   * This is typically done in the routine that returns the #GQuark for
   * an error domain.
   * @param errorDomain A #GQuark for an error domain.
   * @param errorCode An error code.
   * @param dbusErrorName A D-Bus error name.
   * @returns %TRUE if the association was created, %FALSE if it already exists.
   */
  function dbusErrorRegisterError(
    errorDomain: GLib.Quark,
    errorCode: number,
    dbusErrorName: string
  ): boolean
  /**
   * Helper function for associating a #GError error domain with D-Bus error names.
   *
   * While `quark_volatile` has a `volatile` qualifier, this is a historical
   * artifact and the argument passed to it should not be `volatile`.
   * @param errorDomainQuarkName The error domain name.
   * @param quarkVolatile A pointer where to store the #GQuark.
   * @param entries A pointer to `num_entries` #GDBusErrorEntry struct items.
   */
  function dbusErrorRegisterErrorDomain(
    errorDomainQuarkName: string,
    quarkVolatile: number,
    entries: DBusErrorEntry[]
  ): void
  /**
   * Looks for extra information in the error message used to recover
   * the D-Bus error name and strips it if found. If stripped, the
   * message field in `error` will correspond exactly to what was
   * received on the wire.
   *
   * This is typically used when presenting errors to the end user.
   * @param error A #GError.
   * @returns %TRUE if information was stripped, %FALSE otherwise.
   */
  function dbusErrorStripRemoteError(error: GLib.Error): boolean
  /**
   * Destroys an association previously set up with g_dbus_error_register_error().
   * @param errorDomain A #GQuark for an error domain.
   * @param errorCode An error code.
   * @param dbusErrorName A D-Bus error name.
   * @returns %TRUE if the association was destroyed, %FALSE if it wasn't found.
   */
  function dbusErrorUnregisterError(
    errorDomain: GLib.Quark,
    errorCode: number,
    dbusErrorName: string
  ): boolean
  /**
   * This is a language binding friendly version of g_dbus_escape_object_path_bytestring().
   * @param s the string to escape
   * @returns an escaped version of @s. Free with g_free().
   */
  function dbusEscapeObjectPath(s: string): string | null
  /**
   * Escapes `bytes` for use in a D-Bus object path component.
   * `bytes` is an array of zero or more nonzero bytes in an
   * unspecified encoding, followed by a single zero byte.
   *
   * The escaping method consists of replacing all non-alphanumeric
   * characters (see g_ascii_isalnum()) with their hexadecimal value
   * preceded by an underscore (`_`). For example:
   * `foo.bar.baz` will become `foo_2ebar_2ebaz`.
   *
   * This method is appropriate to use when the input is nearly
   * a valid object path component but is not when your input
   * is far from being a valid object path component.
   * Other escaping algorithms are also valid to use with
   * D-Bus object paths.
   *
   * This can be reversed with g_dbus_unescape_object_path().
   * @param bytes the string of bytes to escape
   * @returns an escaped version of @bytes. Free with g_free().
   */
  function dbusEscapeObjectPathBytestring(bytes: number[]): string | null
  /**
   * Generate a D-Bus GUID that can be used with
   * e.g. g_dbus_connection_new().
   *
   * See the
   * [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#uuids)
   * regarding what strings are valid D-Bus GUIDs. The specification refers to
   * these as ‘UUIDs’ whereas GLib (for historical reasons) refers to them as
   * ‘GUIDs’. The terms are interchangeable.
   *
   * Note that D-Bus GUIDs do not follow
   * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122).
   * @returns A valid D-Bus GUID. Free with g_free().
   */
  function dbusGenerateGuid(): string | null
  /**
   * Converts a #GValue to a #GVariant of the type indicated by the `type`
   * parameter.
   *
   * The conversion is using the following rules:
   *
   * - `G_TYPE_STRING`: 's', 'o', 'g' or 'ay'
   * - `G_TYPE_STRV`: 'as', 'ao' or 'aay'
   * - `G_TYPE_BOOLEAN`: 'b'
   * - `G_TYPE_UCHAR`: 'y'
   * - `G_TYPE_INT`: 'i', 'n'
   * - `G_TYPE_UINT`: 'u', 'q'
   * - `G_TYPE_INT64`: 'x'
   * - `G_TYPE_UINT64`: 't'
   * - `G_TYPE_DOUBLE`: 'd'
   * - `G_TYPE_VARIANT`: Any #GVariantType
   *
   * This can fail if e.g. `gvalue` is of type %G_TYPE_STRING and `type`
   * is 'i', i.e. %G_VARIANT_TYPE_INT32. It will also fail for any #GType
   * (including e.g. %G_TYPE_OBJECT and %G_TYPE_BOXED derived-types) not
   * in the table above.
   *
   * Note that if `gvalue` is of type %G_TYPE_VARIANT and its value is
   * %NULL, the empty #GVariant instance (never %NULL) for `type` is
   * returned (e.g. 0 for scalar types, the empty string for string types,
   * '/' for object path types, the empty array for any array type and so on).
   *
   * See the g_dbus_gvariant_to_gvalue() function for how to convert a
   * #GVariant to a #GValue.
   * @param gvalue A #GValue to convert to a #GVariant
   * @param type A #GVariantType
   * @returns A #GVariant (never floating) of     #GVariantType @type holding the data from @gvalue or an empty #GVariant     in case of failure. Free with g_variant_unref().
   */
  function dbusGvalueToGvariant(
    gvalue: any,
    type: GLib.VariantType
  ): GLib.Variant
  /**
   * Converts a #GVariant to a #GValue. If `value` is floating, it is consumed.
   *
   * The rules specified in the g_dbus_gvalue_to_gvariant() function are
   * used - this function is essentially its reverse form. So, a #GVariant
   * containing any basic or string array type will be converted to a #GValue
   * containing a basic value or string array. Any other #GVariant (handle,
   * variant, tuple, dict entry) will be converted to a #GValue containing that
   * #GVariant.
   *
   * The conversion never fails - a valid #GValue is always returned in
   * `out_gvalue`.
   * @param value A #GVariant.
   */
  function dbusGvariantToGvalue(value: GLib.Variant): /* outGvalue */ any
  /**
   * Checks if `string` is a
   * [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
   *
   * This doesn't check if `string` is actually supported by #GDBusServer
   * or #GDBusConnection - use g_dbus_is_supported_address() to do more
   * checks.
   * @param string A string.
   * @returns %TRUE if @string is a valid D-Bus address, %FALSE otherwise.
   */
  function dbusIsAddress(string: string): boolean
  /**
   * Check whether `string` is a valid D-Bus error name.
   *
   * This function returns the same result as g_dbus_is_interface_name(),
   * because D-Bus error names are defined to have exactly the
   * same syntax as interface names.
   * @param string The string to check.
   * @returns %TRUE if valid, %FALSE otherwise.
   */
  function dbusIsErrorName(string: string): boolean
  /**
   * Checks if `string` is a D-Bus GUID.
   *
   * See the documentation for g_dbus_generate_guid() for more information about
   * the format of a GUID.
   * @param string The string to check.
   * @returns %TRUE if @string is a GUID, %FALSE otherwise.
   */
  function dbusIsGuid(string: string): boolean
  /**
   * Checks if `string` is a valid D-Bus interface name.
   * @param string The string to check.
   * @returns %TRUE if valid, %FALSE otherwise.
   */
  function dbusIsInterfaceName(string: string): boolean
  /**
   * Checks if `string` is a valid D-Bus member (e.g. signal or method) name.
   * @param string The string to check.
   * @returns %TRUE if valid, %FALSE otherwise.
   */
  function dbusIsMemberName(string: string): boolean
  /**
   * Checks if `string` is a valid D-Bus bus name (either unique or well-known).
   * @param string The string to check.
   * @returns %TRUE if valid, %FALSE otherwise.
   */
  function dbusIsName(string: string): boolean
  /**
   * Like g_dbus_is_address() but also checks if the library supports the
   * transports in `string` and that key/value pairs for each transport
   * are valid. See the specification of the
   * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
   * @param string A string.
   * @returns %TRUE if @string is a valid D-Bus address that is supported by this library, %FALSE if @error is set.
   */
  function dbusIsSupportedAddress(string: string): boolean
  /**
   * Checks if `string` is a valid D-Bus unique bus name.
   * @param string The string to check.
   * @returns %TRUE if valid, %FALSE otherwise.
   */
  function dbusIsUniqueName(string: string): boolean
  /**
   * Unescapes an string that was previously escaped with
   * g_dbus_escape_object_path(). If the string is in a format that could
   * not have been returned by g_dbus_escape_object_path(), this function
   * returns %NULL.
   *
   * Encoding alphanumeric characters which do not need to be
   * encoded is not allowed (e.g `_63` is not valid, the string
   * should contain `c` instead).
   * @param s the string to unescape
   * @returns an   unescaped version of @s, or %NULL if @s is not a string returned   from g_dbus_escape_object_path(). Free with g_free().
   */
  function dbusUnescapeObjectPath(s: string): number[] | null
  /**
   * Creates a new #GDtlsClientConnection wrapping `base_socket` which is
   * assumed to communicate with the server identified by `server_identity`.
   * @param baseSocket the #GDatagramBased to wrap
   * @param serverIdentity the expected identity of the server
   * @returns the new   #GDtlsClientConnection, or %NULL on error
   */
  function dtlsClientConnectionNew(
    baseSocket: DatagramBased,
    serverIdentity: SocketConnectable | null
  ): DtlsClientConnection
  /**
   * Creates a new #GDtlsServerConnection wrapping `base_socket`.
   * @param baseSocket the #GDatagramBased to wrap
   * @param certificate the default server certificate, or %NULL
   * @returns the new   #GDtlsServerConnection, or %NULL on error
   */
  function dtlsServerConnectionNew(
    baseSocket: DatagramBased,
    certificate: TlsCertificate | null
  ): DtlsServerConnection
  /**
   * Constructs a #GFile from a vector of elements using the correct
   * separator for filenames.
   *
   * Using this function is equivalent to calling g_build_filenamev(),
   * followed by g_file_new_for_path() on the result.
   * @param args %NULL-terminated   array of strings containing the path elements.
   * @returns a new #GFile
   */
  function fileNewBuildFilenamev(args: string[]): File
  /**
   * Creates a #GFile with the given argument from the command line.
   * The value of `arg` can be either a URI, an absolute path or a
   * relative path resolved relative to the current working directory.
   * This operation never fails, but the returned object might not
   * support any I/O operation if `arg` points to a malformed path.
   *
   * Note that on Windows, this function expects its argument to be in
   * UTF-8 -- not the system code page.  This means that you
   * should not use this function with string from argv as it is passed
   * to main().  g_win32_get_command_line() will return a UTF-8 version of
   * the commandline.  #GApplication also uses UTF-8 but
   * g_application_command_line_create_file_for_arg() may be more useful
   * for you there.  It is also always possible to use this function with
   * #GOptionContext arguments of type %G_OPTION_ARG_FILENAME.
   * @param arg a command line string
   * @returns a new #GFile.   Free the returned object with g_object_unref().
   */
  function fileNewForCommandlineArg(arg: string): File
  /**
   * Creates a #GFile with the given argument from the command line.
   *
   * This function is similar to g_file_new_for_commandline_arg() except
   * that it allows for passing the current working directory as an
   * argument instead of using the current working directory of the
   * process.
   *
   * This is useful if the commandline argument was given in a context
   * other than the invocation of the current process.
   *
   * See also g_application_command_line_create_file_for_arg().
   * @param arg a command line string
   * @param cwd the current working directory of the commandline
   * @returns a new #GFile
   */
  function fileNewForCommandlineArgAndCwd(arg: string, cwd: string): File
  /**
   * Constructs a #GFile for a given path. This operation never
   * fails, but the returned object might not support any I/O
   * operation if `path` is malformed.
   * @param path a string containing a relative or absolute path.   The string must be encoded in the glib filename encoding.
   * @returns a new #GFile for the given @path.   Free the returned object with g_object_unref().
   */
  function fileNewForPath(path: string): File
  /**
   * Constructs a #GFile for a given URI. This operation never
   * fails, but the returned object might not support any I/O
   * operation if `uri` is malformed or if the uri type is
   * not supported.
   * @param uri a UTF-8 string containing a URI
   * @returns a new #GFile for the given @uri.   Free the returned object with g_object_unref().
   */
  function fileNewForUri(uri: string): File
  /**
   * Opens a file in the preferred directory for temporary files (as
   * returned by g_get_tmp_dir()) and returns a #GFile and
   * #GFileIOStream pointing to it.
   *
   * `tmpl` should be a string in the GLib file name encoding
   * containing a sequence of six 'X' characters, and containing no
   * directory components. If it is %NULL, a default template is used.
   *
   * Unlike the other #GFile constructors, this will return %NULL if
   * a temporary file could not be created.
   * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
   * @returns a new #GFile.   Free the returned object with g_object_unref().
   */
  function fileNewTmp(
    tmpl: string | null
  ): [/* returnType */ File, /* iostream */ FileIOStream]
  /**
   * Asynchronously opens a file in the preferred directory for temporary files
   *  (as returned by g_get_tmp_dir()) as g_file_new_tmp().
   *
   * `tmpl` should be a string in the GLib file name encoding
   * containing a sequence of six 'X' characters, and containing no
   * directory components. If it is %NULL, a default template is used.
   * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
   * @param ioPriority the [I/O priority][io-priority] of the request
   * @param cancellable optional #GCancellable object, %NULL to ignore
   * @param callback a #GAsyncReadyCallback to call when the request is done
   */
  function fileNewTmpAsync(
    tmpl: string | null,
    ioPriority: number,
    cancellable: Cancellable | null,
    callback: AsyncReadyCallback | null
  ): void
  /**
   * Asynchronously creates a directory in the preferred directory for
   * temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
   *
   * `tmpl` should be a string in the GLib file name encoding
   * containing a sequence of six 'X' characters, and containing no
   * directory components. If it is %NULL, a default template is used.
   * @param tmpl Template for the file   name, as in g_dir_make_tmp(), or %NULL for a default template
   * @param ioPriority the [I/O priority][io-priority] of the request
   * @param cancellable optional #GCancellable object, %NULL to ignore
   * @param callback a #GAsyncReadyCallback to call when the request is done
   */
  function fileNewTmpDirAsync(
    tmpl: string | null,
    ioPriority: number,
    cancellable: Cancellable | null,
    callback: AsyncReadyCallback | null
  ): void
  /**
   * Finishes a temporary directory creation started by
   * g_file_new_tmp_dir_async().
   * @param result a #GAsyncResult
   * @returns a new #GFile.   Free the returned object with g_object_unref().
   */
  function fileNewTmpDirFinish(result: AsyncResult): File
  /**
   * Finishes a temporary file creation started by g_file_new_tmp_async().
   * @param result a #GAsyncResult
   * @returns a new #GFile.   Free the returned object with g_object_unref().
   */
  function fileNewTmpFinish(
    result: AsyncResult
  ): [/* returnType */ File, /* iostream */ FileIOStream]
  /**
   * Constructs a #GFile with the given `parse_name` (i.e. something
   * given by g_file_get_parse_name()). This operation never fails,
   * but the returned object might not support any I/O operation if
   * the `parse_name` cannot be parsed.
   * @param parseName a file name or path to be parsed
   * @returns a new #GFile.
   */
  function fileParseName(parseName: string): File
  /**
   * Deserializes a #GIcon previously serialized using g_icon_serialize().
   * @param value a #GVariant created with g_icon_serialize()
   * @returns a #GIcon, or %NULL when deserialization fails.
   */
  function iconDeserialize(value: GLib.Variant): Icon | null
  /**
   * Generate a #GIcon instance from `str`. This function can fail if
   * `str` is not valid - see g_icon_to_string() for discussion.
   *
   * If your application or library provides one or more #GIcon
   * implementations you need to ensure that each #GType is registered
   * with the type system prior to calling g_icon_new_for_string().
   * @param str A string obtained via g_icon_to_string().
   * @returns An object implementing the #GIcon          interface or %NULL if @error is set.
   */
  function iconNewForString(str: string): Icon
  /**
   * Helper function for constructing #GInitable object. This is
   * similar to g_object_newv() but also initializes the object
   * and returns %NULL, setting an error on failure.
   * @param objectType a #GType supporting #GInitable.
   * @param parameters the parameters to use to construct the object
   * @param cancellable optional #GCancellable object, %NULL to ignore.
   * @returns a newly allocated      #GObject, or %NULL on error
   */
  function initableNewv(
    objectType: GObject.GType,
    parameters: GObject.Parameter[],
    cancellable: Cancellable | null
  ): GObject.Object
  /**
   * Converts `errno.h` error codes into GIO error codes.
   *
   * The fallback value %G_IO_ERROR_FAILED is returned for error codes not
   * currently handled (but note that future GLib releases may return a more
   * specific value instead).
   *
   * As `errno` is global and may be modified by intermediate function
   * calls, you should save its value immediately after the call returns,
   * and use the saved value instead of `errno`:
   *
   *
   *
   * ```c
   *   int saved_errno;
   *
   *   ret = read (blah);
   *   saved_errno = errno;
   *
   *   g_io_error_from_errno (saved_errno);
   * ```
   *
   * @param errNo Error number as defined in errno.h.
   * @returns #GIOErrorEnum value for the given `errno.h` error number
   */
  function ioErrorFromErrno(errNo: number): IOErrorEnum
  /**
   * Converts #GFileError error codes into GIO error codes.
   * @param fileError a #GFileError.
   * @returns #GIOErrorEnum value for the given #GFileError error value.
   */
  function ioErrorFromFileError(fileError: GLib.FileError): IOErrorEnum
  /**
   * Gets the GIO Error Quark.
   * @returns a #GQuark.
   */
  function ioErrorQuark(): GLib.Quark
  /**
   * Registers `type` as extension for the extension point with name
   * `extension_point_name`.
   *
   * If `type` has already been registered as an extension for this
   * extension point, the existing #GIOExtension object is returned.
   * @param extensionPointName the name of the extension point
   * @param type the #GType to register as extension
   * @param extensionName the name for the extension
   * @param priority the priority for the extension
   * @returns a #GIOExtension object for #GType
   */
  function ioExtensionPointImplement(
    extensionPointName: string,
    type: GObject.GType,
    extensionName: string,
    priority: number
  ): IOExtension
  /**
   * Looks up an existing extension point.
   * @param name the name of the extension point
   * @returns the #GIOExtensionPoint, or %NULL if there    is no registered extension point with the given name.
   */
  function ioExtensionPointLookup(name: string): IOExtensionPoint
  /**
   * Registers an extension point.
   * @param name The name of the extension point
   * @returns the new #GIOExtensionPoint. This object is    owned by GIO and should not be freed.
   */
  function ioExtensionPointRegister(name: string): IOExtensionPoint
  /**
   * Loads all the modules in the specified directory.
   *
   * If don't require all modules to be initialized (and thus registering
   * all gtypes) then you can use g_io_modules_scan_all_in_directory()
   * which allows delayed/lazy loading of modules.
   * @param dirname pathname for a directory containing modules     to load.
   * @returns a list of #GIOModules loaded      from the directory,      All the modules are loaded into memory, if you want to      unload them (enabling on-demand loading) you must call      g_type_module_unuse() on all the modules. Free the list      with g_list_free().
   */
  function ioModulesLoadAllInDirectory(dirname: string): IOModule[]
  /**
   * Loads all the modules in the specified directory.
   *
   * If don't require all modules to be initialized (and thus registering
   * all gtypes) then you can use g_io_modules_scan_all_in_directory()
   * which allows delayed/lazy loading of modules.
   * @param dirname pathname for a directory containing modules     to load.
   * @param scope a scope to use when scanning the modules.
   * @returns a list of #GIOModules loaded      from the directory,      All the modules are loaded into memory, if you want to      unload them (enabling on-demand loading) you must call      g_type_module_unuse() on all the modules. Free the list      with g_list_free().
   */
  function ioModulesLoadAllInDirectoryWithScope(
    dirname: string,
    scope: IOModuleScope
  ): IOModule[]
  /**
   * Scans all the modules in the specified directory, ensuring that
   * any extension point implemented by a module is registered.
   *
   * This may not actually load and initialize all the types in each
   * module, some modules may be lazily loaded and initialized when
   * an extension point it implements is used with e.g.
   * g_io_extension_point_get_extensions() or
   * g_io_extension_point_get_extension_by_name().
   *
   * If you need to guarantee that all types are loaded in all the modules,
   * use g_io_modules_load_all_in_directory().
   * @param dirname pathname for a directory containing modules     to scan.
   */
  function ioModulesScanAllInDirectory(dirname: string): void
  /**
   * Scans all the modules in the specified directory, ensuring that
   * any extension point implemented by a module is registered.
   *
   * This may not actually load and initialize all the types in each
   * module, some modules may be lazily loaded and initialized when
   * an extension point it implements is used with e.g.
   * g_io_extension_point_get_extensions() or
   * g_io_extension_point_get_extension_by_name().
   *
   * If you need to guarantee that all types are loaded in all the modules,
   * use g_io_modules_load_all_in_directory().
   * @param dirname pathname for a directory containing modules     to scan.
   * @param scope a scope to use when scanning the modules
   */
  function ioModulesScanAllInDirectoryWithScope(
    dirname: string,
    scope: IOModuleScope
  ): void
  /**
   * Cancels all cancellable I/O jobs.
   *
   * A job is cancellable if a #GCancellable was passed into
   * g_io_scheduler_push_job().
   */
  function ioSchedulerCancelAllJobs(): void
  /**
   * Schedules the I/O job to run in another thread.
   *
   * `notify` will be called on `user_data` after `job_func` has returned,
   * regardless whether the job was cancelled or has run to completion.
   *
   * If `cancellable` is not %NULL, it can be used to cancel the I/O job
   * by calling g_cancellable_cancel() or by calling
   * g_io_scheduler_cancel_all_jobs().
   * @param jobFunc a #GIOSchedulerJobFunc.
   * @param ioPriority the [I/O priority][io-priority] of the request.
   * @param cancellable optional #GCancellable object, %NULL to ignore.
   */
  function ioSchedulerPushJob(
    jobFunc: IOSchedulerJobFunc,
    ioPriority: number,
    cancellable: Cancellable | null
  ): void
  /**
   * Creates a keyfile-backed #GSettingsBackend.
   *
   * The filename of the keyfile to use is given by `filename`.
   *
   * All settings read to or written from the backend must fall under the
   * path given in `root_path` (which must start and end with a slash and
   * not contain two consecutive slashes).  `root_path` may be "/".
   *
   * If `root_group` is non-%NULL then it specifies the name of the keyfile
   * group used for keys that are written directly below `root_path`.  For
   * example, if `root_path` is "/apps/example/" and `root_group` is
   * "toplevel", then settings the key "/apps/example/enabled" to a value
   * of %TRUE will cause the following to appear in the keyfile:
   *
   *
   * ```
   *   [toplevel]
   *   enabled=true
   * ```
   *
   *
   * If `root_group` is %NULL then it is not permitted to store keys
   * directly below the `root_path`.
   *
   * For keys not stored directly below `root_path` (ie: in a sub-path),
   * the name of the subpath (with the final slash stripped) is used as
   * the name of the keyfile group.  To continue the example, if
   * "/apps/example/profiles/default/font-size" were set to
   * 12 then the following would appear in the keyfile:
   *
   *
   * ```
   *   [profiles/default]
   *   font-size=12
   * ```
   *
   *
   * The backend will refuse writes (and return writability as being
   * %FALSE) for keys outside of `root_path` and, in the event that
   * `root_group` is %NULL, also for keys directly under `root_path`.
   * Writes will also be refused if the backend detects that it has the
   * inability to rewrite the keyfile (ie: the containing directory is not
   * writable).
   *
   * There is no checking done for your key namespace clashing with the
   * syntax of the key file format.  For example, if you have '[' or ']'
   * characters in your path names or '=' in your key names you may be in
   * trouble.
   *
   * The backend reads default values from a keyfile called `defaults` in
   * the directory specified by the #GKeyfileSettingsBackend:defaults-dir property,
   * and a list of locked keys from a text file with the name `locks` in
   * the same location.
   * @param filename the filename of the keyfile
   * @param rootPath the path under which all settings keys appear
   * @param rootGroup the group name corresponding to              `root_path,` or %NULL
   * @returns a keyfile-backed #GSettingsBackend
   */
  function keyfileSettingsBackendNew(
    filename: string,
    rootPath: string,
    rootGroup: string | null
  ): SettingsBackend
  /**
   * Gets a reference to the default #GMemoryMonitor for the system.
   * @returns a new reference to the default #GMemoryMonitor
   */
  function memoryMonitorDupDefault(): MemoryMonitor
  /**
   * Creates a memory-backed #GSettingsBackend.
   *
   * This backend allows changes to settings, but does not write them
   * to any backing storage, so the next time you run your application,
   * the memory backend will start out with the default values again.
   * @returns a newly created #GSettingsBackend
   */
  function memorySettingsBackendNew(): SettingsBackend
  /**
   * Gets the default #GNetworkMonitor for the system.
   * @returns a #GNetworkMonitor, which will be     a dummy object if no network monitor is available
   */
  function networkMonitorGetDefault(): NetworkMonitor
  /**
   * Initializes the platform networking libraries (eg, on Windows, this
   * calls WSAStartup()). GLib will call this itself if it is needed, so
   * you only need to call it if you directly call system networking
   * functions (without calling any GLib networking functions first).
   */
  function networkingInit(): void
  /**
   * Creates a readonly #GSettingsBackend.
   *
   * This backend does not allow changes to settings, so all settings
   * will always have their default values.
   * @returns a newly created #GSettingsBackend
   */
  function nullSettingsBackendNew(): SettingsBackend
  /**
   * Utility method for #GPollableInputStream and #GPollableOutputStream
   * implementations. Creates a new #GSource that expects a callback of
   * type #GPollableSourceFunc. The new source does not actually do
   * anything on its own; use g_source_add_child_source() to add other
   * sources to it to cause it to trigger.
   * @param pollableStream the stream associated with the new source
   * @returns the new #GSource.
   */
  function pollableSourceNew(pollableStream: GObject.Object): GLib.Source
  /**
   * Utility method for #GPollableInputStream and #GPollableOutputStream
   * implementations. Creates a new #GSource, as with
   * g_pollable_source_new(), but also attaching `child_source` (with a
   * dummy callback), and `cancellable,` if they are non-%NULL.
   * @param pollableStream the stream associated with the   new source
   * @param childSource optional child source to attach
   * @param cancellable optional #GCancellable to attach
   * @returns the new #GSource.
   */
  function pollableSourceNewFull(
    pollableStream: GObject.Object,
    childSource: GLib.Source | null,
    cancellable: Cancellable | null
  ): GLib.Source
  /**
   * Tries to read from `stream,` as with g_input_stream_read() (if
   * `blocking` is %TRUE) or g_pollable_input_stream_read_nonblocking()
   * (if `blocking` is %FALSE). This can be used to more easily share
   * code between blocking and non-blocking implementations of a method.
   *
   * If `blocking` is %FALSE, then `stream` must be a
   * #GPollableInputStream for which g_pollable_input_stream_can_poll()
   * returns %TRUE, or else the behavior is undefined. If `blocking` is
   * %TRUE, then `stream` does not need to be a #GPollableInputStream.
   * @param stream a #GInputStream
   * @param buffer a buffer to   read data into
   * @param blocking whether to do blocking I/O
   * @param cancellable optional #GCancellable object, %NULL to ignore.
   * @returns the number of bytes read, or -1 on error.
   */
  function pollableStreamRead(
    stream: InputStream,
    buffer: number[],
    blocking: boolean,
    cancellable: Cancellable | null
  ): number
  /**
   * Tries to write to `stream,` as with g_output_stream_write() (if
   * `blocking` is %TRUE) or g_pollable_output_stream_write_nonblocking()
   * (if `blocking` is %FALSE). This can be used to more easily share
   * code between blocking and non-blocking implementations of a method.
   *
   * If `blocking` is %FALSE, then `stream` must be a
   * #GPollableOutputStream for which
   * g_pollable_output_stream_can_poll() returns %TRUE or else the
   * behavior is undefined. If `blocking` is %TRUE, then `stream` does not
   * need to be a #GPollableOutputStream.
   * @param stream a #GOutputStream.
   * @param buffer the buffer   containing the data to write.
   * @param blocking whether to do blocking I/O
   * @param cancellable optional #GCancellable object, %NULL to ignore.
   * @returns the number of bytes written, or -1 on error.
   */
  function pollableStreamWrite(
    stream: OutputStream,
    buffer: number[],
    blocking: boolean,
    cancellable: Cancellable | null
  ): number
  /**
   * Tries to write `count` bytes to `stream,` as with
   * g_output_stream_write_all(), but using g_pollable_stream_write()
   * rather than g_output_stream_write().
   *
   * On a successful write of `count` bytes, %TRUE is returned, and
   * `bytes_written` is set to `count`.
   *
   * If there is an error during the operation (including
   * %G_IO_ERROR_WOULD_BLOCK in the non-blocking case), %FALSE is
   * returned and `error` is set to indicate the error status,
   * `bytes_written` is updated to contain the number of bytes written
   * into the stream before the error occurred.
   *
   * As with g_pollable_stream_write(), if `blocking` is %FALSE, then
   * `stream` must be a #GPollableOutputStream for which
   * g_pollable_output_stream_can_poll() returns %TRUE or else the
   * behavior is undefined. If `blocking` is %TRUE, then `stream` does not
   * need to be a #GPollableOutputStream.
   * @param stream a #GOutputStream.
   * @param buffer the buffer   containing the data to write.
   * @param blocking whether to do blocking I/O
   * @param cancellable optional #GCancellable object, %NULL to ignore.
   * @returns %TRUE on success, %FALSE if there was an error
   */
  function pollableStreamWriteAll(
    stream: OutputStream,
    buffer: number[],
    blocking: boolean,
    cancellable: Cancellable | null
  ): [/* returnType */ boolean, /* bytesWritten */ number]
  /**
   * Gets a reference to the default #GPowerProfileMonitor for the system.
   * @returns a new reference to the default #GPowerProfileMonitor
   */
  function powerProfileMonitorDupDefault(): PowerProfileMonitor
  /**
   * Find the `gio-proxy` extension point for a proxy implementation that supports
   * the specified protocol.
   * @param protocol the proxy protocol name (e.g. http, socks, etc)
   * @returns return a #GProxy or NULL if protocol               is not supported.
   */
  function proxyGetDefaultForProtocol(protocol: string): Proxy | null
  /**
   * Gets the default #GProxyResolver for the system.
   * @returns the default #GProxyResolver, which     will be a dummy object if no proxy resolver is available
   */
  function proxyResolverGetDefault(): ProxyResolver
  /**
   * Gets the #GResolver Error Quark.
   * @returns a #GQuark.
   */
  function resolverErrorQuark(): GLib.Quark
  /**
   * Gets the #GResource Error Quark.
   * @returns a #GQuark
   */
  function resourceErrorQuark(): GLib.Quark
  /**
   * Loads a binary resource bundle and creates a #GResource representation of it, allowing
   * you to query it for data.
   *
   * If you want to use this resource in the global resource namespace you need
   * to register it with g_resources_register().
   *
   * If `filename` is empty or the data in it is corrupt,
   * %G_RESOURCE_ERROR_INTERNAL will be returned. If `filename` doesn’t exist, or
   * there is an error in reading it, an error from g_mapped_file_new() will be
   * returned.
   * @param filename the path of a filename to load, in the GLib filename encoding
   * @returns a new #GResource, or %NULL on error
   */
  function resourceLoad(filename: string): Resource
  /**
   * Returns all the names of children at the specified `path` in the set of
   * globally registered resources.
   * The return result is a %NULL terminated list of strings which should
   * be released with g_strfreev().
   *
   * `lookup_flags` controls the behaviour of the lookup.
   * @param path A pathname inside the resource
   * @param lookupFlags A #GResourceLookupFlags
   * @returns an array of constant strings
   */
  function resourcesEnumerateChildren(
    path: string,
    lookupFlags: ResourceLookupFlags
  ): string[]
  /**
   * Looks for a file at the specified `path` in the set of
   * globally registered resources and if found returns information about it.
   *
   * `lookup_flags` controls the behaviour of the lookup.
   * @param path A pathname inside the resource
   * @param lookupFlags A #GResourceLookupFlags
   * @returns %TRUE if the file was found. %FALSE if there were errors
   */
  function resourcesGetInfo(
    path: string,
    lookupFlags: ResourceLookupFlags
  ): [/* returnType */ boolean, /* size */ number, /* flags */ number]
  /**
   * Looks for a file at the specified `path` in the set of
   * globally registered resources and returns a #GBytes that
   * lets you directly access the data in memory.
   *
   * The data is always followed by a zero byte, so you
   * can safely use the data as a C string. However, that byte
   * is not included in the size of the GBytes.
   *
   * For uncompressed resource files this is a pointer directly into
   * the resource bundle, which is typically in some readonly data section
   * in the program binary. For compressed files we allocate memory on
   * the heap and automatically uncompress the data.
   *
   * `lookup_flags` controls the behaviour of the lookup.
   * @param path A pathname inside the resource
   * @param lookupFlags A #GResourceLookupFlags
   * @returns #GBytes or %NULL on error.     Free the returned object with g_bytes_unref()
   */
  function resourcesLookupData(
    path: string,
    lookupFlags: ResourceLookupFlags
  ): any
  /**
   * Looks for a file at the specified `path` in the set of
   * globally registered resources and returns a #GInputStream
   * that lets you read the data.
   *
   * `lookup_flags` controls the behaviour of the lookup.
   * @param path A pathname inside the resource
   * @param lookupFlags A #GResourceLookupFlags
   * @returns #GInputStream or %NULL on error.     Free the returned object with g_object_unref()
   */
  function resourcesOpenStream(
    path: string,
    lookupFlags: ResourceLookupFlags
  ): InputStream
  /**
   * Registers the resource with the process-global set of resources.
   * Once a resource is registered the files in it can be accessed
   * with the global resource lookup functions like g_resources_lookup_data().
   * @param resource A #GResource
   */
  function resourcesRegister(resource: Resource): void
  /**
   * Unregisters the resource from the process-global set of resources.
   * @param resource A #GResource
   */
  function resourcesUnregister(resource: Resource): void
  /**
   * Gets the default system schema source.
   *
   * This function is not required for normal uses of #GSettings but it
   * may be useful to authors of plugin management systems or to those who
   * want to introspect the content of schemas.
   *
   * If no schemas are installed, %NULL will be returned.
   *
   * The returned source may actually consist of multiple schema sources
   * from different directories, depending on which directories were given
   * in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all
   * lookups performed against the default source should probably be done
   * recursively.
   * @returns the default schema source
   */
  function settingsSchemaSourceGetDefault(): SettingsSchemaSource | null
  /**
   * Reports an error in an idle function. Similar to
   * g_simple_async_report_error_in_idle(), but takes a #GError rather
   * than building a new one.
   * @param object a #GObject, or %NULL
   * @param callback a #GAsyncReadyCallback.
   * @param error the #GError to report
   */
  function simpleAsyncReportGerrorInIdle(
    object: GObject.Object | null,
    callback: AsyncReadyCallback | null,
    error: GLib.Error
  ): void
  /**
   * Gets the default #GTlsBackend for the system.
   * @returns a #GTlsBackend, which will be a     dummy object if no TLS backend is available
   */
  function tlsBackendGetDefault(): TlsBackend
  /**
   * Gets the TLS channel binding error quark.
   * @returns a #GQuark.
   */
  function tlsChannelBindingErrorQuark(): GLib.Quark
  /**
   * Creates a new #GTlsClientConnection wrapping `base_io_stream` (which
   * must have pollable input and output streams) which is assumed to
   * communicate with the server identified by `server_identity`.
   *
   * See the documentation for #GTlsConnection:base-io-stream for restrictions
   * on when application code can run operations on the `base_io_stream` after
   * this function has returned.
   * @param baseIoStream the #GIOStream to wrap
   * @param serverIdentity the expected identity of the server
   * @returns the new #GTlsClientConnection, or %NULL on error
   */
  function tlsClientConnectionNew(
    baseIoStream: IOStream,
    serverIdentity: SocketConnectable | null
  ): TlsClientConnection
  /**
   * Gets the TLS error quark.
   * @returns a #GQuark.
   */
  function tlsErrorQuark(): GLib.Quark
  /**
   * Creates a new #GTlsFileDatabase which uses anchor certificate authorities
   * in `anchors` to verify certificate chains.
   *
   * The certificates in `anchors` must be PEM encoded.
   * @param anchors filename of anchor certificate authorities.
   * @returns the new #GTlsFileDatabase, or %NULL on error
   */
  function tlsFileDatabaseNew(anchors: string): TlsFileDatabase
  /**
   * Creates a new #GTlsServerConnection wrapping `base_io_stream` (which
   * must have pollable input and output streams).
   *
   * See the documentation for #GTlsConnection:base-io-stream for restrictions
   * on when application code can run operations on the `base_io_stream` after
   * this function has returned.
   * @param baseIoStream the #GIOStream to wrap
   * @param certificate the default server certificate, or %NULL
   * @returns the new #GTlsServerConnection, or %NULL on error
   */
  function tlsServerConnectionNew(
    baseIoStream: IOStream,
    certificate: TlsCertificate | null
  ): TlsServerConnection
  /**
   * Determines if `mount_path` is considered an implementation of the
   * OS. This is primarily used for hiding mountable and mounted volumes
   * that only are used in the OS and has little to no relevance to the
   * casual user.
   * @param mountPath a mount path, e.g. `/media/disk` or `/usr`
   * @returns %TRUE if @mount_path is considered an implementation detail     of the OS.
   */
  function unixIsMountPathSystemInternal(mountPath: string): boolean
  /**
   * Determines if `device_path` is considered a block device path which is only
   * used in implementation of the OS. This is primarily used for hiding
   * mounted volumes that are intended as APIs for programs to read, and system
   * administrators at a shell; rather than something that should, for example,
   * appear in a GUI. For example, the Linux `/proc` filesystem.
   *
   * The list of device paths considered ‘system’ ones may change over time.
   * @param devicePath a device path, e.g. `/dev/loop0` or `nfsd`
   * @returns %TRUE if @device_path is considered an implementation detail of    the OS.
   */
  function unixIsSystemDevicePath(devicePath: string): boolean
  /**
   * Determines if `fs_type` is considered a type of file system which is only
   * used in implementation of the OS. This is primarily used for hiding
   * mounted volumes that are intended as APIs for programs to read, and system
   * administrators at a shell; rather than something that should, for example,
   * appear in a GUI. For example, the Linux `/proc` filesystem.
   *
   * The list of file system types considered ‘system’ ones may change over time.
   * @param fsType a file system type, e.g. `procfs` or `tmpfs`
   * @returns %TRUE if @fs_type is considered an implementation detail of the OS.
   */
  function unixIsSystemFsType(fsType: string): boolean
  /**
   * Gets a #GUnixMountEntry for a given mount path. If `time_read`
   * is set, it will be filled with a unix timestamp for checking
   * if the mounts have changed since with g_unix_mounts_changed_since().
   *
   * If more mounts have the same mount path, the last matching mount
   * is returned.
   *
   * This will return %NULL if there is no mount point at `mount_path`.
   * @param mountPath path for a possible unix mount.
   * @returns a #GUnixMountEntry.
   */
  function unixMountAt(
    mountPath: string
  ): [/* returnType */ UnixMountEntry | null, /* timeRead */ number]
  /**
   * Compares two unix mounts.
   * @param mount1 first #GUnixMountEntry to compare.
   * @param mount2 second #GUnixMountEntry to compare.
   * @returns 1, 0 or -1 if @mount1 is greater than, equal to, or less than @mount2, respectively.
   */
  function unixMountCompare(
    mount1: UnixMountEntry,
    mount2: UnixMountEntry
  ): number
  /**
   * Makes a copy of `mount_entry`.
   * @param mountEntry a #GUnixMountEntry.
   * @returns a new #GUnixMountEntry
   */
  function unixMountCopy(mountEntry: UnixMountEntry): UnixMountEntry
  /**
   * Gets a #GUnixMountEntry for a given file path. If `time_read`
   * is set, it will be filled with a unix timestamp for checking
   * if the mounts have changed since with g_unix_mounts_changed_since().
   *
   * If more mounts have the same mount path, the last matching mount
   * is returned.
   *
   * This will return %NULL if looking up the mount entry fails, if
   * `file_path` doesn’t exist or there is an I/O error.
   * @param filePath file path on some unix mount.
   * @returns a #GUnixMountEntry.
   */
  function unixMountFor(
    filePath: string
  ): [/* returnType */ UnixMountEntry | null, /* timeRead */ number]
  /**
   * Frees a unix mount.
   * @param mountEntry a #GUnixMountEntry.
   */
  function unixMountFree(mountEntry: UnixMountEntry): void
  /**
   * Gets the device path for a unix mount.
   * @param mountEntry a #GUnixMount.
   * @returns a string containing the device path.
   */
  function unixMountGetDevicePath(mountEntry: UnixMountEntry): string
  /**
   * Gets the filesystem type for the unix mount.
   * @param mountEntry a #GUnixMount.
   * @returns a string containing the file system type.
   */
  function unixMountGetFsType(mountEntry: UnixMountEntry): string
  /**
   * Gets the mount path for a unix mount.
   * @param mountEntry input #GUnixMountEntry to get the mount path for.
   * @returns the mount path for @mount_entry.
   */
  function unixMountGetMountPath(mountEntry: UnixMountEntry): string
  /**
   * Gets a comma-separated list of mount options for the unix mount. For example,
   * `rw,relatime,seclabel,data=ordered`.
   *
   * This is similar to g_unix_mount_point_get_options(), but it takes
   * a #GUnixMountEntry as an argument.
   * @param mountEntry a #GUnixMountEntry.
   * @returns a string containing the options, or %NULL if not available.
   */
  function unixMountGetOptions(mountEntry: UnixMountEntry): string | null
  /**
   * Gets the root of the mount within the filesystem. This is useful e.g. for
   * mounts created by bind operation, or btrfs subvolumes.
   *
   * For example, the root path is equal to "/" for mount created by
   * "mount /dev/sda1 /mnt/foo" and "/bar" for
   * "mount --bind /mnt/foo/bar /mnt/bar".
   * @param mountEntry a #GUnixMountEntry.
   * @returns a string containing the root, or %NULL if not supported.
   */
  function unixMountGetRootPath(mountEntry: UnixMountEntry): string | null
  /**
   * Guesses whether a Unix mount can be ejected.
   * @param mountEntry a #GUnixMountEntry
   * @returns %TRUE if @mount_entry is deemed to be ejectable.
   */
  function unixMountGuessCanEject(mountEntry: UnixMountEntry): boolean
  /**
   * Guesses the icon of a Unix mount.
   * @param mountEntry a #GUnixMountEntry
   * @returns a #GIcon
   */
  function unixMountGuessIcon(mountEntry: UnixMountEntry): Icon
  /**
   * Guesses the name of a Unix mount.
   * The result is a translated string.
   * @param mountEntry a #GUnixMountEntry
   * @returns A newly allocated string that must     be freed with g_free()
   */
  function unixMountGuessName(mountEntry: UnixMountEntry): string | null
  /**
   * Guesses whether a Unix mount should be displayed in the UI.
   * @param mountEntry a #GUnixMountEntry
   * @returns %TRUE if @mount_entry is deemed to be displayable.
   */
  function unixMountGuessShouldDisplay(mountEntry: UnixMountEntry): boolean
  /**
   * Guesses the symbolic icon of a Unix mount.
   * @param mountEntry a #GUnixMountEntry
   * @returns a #GIcon
   */
  function unixMountGuessSymbolicIcon(mountEntry: UnixMountEntry): Icon
  /**
   * Checks if a unix mount is mounted read only.
   * @param mountEntry a #GUnixMount.
   * @returns %TRUE if @mount_entry is read only.
   */
  function unixMountIsReadonly(mountEntry: UnixMountEntry): boolean
  /**
   * Checks if a Unix mount is a system mount. This is the Boolean OR of
   * g_unix_is_system_fs_type(), g_unix_is_system_device_path() and
   * g_unix_is_mount_path_system_internal() on `mount_entry’`s properties.
   *
   * The definition of what a ‘system’ mount entry is may change over time as new
   * file system types and device paths are ignored.
   * @param mountEntry a #GUnixMount.
   * @returns %TRUE if the unix mount is for a system path.
   */
  function unixMountIsSystemInternal(mountEntry: UnixMountEntry): boolean
  /**
   * Gets a #GUnixMountPoint for a given mount path. If `time_read` is set, it
   * will be filled with a unix timestamp for checking if the mount points have
   * changed since with g_unix_mount_points_changed_since().
   *
   * If more mount points have the same mount path, the last matching mount point
   * is returned.
   * @param mountPath path for a possible unix mount point.
   * @returns a #GUnixMountPoint, or %NULL if no match is found.
   */
  function unixMountPointAt(
    mountPath: string
  ): [/* returnType */ UnixMountPoint | null, /* timeRead */ number]
  /**
   * Checks if the unix mount points have changed since a given unix time.
   * @param time guint64 to contain a timestamp.
   * @returns %TRUE if the mount points have changed since @time.
   */
  function unixMountPointsChangedSince(time: number): boolean
  /**
   * Gets a #GList of #GUnixMountPoint containing the unix mount points.
   * If `time_read` is set, it will be filled with the mount timestamp,
   * allowing for checking if the mounts have changed with
   * g_unix_mount_points_changed_since().
   * @returns a #GList of the UNIX mountpoints.
   */
  function unixMountPointsGet(): [
    /* returnType */ UnixMountPoint[],
    /* timeRead */ number,
  ]
  /**
   * Checks if the unix mounts have changed since a given unix time.
   * @param time guint64 to contain a timestamp.
   * @returns %TRUE if the mounts have changed since @time.
   */
  function unixMountsChangedSince(time: number): boolean
  /**
   * Gets a #GList of #GUnixMountEntry containing the unix mounts.
   * If `time_read` is set, it will be filled with the mount
   * timestamp, allowing for checking if the mounts have changed
   * with g_unix_mounts_changed_since().
   * @returns a #GList of the UNIX mounts.
   */
  function unixMountsGet(): [
    /* returnType */ UnixMountEntry[],
    /* timeRead */ number,
  ]
  /**
   * Type definition for a function that will be called back when an asynchronous
   * operation within GIO has been completed. #GAsyncReadyCallback
   * callbacks from #GTask are guaranteed to be invoked in a later
   * iteration of the
   * [thread-default main context][g-main-context-push-thread-default]
   * where the #GTask was created. All other users of
   * #GAsyncReadyCallback must likewise call it asynchronously in a
   * later iteration of the main context.
   *
   * The asynchronous operation is guaranteed to have held a reference to
   * `source_object` from the time when the `*_async()` function was called, until
   * after this callback returns.
   * @callback
   * @param sourceObject the object the asynchronous operation was started with.
   * @param res a #GAsyncResult.
   * @param data user data passed to the callback.
   */
  interface AsyncReadyCallback {
    (
      sourceObject: GObject.Object | null,
      res: AsyncResult,
      data: any | null
    ): void
  }
  /**
   * Invoked when a connection to a message bus has been obtained.
   * @callback
   * @param connection The #GDBusConnection to a message bus.
   * @param name The name that is requested to be owned.
   */
  interface BusAcquiredCallback {
    (connection: DBusConnection, name: string): void
  }
  /**
   * Invoked when the name is acquired.
   * @callback
   * @param connection The #GDBusConnection on which to acquired the name.
   * @param name The name being owned.
   */
  interface BusNameAcquiredCallback {
    (connection: DBusConnection, name: string): void
  }
  /**
   * Invoked when the name being watched is known to have to have an owner.
   * @callback
   * @param connection The #GDBusConnection the name is being watched on.
   * @param name The name being watched.
   * @param nameOwner Unique name of the owner of the name being watched.
   */
  interface BusNameAppearedCallback {
    (connection: DBusConnection, name: string, nameOwner: string): void
  }
  /**
   * Invoked when the name is lost or `connection` has been closed.
   * @callback
   * @param connection The #GDBusConnection on which to acquire the name or %NULL if the connection was disconnected.
   * @param name The name being owned.
   */
  interface BusNameLostCallback {
    (connection: DBusConnection, name: string): void
  }
  /**
   * Invoked when the name being watched is known not to have to have an owner.
   *
   * This is also invoked when the #GDBusConnection on which the watch was
   * established has been closed.  In that case, `connection` will be
   * %NULL.
   * @callback
   * @param connection The #GDBusConnection the name is being watched on, or     %NULL.
   * @param name The name being watched.
   */
  interface BusNameVanishedCallback {
    (connection: DBusConnection, name: string): void
  }
  /**
   * This is the function type of the callback used for the #GSource
   * returned by g_cancellable_source_new().
   * @callback
   * @param cancellable the #GCancellable
   * @param data data passed in by the user.
   * @returns it should return %FALSE if the source should be removed.
   */
  interface CancellableSourceFunc {
    (cancellable: Cancellable | null, data: any | null): boolean
  }
  /**
   * The type of the `get_property` function in #GDBusInterfaceVTable.
   * @callback
   * @param connection A #GDBusConnection.
   * @param sender The unique bus name of the remote caller.
   * @param objectPath The object path that the method was invoked on.
   * @param interfaceName The D-Bus interface name for the property.
   * @param propertyName The name of the property to get the value of.
   * @param error Return location for error.
   * @returns A #GVariant with the value for @property_name or %NULL if     @error is set. If the returned #GVariant is floating, it is     consumed - otherwise its reference count is decreased by one.
   */
  interface DBusInterfaceGetPropertyFunc {
    (
      connection: DBusConnection,
      sender: string,
      objectPath: string,
      interfaceName: string,
      propertyName: string,
      error: GLib.Error
    ): GLib.Variant
  }
  /**
   * The type of the `method_call` function in #GDBusInterfaceVTable.
   * @callback
   * @param connection A #GDBusConnection.
   * @param sender The unique bus name of the remote caller.
   * @param objectPath The object path that the method was invoked on.
   * @param interfaceName The D-Bus interface name the method was invoked on.
   * @param methodName The name of the method that was invoked.
   * @param parameters A #GVariant tuple with parameters.
   * @param invocation A #GDBusMethodInvocation object that must be used to return a value or error.
   */
  interface DBusInterfaceMethodCallFunc {
    (
      connection: DBusConnection,
      sender: string,
      objectPath: string,
      interfaceName: string,
      methodName: string,
      parameters: GLib.Variant,
      invocation: DBusMethodInvocation
    ): void
  }
  /**
   * The type of the `set_property` function in #GDBusInterfaceVTable.
   * @callback
   * @param connection A #GDBusConnection.
   * @param sender The unique bus name of the remote caller.
   * @param objectPath The object path that the method was invoked on.
   * @param interfaceName The D-Bus interface name for the property.
   * @param propertyName The name of the property to get the value of.
   * @param value The value to set the property to.
   * @param error Return location for error.
   * @returns %TRUE if the property was set to @value, %FALSE if @error is set.
   */
  interface DBusInterfaceSetPropertyFunc {
    (
      connection: DBusConnection,
      sender: string,
      objectPath: string,
      interfaceName: string,
      propertyName: string,
      value: GLib.Variant,
      error: GLib.Error
    ): boolean
  }
  /**
   * Signature for function used in g_dbus_connection_add_filter().
   *
   * A filter function is passed a #GDBusMessage and expected to return
   * a #GDBusMessage too. Passive filter functions that don't modify the
   * message can simply return the `message` object:
   *
   * ```
   * static GDBusMessage *
   * passive_filter (GDBusConnection *connection
   *                 GDBusMessage    *message,
   *                 gboolean         incoming,
   *                 gpointer         user_data)
   * {
   *   // inspect `message`
   *   return message;
   * }
   * ```
   *
   * Filter functions that wants to drop a message can simply return %NULL:
   *
   * ```
   * static GDBusMessage *
   * drop_filter (GDBusConnection *connection
   *              GDBusMessage    *message,
   *              gboolean         incoming,
   *              gpointer         user_data)
   * {
   *   if (should_drop_message)
   *     {
   *       g_object_unref (message);
   *       message = NULL;
   *     }
   *   return message;
   * }
   * ```
   *
   * Finally, a filter function may modify a message by copying it:
   *
   * ```
   * static GDBusMessage *
   * modifying_filter (GDBusConnection *connection
   *                   GDBusMessage    *message,
   *                   gboolean         incoming,
   *                   gpointer         user_data)
   * {
   *   GDBusMessage *copy;
   *   GError *error;
   *
   *   error = NULL;
   *   copy = g_dbus_message_copy (message, &error);
   *   // handle `error` being set
   *   g_object_unref (message);
   *
   *   // modify `copy`
   *
   *   return copy;
   * }
   * ```
   *
   * If the returned #GDBusMessage is different from `message` and cannot
   * be sent on `connection` (it could use features, such as file
   * descriptors, not compatible with `connection)`, then a warning is
   * logged to standard error. Applications can
   * check this ahead of time using g_dbus_message_to_blob() passing a
   * #GDBusCapabilityFlags value obtained from `connection`.
   * @callback
   * @param connection A #GDBusConnection.
   * @param message A locked #GDBusMessage that the filter function takes ownership of.
   * @param incoming %TRUE if it is a message received from the other peer, %FALSE if it is a message to be sent to the other peer.
   * @returns A #GDBusMessage that will be freed with g_object_unref() or %NULL to drop the message. Passive filter functions can simply return the passed @message object.
   */
  interface DBusMessageFilterFunction {
    (
      connection: DBusConnection,
      message: DBusMessage,
      incoming: boolean
    ): DBusMessage | null
  }
  /**
   * Function signature for a function used to determine the #GType to
   * use for an interface proxy (if `interface_name` is not %NULL) or
   * object proxy (if `interface_name` is %NULL).
   *
   * This function is called in the
   * [thread-default main loop][g-main-context-push-thread-default]
   * that `manager` was constructed in.
   * @callback
   * @param manager A #GDBusObjectManagerClient.
   * @param objectPath The object path of the remote object.
   * @param interfaceName The interface name of the remote object or %NULL if a #GDBusObjectProxy #GType is requested.
   * @param data data passed in by the user.
   * @returns A #GType to use for the remote object. The returned type   must be a #GDBusProxy or #GDBusObjectProxy -derived   type.
   */
  interface DBusProxyTypeFunc {
    (
      manager: DBusObjectManagerClient,
      objectPath: string,
      interfaceName: string | null,
      data: any | null
    ): GObject.GType
  }
  /**
   * Signature for callback function used in g_dbus_connection_signal_subscribe().
   * @callback
   * @param connection A #GDBusConnection.
   * @param senderName The unique bus name of the sender of the signal,    or %NULL on a peer-to-peer D-Bus connection.
   * @param objectPath The object path that the signal was emitted on.
   * @param interfaceName The name of the interface.
   * @param signalName The name of the signal.
   * @param parameters A #GVariant tuple with parameters for the signal.
   */
  interface DBusSignalCallback {
    (
      connection: DBusConnection,
      senderName: string | null,
      objectPath: string,
      interfaceName: string,
      signalName: string,
      parameters: GLib.Variant
    ): void
  }
  /**
   * The type of the `dispatch` function in #GDBusSubtreeVTable.
   *
   * Subtrees are flat.  `node,` if non-%NULL, is always exactly one
   * segment of the object path (ie: it never contains a slash).
   * @callback
   * @param connection A #GDBusConnection.
   * @param sender The unique bus name of the remote caller.
   * @param objectPath The object path that was registered with g_dbus_connection_register_subtree().
   * @param interfaceName The D-Bus interface name that the method call or property access is for.
   * @param node A node that is a child of `object_path` (relative to `object_path)` or %NULL for the root of the subtree.
   * @param outUserData Return location for user data to pass to functions in the returned #GDBusInterfaceVTable.
   * @returns A #GDBusInterfaceVTable or %NULL if you don't want to handle the methods.
   */
  interface DBusSubtreeDispatchFunc {
    (
      connection: DBusConnection,
      sender: string,
      objectPath: string,
      interfaceName: string,
      node: string,
      outUserData: any
    ): DBusInterfaceVTable | null
  }
  /**
   * The type of the `enumerate` function in #GDBusSubtreeVTable.
   *
   * This function is called when generating introspection data and also
   * when preparing to dispatch incoming messages in the event that the
   * %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is not
   * specified (ie: to verify that the object path is valid).
   *
   * Hierarchies are not supported; the items that you return should not
   * contain the `/` character.
   *
   * The return value will be freed with g_strfreev().
   * @callback
   * @param connection A #GDBusConnection.
   * @param sender The unique bus name of the remote caller.
   * @param objectPath The object path that was registered with g_dbus_connection_register_subtree().
   * @returns A newly allocated array of strings for node names that are children of @object_path.
   */
  interface DBusSubtreeEnumerateFunc {
    (connection: DBusConnection, sender: string, objectPath: string): string[]
  }
  /**
   * The type of the `introspect` function in #GDBusSubtreeVTable.
   *
   * Subtrees are flat.  `node,` if non-%NULL, is always exactly one
   * segment of the object path (ie: it never contains a slash).
   *
   * This function should return %NULL to indicate that there is no object
   * at this node.
   *
   * If this function returns non-%NULL, the return value is expected to
   * be a %NULL-terminated array of pointers to #GDBusInterfaceInfo
   * structures describing the interfaces implemented by `node`.  This
   * array will have g_dbus_interface_info_unref() called on each item
   * before being freed with g_free().
   *
   * The difference between returning %NULL and an array containing zero
   * items is that the standard DBus interfaces will returned to the
   * remote introspector in the empty array case, but not in the %NULL
   * case.
   * @callback
   * @param connection A #GDBusConnection.
   * @param sender The unique bus name of the remote caller.
   * @param objectPath The object path that was registered with g_dbus_connection_register_subtree().
   * @param node A node that is a child of `object_path` (relative to `object_path)` or %NULL for the root of the subtree.
   * @returns A %NULL-terminated array of pointers to #GDBusInterfaceInfo, or %NULL.
   */
  interface DBusSubtreeIntrospectFunc {
    (
      connection: DBusConnection,
      sender: string,
      objectPath: string,
      node: string
    ): DBusInterfaceInfo[] | null
  }
  /**
   * This is the function type of the callback used for the #GSource
   * returned by g_datagram_based_create_source().
   * @callback
   * @param datagramBased the #GDatagramBased
   * @param condition the current condition at the source fired
   * @param data data passed in by the user
   * @returns %G_SOURCE_REMOVE if the source should be removed,   %G_SOURCE_CONTINUE otherwise
   */
  interface DatagramBasedSourceFunc {
    (
      datagramBased: DatagramBased,
      condition: GLib.IOCondition,
      data: any | null
    ): boolean
  }
  /**
   * During invocation, g_desktop_app_info_launch_uris_as_manager() may
   * create one or more child processes.  This callback is invoked once
   * for each, providing the process ID.
   * @callback
   * @param appinfo a #GDesktopAppInfo
   * @param pid Process identifier
   */
  interface DesktopAppLaunchCallback {
    (appinfo: DesktopAppInfo, pid: GLib.Pid): void
  }
  /**
   * This callback type is used by g_file_measure_disk_usage() to make
   * periodic progress reports when measuring the amount of disk spaced
   * used by a directory.
   *
   * These calls are made on a best-effort basis and not all types of
   * #GFile will support them.  At the minimum, however, one call will
   * always be made immediately.
   *
   * In the case that there is no support, `reporting` will be set to
   * %FALSE (and the other values undefined) and no further calls will be
   * made.  Otherwise, the `reporting` will be %TRUE and the other values
   * all-zeros during the first (immediate) call.  In this way, you can
   * know which type of progress UI to show without a delay.
   *
   * For g_file_measure_disk_usage() the callback is made directly.  For
   * g_file_measure_disk_usage_async() the callback is made via the
   * default main context of the calling thread (ie: the same way that the
   * final async result would be reported).
   *
   * `current_size` is in the same units as requested by the operation (see
   * %G_FILE_MEASURE_APPARENT_SIZE).
   *
   * The frequency of the updates is implementation defined, but is
   * ideally about once every 200ms.
   *
   * The last progress callback may or may not be equal to the final
   * result.  Always check the async result to get the final value.
   * @callback
   * @param reporting %TRUE if more reports will come
   * @param currentSize the current cumulative size measurement
   * @param numDirs the number of directories visited so far
   * @param numFiles the number of non-directory files encountered
   * @param data the data passed to the original request for this callback
   */
  interface FileMeasureProgressCallback {
    (
      reporting: boolean,
      currentSize: number,
      numDirs: number,
      numFiles: number,
      data: any | null
    ): void
  }
  /**
   * When doing file operations that may take a while, such as moving
   * a file or copying a file, a progress callback is used to pass how
   * far along that operation is to the application.
   * @callback
   * @param currentNumBytes the current number of bytes in the operation.
   * @param totalNumBytes the total number of bytes in the operation.
   * @param data user data passed to the callback.
   */
  interface FileProgressCallback {
    (currentNumBytes: number, totalNumBytes: number, data: any | null): void
  }
  /**
   * When loading the partial contents of a file with g_file_load_partial_contents_async(),
   * it may become necessary to determine if any more data from the file should be loaded.
   * A #GFileReadMoreCallback function facilitates this by returning %TRUE if more data
   * should be read, or %FALSE otherwise.
   * @callback
   * @param fileContents the data as currently read.
   * @param fileSize the size of the data currently read.
   * @param callbackData data passed to the callback.
   * @returns %TRUE if more data should be read back. %FALSE otherwise.
   */
  interface FileReadMoreCallback {
    (fileContents: string, fileSize: number, callbackData: any | null): boolean
  }
  /**
   * I/O Job function.
   *
   * Long-running jobs should periodically check the `cancellable`
   * to see if they have been cancelled.
   * @callback
   * @param job a #GIOSchedulerJob.
   * @param cancellable optional #GCancellable object, %NULL to ignore.
   * @param data data passed to the callback function
   * @returns %TRUE if this function should be called again to    complete the job, %FALSE if the job is complete (or cancelled)
   */
  interface IOSchedulerJobFunc {
    (
      job: IOSchedulerJob,
      cancellable: Cancellable | null,
      data: any | null
    ): boolean
  }
  /**
   * This is the function type of the callback used for the #GSource
   * returned by g_pollable_input_stream_create_source() and
   * g_pollable_output_stream_create_source().
   * @callback
   * @param pollableStream the #GPollableInputStream or #GPollableOutputStream
   * @param data data passed in by the user.
   * @returns it should return %FALSE if the source should be removed.
   */
  interface PollableSourceFunc {
    (pollableStream: GObject.Object, data: any | null): boolean
  }
  /**
   * Changes the size of the memory block pointed to by `data` to
   * `size` bytes.
   *
   * The function should have the same semantics as realloc().
   * @callback
   * @param data memory block to reallocate
   * @param size size to reallocate `data` to
   * @returns a pointer to the reallocated memory
   */
  interface ReallocFunc {
    (data: any | null, size: number): any | null
  }
  /**
   * The type for the function that is used to convert from #GSettings to
   * an object property. The `value` is already initialized to hold values
   * of the appropriate type.
   * @callback
   * @param value return location for the property value
   * @param variant the #GVariant
   * @returns %TRUE if the conversion succeeded, %FALSE in case of an error
   */
  interface SettingsBindGetMapping {
    (value: any, variant: GLib.Variant): boolean
  }
  /**
   * The type for the function that is used to convert an object property
   * value to a #GVariant for storing it in #GSettings.
   * @callback
   * @param value a #GValue containing the property value to map
   * @param expectedType the #GVariantType to create
   * @returns a new #GVariant holding the data from @value,     or %NULL in case of an error
   */
  interface SettingsBindSetMapping {
    (value: any, expectedType: GLib.VariantType): GLib.Variant
  }
  /**
   * The type of the function that is used to convert from a value stored
   * in a #GSettings to a value that is useful to the application.
   *
   * If the value is successfully mapped, the result should be stored at
   * `result` and %TRUE returned.  If mapping fails (for example, if `value`
   * is not in the right format) then %FALSE should be returned.
   *
   * If `value` is %NULL then it means that the mapping function is being
   * given a "last chance" to successfully return a valid value.  %TRUE
   * must be returned in this case.
   * @callback
   * @param value the #GVariant to map, or %NULL
   * @returns %TRUE if the conversion succeeded, %FALSE in case of an error
   */
  interface SettingsGetMapping {
    (value: GLib.Variant): boolean
  }
  /**
   * Simple thread function that runs an asynchronous operation and
   * checks for cancellation.
   * @callback
   * @param res a #GSimpleAsyncResult.
   * @param object a #GObject.
   * @param cancellable optional #GCancellable object, %NULL to ignore.
   */
  interface SimpleAsyncThreadFunc {
    (
      res: SimpleAsyncResult,
      object: GObject.Object,
      cancellable: Cancellable | null
    ): void
  }
  /**
   * This is the function type of the callback used for the #GSource
   * returned by g_socket_create_source().
   * @callback
   * @param socket the #GSocket
   * @param condition the current condition at the source fired.
   * @param data data passed in by the user.
   * @returns it should return %FALSE if the source should be removed.
   */
  interface SocketSourceFunc {
    (socket: Socket, condition: GLib.IOCondition, data: any | null): boolean
  }
  /**
   * The prototype for a task function to be run in a thread via
   * g_task_run_in_thread() or g_task_run_in_thread_sync().
   *
   * If the return-on-cancel flag is set on `task,` and `cancellable` gets
   * cancelled, then the #GTask will be completed immediately (as though
   * g_task_return_error_if_cancelled() had been called), without
   * waiting for the task function to complete. However, the task
   * function will continue running in its thread in the background. The
   * function therefore needs to be careful about how it uses
   * externally-visible state in this case. See
   * g_task_set_return_on_cancel() for more details.
   *
   * Other than in that case, `task` will be completed when the
   * #GTaskThreadFunc returns, not when it calls a
   * `g_task_return_` function.
   * @callback
   * @param task the #GTask
   * @param sourceObject `task'`s source object
   * @param taskData `task'`s task data
   * @param cancellable `task'`s #GCancellable, or %NULL
   */
  interface TaskThreadFunc {
    (
      task: Task,
      sourceObject: GObject.Object,
      taskData: any | null,
      cancellable: Cancellable | null
    ): void
  }
  /**
   * This function type is used by g_vfs_register_uri_scheme() to make it
   * possible for a client to associate an URI scheme to a different #GFile
   * implementation.
   *
   * The client should return a reference to the new file that has been
   * created for `uri,` or %NULL to continue with the default implementation.
   * @callback
   * @param vfs a #GVfs
   * @param identifier the identifier to look up a #GFile for. This can either     be an URI or a parse name as returned by g_file_get_parse_name()
   * @returns a #GFile for @identifier.
   */
  interface VfsFileLookupFunc {
    (vfs: Vfs, identifier: string): File
  }
  module Action {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Action {
    // Own properties of Gio-2.0.Gio.Action

    /**
     * If `action` is currently enabled.
     *
     * If the action is disabled then calls to g_action_activate() and
     * g_action_change_state() have no effect.
     */
    readonly enabled: boolean
    /**
     * The name of the action.  This is mostly meaningful for identifying
     * the action once it has been added to a #GActionGroup. It is immutable.
     */
    readonly name: string | null
    /**
     * The type of the parameter that must be given when activating the
     * action. This is immutable, and may be %NULL if no parameter is needed when
     * activating the action.
     */
    readonly parameterType: GLib.VariantType
    /**
     * The state of the action, or %NULL if the action is stateless.
     */
    readonly state: GLib.Variant
    /**
     * The #GVariantType of the state that the action has, or %NULL if the
     * action is stateless. This is immutable.
     */
    readonly stateType: GLib.VariantType
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Action

    // Has conflict: activate(parameter: GLib.Variant | null): void
    // Has conflict: changeState(value: GLib.Variant): void
    // Has conflict: getEnabled(): boolean
    // Has conflict: getName(): string
    // Has conflict: getParameterType(): GLib.VariantType | null
    // Has conflict: getState(): GLib.Variant | null
    // Has conflict: getStateHint(): GLib.Variant | null
    // Has conflict: getStateType(): GLib.VariantType | null

    // Own virtual methods of Gio-2.0.Gio.Action

    /**
     * Activates the action.
     *
     * `parameter` must be the correct type of parameter for the action (ie:
     * the parameter type given at construction time).  If the parameter
     * type was %NULL then `parameter` must also be %NULL.
     *
     * If the `parameter` GVariant is floating, it is consumed.
     * @virtual
     * @param parameter the parameter to the activation
     */
    activate(parameter: GLib.Variant | null): void
    /**
     * Request for the state of `action` to be changed to `value`.
     *
     * The action must be stateful and `value` must be of the correct type.
     * See g_action_get_state_type().
     *
     * This call merely requests a change.  The action may refuse to change
     * its state or may change its state to something other than `value`.
     * See g_action_get_state_hint().
     *
     * If the `value` GVariant is floating, it is consumed.
     * @virtual
     * @param value the new state
     */
    changeState(value: GLib.Variant): void
    /**
     * Checks if `action` is currently enabled.
     *
     * An action must be enabled in order to be activated or in order to
     * have its state changed from outside callers.
     * @virtual
     * @returns whether the action is enabled
     */
    getEnabled(): boolean
    /**
     * Queries the name of `action`.
     * @virtual
     * @returns the name of the action
     */
    getName(): string
    /**
     * Queries the type of the parameter that must be given when activating
     * `action`.
     *
     * When activating the action using g_action_activate(), the #GVariant
     * given to that function must be of the type returned by this function.
     *
     * In the case that this function returns %NULL, you must not give any
     * #GVariant, but %NULL instead.
     * @virtual
     * @returns the parameter type
     */
    getParameterType(): GLib.VariantType | null
    /**
     * Queries the current state of `action`.
     *
     * If the action is not stateful then %NULL will be returned.  If the
     * action is stateful then the type of the return value is the type
     * given by g_action_get_state_type().
     *
     * The return value (if non-%NULL) should be freed with
     * g_variant_unref() when it is no longer required.
     * @virtual
     * @returns the current state of the action
     */
    getState(): GLib.Variant | null
    /**
     * Requests a hint about the valid range of values for the state of
     * `action`.
     *
     * If %NULL is returned it either means that the action is not stateful
     * or that there is no hint about the valid range of values for the
     * state of the action.
     *
     * If a #GVariant array is returned then each item in the array is a
     * possible value for the state.  If a #GVariant pair (ie: two-tuple) is
     * returned then the tuple specifies the inclusive lower and upper bound
     * of valid values for the state.
     *
     * In any case, the information is merely a hint.  It may be possible to
     * have a state value outside of the hinted range and setting a value
     * within the range may fail.
     *
     * The return value (if non-%NULL) should be freed with
     * g_variant_unref() when it is no longer required.
     * @virtual
     * @returns the state range hint
     */
    getStateHint(): GLib.Variant | null
    /**
     * Queries the type of the state of `action`.
     *
     * If the action is stateful (e.g. created with
     * g_simple_action_new_stateful()) then this function returns the
     * #GVariantType of the state.  This is the type of the initial value
     * given as the state. All calls to g_action_change_state() must give a
     * #GVariant of this type and g_action_get_state() will return a
     * #GVariant of the same type.
     *
     * If the action is not stateful (e.g. created with g_simple_action_new())
     * then this function will return %NULL. In that case, g_action_get_state()
     * will return %NULL and you must not call g_action_change_state().
     * @virtual
     * @returns the state type, if the action is stateful
     */
    getStateType(): GLib.VariantType | null

    // Class property signals of Gio-2.0.Gio.Action

    connect(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enabled", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parameter-type", ...args: any[]): void
    connect(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state", ...args: any[]): void
    connect(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state-type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GAction` represents a single named action.
   *
   * The main interface to an action is that it can be activated with
   * [method`Gio`.Action.activate]. This results in the 'activate' signal being
   * emitted. An activation has a `GVariant` parameter (which may be
   * `NULL`). The correct type for the parameter is determined by a static
   * parameter type (which is given at construction time).
   *
   * An action may optionally have a state, in which case the state may be
   * set with [method`Gio`.Action.change_state]. This call takes a #GVariant. The
   * correct type for the state is determined by a static state type
   * (which is given at construction time).
   *
   * The state may have a hint associated with it, specifying its valid
   * range.
   *
   * `GAction` is merely the interface to the concept of an action, as
   * described above.  Various implementations of actions exist, including
   * [class`Gio`.SimpleAction].
   *
   * In all cases, the implementing class is responsible for storing the
   * name of the action, the parameter type, the enabled state, the optional
   * state type and the state and emitting the appropriate signals when these
   * change. The implementor is responsible for filtering calls to
   * [method`Gio`.Action.activate] and [method`Gio`.Action.change_state]
   * for type safety and for the state being enabled.
   *
   * Probably the only useful thing to do with a `GAction` is to put it
   * inside of a [class`Gio`.SimpleActionGroup].
   * @interface
   */
  class Action extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Action

    static name: string

    // Constructors of Gio-2.0.Gio.Action

    constructor(config?: Action.ConstructorProperties)
    _init(config?: Action.ConstructorProperties): void
    /**
     * Checks if `action_name` is valid.
     *
     * `action_name` is valid if it consists only of alphanumeric characters,
     * plus '-' and '.'.  The empty string is not a valid action name.
     *
     * It is an error to call this function with a non-utf8 `action_name`.
     * `action_name` must not be %NULL.
     * @param actionName a potential action name
     * @returns %TRUE if @action_name is valid
     */
    static nameIsValid(actionName: string): boolean
    /**
     * Parses a detailed action name into its separate name and target
     * components.
     *
     * Detailed action names can have three formats.
     *
     * The first format is used to represent an action name with no target
     * value and consists of just an action name containing no whitespace
     * nor the characters `:`, `(` or `)`.  For example: `app.action`.
     *
     * The second format is used to represent an action with a target value
     * that is a non-empty string consisting only of alphanumerics, plus `-`
     * and `.`.  In that case, the action name and target value are
     * separated by a double colon (`::`).  For example:
     * `app.action::target`.
     *
     * The third format is used to represent an action with any type of
     * target value, including strings.  The target value follows the action
     * name, surrounded in parens.  For example: `app.action(42)`.  The
     * target value is parsed using g_variant_parse().  If a tuple-typed
     * value is desired, it must be specified in the same way, resulting in
     * two sets of parens, for example: `app.action((1,2,3))`.  A string
     * target can be specified this way as well: `app.action('target')`.
     * For strings, this third format must be used if target value is
     * empty or contains characters other than alphanumerics, `-` and `.`.
     *
     * If this function returns %TRUE, a non-%NULL value is guaranteed to be returned
     * in `action_name` (if a pointer is passed in). A %NULL value may still be
     * returned in `target_value,` as the `detailed_name` may not contain a target.
     *
     * If returned, the #GVariant in `target_value` is guaranteed to not be floating.
     * @param detailedName a detailed action name
     * @returns %TRUE if successful, else %FALSE with @error set
     */
    static parseDetailedName(
      detailedName: string
    ): [
      /* returnType */ boolean,
      /* actionName */ string,
      /* targetValue */ GLib.Variant | null,
    ]
    /**
     * Formats a detailed action name from `action_name` and `target_value`.
     *
     * It is an error to call this function with an invalid action name.
     *
     * This function is the opposite of g_action_parse_detailed_name().
     * It will produce a string that can be parsed back to the `action_name`
     * and `target_value` by that function.
     *
     * See that function for the types of strings that will be printed by
     * this function.
     * @param actionName a valid action name
     * @param targetValue a #GVariant target value, or %NULL
     * @returns a detailed format string
     */
    static printDetailedName(
      actionName: string,
      targetValue: GLib.Variant | null
    ): string | null
  }

  module ActionGroup {
    // Signal callback interfaces

    /**
     * Signal callback interface for `action-added`
     */
    interface ActionAddedSignalCallback {
      (actionName: string | null): void
    }

    /**
     * Signal callback interface for `action-enabled-changed`
     */
    interface ActionEnabledChangedSignalCallback {
      (actionName: string | null, enabled: boolean): void
    }

    /**
     * Signal callback interface for `action-removed`
     */
    interface ActionRemovedSignalCallback {
      (actionName: string | null): void
    }

    /**
     * Signal callback interface for `action-state-changed`
     */
    interface ActionStateChangedSignalCallback {
      (actionName: string | null, value: GLib.Variant): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ActionGroup {
    // Own properties of Gio-2.0.Gio.ActionGroup

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ActionGroup

    // Has conflict: actionAdded(actionName: string): void
    // Has conflict: actionEnabledChanged(actionName: string, enabled: boolean): void
    // Has conflict: actionRemoved(actionName: string): void
    // Has conflict: actionStateChanged(actionName: string, state: GLib.Variant): void
    // Has conflict: activateAction(actionName: string, parameter: GLib.Variant | null): void
    // Has conflict: changeActionState(actionName: string, value: GLib.Variant): void
    // Has conflict: getActionEnabled(actionName: string): boolean
    // Has conflict: getActionParameterType(actionName: string): GLib.VariantType | null
    // Has conflict: getActionState(actionName: string): GLib.Variant | null
    // Has conflict: getActionStateHint(actionName: string): GLib.Variant | null
    // Has conflict: getActionStateType(actionName: string): GLib.VariantType | null
    // Has conflict: hasAction(actionName: string): boolean
    // Has conflict: listActions(): string[]
    // Has conflict: queryAction(actionName: string): [ /* returnType */ boolean, /* enabled */ boolean, /* parameterType */ GLib.VariantType, /* stateType */ GLib.VariantType, /* stateHint */ GLib.Variant, /* state */ GLib.Variant ]

    // Own virtual methods of Gio-2.0.Gio.ActionGroup

    /**
     * Emits the #GActionGroup::action-added signal on `action_group`.
     *
     * This function should only be called by #GActionGroup implementations.
     * @virtual
     * @param actionName the name of an action in the group
     */
    actionAdded(actionName: string): void
    /**
     * Emits the #GActionGroup::action-enabled-changed signal on `action_group`.
     *
     * This function should only be called by #GActionGroup implementations.
     * @virtual
     * @param actionName the name of an action in the group
     * @param enabled whether or not the action is now enabled
     */
    actionEnabledChanged(actionName: string, enabled: boolean): void
    /**
     * Emits the #GActionGroup::action-removed signal on `action_group`.
     *
     * This function should only be called by #GActionGroup implementations.
     * @virtual
     * @param actionName the name of an action in the group
     */
    actionRemoved(actionName: string): void
    /**
     * Emits the #GActionGroup::action-state-changed signal on `action_group`.
     *
     * This function should only be called by #GActionGroup implementations.
     * @virtual
     * @param actionName the name of an action in the group
     * @param state the new state of the named action
     */
    actionStateChanged(actionName: string, state: GLib.Variant): void
    /**
     * Activate the named action within `action_group`.
     *
     * If the action is expecting a parameter, then the correct type of
     * parameter must be given as `parameter`.  If the action is expecting no
     * parameters then `parameter` must be %NULL.  See
     * g_action_group_get_action_parameter_type().
     *
     * If the #GActionGroup implementation supports asynchronous remote
     * activation over D-Bus, this call may return before the relevant
     * D-Bus traffic has been sent, or any replies have been received. In
     * order to block on such asynchronous activation calls,
     * g_dbus_connection_flush() should be called prior to the code, which
     * depends on the result of the action activation. Without flushing
     * the D-Bus connection, there is no guarantee that the action would
     * have been activated.
     *
     * The following code which runs in a remote app instance, shows an
     * example of a "quit" action being activated on the primary app
     * instance over D-Bus. Here g_dbus_connection_flush() is called
     * before `exit()`. Without g_dbus_connection_flush(), the "quit" action
     * may fail to be activated on the primary instance.
     *
     *
     * ```c
     * // call "quit" action on primary instance
     * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
     *
     * // make sure the action is activated now
     * g_dbus_connection_flush (...);
     *
     * g_debug ("application has been terminated. exiting.");
     *
     * exit (0);
     * ```
     *
     * @virtual
     * @param actionName the name of the action to activate
     * @param parameter parameters to the activation
     */
    activateAction(actionName: string, parameter: GLib.Variant | null): void
    /**
     * Request for the state of the named action within `action_group` to be
     * changed to `value`.
     *
     * The action must be stateful and `value` must be of the correct type.
     * See g_action_group_get_action_state_type().
     *
     * This call merely requests a change.  The action may refuse to change
     * its state or may change its state to something other than `value`.
     * See g_action_group_get_action_state_hint().
     *
     * If the `value` GVariant is floating, it is consumed.
     * @virtual
     * @param actionName the name of the action to request the change on
     * @param value the new state
     */
    changeActionState(actionName: string, value: GLib.Variant): void
    /**
     * Checks if the named action within `action_group` is currently enabled.
     *
     * An action must be enabled in order to be activated or in order to
     * have its state changed from outside callers.
     * @virtual
     * @param actionName the name of the action to query
     * @returns whether or not the action is currently enabled
     */
    getActionEnabled(actionName: string): boolean
    /**
     * Queries the type of the parameter that must be given when activating
     * the named action within `action_group`.
     *
     * When activating the action using g_action_group_activate_action(),
     * the #GVariant given to that function must be of the type returned
     * by this function.
     *
     * In the case that this function returns %NULL, you must not give any
     * #GVariant, but %NULL instead.
     *
     * The parameter type of a particular action will never change but it is
     * possible for an action to be removed and for a new action to be added
     * with the same name but a different parameter type.
     * @virtual
     * @param actionName the name of the action to query
     * @returns the parameter type
     */
    getActionParameterType(actionName: string): GLib.VariantType | null
    /**
     * Queries the current state of the named action within `action_group`.
     *
     * If the action is not stateful then %NULL will be returned.  If the
     * action is stateful then the type of the return value is the type
     * given by g_action_group_get_action_state_type().
     *
     * The return value (if non-%NULL) should be freed with
     * g_variant_unref() when it is no longer required.
     * @virtual
     * @param actionName the name of the action to query
     * @returns the current state of the action
     */
    getActionState(actionName: string): GLib.Variant | null
    /**
     * Requests a hint about the valid range of values for the state of the
     * named action within `action_group`.
     *
     * If %NULL is returned it either means that the action is not stateful
     * or that there is no hint about the valid range of values for the
     * state of the action.
     *
     * If a #GVariant array is returned then each item in the array is a
     * possible value for the state.  If a #GVariant pair (ie: two-tuple) is
     * returned then the tuple specifies the inclusive lower and upper bound
     * of valid values for the state.
     *
     * In any case, the information is merely a hint.  It may be possible to
     * have a state value outside of the hinted range and setting a value
     * within the range may fail.
     *
     * The return value (if non-%NULL) should be freed with
     * g_variant_unref() when it is no longer required.
     * @virtual
     * @param actionName the name of the action to query
     * @returns the state range hint
     */
    getActionStateHint(actionName: string): GLib.Variant | null
    /**
     * Queries the type of the state of the named action within
     * `action_group`.
     *
     * If the action is stateful then this function returns the
     * #GVariantType of the state.  All calls to
     * g_action_group_change_action_state() must give a #GVariant of this
     * type and g_action_group_get_action_state() will return a #GVariant
     * of the same type.
     *
     * If the action is not stateful then this function will return %NULL.
     * In that case, g_action_group_get_action_state() will return %NULL
     * and you must not call g_action_group_change_action_state().
     *
     * The state type of a particular action will never change but it is
     * possible for an action to be removed and for a new action to be added
     * with the same name but a different state type.
     * @virtual
     * @param actionName the name of the action to query
     * @returns the state type, if the action is stateful
     */
    getActionStateType(actionName: string): GLib.VariantType | null
    /**
     * Checks if the named action exists within `action_group`.
     * @virtual
     * @param actionName the name of the action to check for
     * @returns whether the named action exists
     */
    hasAction(actionName: string): boolean
    /**
     * Lists the actions contained within `action_group`.
     *
     * The caller is responsible for freeing the list with g_strfreev() when
     * it is no longer required.
     * @virtual
     * @returns a %NULL-terminated array of the names of the actions in the group
     */
    listActions(): string[]
    /**
     * Queries all aspects of the named action within an `action_group`.
     *
     * This function acquires the information available from
     * g_action_group_has_action(), g_action_group_get_action_enabled(),
     * g_action_group_get_action_parameter_type(),
     * g_action_group_get_action_state_type(),
     * g_action_group_get_action_state_hint() and
     * g_action_group_get_action_state() with a single function call.
     *
     * This provides two main benefits.
     *
     * The first is the improvement in efficiency that comes with not having
     * to perform repeated lookups of the action in order to discover
     * different things about it.  The second is that implementing
     * #GActionGroup can now be done by only overriding this one virtual
     * function.
     *
     * The interface provides a default implementation of this function that
     * calls the individual functions, as required, to fetch the
     * information.  The interface also provides default implementations of
     * those functions that call this function.  All implementations,
     * therefore, must override either this function or all of the others.
     *
     * If the action exists, %TRUE is returned and any of the requested
     * fields (as indicated by having a non-%NULL reference passed in) are
     * filled.  If the action doesn't exist, %FALSE is returned and the
     * fields may or may not have been modified.
     * @virtual
     * @param actionName the name of an action in the group
     * @returns %TRUE if the action exists, else %FALSE
     */
    queryAction(
      actionName: string
    ): [
      /* returnType */ boolean,
      /* enabled */ boolean,
      /* parameterType */ GLib.VariantType,
      /* stateType */ GLib.VariantType,
      /* stateHint */ GLib.Variant,
      /* state */ GLib.Variant,
    ]

    // Own signals of Gio-2.0.Gio.ActionGroup

    connect(
      sigName: "action-added",
      callback: ActionGroup.ActionAddedSignalCallback
    ): number
    on(
      sigName: "action-added",
      callback: ActionGroup.ActionAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "action-added",
      callback: ActionGroup.ActionAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "action-added",
      callback: ActionGroup.ActionAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "action-added", ...args: any[]): void
    connect(
      sigName: "action-enabled-changed",
      callback: ActionGroup.ActionEnabledChangedSignalCallback
    ): number
    on(
      sigName: "action-enabled-changed",
      callback: ActionGroup.ActionEnabledChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "action-enabled-changed",
      callback: ActionGroup.ActionEnabledChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "action-enabled-changed",
      callback: ActionGroup.ActionEnabledChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "action-enabled-changed",
      enabled: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "action-removed",
      callback: ActionGroup.ActionRemovedSignalCallback
    ): number
    on(
      sigName: "action-removed",
      callback: ActionGroup.ActionRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "action-removed",
      callback: ActionGroup.ActionRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "action-removed",
      callback: ActionGroup.ActionRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "action-removed", ...args: any[]): void
    connect(
      sigName: "action-state-changed",
      callback: ActionGroup.ActionStateChangedSignalCallback
    ): number
    on(
      sigName: "action-state-changed",
      callback: ActionGroup.ActionStateChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "action-state-changed",
      callback: ActionGroup.ActionStateChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "action-state-changed",
      callback: ActionGroup.ActionStateChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "action-state-changed",
      value: GLib.Variant,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.ActionGroup

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GActionGroup` represents a group of actions.
   *
   * Actions can be used to expose functionality in a structured way, either
   * from one part of a program to another, or to the outside world. Action
   * groups are often used together with a `GMenuModel` that provides additional
   * representation data for displaying the actions to the user, e.g. in a menu.
   *
   * The main way to interact with the actions in a `GActionGroup` is to
   * activate them with [method`Gio`.ActionGroup.activate_action]. Activating an
   * action may require a `GVariant` parameter. The required type of the
   * parameter can be inquired with [method`Gio`.ActionGroup.get_action_parameter_type].
   * Actions may be disabled, see [method`Gio`.ActionGroup.get_action_enabled].
   * Activating a disabled action has no effect.
   *
   * Actions may optionally have a state in the form of a #GVariant. The current
   * state of an action can be inquired with [method`Gio`.ActionGroup.get_action_state].
   * Activating a stateful action may change its state, but it is also possible to
   * set the state by calling [method`Gio`.ActionGroup.change_action_state].
   *
   * As typical example, consider a text editing application which has an
   * option to change the current font to 'bold'. A good way to represent
   * this would be a stateful action, with a boolean state. Activating the
   * action would toggle the state.
   *
   * Each action in the group has a unique name (which is a string).  All
   * method calls, except [method`Gio`.ActionGroup.list_actions] take the name of
   * an action as an argument.
   *
   * The `GActionGroup` API is meant to be the 'public' API to the action
   * group. The calls here are exactly the interaction that 'external
   * forces' (eg: UI, incoming D-Bus messages, etc.) are supposed to have
   * with actions. 'Internal' APIs (ie: ones meant only to be accessed by
   * the action group implementation) are found on subclasses. This is
   * why you will find - for example - [method`Gio`.ActionGroup.get_action_enabled]
   * but not an equivalent set() call.
   *
   * Signals are emitted on the action group in response to state changes
   * on individual actions.
   *
   * Implementations of `GActionGroup` should provide implementations for
   * the virtual functions [method`Gio`.ActionGroup.list_actions] and
   * [method`Gio`.ActionGroup.query_action]. The other virtual functions should
   * not be implemented - their "wrappers" are actually implemented with
   * calls to [method`Gio`.ActionGroup.query_action].
   * @interface
   */
  class ActionGroup extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ActionGroup

    static name: string

    // Constructors of Gio-2.0.Gio.ActionGroup

    constructor(config?: ActionGroup.ConstructorProperties)
    _init(config?: ActionGroup.ConstructorProperties): void
  }

  module ActionMap {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ActionMap {
    // Own properties of Gio-2.0.Gio.ActionMap

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ActionMap

    // Has conflict: addAction(action: Action): void
    /**
     * A convenience function for creating multiple #GSimpleAction instances
     * and adding them to a #GActionMap.
     *
     * Each action is constructed as per one #GActionEntry.
     *
     *
     * ```c
     * static void
     * activate_quit (GSimpleAction *simple,
     *                GVariant      *parameter,
     *                gpointer       user_data)
     * {
     *   exit (0);
     * }
     *
     * static void
     * activate_print_string (GSimpleAction *simple,
     *                        GVariant      *parameter,
     *                        gpointer       user_data)
     * {
     *   g_print ("%s\n", g_variant_get_string (parameter, NULL));
     * }
     *
     * static GActionGroup *
     * create_action_group (void)
     * {
     *   const GActionEntry entries[] = {
     *     { "quit",         activate_quit              },
     *     { "print-string", activate_print_string, "s" }
     *   };
     *   GSimpleActionGroup *group;
     *
     *   group = g_simple_action_group_new ();
     *   g_action_map_add_action_entries (G_ACTION_MAP (group), entries, G_N_ELEMENTS (entries), NULL);
     *
     *   return G_ACTION_GROUP (group);
     * }
     * ```
     *
     * @param entries a pointer to           the first item in an array of #GActionEntry structs
     * @param userData the user data for signal connections
     */
    addActionEntries(entries: ActionEntry[], userData: any | null): void
    // Has conflict: lookupAction(actionName: string): Action | null
    // Has conflict: removeAction(actionName: string): void
    /**
     * Remove actions from a #GActionMap. This is meant as the reverse of
     * g_action_map_add_action_entries().
     *
     *
     *
     * ```c
     * static const GActionEntry entries[] = {
     *     { "quit",         activate_quit              },
     *     { "print-string", activate_print_string, "s" }
     * };
     *
     * void
     * add_actions (GActionMap *map)
     * {
     *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
     * }
     *
     * void
     * remove_actions (GActionMap *map)
     * {
     *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
     * }
     * ```
     *
     * @param entries a pointer to           the first item in an array of #GActionEntry structs
     */
    removeActionEntries(entries: ActionEntry[]): void

    // Own virtual methods of Gio-2.0.Gio.ActionMap

    /**
     * Adds an action to the `action_map`.
     *
     * If the action map already contains an action with the same name
     * as `action` then the old action is dropped from the action map.
     *
     * The action map takes its own reference on `action`.
     * @virtual
     * @param action a #GAction
     */
    addAction(action: Action): void
    /**
     * Looks up the action with the name `action_name` in `action_map`.
     *
     * If no such action exists, returns %NULL.
     * @virtual
     * @param actionName the name of an action
     * @returns a #GAction, or %NULL
     */
    lookupAction(actionName: string): Action | null
    /**
     * Removes the named action from the action map.
     *
     * If no action of this name is in the map then nothing happens.
     * @virtual
     * @param actionName the name of the action
     */
    removeAction(actionName: string): void

    // Class property signals of Gio-2.0.Gio.ActionMap

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GActionMap` is an interface for action containers.
   *
   * The `GActionMap` interface is implemented by [iface`Gio`.ActionGroup]
   * implementations that operate by containing a number of named
   * [iface`Gio`.Action] instances, such as [class`Gio`.SimpleActionGroup].
   *
   * One useful application of this interface is to map the
   * names of actions from various action groups to unique,
   * prefixed names (e.g. by prepending "app." or "win.").
   * This is the motivation for the 'Map' part of the interface
   * name.
   * @interface
   */
  class ActionMap extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ActionMap

    static name: string

    // Constructors of Gio-2.0.Gio.ActionMap

    constructor(config?: ActionMap.ConstructorProperties)
    _init(config?: ActionMap.ConstructorProperties): void
  }

  module AppInfo {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface AppInfo {
    // Own properties of Gio-2.0.Gio.AppInfo

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.AppInfo

    // Has conflict: addSupportsType(contentType: string): boolean
    // Has conflict: canDelete(): boolean
    // Has conflict: canRemoveSupportsType(): boolean
    /**
     * Tries to delete a #GAppInfo.
     *
     * On some platforms, there may be a difference between user-defined
     * #GAppInfos which can be deleted, and system-wide ones which cannot.
     * See g_app_info_can_delete().
     * @returns %TRUE if @appinfo has been deleted
     */
    delete(): boolean
    // Has conflict: dup(): AppInfo
    // Has conflict: equal(appinfo2: AppInfo): boolean
    // Has conflict: getCommandline(): string | null
    // Has conflict: getDescription(): string | null
    // Has conflict: getDisplayName(): string
    // Has conflict: getExecutable(): string
    // Has conflict: getIcon(): Icon | null
    // Has conflict: getId(): string | null
    // Has conflict: getName(): string
    // Has conflict: getSupportedTypes(): string[]
    // Has conflict: launch(files: File[] | null, context: AppLaunchContext | null): boolean
    // Has conflict: launchUris(uris: string[] | null, context: AppLaunchContext | null): boolean
    // Has conflict: launchUrisAsync(uris: string[] | null, context: AppLaunchContext | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: launchUrisFinish(result: AsyncResult): boolean
    // Has conflict: removeSupportsType(contentType: string): boolean
    // Has conflict: setAsDefaultForExtension(extension: string): boolean
    // Has conflict: setAsDefaultForType(contentType: string): boolean
    // Has conflict: setAsLastUsedForType(contentType: string): boolean
    // Has conflict: shouldShow(): boolean
    // Has conflict: supportsFiles(): boolean
    // Has conflict: supportsUris(): boolean

    // Own virtual methods of Gio-2.0.Gio.AppInfo

    /**
     * Adds a content type to the application information to indicate the
     * application is capable of opening files with the given content type.
     * @virtual
     * @param contentType a string.
     * @returns %TRUE on success, %FALSE on error.
     */
    addSupportsType(contentType: string): boolean
    /**
     * Obtains the information whether the #GAppInfo can be deleted.
     * See g_app_info_delete().
     * @virtual
     * @returns %TRUE if @appinfo can be deleted
     */
    canDelete(): boolean
    /**
     * Checks if a supported content type can be removed from an application.
     * @virtual
     * @returns %TRUE if it is possible to remove supported     content types from a given @appinfo, %FALSE if not.
     */
    canRemoveSupportsType(): boolean
    /**
     * Tries to delete a #GAppInfo.
     *
     * On some platforms, there may be a difference between user-defined
     * #GAppInfos which can be deleted, and system-wide ones which cannot.
     * See g_app_info_can_delete().
     * @virtual
     * @returns %TRUE if @appinfo has been deleted
     */
    doDelete(): boolean
    /**
     * Creates a duplicate of a #GAppInfo.
     * @virtual
     * @returns a duplicate of @appinfo.
     */
    dup(): AppInfo
    /**
     * Checks if two #GAppInfos are equal.
     *
     * Note that the check *may not* compare each individual
     * field, and only does an identity check. In case detecting changes in the
     * contents is needed, program code must additionally compare relevant fields.
     * @virtual
     * @param appinfo2 the second #GAppInfo.
     * @returns %TRUE if @appinfo1 is equal to @appinfo2. %FALSE otherwise.
     */
    equal(appinfo2: AppInfo): boolean
    /**
     * Gets the commandline with which the application will be
     * started.
     * @virtual
     * @returns a string containing the @appinfo's commandline,     or %NULL if this information is not available
     */
    getCommandline(): string | null
    /**
     * Gets a human-readable description of an installed application.
     * @virtual
     * @returns a string containing a description of the application @appinfo, or %NULL if none.
     */
    getDescription(): string | null
    /**
     * Gets the display name of the application. The display name is often more
     * descriptive to the user than the name itself.
     * @virtual
     * @returns the display name of the application for @appinfo, or the name if no display name is available.
     */
    getDisplayName(): string
    /**
     * Gets the executable's name for the installed application.
     *
     * This is intended to be used for debugging or labelling what program is going
     * to be run. To launch the executable, use g_app_info_launch() and related
     * functions, rather than spawning the return value from this function.
     * @virtual
     * @returns a string containing the @appinfo's application binaries name
     */
    getExecutable(): string
    /**
     * Gets the icon for the application.
     * @virtual
     * @returns the default #GIcon for @appinfo or %NULL if there is no default icon.
     */
    getIcon(): Icon | null
    /**
     * Gets the ID of an application. An id is a string that
     * identifies the application. The exact format of the id is
     * platform dependent. For instance, on Unix this is the
     * desktop file id from the xdg menu specification.
     *
     * Note that the returned ID may be %NULL, depending on how
     * the `appinfo` has been constructed.
     * @virtual
     * @returns a string containing the application's ID.
     */
    getId(): string | null
    /**
     * Gets the installed name of the application.
     * @virtual
     * @returns the name of the application for @appinfo.
     */
    getName(): string
    /**
     * Retrieves the list of content types that `app_info` claims to support.
     * If this information is not provided by the environment, this function
     * will return %NULL.
     * This function does not take in consideration associations added with
     * g_app_info_add_supports_type(), but only those exported directly by
     * the application.
     * @virtual
     * @returns a list of content types.
     */
    getSupportedTypes(): string[]
    /**
     * Launches the application. Passes `files` to the launched application
     * as arguments, using the optional `context` to get information
     * about the details of the launcher (like what screen it is on).
     * On error, `error` will be set accordingly.
     *
     * To launch the application without arguments pass a %NULL `files` list.
     *
     * Note that even if the launch is successful the application launched
     * can fail to start if it runs into problems during startup. There is
     * no way to detect this.
     *
     * Some URIs can be changed when passed through a GFile (for instance
     * unsupported URIs with strange formats like mailto:), so if you have
     * a textual URI you want to pass in as argument, consider using
     * g_app_info_launch_uris() instead.
     *
     * The launched application inherits the environment of the launching
     * process, but it can be modified with g_app_launch_context_setenv()
     * and g_app_launch_context_unsetenv().
     *
     * On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
     * environment variable with the path of the launched desktop file and
     * `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
     * process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
     * should it be inherited by further processes. The `DISPLAY`,
     * `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
     * variables are also set, based on information provided in `context`.
     * @virtual
     * @param files a #GList of #GFile objects
     * @param context a #GAppLaunchContext or %NULL
     * @returns %TRUE on successful launch, %FALSE otherwise.
     */
    launch(files: File[] | null, context: AppLaunchContext | null): boolean
    /**
     * Launches the application. This passes the `uris` to the launched application
     * as arguments, using the optional `context` to get information
     * about the details of the launcher (like what screen it is on).
     * On error, `error` will be set accordingly. If the application only supports
     * one URI per invocation as part of their command-line, multiple instances
     * of the application will be spawned.
     *
     * To launch the application without arguments pass a %NULL `uris` list.
     *
     * Note that even if the launch is successful the application launched
     * can fail to start if it runs into problems during startup. There is
     * no way to detect this.
     * @virtual
     * @param uris a #GList containing URIs to launch.
     * @param context a #GAppLaunchContext or %NULL
     * @returns %TRUE on successful launch, %FALSE otherwise.
     */
    launchUris(uris: string[] | null, context: AppLaunchContext | null): boolean
    /**
     * Async version of g_app_info_launch_uris().
     *
     * The `callback` is invoked immediately after the application launch, but it
     * waits for activation in case of D-Bus–activated applications and also provides
     * extended error information for sandboxed applications, see notes for
     * g_app_info_launch_default_for_uri_async().
     * @virtual
     * @param uris a #GList containing URIs to launch.
     * @param context a #GAppLaunchContext or %NULL
     * @param cancellable a #GCancellable
     * @param callback a #GAsyncReadyCallback to call when the request is done
     */
    launchUrisAsync(
      uris: string[] | null,
      context: AppLaunchContext | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a g_app_info_launch_uris_async() operation.
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE on successful launch, %FALSE otherwise.
     */
    launchUrisFinish(result: AsyncResult): boolean
    /**
     * Removes a supported type from an application, if possible.
     * @virtual
     * @param contentType a string.
     * @returns %TRUE on success, %FALSE on error.
     */
    removeSupportsType(contentType: string): boolean
    /**
     * Sets the application as the default handler for the given file extension.
     * @virtual
     * @param extension a string containing the file extension     (without the dot).
     * @returns %TRUE on success, %FALSE on error.
     */
    setAsDefaultForExtension(extension: string): boolean
    /**
     * Sets the application as the default handler for a given type.
     * @virtual
     * @param contentType the content type.
     * @returns %TRUE on success, %FALSE on error.
     */
    setAsDefaultForType(contentType: string): boolean
    /**
     * Sets the application as the last used application for a given type.
     * This will make the application appear as first in the list returned
     * by g_app_info_get_recommended_for_type(), regardless of the default
     * application for that content type.
     * @virtual
     * @param contentType the content type.
     * @returns %TRUE on success, %FALSE on error.
     */
    setAsLastUsedForType(contentType: string): boolean
    /**
     * Checks if the application info should be shown in menus that
     * list available applications.
     * @virtual
     * @returns %TRUE if the @appinfo should be shown, %FALSE otherwise.
     */
    shouldShow(): boolean
    /**
     * Checks if the application accepts files as arguments.
     * @virtual
     * @returns %TRUE if the @appinfo supports files.
     */
    supportsFiles(): boolean
    /**
     * Checks if the application supports reading files and directories from URIs.
     * @virtual
     * @returns %TRUE if the @appinfo supports URIs.
     */
    supportsUris(): boolean

    // Class property signals of Gio-2.0.Gio.AppInfo

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Information about an installed application and methods to launch
   * it (with file arguments).
   *
   * `GAppInfo` and `GAppLaunchContext` are used for describing and launching
   * applications installed on the system.
   *
   * As of GLib 2.20, URIs will always be converted to POSIX paths
   * (using [method`Gio`.File.get_path]) when using [method`Gio`.AppInfo.launch]
   * even if the application requested an URI and not a POSIX path. For example
   * for a desktop-file based application with Exec key `totem
   * %U` and a single URI, `sftp://foo/file.avi`, then
   * `/home/user/.gvfs/sftp on foo/file.avi` will be passed. This will
   * only work if a set of suitable GIO extensions (such as GVfs 2.26
   * compiled with FUSE support), is available and operational; if this
   * is not the case, the URI will be passed unmodified to the application.
   * Some URIs, such as `mailto:`, of course cannot be mapped to a POSIX
   * path (in GVfs there's no FUSE mount for it); such URIs will be
   * passed unmodified to the application.
   *
   * Specifically for GVfs 2.26 and later, the POSIX URI will be mapped
   * back to the GIO URI in the [iface`Gio`.File] constructors (since GVfs
   * implements the GVfs extension point). As such, if the application
   * needs to examine the URI, it needs to use [method`Gio`.File.get_uri]
   * or similar on [iface`Gio`.File]. In other words, an application cannot
   * assume that the URI passed to e.g. [func`Gio`.File.new_for_commandline_arg]
   * is equal to the result of [method`Gio`.File.get_uri]. The following snippet
   * illustrates this:
   *
   * ```c
   * GFile *f;
   * char *uri;
   *
   * file = g_file_new_for_commandline_arg (uri_from_commandline);
   *
   * uri = g_file_get_uri (file);
   * strcmp (uri, uri_from_commandline) == 0;
   * g_free (uri);
   *
   * if (g_file_has_uri_scheme (file, "cdda"))
   *   {
   *     // do something special with uri
   *   }
   * g_object_unref (file);
   * ```
   *
   * This code will work when both `cdda://sr0/Track 1.wav` and
   * `/home/user/.gvfs/cdda on sr0/Track 1.wav` is passed to the
   * application. It should be noted that it's generally not safe
   * for applications to rely on the format of a particular URIs.
   * Different launcher applications (e.g. file managers) may have
   * different ideas of what a given URI means.
   * @interface
   */
  class AppInfo extends GObject.Object {
    // Own properties of Gio-2.0.Gio.AppInfo

    static name: string

    // Constructors of Gio-2.0.Gio.AppInfo

    constructor(config?: AppInfo.ConstructorProperties)
    _init(config?: AppInfo.ConstructorProperties): void
    /**
     * Creates a new #GAppInfo from the given information.
     *
     * Note that for `commandline,` the quoting rules of the Exec key of the
     * [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
     * are applied. For example, if the `commandline` contains
     * percent-encoded URIs, the percent-character must be doubled in order to prevent it from
     * being swallowed by Exec key unquoting. See the specification for exact quoting rules.
     * @param commandline the commandline to use
     * @param applicationName the application name, or %NULL to use `commandline`
     * @param flags flags that can specify details of the created #GAppInfo
     * @returns new #GAppInfo for given command.
     */
    static createFromCommandline(
      commandline: string,
      applicationName: string | null,
      flags: AppInfoCreateFlags
    ): AppInfo
    /**
     * Gets a list of all of the applications currently registered
     * on this system.
     *
     * For desktop files, this includes applications that have
     * `NoDisplay=true` set or are excluded from display by means
     * of `OnlyShowIn` or `NotShowIn`. See g_app_info_should_show().
     * The returned list does not include applications which have
     * the `Hidden` key set.
     * @returns a newly allocated #GList of references to #GAppInfos.
     */
    static getAll(): AppInfo[]
    /**
     * Gets a list of all #GAppInfos for a given content type,
     * including the recommended and fallback #GAppInfos. See
     * g_app_info_get_recommended_for_type() and
     * g_app_info_get_fallback_for_type().
     * @param contentType the content type to find a #GAppInfo for
     * @returns #GList of #GAppInfos     for given @content_type or %NULL on error.
     */
    static getAllForType(contentType: string): AppInfo[]
    /**
     * Gets the default #GAppInfo for a given content type.
     * @param contentType the content type to find a #GAppInfo for
     * @param mustSupportUris if %TRUE, the #GAppInfo is expected to     support URIs
     * @returns #GAppInfo for given @content_type or     %NULL on error.
     */
    static getDefaultForType(
      contentType: string,
      mustSupportUris: boolean
    ): AppInfo | null
    /**
     * Asynchronously gets the default #GAppInfo for a given content type.
     * @param contentType the content type to find a #GAppInfo for
     * @param mustSupportUris if %TRUE, the #GAppInfo is expected to     support URIs
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is done
     */
    static getDefaultForTypeAsync(
      contentType: string,
      mustSupportUris: boolean,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a default #GAppInfo lookup started by
     * g_app_info_get_default_for_type_async().
     *
     * If no #GAppInfo is found, then `error` will be set to %G_IO_ERROR_NOT_FOUND.
     * @param result a #GAsyncResult
     * @returns #GAppInfo for given @content_type or     %NULL on error.
     */
    static getDefaultForTypeFinish(result: AsyncResult): AppInfo
    /**
     * Gets the default application for handling URIs with
     * the given URI scheme. A URI scheme is the initial part
     * of the URI, up to but not including the ':', e.g. "http",
     * "ftp" or "sip".
     * @param uriScheme a string containing a URI scheme.
     * @returns #GAppInfo for given @uri_scheme or     %NULL on error.
     */
    static getDefaultForUriScheme(uriScheme: string): AppInfo | null
    /**
     * Asynchronously gets the default application for handling URIs with
     * the given URI scheme. A URI scheme is the initial part
     * of the URI, up to but not including the ':', e.g. "http",
     * "ftp" or "sip".
     * @param uriScheme a string containing a URI scheme.
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is done
     */
    static getDefaultForUriSchemeAsync(
      uriScheme: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a default #GAppInfo lookup started by
     * g_app_info_get_default_for_uri_scheme_async().
     *
     * If no #GAppInfo is found, then `error` will be set to %G_IO_ERROR_NOT_FOUND.
     * @param result a #GAsyncResult
     * @returns #GAppInfo for given @uri_scheme or     %NULL on error.
     */
    static getDefaultForUriSchemeFinish(result: AsyncResult): AppInfo
    /**
     * Gets a list of fallback #GAppInfos for a given content type, i.e.
     * those applications which claim to support the given content type
     * by MIME type subclassing and not directly.
     * @param contentType the content type to find a #GAppInfo for
     * @returns #GList of #GAppInfos     for given @content_type or %NULL on error.
     */
    static getFallbackForType(contentType: string): AppInfo[]
    /**
     * Gets a list of recommended #GAppInfos for a given content type, i.e.
     * those applications which claim to support the given content type exactly,
     * and not by MIME type subclassing.
     * Note that the first application of the list is the last used one, i.e.
     * the last one for which g_app_info_set_as_last_used_for_type() has been
     * called.
     * @param contentType the content type to find a #GAppInfo for
     * @returns #GList of #GAppInfos     for given @content_type or %NULL on error.
     */
    static getRecommendedForType(contentType: string): AppInfo[]
    /**
     * Utility function that launches the default application
     * registered to handle the specified uri. Synchronous I/O
     * is done on the uri to detect the type of the file if
     * required.
     *
     * The D-Bus–activated applications don't have to be started if your application
     * terminates too soon after this function. To prevent this, use
     * g_app_info_launch_default_for_uri_async() instead.
     * @param uri the uri to show
     * @param context an optional #GAppLaunchContext
     * @returns %TRUE on success, %FALSE on error.
     */
    static launchDefaultForUri(
      uri: string,
      context: AppLaunchContext | null
    ): boolean
    /**
     * Async version of g_app_info_launch_default_for_uri().
     *
     * This version is useful if you are interested in receiving
     * error information in the case where the application is
     * sandboxed and the portal may present an application chooser
     * dialog to the user.
     *
     * This is also useful if you want to be sure that the D-Bus–activated
     * applications are really started before termination and if you are interested
     * in receiving error information from their activation.
     * @param uri the uri to show
     * @param context an optional #GAppLaunchContext
     * @param cancellable a #GCancellable
     * @param callback a #GAsyncReadyCallback to call when the request is done
     */
    static launchDefaultForUriAsync(
      uri: string,
      context: AppLaunchContext | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous launch-default-for-uri operation.
     * @param result a #GAsyncResult
     * @returns %TRUE if the launch was successful, %FALSE if @error is set
     */
    static launchDefaultForUriFinish(result: AsyncResult): boolean
    /**
     * Removes all changes to the type associations done by
     * g_app_info_set_as_default_for_type(),
     * g_app_info_set_as_default_for_extension(),
     * g_app_info_add_supports_type() or
     * g_app_info_remove_supports_type().
     * @param contentType a content type
     */
    static resetTypeAssociations(contentType: string): void
  }

  module AsyncInitable {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface AsyncInitable {
    // Own properties of Gio-2.0.Gio.AsyncInitable

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.AsyncInitable

    // Has conflict: initAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: initFinish(res: AsyncResult): boolean
    /**
     * Finishes the async construction for the various g_async_initable_new
     * calls, returning the created object or %NULL on error.
     * @param res the #GAsyncResult from the callback
     * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
     */
    newFinish(res: AsyncResult): GObject.Object

    // Own virtual methods of Gio-2.0.Gio.AsyncInitable

    /**
     * Starts asynchronous initialization of the object implementing the
     * interface. This must be done before any real use of the object after
     * initial construction. If the object also implements #GInitable you can
     * optionally call g_initable_init() instead.
     *
     * This method is intended for language bindings. If writing in C,
     * g_async_initable_new_async() should typically be used instead.
     *
     * When the initialization is finished, `callback` will be called. You can
     * then call g_async_initable_init_finish() to get the result of the
     * initialization.
     *
     * Implementations may also support cancellation. If `cancellable` is not
     * %NULL, then initialization can be cancelled by triggering the cancellable
     * object from another thread. If the operation was cancelled, the error
     * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
     * the object doesn't support cancellable initialization, the error
     * %G_IO_ERROR_NOT_SUPPORTED will be returned.
     *
     * As with #GInitable, if the object is not initialized, or initialization
     * returns with an error, then all operations on the object except
     * g_object_ref() and g_object_unref() are considered to be invalid, and
     * have undefined behaviour. They will often fail with g_critical() or
     * g_warning(), but this must not be relied on.
     *
     * Callers should not assume that a class which implements #GAsyncInitable can
     * be initialized multiple times; for more information, see g_initable_init().
     * If a class explicitly supports being initialized multiple times,
     * implementation requires yielding all subsequent calls to init_async() on the
     * results of the first call.
     *
     * For classes that also support the #GInitable interface, the default
     * implementation of this method will run the g_initable_init() function
     * in a thread, so if you want to support asynchronous initialization via
     * threads, just implement the #GAsyncInitable interface without overriding
     * any interface methods.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the operation
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback to call when the request is satisfied
     */
    initAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes asynchronous initialization and returns the result.
     * See g_async_initable_init_async().
     * @virtual
     * @param res a #GAsyncResult.
     * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
     */
    initFinish(res: AsyncResult): boolean

    // Class property signals of Gio-2.0.Gio.AsyncInitable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GAsyncInitable` is an interface for asynchronously initializable objects.
   *
   * This is the asynchronous version of [iface`Gio`.Initable]; it behaves the same
   * in all ways except that initialization is asynchronous. For more details
   * see the descriptions on `GInitable`.
   *
   * A class may implement both the `GInitable` and `GAsyncInitable` interfaces.
   *
   * Users of objects implementing this are not intended to use the interface
   * method directly; instead it will be used automatically in various ways.
   * For C applications you generally just call [func`Gio`.AsyncInitable.new_async]
   * directly, or indirectly via a foo_thing_new_async() wrapper. This will call
   * [method`Gio`.AsyncInitable.init_async] under the covers, calling back with `NULL`
   * and a set `GError` on failure.
   *
   * A typical implementation might look something like this:
   *
   * ```c
   * enum {
   *    NOT_INITIALIZED,
   *    INITIALIZING,
   *    INITIALIZED
   * };
   *
   * static void
   * _foo_ready_cb (Foo *self)
   * {
   *   GList *l;
   *
   *   self->priv->state = INITIALIZED;
   *
   *   for (l = self->priv->init_results; l != NULL; l = l->next)
   *     {
   *       GTask *task = l->data;
   *
   *       if (self->priv->success)
   *         g_task_return_boolean (task, TRUE);
   *       else
   *         g_task_return_new_error (task, ...);
   *       g_object_unref (task);
   *     }
   *
   *   g_list_free (self->priv->init_results);
   *   self->priv->init_results = NULL;
   * }
   *
   * static void
   * foo_init_async (GAsyncInitable       *initable,
   *                 int                   io_priority,
   *                 GCancellable         *cancellable,
   *                 GAsyncReadyCallback   callback,
   *                 gpointer              user_data)
   * {
   *   Foo *self = FOO (initable);
   *   GTask *task;
   *
   *   task = g_task_new (initable, cancellable, callback, user_data);
   *   g_task_set_name (task, G_STRFUNC);
   *
   *   switch (self->priv->state)
   *     {
   *       case NOT_INITIALIZED:
   *         _foo_get_ready (self);
   *         self->priv->init_results = g_list_append (self->priv->init_results,
   *                                                   task);
   *         self->priv->state = INITIALIZING;
   *         break;
   *       case INITIALIZING:
   *         self->priv->init_results = g_list_append (self->priv->init_results,
   *                                                   task);
   *         break;
   *       case INITIALIZED:
   *         if (!self->priv->success)
   *           g_task_return_new_error (task, ...);
   *         else
   *           g_task_return_boolean (task, TRUE);
   *         g_object_unref (task);
   *         break;
   *     }
   * }
   *
   * static gboolean
   * foo_init_finish (GAsyncInitable       *initable,
   *                  GAsyncResult         *result,
   *                  GError              **error)
   * {
   *   g_return_val_if_fail (g_task_is_valid (result, initable), FALSE);
   *
   *   return g_task_propagate_boolean (G_TASK (result), error);
   * }
   *
   * static void
   * foo_async_initable_iface_init (gpointer g_iface,
   *                                gpointer data)
   * {
   *   GAsyncInitableIface *iface = g_iface;
   *
   *   iface->init_async = foo_init_async;
   *   iface->init_finish = foo_init_finish;
   * }
   * ```
   * @interface
   */
  class AsyncInitable extends GObject.Object {
    // Own properties of Gio-2.0.Gio.AsyncInitable

    static name: string

    // Constructors of Gio-2.0.Gio.AsyncInitable

    constructor(config?: AsyncInitable.ConstructorProperties)
    _init(config?: AsyncInitable.ConstructorProperties): void
    /**
     * Helper function for constructing #GAsyncInitable object. This is
     * similar to g_object_newv() but also initializes the object asynchronously.
     *
     * When the initialization is finished, `callback` will be called. You can
     * then call g_async_initable_new_finish() to get the new object and check
     * for any errors.
     * @param objectType a #GType supporting #GAsyncInitable.
     * @param nParameters the number of parameters in `parameters`
     * @param parameters the parameters to use to construct the object
     * @param ioPriority the [I/O priority][io-priority] of the operation
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback to call when the initialization is     finished
     */
    static newvAsync(
      objectType: GObject.GType,
      nParameters: number,
      parameters: GObject.Parameter,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
  }

  module AsyncResult {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface AsyncResult {
    // Own properties of Gio-2.0.Gio.AsyncResult

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.AsyncResult

    // Has conflict: getSourceObject(): GObject.Object | null
    // Has conflict: getUserData(): any | null
    // Has conflict: isTagged(sourceTag: any | null): boolean
    /**
     * If `res` is a #GSimpleAsyncResult, this is equivalent to
     * g_simple_async_result_propagate_error(). Otherwise it returns
     * %FALSE.
     *
     * This can be used for legacy error handling in async *_finish()
     * wrapper functions that traditionally handled #GSimpleAsyncResult
     * error returns themselves rather than calling into the virtual method.
     * This should not be used in new code; #GAsyncResult errors that are
     * set by virtual methods should also be extracted by virtual methods,
     * to enable subclasses to chain up correctly.
     * @returns %TRUE if @error is has been filled in with an error from   @res, %FALSE if not.
     */
    legacyPropagateError(): boolean

    // Own virtual methods of Gio-2.0.Gio.AsyncResult

    /**
     * Gets the source object from a #GAsyncResult.
     * @virtual
     * @returns a new reference to the source    object for the @res, or %NULL if there is none.
     */
    getSourceObject(): GObject.Object | null
    /**
     * Gets the user data from a #GAsyncResult.
     * @virtual
     * @returns the user data for @res.
     */
    getUserData(): any | null
    /**
     * Checks if `res` has the given `source_tag` (generally a function
     * pointer indicating the function `res` was created by).
     * @virtual
     * @param sourceTag an application-defined tag
     * @returns %TRUE if @res has the indicated @source_tag, %FALSE if   not.
     */
    isTagged(sourceTag: any | null): boolean

    // Class property signals of Gio-2.0.Gio.AsyncResult

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GAsyncResult` provides a base class for implementing asynchronous function results.
   *
   * Asynchronous operations are broken up into two separate operations
   * which are chained together by a `GAsyncReadyCallback`. To begin
   * an asynchronous operation, provide a `GAsyncReadyCallback` to the
   * asynchronous function. This callback will be triggered when the
   * operation has completed, and must be run in a later iteration of
   * the thread-default main context (see
   * [method`GLib`.MainContext.push_thread_default]) from where the operation was
   * initiated. It will be passed a `GAsyncResult` instance filled with the
   * details of the operation's success or failure, the object the asynchronous
   * function was started for and any error codes returned. The asynchronous
   * callback function is then expected to call the corresponding `_finish()`
   * function, passing the object the function was called for, the
   * `GAsyncResult` instance, and (optionally) an `error` to grab any
   * error conditions that may have occurred.
   *
   * The `_finish()` function for an operation takes the generic result
   * (of type `GAsyncResult`) and returns the specific result that the
   * operation in question yields (e.g. a [class`Gio`.FileEnumerator] for a
   * "enumerate children" operation). If the result or error status of the
   * operation is not needed, there is no need to call the `_finish()`
   * function; GIO will take care of cleaning up the result and error
   * information after the `GAsyncReadyCallback` returns. You can pass
   * `NULL` for the `GAsyncReadyCallback` if you don't need to take any
   * action at all after the operation completes. Applications may also
   * take a reference to the `GAsyncResult` and call `_finish()` later;
   * however, the `_finish()` function may be called at most once.
   *
   * Example of a typical asynchronous operation flow:
   *
   * ```c
   * void _theoretical_frobnitz_async (Theoretical         *t,
   *                                   GCancellable        *c,
   *                                   GAsyncReadyCallback  cb,
   *                                   gpointer             u);
   *
   * gboolean _theoretical_frobnitz_finish (Theoretical   *t,
   *                                        GAsyncResult  *res,
   *                                        GError       **e);
   *
   * static void
   * frobnitz_result_func (GObject      *source_object,
   * 		 GAsyncResult *res,
   * 		 gpointer      user_data)
   * {
   *   gboolean success = FALSE;
   *
   *   success = _theoretical_frobnitz_finish (source_object, res, NULL);
   *
   *   if (success)
   *     g_printf ("Hurray!\n");
   *   else
   *     g_printf ("Uh oh!\n");
   *
   *   ...
   *
   * }
   *
   * int main (int argc, void *argv[])
   * {
   *    ...
   *
   *    _theoretical_frobnitz_async (theoretical_data,
   *                                 NULL,
   *                                 frobnitz_result_func,
   *                                 NULL);
   *
   *    ...
   * }
   * ```
   *
   * The callback for an asynchronous operation is called only once, and is
   * always called, even in the case of a cancelled operation. On cancellation
   * the result is a `G_IO_ERROR_CANCELLED` error.
   *
   * ## I/O Priority
   *
   * Many I/O-related asynchronous operations have a priority parameter,
   * which is used in certain cases to determine the order in which
   * operations are executed. They are not used to determine system-wide
   * I/O scheduling. Priorities are integers, with lower numbers indicating
   * higher priority. It is recommended to choose priorities between
   * `G_PRIORITY_LOW` and `G_PRIORITY_HIGH`, with `G_PRIORITY_DEFAULT`
   * as a default.
   * @interface
   */
  class AsyncResult extends GObject.Object {
    // Own properties of Gio-2.0.Gio.AsyncResult

    static name: string

    // Constructors of Gio-2.0.Gio.AsyncResult

    constructor(config?: AsyncResult.ConstructorProperties)
    _init(config?: AsyncResult.ConstructorProperties): void
  }

  module Converter {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Converter {
    // Own properties of Gio-2.0.Gio.Converter

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Converter

    // Has conflict: convert(inbuf: number[], outbuf: number[], flags: ConverterFlags): [ /* returnType */ ConverterResult, /* bytesRead */ number, /* bytesWritten */ number ]
    // Has conflict: reset(): void

    // Own virtual methods of Gio-2.0.Gio.Converter

    /**
     * This is the main operation used when converting data. It is to be called
     * multiple times in a loop, and each time it will do some work, i.e.
     * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
     * both. If its not possible to do any work an error is returned.
     *
     * Note that a single call may not consume all input (or any input at all).
     * Also a call may produce output even if given no input, due to state stored
     * in the converter producing output.
     *
     * If any data was either produced or consumed, and then an error happens, then
     * only the successful conversion is reported and the error is returned on the
     * next call.
     *
     * A full conversion loop involves calling this method repeatedly, each time
     * giving it new input and space output space. When there is no more input
     * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
     * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
     * each time until all data is consumed and all output is produced, then
     * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
     * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
     * in a decompression converter where the end of data is detectable from the
     * data (and there might even be other data after the end of the compressed data).
     *
     * When some data has successfully been converted `bytes_read` and is set to
     * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
     * how many bytes was written to `outbuf`. If there are more data to output
     * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
     * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
     * then %G_CONVERTER_FINISHED is returned.
     *
     * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
     * Some errors need special handling:
     *
     * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
     * to write the resulting converted data, the application should
     * call the function again with a larger `outbuf` to continue.
     *
     * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
     * input to fully determine what the conversion should produce,
     * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
     * example with an incomplete multibyte sequence when converting text,
     * or when a regexp matches up to the end of the input (and may match
     * further input). It may also happen when `inbuf_size` is zero and
     * there is no more data to produce.
     *
     * When this happens the application should read more input and then
     * call the function again. If further input shows that there is no
     * more data call the function again with the same data but with
     * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
     * to finish as e.g. in the regexp match case (or, to fail again with
     * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
     * input is actually partial).
     *
     * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
     * converter object is in an invalid state where its not allowed
     * to call g_converter_convert() anymore. At this time you can only
     * free the object or call g_converter_reset() to reset it to the
     * initial state.
     *
     * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
     * to try to write out all internal state to the output. The application
     * has to call the function multiple times with the flag set, and when
     * the available input has been consumed and all internal state has
     * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
     * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
     * This is somewhat similar to what happens at the end of the input stream,
     * but done in the middle of the data.
     *
     * This has different meanings for different conversions. For instance
     * in a compression converter it would mean that we flush all the
     * compression state into output such that if you uncompress the
     * compressed data you get back all the input data. Doing this may
     * make the final file larger due to padding though. Another example
     * is a regexp conversion, where if you at the end of the flushed data
     * have a match, but there is also a potential longer match. In the
     * non-flushed case we would ask for more input, but when flushing we
     * treat this as the end of input and do the match.
     *
     * Flushing is not always possible (like if a charset converter flushes
     * at a partial multibyte sequence). Converters are supposed to try
     * to produce as much output as possible and then return an error
     * (typically %G_IO_ERROR_PARTIAL_INPUT).
     * @virtual
     * @param inbuf the buffer         containing the data to convert.
     * @param outbuf a    buffer to write converted data in.
     * @param flags a #GConverterFlags controlling the conversion details
     * @returns a #GConverterResult, %G_CONVERTER_ERROR on error.
     */
    convert(
      inbuf: number[] | null,
      outbuf: number[],
      flags: ConverterFlags
    ): [
      /* returnType */ ConverterResult,
      /* bytesRead */ number,
      /* bytesWritten */ number,
    ]
    /**
     * Resets all internal state in the converter, making it behave
     * as if it was just created. If the converter has any internal
     * state that would produce output then that output is lost.
     * @virtual
     */
    reset(): void

    // Class property signals of Gio-2.0.Gio.Converter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GConverter` is an interface for streaming conversions.
   *
   * `GConverter` is implemented by objects that convert
   * binary data in various ways. The conversion can be
   * stateful and may fail at any place.
   *
   * Some example conversions are: character set conversion,
   * compression, decompression and regular expression
   * replace.
   * @interface
   */
  class Converter extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Converter

    static name: string

    // Constructors of Gio-2.0.Gio.Converter

    constructor(config?: Converter.ConstructorProperties)
    _init(config?: Converter.ConstructorProperties): void
  }

  module DBusInterface {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface DBusInterface {
    // Own properties of Gio-2.0.Gio.DBusInterface

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusInterface

    /**
     * Gets the #GDBusObject that `interface_` belongs to, if any.
     * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
     */
    getObject(): DBusObject | null
    // Has conflict: getInfo(): DBusInterfaceInfo
    // Has conflict: setObject(object: DBusObject | null): void

    // Own virtual methods of Gio-2.0.Gio.DBusInterface

    /**
     * Gets the #GDBusObject that `interface_` belongs to, if any.
     * @virtual
     * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
     */
    dupObject(): DBusObject | null
    /**
     * Gets D-Bus introspection information for the D-Bus interface
     * implemented by `interface_`.
     * @virtual
     * @returns A #GDBusInterfaceInfo. Do not free.
     */
    getInfo(): DBusInterfaceInfo
    /**
     * Sets the #GDBusObject for `interface_` to `object`.
     *
     * Note that `interface_` will hold a weak reference to `object`.
     * @virtual
     * @param object A #GDBusObject or %NULL.
     */
    setObject(object: DBusObject | null): void

    // Class property signals of Gio-2.0.Gio.DBusInterface

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Base type for D-Bus interfaces.
   *
   * The `GDBusInterface` type is the base type for D-Bus interfaces both
   * on the service side (see [class`Gio`.DBusInterfaceSkeleton]) and client side
   * (see [class`Gio`.DBusProxy]).
   * @interface
   */
  class DBusInterface extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusInterface

    static name: string

    // Constructors of Gio-2.0.Gio.DBusInterface

    constructor(config?: DBusInterface.ConstructorProperties)
    _init(config?: DBusInterface.ConstructorProperties): void
  }

  module DBusObject {
    // Signal callback interfaces

    /**
     * Signal callback interface for `interface-added`
     */
    interface InterfaceAddedSignalCallback {
      (interface: DBusInterface): void
    }

    /**
     * Signal callback interface for `interface-removed`
     */
    interface InterfaceRemovedSignalCallback {
      (interface: DBusInterface): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface DBusObject {
    // Own properties of Gio-2.0.Gio.DBusObject

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusObject

    // Has conflict: getInterface(interfaceName: string): DBusInterface | null
    // Has conflict: getInterfaces(): DBusInterface[]
    // Has conflict: getObjectPath(): string

    // Own virtual methods of Gio-2.0.Gio.DBusObject

    /**
     * Gets the D-Bus interface with name `interface_name` associated with
     * `object,` if any.
     * @virtual
     * @param interfaceName A D-Bus interface name.
     * @returns %NULL if not found, otherwise a   #GDBusInterface that must be freed with g_object_unref().
     */
    getInterface(interfaceName: string): DBusInterface | null
    /**
     * Gets the D-Bus interfaces associated with `object`.
     * @virtual
     * @returns A list of #GDBusInterface instances.   The returned list must be freed by g_list_free() after each element has been freed   with g_object_unref().
     */
    getInterfaces(): DBusInterface[]
    /**
     * Gets the object path for `object`.
     * @virtual
     * @returns A string owned by @object. Do not free.
     */
    getObjectPath(): string
    /**
     * Signal handler for the #GDBusObject::interface-added signal.
     * @virtual
     * @param interface
     */
    interfaceAdded(interface: DBusInterface): void
    /**
     * Signal handler for the #GDBusObject::interface-removed signal.
     * @virtual
     * @param interface
     */
    interfaceRemoved(interface: DBusInterface): void

    // Own signals of Gio-2.0.Gio.DBusObject

    connect(
      sigName: "interface-added",
      callback: DBusObject.InterfaceAddedSignalCallback
    ): number
    on(
      sigName: "interface-added",
      callback: DBusObject.InterfaceAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "interface-added",
      callback: DBusObject.InterfaceAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "interface-added",
      callback: DBusObject.InterfaceAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "interface-added", ...args: any[]): void
    connect(
      sigName: "interface-removed",
      callback: DBusObject.InterfaceRemovedSignalCallback
    ): number
    on(
      sigName: "interface-removed",
      callback: DBusObject.InterfaceRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "interface-removed",
      callback: DBusObject.InterfaceRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "interface-removed",
      callback: DBusObject.InterfaceRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "interface-removed", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.DBusObject

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GDBusObject` type is the base type for D-Bus objects on both
   * the service side (see [class`Gio`.DBusObjectSkeleton]) and the client side
   * (see [class`Gio`.DBusObjectProxy]). It is essentially just a container of
   * interfaces.
   * @interface
   */
  class DBusObject extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusObject

    static name: string

    // Constructors of Gio-2.0.Gio.DBusObject

    constructor(config?: DBusObject.ConstructorProperties)
    _init(config?: DBusObject.ConstructorProperties): void
  }

  module DBusObjectManager {
    // Signal callback interfaces

    /**
     * Signal callback interface for `interface-added`
     */
    interface InterfaceAddedSignalCallback {
      (object: DBusObject, interface: DBusInterface): void
    }

    /**
     * Signal callback interface for `interface-removed`
     */
    interface InterfaceRemovedSignalCallback {
      (object: DBusObject, interface: DBusInterface): void
    }

    /**
     * Signal callback interface for `object-added`
     */
    interface ObjectAddedSignalCallback {
      (object: DBusObject): void
    }

    /**
     * Signal callback interface for `object-removed`
     */
    interface ObjectRemovedSignalCallback {
      (object: DBusObject): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface DBusObjectManager {
    // Own properties of Gio-2.0.Gio.DBusObjectManager

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusObjectManager

    // Has conflict: getInterface(objectPath: string, interfaceName: string): DBusInterface | null
    // Has conflict: getObject(objectPath: string): DBusObject | null
    // Has conflict: getObjectPath(): string
    // Has conflict: getObjects(): DBusObject[]

    // Own virtual methods of Gio-2.0.Gio.DBusObjectManager

    /**
     * Gets the interface proxy for `interface_name` at `object_path,` if
     * any.
     * @virtual
     * @param objectPath Object path to look up.
     * @param interfaceName D-Bus interface name to look up.
     * @returns A #GDBusInterface instance or %NULL. Free   with g_object_unref().
     */
    getInterface(
      objectPath: string,
      interfaceName: string
    ): DBusInterface | null
    /**
     * Gets the #GDBusObject at `object_path,` if any.
     * @virtual
     * @param objectPath Object path to look up.
     * @returns A #GDBusObject or %NULL. Free with   g_object_unref().
     */
    getObject(objectPath: string): DBusObject | null
    /**
     * Gets the object path that `manager` is for.
     * @virtual
     * @returns A string owned by @manager. Do not free.
     */
    getObjectPath(): string
    /**
     * Gets all #GDBusObject objects known to `manager`.
     * @virtual
     * @returns A list of   #GDBusObject objects. The returned list should be freed with   g_list_free() after each element has been freed with   g_object_unref().
     */
    getObjects(): DBusObject[]
    /**
     * Signal handler for the #GDBusObjectManager::interface-added signal.
     * @virtual
     * @param object
     * @param interface
     */
    interfaceAdded(object: DBusObject, interface: DBusInterface): void
    /**
     * Signal handler for the #GDBusObjectManager::interface-removed signal.
     * @virtual
     * @param object
     * @param interface
     */
    interfaceRemoved(object: DBusObject, interface: DBusInterface): void
    /**
     * Signal handler for the #GDBusObjectManager::object-added signal.
     * @virtual
     * @param object
     */
    objectAdded(object: DBusObject): void
    /**
     * Signal handler for the #GDBusObjectManager::object-removed signal.
     * @virtual
     * @param object
     */
    objectRemoved(object: DBusObject): void

    // Own signals of Gio-2.0.Gio.DBusObjectManager

    connect(
      sigName: "interface-added",
      callback: DBusObjectManager.InterfaceAddedSignalCallback
    ): number
    on(
      sigName: "interface-added",
      callback: DBusObjectManager.InterfaceAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "interface-added",
      callback: DBusObjectManager.InterfaceAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "interface-added",
      callback: DBusObjectManager.InterfaceAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "interface-added",
      interface: DBusInterface,
      ...args: any[]
    ): void
    connect(
      sigName: "interface-removed",
      callback: DBusObjectManager.InterfaceRemovedSignalCallback
    ): number
    on(
      sigName: "interface-removed",
      callback: DBusObjectManager.InterfaceRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "interface-removed",
      callback: DBusObjectManager.InterfaceRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "interface-removed",
      callback: DBusObjectManager.InterfaceRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "interface-removed",
      interface: DBusInterface,
      ...args: any[]
    ): void
    connect(
      sigName: "object-added",
      callback: DBusObjectManager.ObjectAddedSignalCallback
    ): number
    on(
      sigName: "object-added",
      callback: DBusObjectManager.ObjectAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "object-added",
      callback: DBusObjectManager.ObjectAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "object-added",
      callback: DBusObjectManager.ObjectAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "object-added", ...args: any[]): void
    connect(
      sigName: "object-removed",
      callback: DBusObjectManager.ObjectRemovedSignalCallback
    ): number
    on(
      sigName: "object-removed",
      callback: DBusObjectManager.ObjectRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "object-removed",
      callback: DBusObjectManager.ObjectRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "object-removed",
      callback: DBusObjectManager.ObjectRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "object-removed", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.DBusObjectManager

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GDBusObjectManager` type is the base type for service- and
   * client-side implementations of the standardized
   * [`org.freedesktop.DBus.ObjectManager`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
   * interface.
   *
   * See [class`Gio`.DBusObjectManagerClient] for the client-side implementation
   * and [class`Gio`.DBusObjectManagerServer] for the service-side implementation.
   * @interface
   */
  class DBusObjectManager extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusObjectManager

    static name: string

    // Constructors of Gio-2.0.Gio.DBusObjectManager

    constructor(config?: DBusObjectManager.ConstructorProperties)
    _init(config?: DBusObjectManager.ConstructorProperties): void
  }

  module DatagramBased {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface DatagramBased {
    // Own properties of Gio-2.0.Gio.DatagramBased

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DatagramBased

    // Has conflict: conditionCheck(condition: GLib.IOCondition): GLib.IOCondition
    // Has conflict: conditionWait(condition: GLib.IOCondition, timeout: number, cancellable: Cancellable | null): boolean
    // Has conflict: createSource(condition: GLib.IOCondition, cancellable: Cancellable | null): GLib.Source
    // Has conflict: receiveMessages(messages: InputMessage[], flags: number, timeout: number, cancellable: Cancellable | null): number
    // Has conflict: sendMessages(messages: OutputMessage[], flags: number, timeout: number, cancellable: Cancellable | null): number

    // Own virtual methods of Gio-2.0.Gio.DatagramBased

    /**
     * Checks on the readiness of `datagram_based` to perform operations. The
     * operations specified in `condition` are checked for and masked against the
     * currently-satisfied conditions on `datagram_based`. The result is returned.
     *
     * %G_IO_IN will be set in the return value if data is available to read with
     * g_datagram_based_receive_messages(), or if the connection is closed remotely
     * (EOS); and if the datagram_based has not been closed locally using some
     * implementation-specific method (such as g_socket_close() or
     * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket).
     *
     * If the connection is shut down or closed (by calling g_socket_close() or
     * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
     * example), all calls to this function will return %G_IO_ERROR_CLOSED.
     *
     * %G_IO_OUT will be set if it is expected that at least one byte can be sent
     * using g_datagram_based_send_messages() without blocking. It will not be set
     * if the datagram_based has been closed locally.
     *
     * %G_IO_HUP will be set if the connection has been closed locally.
     *
     * %G_IO_ERR will be set if there was an asynchronous error in transmitting data
     * previously enqueued using g_datagram_based_send_messages().
     *
     * Note that on Windows, it is possible for an operation to return
     * %G_IO_ERROR_WOULD_BLOCK even immediately after
     * g_datagram_based_condition_check() has claimed that the #GDatagramBased is
     * ready for writing. Rather than calling g_datagram_based_condition_check() and
     * then writing to the #GDatagramBased if it succeeds, it is generally better to
     * simply try writing right away, and try again later if the initial attempt
     * returns %G_IO_ERROR_WOULD_BLOCK.
     *
     * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
     * conditions will always be set in the output if they are true. Apart from
     * these flags, the output is guaranteed to be masked by `condition`.
     *
     * This call never blocks.
     * @virtual
     * @param condition a #GIOCondition mask to check
     * @returns the #GIOCondition mask of the current state
     */
    conditionCheck(condition: GLib.IOCondition): GLib.IOCondition
    /**
     * Waits for up to `timeout` microseconds for condition to become true on
     * `datagram_based`. If the condition is met, %TRUE is returned.
     *
     * If `cancellable` is cancelled before the condition is met, or if `timeout` is
     * reached before the condition is met, then %FALSE is returned and `error` is
     * set appropriately (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT).
     * @virtual
     * @param condition a #GIOCondition mask to wait for
     * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
     * @param cancellable a #GCancellable
     * @returns %TRUE if the condition was met, %FALSE otherwise
     */
    conditionWait(
      condition: GLib.IOCondition,
      timeout: number,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Creates a #GSource that can be attached to a #GMainContext to monitor for
     * the availability of the specified `condition` on the #GDatagramBased. The
     * #GSource keeps a reference to the `datagram_based`.
     *
     * The callback on the source is of the #GDatagramBasedSourceFunc type.
     *
     * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
     * conditions will always be reported in the callback if they are true.
     *
     * If non-%NULL, `cancellable` can be used to cancel the source, which will
     * cause the source to trigger, reporting the current condition (which is
     * likely 0 unless cancellation happened at the same time as a condition
     * change). You can check for this in the callback using
     * g_cancellable_is_cancelled().
     * @virtual
     * @param condition a #GIOCondition mask to monitor
     * @param cancellable a #GCancellable
     * @returns a newly allocated #GSource
     */
    createSource(
      condition: GLib.IOCondition,
      cancellable: Cancellable | null
    ): GLib.Source
    /**
     * Receive one or more data messages from `datagram_based` in one go.
     *
     * `messages` must point to an array of #GInputMessage structs and
     * `num_messages` must be the length of this array. Each #GInputMessage
     * contains a pointer to an array of #GInputVector structs describing the
     * buffers that the data received in each message will be written to.
     *
     * `flags` modify how all messages are received. The commonly available
     * arguments for this are available in the #GSocketMsgFlags enum, but the
     * values there are the same as the system values, and the flags
     * are passed in as-is, so you can pass in system-specific flags too. These
     * flags affect the overall receive operation. Flags affecting individual
     * messages are returned in #GInputMessage.flags.
     *
     * The other members of #GInputMessage are treated as described in its
     * documentation.
     *
     * If `timeout` is negative the call will block until `num_messages` have been
     * received, the connection is closed remotely (EOS), `cancellable` is cancelled,
     * or an error occurs.
     *
     * If `timeout` is 0 the call will return up to `num_messages` without blocking,
     * or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the operating system
     * to be received.
     *
     * If `timeout` is positive the call will block on the same conditions as if
     * `timeout` were negative. If the timeout is reached
     * before any messages are received, %G_IO_ERROR_TIMED_OUT is returned,
     * otherwise it will return the number of messages received before timing out.
     * (Note: This is effectively the behaviour of `MSG_WAITFORONE` with
     * recvmmsg().)
     *
     * To be notified when messages are available, wait for the %G_IO_IN condition.
     * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
     * g_datagram_based_receive_messages() even if you were previously notified of a
     * %G_IO_IN condition.
     *
     * If the remote peer closes the connection, any messages queued in the
     * underlying receive buffer will be returned, and subsequent calls to
     * g_datagram_based_receive_messages() will return 0 (with no error set).
     *
     * If the connection is shut down or closed (by calling g_socket_close() or
     * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
     * example), all calls to this function will return %G_IO_ERROR_CLOSED.
     *
     * On error -1 is returned and `error` is set accordingly. An error will only
     * be returned if zero messages could be received; otherwise the number of
     * messages successfully received before the error will be returned. If
     * `cancellable` is cancelled, %G_IO_ERROR_CANCELLED is returned as with any
     * other error.
     * @virtual
     * @param messages an array of #GInputMessage structs
     * @param flags an int containing #GSocketMsgFlags flags for the overall operation
     * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
     * @param cancellable a %GCancellable
     * @returns number of messages received, or -1 on error. Note that the number     of messages received may be smaller than @num_messages if @timeout is     zero or positive, if the peer closed the connection, or if @num_messages     was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try     to receive the remaining messages.
     */
    receiveMessages(
      messages: InputMessage[],
      flags: number,
      timeout: number,
      cancellable: Cancellable | null
    ): number
    /**
     * Send one or more data messages from `datagram_based` in one go.
     *
     * `messages` must point to an array of #GOutputMessage structs and
     * `num_messages` must be the length of this array. Each #GOutputMessage
     * contains an address to send the data to, and a pointer to an array of
     * #GOutputVector structs to describe the buffers that the data to be sent
     * for each message will be gathered from.
     *
     * `flags` modify how the message is sent. The commonly available arguments
     * for this are available in the #GSocketMsgFlags enum, but the
     * values there are the same as the system values, and the flags
     * are passed in as-is, so you can pass in system-specific flags too.
     *
     * The other members of #GOutputMessage are treated as described in its
     * documentation.
     *
     * If `timeout` is negative the call will block until `num_messages` have been
     * sent, `cancellable` is cancelled, or an error occurs.
     *
     * If `timeout` is 0 the call will send up to `num_messages` without blocking,
     * or will return %G_IO_ERROR_WOULD_BLOCK if there is no space to send messages.
     *
     * If `timeout` is positive the call will block on the same conditions as if
     * `timeout` were negative. If the timeout is reached before any messages are
     * sent, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number
     * of messages sent before timing out.
     *
     * To be notified when messages can be sent, wait for the %G_IO_OUT condition.
     * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
     * g_datagram_based_send_messages() even if you were previously notified of a
     * %G_IO_OUT condition. (On Windows in particular, this is very common due to
     * the way the underlying APIs work.)
     *
     * If the connection is shut down or closed (by calling g_socket_close() or
     * g_socket_shutdown() with `shutdown_write` set, if it’s a #GSocket, for
     * example), all calls to this function will return %G_IO_ERROR_CLOSED.
     *
     * On error -1 is returned and `error` is set accordingly. An error will only
     * be returned if zero messages could be sent; otherwise the number of messages
     * successfully sent before the error will be returned. If `cancellable` is
     * cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error.
     * @virtual
     * @param messages an array of #GOutputMessage structs
     * @param flags an int containing #GSocketMsgFlags flags
     * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
     * @param cancellable a %GCancellable
     * @returns number of messages sent, or -1 on error. Note that the number of     messages sent may be smaller than @num_messages if @timeout is zero     or positive, or if @num_messages was larger than `UIO_MAXIOV` (1024), in     which case the caller may re-try to send the remaining messages.
     */
    sendMessages(
      messages: OutputMessage[],
      flags: number,
      timeout: number,
      cancellable: Cancellable | null
    ): number

    // Class property signals of Gio-2.0.Gio.DatagramBased

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Interface for socket-like objects with datagram semantics.
   *
   * A `GDatagramBased` is a networking interface for representing datagram-based
   * communications. It is a more or less direct mapping of the core parts of the
   * BSD socket API in a portable GObject interface. It is implemented by
   * [class`Gio`.Socket], which wraps the UNIX socket API on UNIX and winsock2 on Windows.
   *
   * `GDatagramBased` is entirely platform independent, and is intended to be used
   * alongside higher-level networking APIs such as [class`Gio`.IOStream].
   *
   * It uses vectored scatter/gather I/O by default, allowing for many messages
   * to be sent or received in a single call. Where possible, implementations of
   * the interface should take advantage of vectored I/O to minimise processing
   * or system calls. For example, `GSocket` uses `recvmmsg()` and `sendmmsg()`
   * where possible. Callers should take advantage of scatter/gather I/O (the use of
   * multiple buffers per message) to avoid unnecessary copying of data to
   * assemble or disassemble a message.
   *
   * Each `GDatagramBased` operation has a timeout parameter which may be negative
   * for blocking behaviour, zero for non-blocking behaviour, or positive for
   * timeout behaviour. A blocking operation blocks until finished or there is an
   * error. A non-blocking operation will return immediately with a
   * `G_IO_ERROR_WOULD_BLOCK` error if it cannot make progress. A timeout operation
   * will block until the operation is complete or the timeout expires; if the
   * timeout expires it will return what progress it made, or
   * `G_IO_ERROR_TIMED_OUT` if no progress was made. To know when a call would
   * successfully run you can call [method`Gio`.DatagramBased.condition_check] or
   * [method`Gio`.DatagramBased.condition_wait]. You can also use
   * [method`Gio`.DatagramBased.create_source] and attach it to a [struct`GLib`.MainContext]
   * to get callbacks when I/O is possible.
   *
   * When running a non-blocking operation applications should always be able to
   * handle getting a `G_IO_ERROR_WOULD_BLOCK` error even when some other function
   * said that I/O was possible. This can easily happen in case of a race
   * condition in the application, but it can also happen for other reasons. For
   * instance, on Windows a socket is always seen as writable until a write
   * returns `G_IO_ERROR_WOULD_BLOCK`.
   *
   * As with `GSocket`, `GDatagramBased`s can be either connection oriented (for
   * example, SCTP) or connectionless (for example, UDP). `GDatagramBased`s must be
   * datagram-based, not stream-based. The interface does not cover connection
   * establishment — use methods on the underlying type to establish a connection
   * before sending and receiving data through the `GDatagramBased` API. For
   * connectionless socket types the target/source address is specified or
   * received in each I/O operation.
   *
   * Like most other APIs in GLib, `GDatagramBased` is not inherently thread safe.
   * To use a `GDatagramBased` concurrently from multiple threads, you must
   * implement your own locking.
   * @interface
   */
  class DatagramBased extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DatagramBased

    static name: string

    // Constructors of Gio-2.0.Gio.DatagramBased

    constructor(config?: DatagramBased.ConstructorProperties)
    _init(config?: DatagramBased.ConstructorProperties): void
  }

  module DebugController {
    // Constructor properties interface

    interface ConstructorProperties
      extends Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DebugController

      /**
       * %TRUE if debug output should be exposed (for example by forwarding it to
       * the journal), %FALSE otherwise.
       */
      debug_enabled?: boolean | null
    }
  }

  interface DebugController extends Initable {
    // Own properties of Gio-2.0.Gio.DebugController

    /**
     * %TRUE if debug output should be exposed (for example by forwarding it to
     * the journal), %FALSE otherwise.
     */
    debugEnabled: boolean
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DebugController

    /**
     * Get the value of #GDebugController:debug-enabled.
     * @returns %TRUE if debug output should be exposed, %FALSE otherwise
     */
    getDebugEnabled(): boolean
    /**
     * Set the value of #GDebugController:debug-enabled.
     * @param debugEnabled %TRUE if debug output should be exposed, %FALSE otherwise
     */
    setDebugEnabled(debugEnabled: boolean): void

    // Class property signals of Gio-2.0.Gio.DebugController

    connect(
      sigName: "notify::debug-enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::debug-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::debug-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::debug-enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::debug-enabled", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDebugController` is an interface to expose control of debugging features and
   * debug output.
   *
   * It is implemented on Linux using [class`Gio`.DebugControllerDBus], which
   * exposes a D-Bus interface to allow authenticated peers to control debug
   * features in this process.
   *
   * Whether debug output is enabled is exposed as
   * [property`Gio`.DebugController:debug-enabled]. This controls
   * [func`GLib`.log_set_debug_enabled] by default. Application code may
   * connect to the [signal`GObject`.Object::notify] signal for it
   * to control other parts of its debug infrastructure as necessary.
   *
   * If your application or service is using the default GLib log writer function,
   * creating one of the built-in implementations of `GDebugController` should be
   * all that’s needed to dynamically enable or disable debug output.
   * @interface
   */
  class DebugController extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DebugController

    static name: string

    // Constructors of Gio-2.0.Gio.DebugController

    constructor(config?: DebugController.ConstructorProperties)
    _init(config?: DebugController.ConstructorProperties): void
  }

  module DesktopAppInfoLookup {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface DesktopAppInfoLookup {
    // Own properties of Gio-2.0.Gio.DesktopAppInfoLookup

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DesktopAppInfoLookup

    // Has conflict: getDefaultForUriScheme(uriScheme: string): AppInfo | null

    // Own virtual methods of Gio-2.0.Gio.DesktopAppInfoLookup

    /**
     * Gets the default application for launching applications
     * using this URI scheme for a particular #GDesktopAppInfoLookup
     * implementation.
     *
     * The #GDesktopAppInfoLookup interface and this function is used
     * to implement g_app_info_get_default_for_uri_scheme() backends
     * in a GIO module. There is no reason for applications to use it
     * directly. Applications should use g_app_info_get_default_for_uri_scheme().
     * @virtual
     * @param uriScheme a string containing a URI scheme.
     * @returns #GAppInfo for given @uri_scheme or    %NULL on error.
     */
    getDefaultForUriScheme(uriScheme: string): AppInfo | null

    // Class property signals of Gio-2.0.Gio.DesktopAppInfoLookup

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * #GDesktopAppInfoLookup is an opaque data structure and can only be accessed
   * using the following functions.
   * @interface
   */
  class DesktopAppInfoLookup extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DesktopAppInfoLookup

    static name: string

    // Constructors of Gio-2.0.Gio.DesktopAppInfoLookup

    constructor(config?: DesktopAppInfoLookup.ConstructorProperties)
    _init(config?: DesktopAppInfoLookup.ConstructorProperties): void
  }

  module Drive {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `disconnected`
     */
    interface DisconnectedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `eject-button`
     */
    interface EjectButtonSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `stop-button`
     */
    interface StopButtonSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Drive {
    // Own properties of Gio-2.0.Gio.Drive

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Drive

    // Has conflict: canEject(): boolean
    // Has conflict: canPollForMedia(): boolean
    // Has conflict: canStart(): boolean
    // Has conflict: canStartDegraded(): boolean
    // Has conflict: canStop(): boolean
    // Has conflict: eject(flags: MountUnmountFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: ejectFinish(result: AsyncResult): boolean
    // Has conflict: ejectWithOperation(flags: MountUnmountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: ejectWithOperationFinish(result: AsyncResult): boolean
    // Has conflict: enumerateIdentifiers(): string[]
    // Has conflict: getIcon(): Icon
    // Has conflict: getIdentifier(kind: string): string | null
    // Has conflict: getName(): string | null
    // Has conflict: getSortKey(): string | null
    // Has conflict: getStartStopType(): DriveStartStopType
    // Has conflict: getSymbolicIcon(): Icon
    // Has conflict: getVolumes(): Volume[]
    // Has conflict: hasMedia(): boolean
    // Has conflict: hasVolumes(): boolean
    // Has conflict: isMediaCheckAutomatic(): boolean
    // Has conflict: isMediaRemovable(): boolean
    // Has conflict: isRemovable(): boolean
    // Has conflict: pollForMedia(cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: pollForMediaFinish(result: AsyncResult): boolean
    // Has conflict: start(flags: DriveStartFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: startFinish(result: AsyncResult): boolean
    // Has conflict: stop(flags: MountUnmountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: stopFinish(result: AsyncResult): boolean

    // Own virtual methods of Gio-2.0.Gio.Drive

    /**
     * Checks if a drive can be ejected.
     * @virtual
     * @returns %TRUE if the @drive can be ejected, %FALSE otherwise.
     */
    canEject(): boolean
    /**
     * Checks if a drive can be polled for media changes.
     * @virtual
     * @returns %TRUE if the @drive can be polled for media changes,     %FALSE otherwise.
     */
    canPollForMedia(): boolean
    /**
     * Checks if a drive can be started.
     * @virtual
     * @returns %TRUE if the @drive can be started, %FALSE otherwise.
     */
    canStart(): boolean
    /**
     * Checks if a drive can be started degraded.
     * @virtual
     * @returns %TRUE if the @drive can be started degraded, %FALSE otherwise.
     */
    canStartDegraded(): boolean
    /**
     * Checks if a drive can be stopped.
     * @virtual
     * @returns %TRUE if the @drive can be stopped, %FALSE otherwise.
     */
    canStop(): boolean
    /**
     * Signal emitted when the drive is changed.
     * @virtual
     */
    changed(): void
    /**
     * The removed signal that is emitted when the #GDrive have been disconnected. If the recipient is holding references to the object they should release them so the object can be finalized.
     * @virtual
     */
    disconnected(): void
    /**
     * Asynchronously ejects a drive.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_drive_eject_finish() to obtain the
     * result of the operation.
     * @virtual
     * @param flags flags affecting the unmount if required for eject
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    eject(
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Signal emitted when the physical eject button (if any) of a drive have been pressed.
     * @virtual
     */
    ejectButton(): void
    /**
     * Finishes ejecting a drive.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the drive has been ejected successfully,     %FALSE otherwise.
     */
    ejectFinish(result: AsyncResult): boolean
    /**
     * Ejects a drive. This is an asynchronous operation, and is
     * finished by calling g_drive_eject_with_operation_finish() with the `drive`
     * and #GAsyncResult data returned in the `callback`.
     * @virtual
     * @param flags flags affecting the unmount if required for eject
     * @param mountOperation a #GMountOperation or %NULL to avoid     user interaction.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    ejectWithOperation(
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes ejecting a drive. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the drive was successfully ejected. %FALSE otherwise.
     */
    ejectWithOperationFinish(result: AsyncResult): boolean
    /**
     * Gets the kinds of identifiers that `drive` has.
     * Use g_drive_get_identifier() to obtain the identifiers
     * themselves.
     * @virtual
     * @returns a %NULL-terminated     array of strings containing kinds of identifiers. Use g_strfreev()     to free.
     */
    enumerateIdentifiers(): string[]
    /**
     * Gets the icon for `drive`.
     * @virtual
     * @returns #GIcon for the @drive.    Free the returned object with g_object_unref().
     */
    getIcon(): Icon
    /**
     * Gets the identifier of the given kind for `drive`. The only
     * identifier currently available is
     * %G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE.
     * @virtual
     * @param kind the kind of identifier to return
     * @returns a newly allocated string containing the     requested identifier, or %NULL if the #GDrive     doesn't have this kind of identifier.
     */
    getIdentifier(kind: string): string | null
    /**
     * Gets the name of `drive`.
     * @virtual
     * @returns a string containing @drive's name. The returned     string should be freed when no longer needed.
     */
    getName(): string | null
    /**
     * Gets the sort key for `drive,` if any.
     * @virtual
     * @returns Sorting key for @drive or %NULL if no such key is available.
     */
    getSortKey(): string | null
    /**
     * Gets a hint about how a drive can be started/stopped.
     * @virtual
     * @returns A value from the #GDriveStartStopType enumeration.
     */
    getStartStopType(): DriveStartStopType
    /**
     * Gets the icon for `drive`.
     * @virtual
     * @returns symbolic #GIcon for the @drive.    Free the returned object with g_object_unref().
     */
    getSymbolicIcon(): Icon
    /**
     * Get a list of mountable volumes for `drive`.
     *
     * The returned list should be freed with g_list_free(), after
     * its elements have been unreffed with g_object_unref().
     * @virtual
     * @returns #GList containing any #GVolume objects on the given @drive.
     */
    getVolumes(): Volume[]
    /**
     * Checks if the `drive` has media. Note that the OS may not be polling
     * the drive for media changes; see g_drive_is_media_check_automatic()
     * for more details.
     * @virtual
     * @returns %TRUE if @drive has media, %FALSE otherwise.
     */
    hasMedia(): boolean
    /**
     * Check if `drive` has any mountable volumes.
     * @virtual
     * @returns %TRUE if the @drive contains volumes, %FALSE otherwise.
     */
    hasVolumes(): boolean
    /**
     * Checks if `drive` is capable of automatically detecting media changes.
     * @virtual
     * @returns %TRUE if the @drive is capable of automatically detecting     media changes, %FALSE otherwise.
     */
    isMediaCheckAutomatic(): boolean
    /**
     * Checks if the `drive` supports removable media.
     * @virtual
     * @returns %TRUE if @drive supports removable media, %FALSE otherwise.
     */
    isMediaRemovable(): boolean
    /**
     * Checks if the #GDrive and/or its media is considered removable by the user.
     * See g_drive_is_media_removable().
     * @virtual
     * @returns %TRUE if @drive and/or its media is considered removable, %FALSE otherwise.
     */
    isRemovable(): boolean
    /**
     * Asynchronously polls `drive` to see if media has been inserted or removed.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_drive_poll_for_media_finish() to obtain the
     * result of the operation.
     * @virtual
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    pollForMedia(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an operation started with g_drive_poll_for_media() on a drive.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the drive has been poll_for_mediaed successfully,     %FALSE otherwise.
     */
    pollForMediaFinish(result: AsyncResult): boolean
    /**
     * Asynchronously starts a drive.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_drive_start_finish() to obtain the
     * result of the operation.
     * @virtual
     * @param flags flags affecting the start operation.
     * @param mountOperation a #GMountOperation or %NULL to avoid     user interaction.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    start(
      flags: DriveStartFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes starting a drive.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the drive has been started successfully,     %FALSE otherwise.
     */
    startFinish(result: AsyncResult): boolean
    /**
     * Asynchronously stops a drive.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_drive_stop_finish() to obtain the
     * result of the operation.
     * @virtual
     * @param flags flags affecting the unmount if required for stopping.
     * @param mountOperation a #GMountOperation or %NULL to avoid     user interaction.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    stop(
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Signal emitted when the physical stop button (if any) of a drive have been pressed. Since 2.22.
     * @virtual
     */
    stopButton(): void
    /**
     * Finishes stopping a drive.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the drive has been stopped successfully,     %FALSE otherwise.
     */
    stopFinish(result: AsyncResult): boolean

    // Own signals of Gio-2.0.Gio.Drive

    connect(sigName: "changed", callback: Drive.ChangedSignalCallback): number
    on(
      sigName: "changed",
      callback: Drive.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Drive.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Drive.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "disconnected",
      callback: Drive.DisconnectedSignalCallback
    ): number
    on(
      sigName: "disconnected",
      callback: Drive.DisconnectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "disconnected",
      callback: Drive.DisconnectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "disconnected",
      callback: Drive.DisconnectedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "disconnected", ...args: any[]): void
    connect(
      sigName: "eject-button",
      callback: Drive.EjectButtonSignalCallback
    ): number
    on(
      sigName: "eject-button",
      callback: Drive.EjectButtonSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "eject-button",
      callback: Drive.EjectButtonSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "eject-button",
      callback: Drive.EjectButtonSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "eject-button", ...args: any[]): void
    connect(
      sigName: "stop-button",
      callback: Drive.StopButtonSignalCallback
    ): number
    on(
      sigName: "stop-button",
      callback: Drive.StopButtonSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "stop-button",
      callback: Drive.StopButtonSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "stop-button",
      callback: Drive.StopButtonSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "stop-button", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.Drive

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDrive` represents a piece of hardware connected to the machine.
   * It’s generally only created for removable hardware or hardware with
   * removable media.
   *
   * `GDrive` is a container class for [iface`Gio`.Volume] objects that stem from
   * the same piece of media. As such, `GDrive` abstracts a drive with
   * (or without) removable media and provides operations for querying
   * whether media is available, determining whether media change is
   * automatically detected and ejecting the media.
   *
   * If the `GDrive` reports that media isn’t automatically detected, one
   * can poll for media; typically one should not do this periodically
   * as a poll for media operation is potentially expensive and may
   * spin up the drive creating noise.
   *
   * `GDrive` supports starting and stopping drives with authentication
   * support for the former. This can be used to support a diverse set
   * of use cases including connecting/disconnecting iSCSI devices,
   * powering down external disk enclosures and starting/stopping
   * multi-disk devices such as RAID devices. Note that the actual
   * semantics and side-effects of starting/stopping a `GDrive` may vary
   * according to implementation. To choose the correct verbs in e.g. a
   * file manager, use [method`Gio`.Drive.get_start_stop_type].
   *
   * For [porting from GnomeVFS](migrating-gnome-vfs.html) note that there is no
   * equivalent of `GDrive` in that API.
   * @interface
   */
  class Drive extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Drive

    static name: string

    // Constructors of Gio-2.0.Gio.Drive

    constructor(config?: Drive.ConstructorProperties)
    _init(config?: Drive.ConstructorProperties): void
  }

  module DtlsClientConnection {
    // Constructor properties interface

    interface ConstructorProperties
      extends DatagramBased.ConstructorProperties,
        DtlsConnection.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DtlsClientConnection

      /**
       * A #GSocketConnectable describing the identity of the server that
       * is expected on the other end of the connection.
       *
       * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
       * #GDtlsClientConnection:validation-flags, this object will be used
       * to determine the expected identify of the remote end of the
       * connection; if #GDtlsClientConnection:server-identity is not set,
       * or does not match the identity presented by the server, then the
       * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
       *
       * In addition to its use in verifying the server certificate,
       * this is also used to give a hint to the server about what
       * certificate we expect, which is useful for servers that serve
       * virtual hosts.
       */
      server_identity?: SocketConnectable | null
      /**
       * What steps to perform when validating a certificate received from
       * a server. Server certificates that fail to validate in any of the
       * ways indicated here will be rejected unless the application
       * overrides the default via #GDtlsConnection::accept-certificate.
       *
       * GLib guarantees that if certificate verification fails, at least one
       * flag will be set, but it does not guarantee that all possible flags
       * will be set. Accordingly, you may not safely decide to ignore any
       * particular type of error. For example, it would be incorrect to mask
       * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
       * because this could potentially be the only error flag set even if
       * other problems exist with the certificate. Therefore, there is no
       * safe way to use this property. This is not a horrible problem,
       * though, because you should not be attempting to ignore validation
       * errors anyway. If you really must ignore TLS certificate errors,
       * connect to #GDtlsConnection::accept-certificate.
       */
      validation_flags?: TlsCertificateFlags | null
    }
  }

  interface DtlsClientConnection extends DatagramBased, DtlsConnection {
    // Own properties of Gio-2.0.Gio.DtlsClientConnection

    /**
     * A list of the distinguished names of the Certificate Authorities
     * that the server will accept client certificates signed by. If the
     * server requests a client certificate during the handshake, then
     * this property will be set after the handshake completes.
     *
     * Each item in the list is a #GByteArray which contains the complete
     * subject DN of the certificate authority.
     */
    readonly acceptedCas: any[]
    /**
     * A #GSocketConnectable describing the identity of the server that
     * is expected on the other end of the connection.
     *
     * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
     * #GDtlsClientConnection:validation-flags, this object will be used
     * to determine the expected identify of the remote end of the
     * connection; if #GDtlsClientConnection:server-identity is not set,
     * or does not match the identity presented by the server, then the
     * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
     *
     * In addition to its use in verifying the server certificate,
     * this is also used to give a hint to the server about what
     * certificate we expect, which is useful for servers that serve
     * virtual hosts.
     */
    serverIdentity: SocketConnectable
    /**
     * What steps to perform when validating a certificate received from
     * a server. Server certificates that fail to validate in any of the
     * ways indicated here will be rejected unless the application
     * overrides the default via #GDtlsConnection::accept-certificate.
     *
     * GLib guarantees that if certificate verification fails, at least one
     * flag will be set, but it does not guarantee that all possible flags
     * will be set. Accordingly, you may not safely decide to ignore any
     * particular type of error. For example, it would be incorrect to mask
     * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
     * because this could potentially be the only error flag set even if
     * other problems exist with the certificate. Therefore, there is no
     * safe way to use this property. This is not a horrible problem,
     * though, because you should not be attempting to ignore validation
     * errors anyway. If you really must ignore TLS certificate errors,
     * connect to #GDtlsConnection::accept-certificate.
     */
    validationFlags: TlsCertificateFlags
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DtlsClientConnection

    /**
     * Gets the list of distinguished names of the Certificate Authorities
     * that the server will accept certificates from. This will be set
     * during the TLS handshake if the server requests a certificate.
     * Otherwise, it will be %NULL.
     *
     * Each item in the list is a #GByteArray which contains the complete
     * subject DN of the certificate authority.
     * @returns the list of CA DNs. You should unref each element with g_byte_array_unref() and then the free the list with g_list_free().
     */
    getAcceptedCas(): GLib.List[]
    /**
     * Gets `conn'`s expected server identity
     * @returns a #GSocketConnectable describing the expected server identity, or %NULL if the expected identity is not known.
     */
    getServerIdentity(): SocketConnectable
    /**
     * Gets `conn'`s validation flags
     *
     * This function does not work as originally designed and is impossible
     * to use correctly. See #GDtlsClientConnection:validation-flags for more
     * information.
     * @returns the validation flags
     */
    getValidationFlags(): TlsCertificateFlags
    /**
     * Sets `conn'`s expected server identity, which is used both to tell
     * servers on virtual hosts which certificate to present, and also
     * to let `conn` know what name to look for in the certificate when
     * performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled.
     * @param identity a #GSocketConnectable describing the expected server identity
     */
    setServerIdentity(identity: SocketConnectable): void
    /**
     * Sets `conn'`s validation flags, to override the default set of
     * checks performed when validating a server certificate. By default,
     * %G_TLS_CERTIFICATE_VALIDATE_ALL is used.
     *
     * This function does not work as originally designed and is impossible
     * to use correctly. See #GDtlsClientConnection:validation-flags for more
     * information.
     * @param flags the #GTlsCertificateFlags to use
     */
    setValidationFlags(flags: TlsCertificateFlags): void

    // Class property signals of Gio-2.0.Gio.DtlsClientConnection

    connect(
      sigName: "notify::accepted-cas",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accepted-cas",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accepted-cas",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accepted-cas",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accepted-cas", ...args: any[]): void
    connect(
      sigName: "notify::server-identity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::server-identity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::server-identity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::server-identity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::server-identity", ...args: any[]): void
    connect(
      sigName: "notify::validation-flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::validation-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::validation-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::validation-flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::validation-flags", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::advertised-protocols", ...args: any[]): void
    connect(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::base-socket", ...args: any[]): void
    connect(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::certificate", ...args: any[]): void
    connect(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ciphersuite-name", ...args: any[]): void
    connect(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::database", ...args: any[]): void
    connect(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::interaction", ...args: any[]): void
    connect(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::negotiated-protocol", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate-errors", ...args: any[]): void
    connect(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol-version", ...args: any[]): void
    connect(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rehandshake-mode", ...args: any[]): void
    connect(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::require-close-notify", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDtlsClientConnection` is the client-side subclass of
   * [iface`Gio`.DtlsConnection], representing a client-side DTLS connection.
   * @interface
   */
  class DtlsClientConnection extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DtlsClientConnection

    static name: string

    // Constructors of Gio-2.0.Gio.DtlsClientConnection

    constructor(config?: DtlsClientConnection.ConstructorProperties)
    _init(config?: DtlsClientConnection.ConstructorProperties): void
    /**
     * Creates a new #GDtlsClientConnection wrapping `base_socket` which is
     * assumed to communicate with the server identified by `server_identity`.
     * @param baseSocket the #GDatagramBased to wrap
     * @param serverIdentity the expected identity of the server
     * @returns the new   #GDtlsClientConnection, or %NULL on error
     */
    static new(
      baseSocket: DatagramBased,
      serverIdentity: SocketConnectable | null
    ): DtlsClientConnection
  }

  module DtlsConnection {
    // Signal callback interfaces

    /**
     * Signal callback interface for `accept-certificate`
     */
    interface AcceptCertificateSignalCallback {
      (peerCert: TlsCertificate, errors: TlsCertificateFlags): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends DatagramBased.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DtlsConnection

      /**
       * The list of application-layer protocols that the connection
       * advertises that it is willing to speak. See
       * g_dtls_connection_set_advertised_protocols().
       */
      advertised_protocols?: string[] | null
      /**
       * The #GDatagramBased that the connection wraps. Note that this may be any
       * implementation of #GDatagramBased, not just a #GSocket.
       */
      base_socket?: DatagramBased | null
      /**
       * The connection's certificate; see
       * g_dtls_connection_set_certificate().
       */
      certificate?: TlsCertificate | null
      /**
       * The certificate database to use when verifying this TLS connection.
       * If no certificate database is set, then the default database will be
       * used. See g_tls_backend_get_default_database().
       *
       * When using a non-default database, #GDtlsConnection must fall back to using
       * the #GTlsDatabase to perform certificate verification using
       * g_tls_database_verify_chain(), which means certificate verification will
       * not be able to make use of TLS session context. This may be less secure.
       * For example, if you create your own #GTlsDatabase that just wraps the
       * default #GTlsDatabase, you might expect that you have not changed anything,
       * but this is not true because you may have altered the behavior of
       * #GDtlsConnection by causing it to use g_tls_database_verify_chain(). See the
       * documentation of g_tls_database_verify_chain() for more details on specific
       * security checks that may not be performed. Accordingly, setting a
       * non-default database is discouraged except for specialty applications with
       * unusual security requirements.
       */
      database?: TlsDatabase | null
      /**
       * A #GTlsInteraction object to be used when the connection or certificate
       * database need to interact with the user. This will be used to prompt the
       * user for passwords where necessary.
       */
      interaction?: TlsInteraction | null
      /**
       * The rehandshaking mode. See
       * g_dtls_connection_set_rehandshake_mode().
       */
      rehandshake_mode?: TlsRehandshakeMode | null
      /**
       * Whether or not proper TLS close notification is required.
       * See g_dtls_connection_set_require_close_notify().
       */
      require_close_notify?: boolean | null
    }
  }

  interface DtlsConnection extends DatagramBased {
    // Own properties of Gio-2.0.Gio.DtlsConnection

    /**
     * The list of application-layer protocols that the connection
     * advertises that it is willing to speak. See
     * g_dtls_connection_set_advertised_protocols().
     */
    advertisedProtocols: string[]
    /**
     * The #GDatagramBased that the connection wraps. Note that this may be any
     * implementation of #GDatagramBased, not just a #GSocket.
     */
    readonly baseSocket: DatagramBased
    /**
     * The connection's certificate; see
     * g_dtls_connection_set_certificate().
     */
    certificate: TlsCertificate
    /**
     * The name of the DTLS ciphersuite in use. See g_dtls_connection_get_ciphersuite_name().
     */
    readonly ciphersuiteName: string | null
    /**
     * The certificate database to use when verifying this TLS connection.
     * If no certificate database is set, then the default database will be
     * used. See g_tls_backend_get_default_database().
     *
     * When using a non-default database, #GDtlsConnection must fall back to using
     * the #GTlsDatabase to perform certificate verification using
     * g_tls_database_verify_chain(), which means certificate verification will
     * not be able to make use of TLS session context. This may be less secure.
     * For example, if you create your own #GTlsDatabase that just wraps the
     * default #GTlsDatabase, you might expect that you have not changed anything,
     * but this is not true because you may have altered the behavior of
     * #GDtlsConnection by causing it to use g_tls_database_verify_chain(). See the
     * documentation of g_tls_database_verify_chain() for more details on specific
     * security checks that may not be performed. Accordingly, setting a
     * non-default database is discouraged except for specialty applications with
     * unusual security requirements.
     */
    database: TlsDatabase
    /**
     * A #GTlsInteraction object to be used when the connection or certificate
     * database need to interact with the user. This will be used to prompt the
     * user for passwords where necessary.
     */
    interaction: TlsInteraction
    /**
     * The application-layer protocol negotiated during the TLS
     * handshake. See g_dtls_connection_get_negotiated_protocol().
     */
    readonly negotiatedProtocol: string | null
    /**
     * The connection's peer's certificate, after the TLS handshake has
     * completed or failed. Note in particular that this is not yet set
     * during the emission of #GDtlsConnection::accept-certificate.
     *
     * (You can watch for a #GObject::notify signal on this property to
     * detect when a handshake has occurred.)
     */
    readonly peerCertificate: TlsCertificate
    /**
     * The errors noticed while verifying
     * #GDtlsConnection:peer-certificate. Normally this should be 0, but
     * it may not be if #GDtlsClientConnection:validation-flags is not
     * %G_TLS_CERTIFICATE_VALIDATE_ALL, or if
     * #GDtlsConnection::accept-certificate overrode the default
     * behavior.
     *
     * GLib guarantees that if certificate verification fails, at least
     * one error will be set, but it does not guarantee that all possible
     * errors will be set. Accordingly, you may not safely decide to
     * ignore any particular type of error. For example, it would be
     * incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
     * expired certificates, because this could potentially be the only
     * error flag set even if other problems exist with the certificate.
     */
    readonly peerCertificateErrors: TlsCertificateFlags
    /**
     * The DTLS protocol version in use. See g_dtls_connection_get_protocol_version().
     */
    readonly protocolVersion: TlsProtocolVersion
    /**
     * The rehandshaking mode. See
     * g_dtls_connection_set_rehandshake_mode().
     */
    rehandshakeMode: TlsRehandshakeMode
    /**
     * Whether or not proper TLS close notification is required.
     * See g_dtls_connection_set_require_close_notify().
     */
    requireCloseNotify: boolean
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DtlsConnection

    /**
     * Close the DTLS connection. This is equivalent to calling
     * g_dtls_connection_shutdown() to shut down both sides of the connection.
     *
     * Closing a #GDtlsConnection waits for all buffered but untransmitted data to
     * be sent before it completes. It then sends a `close_notify` DTLS alert to the
     * peer and may wait for a `close_notify` to be received from the peer. It does
     * not close the underlying #GDtlsConnection:base-socket; that must be closed
     * separately.
     *
     * Once `conn` is closed, all other operations will return %G_IO_ERROR_CLOSED.
     * Closing a #GDtlsConnection multiple times will not return an error.
     *
     * #GDtlsConnections will be automatically closed when the last reference is
     * dropped, but you might want to call this function to make sure resources are
     * released as early as possible.
     *
     * If `cancellable` is cancelled, the #GDtlsConnection may be left
     * partially-closed and any pending untransmitted data may be lost. Call
     * g_dtls_connection_close() again to complete closing the #GDtlsConnection.
     * @param cancellable a #GCancellable, or %NULL
     * @returns %TRUE on success, %FALSE otherwise
     */
    close(cancellable: Cancellable | null): boolean
    /**
     * Asynchronously close the DTLS connection. See g_dtls_connection_close() for
     * more information.
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call when the close operation is complete
     */
    closeAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous TLS close operation. See g_dtls_connection_close()
     * for more information.
     * @param result a #GAsyncResult
     * @returns %TRUE on success, %FALSE on failure, in which case @error will be set
     */
    closeFinish(result: AsyncResult): boolean
    /**
     * Used by #GDtlsConnection implementations to emit the
     * #GDtlsConnection::accept-certificate signal.
     * @param peerCert the peer's #GTlsCertificate
     * @param errors the problems with `peer_cert`
     * @returns %TRUE if one of the signal handlers has returned     %TRUE to accept @peer_cert
     */
    emitAcceptCertificate(
      peerCert: TlsCertificate,
      errors: TlsCertificateFlags
    ): boolean
    /**
     * Gets `conn'`s certificate, as set by
     * g_dtls_connection_set_certificate().
     * @returns @conn's certificate, or %NULL
     */
    getCertificate(): TlsCertificate | null
    /**
     * Query the TLS backend for TLS channel binding data of `type` for `conn`.
     *
     * This call retrieves TLS channel binding data as specified in RFC
     * [5056](https://tools.ietf.org/html/rfc5056), RFC
     * [5929](https://tools.ietf.org/html/rfc5929), and related RFCs.  The
     * binding data is returned in `data`.  The `data` is resized by the callee
     * using #GByteArray buffer management and will be freed when the `data`
     * is destroyed by g_byte_array_unref(). If `data` is %NULL, it will only
     * check whether TLS backend is able to fetch the data (e.g. whether `type`
     * is supported by the TLS backend). It does not guarantee that the data
     * will be available though.  That could happen if TLS connection does not
     * support `type` or the binding data is not available yet due to additional
     * negotiation or input required.
     * @param type #GTlsChannelBindingType type of data to fetch
     * @returns %TRUE on success, %FALSE otherwise
     */
    getChannelBindingData(
      type: TlsChannelBindingType
    ): [/* returnType */ boolean, /* data */ number[]]
    /**
     * Returns the name of the current DTLS ciphersuite, or %NULL if the
     * connection has not handshaked or has been closed. Beware that the TLS
     * backend may use any of multiple different naming conventions, because
     * OpenSSL and GnuTLS have their own ciphersuite naming conventions that
     * are different from each other and different from the standard, IANA-
     * registered ciphersuite names. The ciphersuite name is intended to be
     * displayed to the user for informative purposes only, and parsing it
     * is not recommended.
     * @returns The name of the current DTLS ciphersuite, or %NULL
     */
    getCiphersuiteName(): string | null
    /**
     * Gets the certificate database that `conn` uses to verify
     * peer certificates. See g_dtls_connection_set_database().
     * @returns the certificate database that @conn uses or %NULL
     */
    getDatabase(): TlsDatabase | null
    /**
     * Get the object that will be used to interact with the user. It will be used
     * for things like prompting the user for passwords. If %NULL is returned, then
     * no user interaction will occur for this connection.
     * @returns The interaction object.
     */
    getInteraction(): TlsInteraction | null
    // Has conflict: getNegotiatedProtocol(): string | null
    /**
     * Gets `conn'`s peer's certificate after the handshake has completed
     * or failed. (It is not set during the emission of
     * #GDtlsConnection::accept-certificate.)
     * @returns @conn's peer's certificate, or %NULL
     */
    getPeerCertificate(): TlsCertificate | null
    /**
     * Gets the errors associated with validating `conn'`s peer's
     * certificate, after the handshake has completed or failed. (It is
     * not set during the emission of #GDtlsConnection::accept-certificate.)
     * @returns @conn's peer's certificate errors
     */
    getPeerCertificateErrors(): TlsCertificateFlags
    /**
     * Returns the current DTLS protocol version, which may be
     * %G_TLS_PROTOCOL_VERSION_UNKNOWN if the connection has not handshaked, or
     * has been closed, or if the TLS backend has implemented a protocol version
     * that is not a recognized #GTlsProtocolVersion.
     * @returns The current DTLS protocol version
     */
    getProtocolVersion(): TlsProtocolVersion
    /**
     * Gets `conn` rehandshaking mode. See
     * g_dtls_connection_set_rehandshake_mode() for details.
     * @returns %G_TLS_REHANDSHAKE_SAFELY
     */
    getRehandshakeMode(): TlsRehandshakeMode
    /**
     * Tests whether or not `conn` expects a proper TLS close notification
     * when the connection is closed. See
     * g_dtls_connection_set_require_close_notify() for details.
     * @returns %TRUE if @conn requires a proper TLS close notification.
     */
    getRequireCloseNotify(): boolean
    // Has conflict: handshake(cancellable: Cancellable | null): boolean
    // Has conflict: handshakeAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: handshakeFinish(result: AsyncResult): boolean
    // Has conflict: setAdvertisedProtocols(protocols: string[] | null): void
    /**
     * This sets the certificate that `conn` will present to its peer
     * during the TLS handshake. For a #GDtlsServerConnection, it is
     * mandatory to set this, and that will normally be done at construct
     * time.
     *
     * For a #GDtlsClientConnection, this is optional. If a handshake fails
     * with %G_TLS_ERROR_CERTIFICATE_REQUIRED, that means that the server
     * requires a certificate, and if you try connecting again, you should
     * call this method first. You can call
     * g_dtls_client_connection_get_accepted_cas() on the failed connection
     * to get a list of Certificate Authorities that the server will
     * accept certificates from.
     *
     * (It is also possible that a server will allow the connection with
     * or without a certificate; in that case, if you don't provide a
     * certificate, you can tell that the server requested one by the fact
     * that g_dtls_client_connection_get_accepted_cas() will return
     * non-%NULL.)
     * @param certificate the certificate to use for `conn`
     */
    setCertificate(certificate: TlsCertificate): void
    /**
     * Sets the certificate database that is used to verify peer certificates.
     * This is set to the default database by default. See
     * g_tls_backend_get_default_database(). If set to %NULL, then
     * peer certificate validation will always set the
     * %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning
     * #GDtlsConnection::accept-certificate will always be emitted on
     * client-side connections, unless that bit is not set in
     * #GDtlsClientConnection:validation-flags).
     *
     * There are nonintuitive security implications when using a non-default
     * database. See #GDtlsConnection:database for details.
     * @param database a #GTlsDatabase
     */
    setDatabase(database: TlsDatabase | null): void
    /**
     * Set the object that will be used to interact with the user. It will be used
     * for things like prompting the user for passwords.
     *
     * The `interaction` argument will normally be a derived subclass of
     * #GTlsInteraction. %NULL can also be provided if no user interaction
     * should occur for this connection.
     * @param interaction an interaction object, or %NULL
     */
    setInteraction(interaction: TlsInteraction | null): void
    /**
     * Since GLib 2.64, changing the rehandshake mode is no longer supported
     * and will have no effect. With TLS 1.3, rehandshaking has been removed from
     * the TLS protocol, replaced by separate post-handshake authentication and
     * rekey operations.
     * @param mode the rehandshaking mode
     */
    setRehandshakeMode(mode: TlsRehandshakeMode): void
    /**
     * Sets whether or not `conn` expects a proper TLS close notification
     * before the connection is closed. If this is %TRUE (the default),
     * then `conn` will expect to receive a TLS close notification from its
     * peer before the connection is closed, and will return a
     * %G_TLS_ERROR_EOF error if the connection is closed without proper
     * notification (since this may indicate a network error, or
     * man-in-the-middle attack).
     *
     * In some protocols, the application will know whether or not the
     * connection was closed cleanly based on application-level data
     * (because the application-level data includes a length field, or is
     * somehow self-delimiting); in this case, the close notify is
     * redundant and may be omitted. You
     * can use g_dtls_connection_set_require_close_notify() to tell `conn`
     * to allow an "unannounced" connection close, in which case the close
     * will show up as a 0-length read, as in a non-TLS
     * #GDatagramBased, and it is up to the application to check that
     * the data has been fully received.
     *
     * Note that this only affects the behavior when the peer closes the
     * connection; when the application calls g_dtls_connection_close_async() on
     * `conn` itself, this will send a close notification regardless of the
     * setting of this property. If you explicitly want to do an unclean
     * close, you can close `conn'`s #GDtlsConnection:base-socket rather
     * than closing `conn` itself.
     * @param requireCloseNotify whether or not to require close notification
     */
    setRequireCloseNotify(requireCloseNotify: boolean): void
    // Has conflict: shutdown(shutdownRead: boolean, shutdownWrite: boolean, cancellable: Cancellable | null): boolean
    // Has conflict: shutdownAsync(shutdownRead: boolean, shutdownWrite: boolean, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: shutdownFinish(result: AsyncResult): boolean

    // Own virtual methods of Gio-2.0.Gio.DtlsConnection

    /**
     * Check whether to accept a certificate.
     * @virtual
     * @param peerCert
     * @param errors
     */
    acceptCertificate(
      peerCert: TlsCertificate,
      errors: TlsCertificateFlags
    ): boolean
    /**
     * Retrieve TLS channel binding data (Since: 2.66)
     * @virtual
     * @param type
     * @param data
     */
    getBindingData(type: TlsChannelBindingType, data: number[]): boolean
    /**
     * Gets the name of the application-layer protocol negotiated during
     * the handshake.
     *
     * If the peer did not use the ALPN extension, or did not advertise a
     * protocol that matched one of `conn'`s protocols, or the TLS backend
     * does not support ALPN, then this will be %NULL. See
     * g_dtls_connection_set_advertised_protocols().
     * @virtual
     * @returns the negotiated protocol, or %NULL
     */
    getNegotiatedProtocol(): string | null
    /**
     * Attempts a TLS handshake on `conn`.
     *
     * On the client side, it is never necessary to call this method;
     * although the connection needs to perform a handshake after
     * connecting, #GDtlsConnection will handle this for you automatically
     * when you try to send or receive data on the connection. You can call
     * g_dtls_connection_handshake() manually if you want to know whether
     * the initial handshake succeeded or failed (as opposed to just
     * immediately trying to use `conn` to read or write, in which case,
     * if it fails, it may not be possible to tell if it failed before
     * or after completing the handshake), but beware that servers may reject
     * client authentication after the handshake has completed, so a
     * successful handshake does not indicate the connection will be usable.
     *
     * Likewise, on the server side, although a handshake is necessary at
     * the beginning of the communication, you do not need to call this
     * function explicitly unless you want clearer error reporting.
     *
     * Previously, calling g_dtls_connection_handshake() after the initial
     * handshake would trigger a rehandshake; however, this usage was
     * deprecated in GLib 2.60 because rehandshaking was removed from the
     * TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after
     * the initial handshake will no longer do anything.
     *
     * #GDtlsConnection::accept_certificate may be emitted during the
     * handshake.
     * @virtual
     * @param cancellable a #GCancellable, or %NULL
     * @returns success or failure
     */
    handshake(cancellable: Cancellable | null): boolean
    /**
     * Asynchronously performs a TLS handshake on `conn`. See
     * g_dtls_connection_handshake() for more information.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call when the handshake is complete
     */
    handshakeAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous TLS handshake operation. See
     * g_dtls_connection_handshake() for more information.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE on success, %FALSE on failure, in which case @error will be set.
     */
    handshakeFinish(result: AsyncResult): boolean
    /**
     * Sets the list of application-layer protocols to advertise that the
     * caller is willing to speak on this connection. The
     * Application-Layer Protocol Negotiation (ALPN) extension will be
     * used to negotiate a compatible protocol with the peer; use
     * g_dtls_connection_get_negotiated_protocol() to find the negotiated
     * protocol after the handshake.  Specifying %NULL for the the value
     * of `protocols` will disable ALPN negotiation.
     *
     * See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)
     * for a list of registered protocol IDs.
     * @virtual
     * @param protocols a %NULL-terminated   array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL
     */
    setAdvertisedProtocols(protocols: string[] | null): void
    /**
     * Shut down part or all of a DTLS connection.
     *
     * If `shutdown_read` is %TRUE then the receiving side of the connection is shut
     * down, and further reading is disallowed. Subsequent calls to
     * g_datagram_based_receive_messages() will return %G_IO_ERROR_CLOSED.
     *
     * If `shutdown_write` is %TRUE then the sending side of the connection is shut
     * down, and further writing is disallowed. Subsequent calls to
     * g_datagram_based_send_messages() will return %G_IO_ERROR_CLOSED.
     *
     * It is allowed for both `shutdown_read` and `shutdown_write` to be TRUE — this
     * is equivalent to calling g_dtls_connection_close().
     *
     * If `cancellable` is cancelled, the #GDtlsConnection may be left
     * partially-closed and any pending untransmitted data may be lost. Call
     * g_dtls_connection_shutdown() again to complete closing the #GDtlsConnection.
     * @virtual
     * @param shutdownRead %TRUE to stop reception of incoming datagrams
     * @param shutdownWrite %TRUE to stop sending outgoing datagrams
     * @param cancellable a #GCancellable, or %NULL
     * @returns %TRUE on success, %FALSE otherwise
     */
    shutdown(
      shutdownRead: boolean,
      shutdownWrite: boolean,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Asynchronously shut down part or all of the DTLS connection. See
     * g_dtls_connection_shutdown() for more information.
     * @virtual
     * @param shutdownRead %TRUE to stop reception of incoming datagrams
     * @param shutdownWrite %TRUE to stop sending outgoing datagrams
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call when the shutdown operation is complete
     */
    shutdownAsync(
      shutdownRead: boolean,
      shutdownWrite: boolean,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous TLS shutdown operation. See
     * g_dtls_connection_shutdown() for more information.
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE on success, %FALSE on failure, in which case @error will be set
     */
    shutdownFinish(result: AsyncResult): boolean

    // Own signals of Gio-2.0.Gio.DtlsConnection

    connect(
      sigName: "accept-certificate",
      callback: DtlsConnection.AcceptCertificateSignalCallback
    ): number
    on(
      sigName: "accept-certificate",
      callback: DtlsConnection.AcceptCertificateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "accept-certificate",
      callback: DtlsConnection.AcceptCertificateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "accept-certificate",
      callback: DtlsConnection.AcceptCertificateSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "accept-certificate",
      errors: TlsCertificateFlags,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.DtlsConnection

    connect(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::advertised-protocols", ...args: any[]): void
    connect(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::base-socket", ...args: any[]): void
    connect(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::certificate", ...args: any[]): void
    connect(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ciphersuite-name", ...args: any[]): void
    connect(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::database", ...args: any[]): void
    connect(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::interaction", ...args: any[]): void
    connect(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::negotiated-protocol", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate-errors", ...args: any[]): void
    connect(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol-version", ...args: any[]): void
    connect(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rehandshake-mode", ...args: any[]): void
    connect(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::require-close-notify", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDtlsConnection` is the base DTLS connection class type, which wraps
   * a [iface`Gio`.DatagramBased] and provides DTLS encryption on top of it. Its
   * subclasses, [iface`Gio`.DtlsClientConnection] and
   * [iface`Gio`.DtlsServerConnection], implement client-side and server-side DTLS,
   * respectively.
   *
   * For TLS support, see [class`Gio`.TlsConnection].
   *
   * As DTLS is datagram based, `GDtlsConnection` implements
   * [iface`Gio`.DatagramBased], presenting a datagram-socket-like API for the
   * encrypted connection. This operates over a base datagram connection, which is
   * also a `GDatagramBased` ([property`Gio`.DtlsConnection:base-socket]).
   *
   * To close a DTLS connection, use [method`Gio`.DtlsConnection.close].
   *
   * Neither [iface`Gio`.DtlsServerConnection] or [iface`Gio`.DtlsClientConnection]
   * set the peer address on their base [iface`Gio`.DatagramBased] if it is a
   * [class`Gio`.Socket] — it is up to the caller to do that if they wish. If they
   * do not, and [method`Gio`.Socket.close] is called on the base socket, the
   * `GDtlsConnection` will not raise a `G_IO_ERROR_NOT_CONNECTED` error on
   * further I/O.
   * @interface
   */
  class DtlsConnection extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DtlsConnection

    static name: string

    // Constructors of Gio-2.0.Gio.DtlsConnection

    constructor(config?: DtlsConnection.ConstructorProperties)
    _init(config?: DtlsConnection.ConstructorProperties): void
  }

  module DtlsServerConnection {
    // Constructor properties interface

    interface ConstructorProperties
      extends DatagramBased.ConstructorProperties,
        DtlsConnection.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DtlsServerConnection

      /**
       * The #GTlsAuthenticationMode for the server. This can be changed
       * before calling g_dtls_connection_handshake() if you want to
       * rehandshake with a different mode from the initial handshake.
       */
      authentication_mode?: TlsAuthenticationMode | null
    }
  }

  interface DtlsServerConnection extends DatagramBased, DtlsConnection {
    // Own properties of Gio-2.0.Gio.DtlsServerConnection

    /**
     * The #GTlsAuthenticationMode for the server. This can be changed
     * before calling g_dtls_connection_handshake() if you want to
     * rehandshake with a different mode from the initial handshake.
     */
    authenticationMode: TlsAuthenticationMode
    __gtype__: number

    // Class property signals of Gio-2.0.Gio.DtlsServerConnection

    connect(
      sigName: "notify::authentication-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::authentication-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::authentication-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::authentication-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::authentication-mode", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::advertised-protocols", ...args: any[]): void
    connect(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::base-socket",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::base-socket", ...args: any[]): void
    connect(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::certificate", ...args: any[]): void
    connect(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ciphersuite-name", ...args: any[]): void
    connect(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::database", ...args: any[]): void
    connect(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::interaction", ...args: any[]): void
    connect(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::negotiated-protocol", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate-errors", ...args: any[]): void
    connect(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol-version", ...args: any[]): void
    connect(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rehandshake-mode", ...args: any[]): void
    connect(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::require-close-notify", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDtlsServerConnection` is the server-side subclass of
   * [iface`Gio`.DtlsConnection], representing a server-side DTLS connection.
   * @interface
   */
  class DtlsServerConnection extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DtlsServerConnection

    static name: string

    // Constructors of Gio-2.0.Gio.DtlsServerConnection

    constructor(config?: DtlsServerConnection.ConstructorProperties)
    _init(config?: DtlsServerConnection.ConstructorProperties): void
    /**
     * Creates a new #GDtlsServerConnection wrapping `base_socket`.
     * @param baseSocket the #GDatagramBased to wrap
     * @param certificate the default server certificate, or %NULL
     * @returns the new   #GDtlsServerConnection, or %NULL on error
     */
    static new(
      baseSocket: DatagramBased,
      certificate: TlsCertificate | null
    ): DtlsServerConnection
  }

  module File {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface File {
    // Own properties of Gio-2.0.Gio.File

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.File

    // Has conflict: appendTo(flags: FileCreateFlags, cancellable: Cancellable | null): FileOutputStream
    // Has conflict: appendToAsync(flags: FileCreateFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: appendToFinish(res: AsyncResult): FileOutputStream
    /**
     * Prepares the file attribute query string for copying to `file`.
     *
     * This function prepares an attribute query string to be
     * passed to g_file_query_info() to get a list of attributes
     * normally copied with the file (see g_file_copy_attributes()
     * for the detailed description). This function is used by the
     * implementation of g_file_copy_attributes() and is useful
     * when one needs to query and set the attributes in two
     * stages (e.g., for recursive move of a directory).
     * @param flags a set of #GFileCopyFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns an attribute query string for g_file_query_info(),   or %NULL if an error occurs.
     */
    buildAttributeListForCopy(
      flags: FileCopyFlags,
      cancellable: Cancellable | null
    ): string | null
    // Has conflict: copy(destination: File, flags: FileCopyFlags, cancellable: Cancellable | null, progressCallback: FileProgressCallback | null): boolean
    // Has conflict: copyAsync(destination: File, flags: FileCopyFlags, ioPriority: number, cancellable: Cancellable | null, progressCallback: FileProgressCallback | null, callback: AsyncReadyCallback | null): void
    /**
     * Copies the file attributes from `source` to `destination`.
     *
     * Normally only a subset of the file attributes are copied,
     * those that are copies in a normal file copy operation
     * (which for instance does not include e.g. owner). However
     * if %G_FILE_COPY_ALL_METADATA is specified in `flags,` then
     * all the metadata that is possible to copy is copied. This
     * is useful when implementing move by copy + delete source.
     * @param destination a #GFile to copy attributes to
     * @param flags a set of #GFileCopyFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the attributes were copied successfully,   %FALSE otherwise.
     */
    copyAttributes(
      destination: File,
      flags: FileCopyFlags,
      cancellable: Cancellable | null
    ): boolean
    // Has conflict: copyFinish(res: AsyncResult): boolean
    // Has conflict: create(flags: FileCreateFlags, cancellable: Cancellable | null): FileOutputStream
    // Has conflict: createAsync(flags: FileCreateFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: createFinish(res: AsyncResult): FileOutputStream
    // Has conflict: createReadwrite(flags: FileCreateFlags, cancellable: Cancellable | null): FileIOStream
    // Has conflict: createReadwriteAsync(flags: FileCreateFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: createReadwriteFinish(res: AsyncResult): FileIOStream
    /**
     * Deletes a file. If the `file` is a directory, it will only be
     * deleted if it is empty. This has the same semantics as g_unlink().
     *
     * If `file` doesn’t exist, %G_IO_ERROR_NOT_FOUND will be returned. This allows
     * for deletion to be implemented avoiding
     * [time-of-check to time-of-use races](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use):
     *
     * ```
     * g_autoptr(GError) local_error = NULL;
     * if (!g_file_delete (my_file, my_cancellable, &local_error) &&
     *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
     *   {
     *     // deletion failed for some reason other than the file not existing:
     *     // so report the error
     *     g_warning ("Failed to delete %s: %s",
     *                g_file_peek_path (my_file), local_error->message);
     *   }
     * ```
     *
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the file was deleted. %FALSE otherwise.
     */
    delete(cancellable: Cancellable | null): boolean
    /**
     * Asynchronously delete a file. If the `file` is a directory, it will
     * only be deleted if it is empty.  This has the same semantics as
     * g_unlink().
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
     */
    deleteAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes deleting a file started with g_file_delete_async().
     * @param result a #GAsyncResult
     * @returns %TRUE if the file was deleted. %FALSE otherwise.
     */
    deleteFinish(result: AsyncResult): boolean
    // Has conflict: dup(): File
    // Has conflict: ejectMountable(flags: MountUnmountFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: ejectMountableFinish(result: AsyncResult): boolean
    // Has conflict: ejectMountableWithOperation(flags: MountUnmountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: ejectMountableWithOperationFinish(result: AsyncResult): boolean
    // Has conflict: enumerateChildren(attributes: string, flags: FileQueryInfoFlags, cancellable: Cancellable | null): FileEnumerator
    // Has conflict: enumerateChildrenAsync(attributes: string, flags: FileQueryInfoFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: enumerateChildrenFinish(res: AsyncResult): FileEnumerator
    // Has conflict: equal(file2: File): boolean
    // Has conflict: findEnclosingMount(cancellable: Cancellable | null): Mount
    // Has conflict: findEnclosingMountAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: findEnclosingMountFinish(res: AsyncResult): Mount
    // Has conflict: getBasename(): string | null
    /**
     * Gets a child of `file` with basename equal to `name`.
     *
     * Note that the file with that specific name might not exist, but
     * you can still have a #GFile that points to it. You can use this
     * for instance to create that file.
     *
     * This call does no blocking I/O.
     * @param name string containing the child's basename
     * @returns a #GFile to a child specified by @name.   Free the returned object with g_object_unref().
     */
    getChild(name: string): File
    // Has conflict: getChildForDisplayName(displayName: string): File
    // Has conflict: getParent(): File | null
    // Has conflict: getParseName(): string | null
    // Has conflict: getPath(): string | null
    // Has conflict: getRelativePath(descendant: File): string | null
    // Has conflict: getUri(): string | null
    // Has conflict: getUriScheme(): string | null
    /**
     * Checks if `file` has a parent, and optionally, if it is `parent`.
     *
     * If `parent` is %NULL then this function returns %TRUE if `file` has any
     * parent at all.  If `parent` is non-%NULL then %TRUE is only returned
     * if `file` is an immediate child of `parent`.
     * @param parent the parent to check for, or %NULL
     * @returns %TRUE if @file is an immediate child of @parent (or any parent in   the case that @parent is %NULL).
     */
    hasParent(parent: File | null): boolean
    /**
     * Checks whether `file` has the prefix specified by `prefix`.
     *
     * In other words, if the names of initial elements of `file'`s
     * pathname match `prefix`. Only full pathname elements are matched,
     * so a path like /foo is not considered a prefix of /foobar, only
     * of /foo/bar.
     *
     * A #GFile is not a prefix of itself. If you want to check for
     * equality, use g_file_equal().
     *
     * This call does no I/O, as it works purely on names. As such it can
     * sometimes return %FALSE even if `file` is inside a `prefix` (from a
     * filesystem point of view), because the prefix of `file` is an alias
     * of `prefix`.
     * @param prefix input #GFile
     * @returns %TRUE if the @file's parent, grandparent, etc is @prefix,   %FALSE otherwise.
     */
    hasPrefix(prefix: File): boolean
    // Has conflict: hasUriScheme(uriScheme: string): boolean
    // Has conflict: hash(): number
    // Has conflict: isNative(): boolean
    /**
     * Loads the contents of `file` and returns it as #GBytes.
     *
     * If `file` is a resource:// based URI, the resulting bytes will reference the
     * embedded resource instead of a copy. Otherwise, this is equivalent to calling
     * g_file_load_contents() and g_bytes_new_take().
     *
     * For resources, `etag_out` will be set to %NULL.
     *
     * The data contained in the resulting #GBytes is always zero-terminated, but
     * this is not included in the #GBytes length. The resulting #GBytes should be
     * freed with g_bytes_unref() when no longer in use.
     * @param cancellable a #GCancellable or %NULL
     * @returns a #GBytes or %NULL and @error is set
     */
    loadBytes(
      cancellable: Cancellable | null
    ): [/* returnType */ any, /* etagOut */ string | null]
    /**
     * Asynchronously loads the contents of `file` as #GBytes.
     *
     * If `file` is a resource:// based URI, the resulting bytes will reference the
     * embedded resource instead of a copy. Otherwise, this is equivalent to calling
     * g_file_load_contents_async() and g_bytes_new_take().
     *
     * `callback` should call g_file_load_bytes_finish() to get the result of this
     * asynchronous operation.
     *
     * See g_file_load_bytes() for more information.
     * @param cancellable a #GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    loadBytesAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Completes an asynchronous request to g_file_load_bytes_async().
     *
     * For resources, `etag_out` will be set to %NULL.
     *
     * The data contained in the resulting #GBytes is always zero-terminated, but
     * this is not included in the #GBytes length. The resulting #GBytes should be
     * freed with g_bytes_unref() when no longer in use.
     *
     * See g_file_load_bytes() for more information.
     * @param result a #GAsyncResult provided to the callback
     * @returns a #GBytes or %NULL and @error is set
     */
    loadBytesFinish(
      result: AsyncResult
    ): [/* returnType */ any, /* etagOut */ string | null]
    /**
     * Loads the content of the file into memory. The data is always
     * zero-terminated, but this is not included in the resultant `length`.
     * The returned `contents` should be freed with g_free() when no longer
     * needed.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns %TRUE if the @file's contents were successfully loaded.   %FALSE if there were errors.
     */
    loadContents(
      cancellable: Cancellable | null
    ): [
      /* returnType */ boolean,
      /* contents */ number[],
      /* etagOut */ string | null,
    ]
    /**
     * Starts an asynchronous load of the `file'`s contents.
     *
     * For more details, see g_file_load_contents() which is
     * the synchronous version of this call.
     *
     * When the load operation has completed, `callback` will be called
     * with `user` data. To finish the operation, call
     * g_file_load_contents_finish() with the #GAsyncResult returned by
     * the `callback`.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is satisfied
     */
    loadContentsAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous load of the `file'`s contents.
     * The contents are placed in `contents,` and `length` is set to the
     * size of the `contents` string. The `contents` should be freed with
     * g_free() when no longer needed. If `etag_out` is present, it will be
     * set to the new entity tag for the `file`.
     * @param res a #GAsyncResult
     * @returns %TRUE if the load was successful. If %FALSE and @error is   present, it will be set appropriately.
     */
    loadContentsFinish(
      res: AsyncResult
    ): [
      /* returnType */ boolean,
      /* contents */ number[],
      /* etagOut */ string | null,
    ]
    /**
     * Finishes an asynchronous partial load operation that was started
     * with g_file_load_partial_contents_async(). The data is always
     * zero-terminated, but this is not included in the resultant `length`.
     * The returned `contents` should be freed with g_free() when no longer
     * needed.
     * @param res a #GAsyncResult
     * @returns %TRUE if the load was successful. If %FALSE and @error is   present, it will be set appropriately.
     */
    loadPartialContentsFinish(
      res: AsyncResult
    ): [
      /* returnType */ boolean,
      /* contents */ number[],
      /* etagOut */ string | null,
    ]
    // Has conflict: makeDirectory(cancellable: Cancellable | null): boolean
    // Has conflict: makeDirectoryAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: makeDirectoryFinish(result: AsyncResult): boolean
    /**
     * Creates a directory and any parent directories that may not
     * exist similar to 'mkdir -p'. If the file system does not support
     * creating directories, this function will fail, setting `error` to
     * %G_IO_ERROR_NOT_SUPPORTED. If the directory itself already exists,
     * this function will fail setting `error` to %G_IO_ERROR_EXISTS, unlike
     * the similar g_mkdir_with_parents().
     *
     * For a local #GFile the newly created directories will have the default
     * (current) ownership and permissions of the current process.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if all directories have been successfully created, %FALSE otherwise.
     */
    makeDirectoryWithParents(cancellable: Cancellable | null): boolean
    // Has conflict: makeSymbolicLink(symlinkValue: string, cancellable: Cancellable | null): boolean
    // Has conflict: makeSymbolicLinkAsync(symlinkValue: string, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: makeSymbolicLinkFinish(result: AsyncResult): boolean
    // Has conflict: measureDiskUsage(flags: FileMeasureFlags, cancellable: Cancellable | null, progressCallback: FileMeasureProgressCallback | null): [ /* returnType */ boolean, /* diskUsage */ number, /* numDirs */ number, /* numFiles */ number ]
    // Has conflict: measureDiskUsageFinish(result: AsyncResult): [ /* returnType */ boolean, /* diskUsage */ number, /* numDirs */ number, /* numFiles */ number ]
    /**
     * Obtains a file or directory monitor for the given file,
     * depending on the type of the file.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param flags a set of #GFileMonitorFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileMonitor for the given @file,   or %NULL on error.   Free the returned object with g_object_unref().
     */
    monitor(
      flags: FileMonitorFlags,
      cancellable: Cancellable | null
    ): FileMonitor
    /**
     * Obtains a directory monitor for the given file.
     * This may fail if directory monitoring is not supported.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * It does not make sense for `flags` to contain
     * %G_FILE_MONITOR_WATCH_HARD_LINKS, since hard links can not be made to
     * directories.  It is not possible to monitor all the files in a
     * directory for changes made via hard links; if you want to do this then
     * you must register individual watches with g_file_monitor().
     * @param flags a set of #GFileMonitorFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileMonitor for the given @file,   or %NULL on error. Free the returned object with g_object_unref().
     */
    monitorDirectory(
      flags: FileMonitorFlags,
      cancellable: Cancellable | null
    ): FileMonitor
    // Has conflict: monitorFile(flags: FileMonitorFlags, cancellable: Cancellable | null): FileMonitor
    // Has conflict: mountEnclosingVolume(flags: MountMountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: mountEnclosingVolumeFinish(result: AsyncResult): boolean
    // Has conflict: mountMountable(flags: MountMountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: mountMountableFinish(result: AsyncResult): File
    // Has conflict: move(destination: File, flags: FileCopyFlags, cancellable: Cancellable | null, progressCallback: FileProgressCallback | null): boolean
    // Has conflict: moveAsync(destination: File, flags: FileCopyFlags, ioPriority: number, cancellable: Cancellable | null, progressCallback: FileProgressCallback | null, callback: AsyncReadyCallback | null): void
    // Has conflict: moveFinish(result: AsyncResult): boolean
    // Has conflict: openReadwrite(cancellable: Cancellable | null): FileIOStream
    // Has conflict: openReadwriteAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: openReadwriteFinish(res: AsyncResult): FileIOStream
    /**
     * Exactly like g_file_get_path(), but caches the result via
     * g_object_set_qdata_full().  This is useful for example in C
     * applications which mix `g_file_*` APIs with native ones.  It
     * also avoids an extra duplicated string when possible, so will be
     * generally more efficient.
     *
     * This call does no blocking I/O.
     * @returns string containing the #GFile's path,   or %NULL if no such path exists. The returned string is owned by @file.
     */
    peekPath(): string | null
    // Has conflict: pollMountable(cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: pollMountableFinish(result: AsyncResult): boolean
    /**
     * Returns the #GAppInfo that is registered as the default
     * application to handle the file specified by `file`.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns a #GAppInfo if the handle was found,   %NULL if there were errors.   When you are done with it, release it with g_object_unref()
     */
    queryDefaultHandler(cancellable: Cancellable | null): AppInfo
    /**
     * Async version of g_file_query_default_handler().
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is done
     */
    queryDefaultHandlerAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a g_file_query_default_handler_async() operation.
     * @param result a #GAsyncResult
     * @returns a #GAppInfo if the handle was found,   %NULL if there were errors.   When you are done with it, release it with g_object_unref()
     */
    queryDefaultHandlerFinish(result: AsyncResult): AppInfo
    /**
     * Utility function to check if a particular file exists. This is
     * implemented using g_file_query_info() and as such does blocking I/O.
     *
     * Note that in many cases it is [racy to first check for file existence](https://en.wikipedia.org/wiki/Time_of_check_to_time_of_use)
     * and then execute something based on the outcome of that, because the
     * file might have been created or removed in between the operations. The
     * general approach to handling that is to not check, but just do the
     * operation and handle the errors as they come.
     *
     * As an example of race-free checking, take the case of reading a file,
     * and if it doesn't exist, creating it. There are two racy versions: read
     * it, and on error create it; and: check if it exists, if not create it.
     * These can both result in two processes creating the file (with perhaps
     * a partially written file as the result). The correct approach is to
     * always try to create the file with g_file_create() which will either
     * atomically create the file or fail with a %G_IO_ERROR_EXISTS error.
     *
     * However, in many cases an existence check is useful in a user interface,
     * for instance to make a menu item sensitive/insensitive, so that you don't
     * have to fool users that something is possible and then just show an error
     * dialog. If you do this, you should make sure to also handle the errors
     * that can happen due to races when you execute the operation.
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the file exists (and can be detected without error),   %FALSE otherwise (or if cancelled).
     */
    queryExists(cancellable: Cancellable | null): boolean
    /**
     * Utility function to inspect the #GFileType of a file. This is
     * implemented using g_file_query_info() and as such does blocking I/O.
     *
     * The primary use case of this method is to check if a file is
     * a regular file, directory, or symlink.
     * @param flags a set of #GFileQueryInfoFlags passed to g_file_query_info()
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns The #GFileType of the file and %G_FILE_TYPE_UNKNOWN   if the file does not exist
     */
    queryFileType(
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): FileType
    // Has conflict: queryFilesystemInfo(attributes: string, cancellable: Cancellable | null): FileInfo
    // Has conflict: queryFilesystemInfoAsync(attributes: string, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: queryFilesystemInfoFinish(res: AsyncResult): FileInfo
    // Has conflict: queryInfo(attributes: string, flags: FileQueryInfoFlags, cancellable: Cancellable | null): FileInfo
    // Has conflict: queryInfoAsync(attributes: string, flags: FileQueryInfoFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: queryInfoFinish(res: AsyncResult): FileInfo
    // Has conflict: querySettableAttributes(cancellable: Cancellable | null): FileAttributeInfoList
    // Has conflict: queryWritableNamespaces(cancellable: Cancellable | null): FileAttributeInfoList
    /**
     * Opens a file for reading. The result is a #GFileInputStream that
     * can be used to read the contents of the file.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be
     * returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
     * error will be returned. Other errors are possible too, and depend
     * on what kind of filesystem the file is on.
     * @param cancellable a #GCancellable
     * @returns #GFileInputStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    read(cancellable: Cancellable | null): FileInputStream
    // Has conflict: readAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: readFinish(res: AsyncResult): FileInputStream
    // Has conflict: replace(etag: string | null, makeBackup: boolean, flags: FileCreateFlags, cancellable: Cancellable | null): FileOutputStream
    // Has conflict: replaceAsync(etag: string | null, makeBackup: boolean, flags: FileCreateFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    /**
     * Replaces the contents of `file` with `contents` of `length` bytes.
     *
     * If `etag` is specified (not %NULL), any existing file must have that etag,
     * or the error %G_IO_ERROR_WRONG_ETAG will be returned.
     *
     * If `make_backup` is %TRUE, this function will attempt to make a backup
     * of `file`. Internally, it uses g_file_replace(), so will try to replace the
     * file contents in the safest way possible. For example, atomic renames are
     * used when replacing local files’ contents.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * The returned `new_etag` can be used to verify that the file hasn't
     * changed the next time it is saved over.
     * @param contents a string containing the new contents for `file`
     * @param etag the old [entity-tag](#entity-tags) for the document,   or %NULL
     * @param makeBackup %TRUE if a backup should be created
     * @param flags a set of #GFileCreateFlags
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns %TRUE if successful. If an error has occurred, this function   will return %FALSE and set @error appropriately if present.
     */
    replaceContents(
      contents: number[],
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ): [/* returnType */ boolean, /* newEtag */ string | null]
    /**
     * Starts an asynchronous replacement of `file` with the given
     * `contents` of `length` bytes. `etag` will replace the document's
     * current entity tag.
     *
     * When this operation has completed, `callback` will be called with
     * `user_user` data, and the operation can be finalized with
     * g_file_replace_contents_finish().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * If `make_backup` is %TRUE, this function will attempt to
     * make a backup of `file`.
     *
     * Note that no copy of `contents` will be made, so it must stay valid
     * until `callback` is called. See g_file_replace_contents_bytes_async()
     * for a #GBytes version that will automatically hold a reference to the
     * contents (without copying) for the duration of the call.
     * @param contents string of contents to replace the file with
     * @param etag a new [entity tag](#entity-tags) for the `file,` or %NULL
     * @param makeBackup %TRUE if a backup should be created
     * @param flags a set of #GFileCreateFlags
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is satisfied
     */
    replaceContentsAsync(
      contents: number[],
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Same as g_file_replace_contents_async() but takes a #GBytes input instead.
     * This function will keep a ref on `contents` until the operation is done.
     * Unlike g_file_replace_contents_async() this allows forgetting about the
     * content without waiting for the callback.
     *
     * When this operation has completed, `callback` will be called with
     * `user_user` data, and the operation can be finalized with
     * g_file_replace_contents_finish().
     * @param contents a #GBytes
     * @param etag a new [entity tag](#entity-tags) for the `file,` or %NULL
     * @param makeBackup %TRUE if a backup should be created
     * @param flags a set of #GFileCreateFlags
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is satisfied
     */
    replaceContentsBytesAsync(
      contents: any,
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous replace of the given `file`. See
     * g_file_replace_contents_async(). Sets `new_etag` to the new entity
     * tag for the document, if present.
     * @param res a #GAsyncResult
     * @returns %TRUE on success, %FALSE on failure.
     */
    replaceContentsFinish(
      res: AsyncResult
    ): [/* returnType */ boolean, /* newEtag */ string | null]
    // Has conflict: replaceFinish(res: AsyncResult): FileOutputStream
    // Has conflict: replaceReadwrite(etag: string | null, makeBackup: boolean, flags: FileCreateFlags, cancellable: Cancellable | null): FileIOStream
    // Has conflict: replaceReadwriteAsync(etag: string | null, makeBackup: boolean, flags: FileCreateFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: replaceReadwriteFinish(res: AsyncResult): FileIOStream
    // Has conflict: resolveRelativePath(relativePath: string): File
    // Has conflict: setAttribute(attribute: string, type: FileAttributeType, valueP: any | null, flags: FileQueryInfoFlags, cancellable: Cancellable | null): boolean
    /**
     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING to `value`.
     * If `attribute` is of a different type, this operation will fail,
     * returning %FALSE.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param attribute a string containing the attribute's name
     * @param value a string containing the attribute's new value
     * @param flags a #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the @attribute was successfully set to @value   in the @file, %FALSE otherwise.
     */
    setAttributeByteString(
      attribute: string,
      value: string,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_INT32 to `value`.
     * If `attribute` is of a different type, this operation will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param attribute a string containing the attribute's name
     * @param value a #gint32 containing the attribute's new value
     * @param flags a #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the @attribute was successfully set to @value   in the @file, %FALSE otherwise.
     */
    setAttributeInt32(
      attribute: string,
      value: number,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_INT64 to `value`.
     * If `attribute` is of a different type, this operation will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param attribute a string containing the attribute's name
     * @param value a #guint64 containing the attribute's new value
     * @param flags a #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the @attribute was successfully set, %FALSE otherwise.
     */
    setAttributeInt64(
      attribute: string,
      value: number,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_STRING to `value`.
     * If `attribute` is of a different type, this operation will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param attribute a string containing the attribute's name
     * @param value a string containing the attribute's value
     * @param flags #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the @attribute was successfully set, %FALSE otherwise.
     */
    setAttributeString(
      attribute: string,
      value: string,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_UINT32 to `value`.
     * If `attribute` is of a different type, this operation will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param attribute a string containing the attribute's name
     * @param value a #guint32 containing the attribute's new value
     * @param flags a #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the @attribute was successfully set to @value   in the @file, %FALSE otherwise.
     */
    setAttributeUint32(
      attribute: string,
      value: number,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_UINT64 to `value`.
     * If `attribute` is of a different type, this operation will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param attribute a string containing the attribute's name
     * @param value a #guint64 containing the attribute's new value
     * @param flags a #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the @attribute was successfully set to @value   in the @file, %FALSE otherwise.
     */
    setAttributeUint64(
      attribute: string,
      value: number,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    // Has conflict: setAttributesAsync(info: FileInfo, flags: FileQueryInfoFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: setAttributesFinish(result: AsyncResult): [ /* returnType */ boolean, /* info */ FileInfo ]
    // Has conflict: setAttributesFromInfo(info: FileInfo, flags: FileQueryInfoFlags, cancellable: Cancellable | null): boolean
    // Has conflict: setDisplayName(displayName: string, cancellable: Cancellable | null): File
    // Has conflict: setDisplayNameAsync(displayName: string, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: setDisplayNameFinish(res: AsyncResult): File
    // Has conflict: startMountable(flags: DriveStartFlags, startOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: startMountableFinish(result: AsyncResult): boolean
    // Has conflict: stopMountable(flags: MountUnmountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: stopMountableFinish(result: AsyncResult): boolean
    /**
     * Checks if `file` supports
     * [thread-default contexts][g-main-context-push-thread-default-context].
     * If this returns %FALSE, you cannot perform asynchronous operations on
     * `file` in a thread that has a thread-default context.
     * @returns Whether or not @file supports thread-default contexts.
     */
    supportsThreadContexts(): boolean
    // Has conflict: trash(cancellable: Cancellable | null): boolean
    // Has conflict: trashAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: trashFinish(result: AsyncResult): boolean
    // Has conflict: unmountMountable(flags: MountUnmountFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: unmountMountableFinish(result: AsyncResult): boolean
    // Has conflict: unmountMountableWithOperation(flags: MountUnmountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: unmountMountableWithOperationFinish(result: AsyncResult): boolean

    // Own virtual methods of Gio-2.0.Gio.File

    /**
     * Gets an output stream for appending data to the file.
     * If the file doesn't already exist it is created.
     *
     * By default files created are generally readable by everyone,
     * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
     * will be made readable only to the current user, to the level that
     * is supported on the target filesystem.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled
     * by triggering the cancellable object from another thread. If the
     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
     * returned.
     *
     * Some file systems don't allow all file names, and may return an
     * %G_IO_ERROR_INVALID_FILENAME error. If the file is a directory the
     * %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are
     * possible too, and depend on what kind of filesystem the file is on.
     * @virtual
     * @param flags a set of #GFileCreateFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileOutputStream, or %NULL on error.   Free the returned object with g_object_unref().
     */
    appendTo(
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ): FileOutputStream
    /**
     * Asynchronously opens `file` for appending.
     *
     * For more details, see g_file_append_to() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_append_to_finish() to get the result
     * of the operation.
     * @virtual
     * @param flags a set of #GFileCreateFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    appendToAsync(
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file append operation started with
     * g_file_append_to_async().
     * @virtual
     * @param res #GAsyncResult
     * @returns a valid #GFileOutputStream   or %NULL on error.   Free the returned object with g_object_unref().
     */
    appendToFinish(res: AsyncResult): FileOutputStream
    /**
     * Copies the file `source` to the location specified by `destination`.
     * Can not handle recursive copies of directories.
     *
     * If the flag %G_FILE_COPY_OVERWRITE is specified an already
     * existing `destination` file is overwritten.
     *
     * If the flag %G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
     * will be copied as symlinks, otherwise the target of the
     * `source` symlink will be copied.
     *
     * If the flag %G_FILE_COPY_ALL_METADATA is specified then all the metadata
     * that is possible to copy is copied, not just the default subset (which,
     * for instance, does not include the owner, see #GFileInfo).
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * If `progress_callback` is not %NULL, then the operation can be monitored
     * by setting this to a #GFileProgressCallback function.
     * `progress_callback_data` will be passed to this function. It is guaranteed
     * that this callback will be called after all data has been transferred with
     * the total number of bytes copied during the operation.
     *
     * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND error
     * is returned, independent on the status of the `destination`.
     *
     * If %G_FILE_COPY_OVERWRITE is not specified and the target exists, then
     * the error %G_IO_ERROR_EXISTS is returned.
     *
     * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
     * error is returned. If trying to overwrite a directory with a directory the
     * %G_IO_ERROR_WOULD_MERGE error is returned.
     *
     * If the source is a directory and the target does not exist, or
     * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then the
     * %G_IO_ERROR_WOULD_RECURSE error is returned.
     *
     * If you are interested in copying the #GFile object itself (not the on-disk
     * file), see g_file_dup().
     * @virtual
     * @param destination destination #GFile
     * @param flags set of #GFileCopyFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param progressCallback function to callback with   progress information, or %NULL if progress information is not needed
     * @returns %TRUE on success, %FALSE otherwise.
     */
    copy(
      destination: File,
      flags: FileCopyFlags,
      cancellable: Cancellable | null,
      progressCallback: FileProgressCallback | null
    ): boolean
    /**
     * Copies the file `source` to the location specified by `destination`
     * asynchronously. For details of the behaviour, see g_file_copy().
     *
     * If `progress_callback` is not %NULL, then that function that will be called
     * just like in g_file_copy(). The callback will run in the default main context
     * of the thread calling g_file_copy_async() — the same context as `callback` is
     * run in.
     *
     * When the operation is finished, `callback` will be called. You can then call
     * g_file_copy_finish() to get the result of the operation.
     * @virtual
     * @param destination destination #GFile
     * @param flags set of #GFileCopyFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param progressCallback function to callback with progress information, or %NULL if   progress information is not needed
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    copyAsync(
      destination: File,
      flags: FileCopyFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      progressCallback: FileProgressCallback | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes copying the file started with g_file_copy_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a %TRUE on success, %FALSE on error.
     */
    copyFinish(res: AsyncResult): boolean
    /**
     * Creates a new file and returns an output stream for writing to it.
     * The file must not already exist.
     *
     * By default files created are generally readable by everyone,
     * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
     * will be made readable only to the current user, to the level
     * that is supported on the target filesystem.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled
     * by triggering the cancellable object from another thread. If the
     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
     * returned.
     *
     * If a file or directory with this name already exists the
     * %G_IO_ERROR_EXISTS error will be returned. Some file systems don't
     * allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME
     * error, and if the name is to long %G_IO_ERROR_FILENAME_TOO_LONG will
     * be returned. Other errors are possible too, and depend on what kind
     * of filesystem the file is on.
     * @virtual
     * @param flags a set of #GFileCreateFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileOutputStream for the newly created   file, or %NULL on error.   Free the returned object with g_object_unref().
     */
    create(
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ): FileOutputStream
    /**
     * Asynchronously creates a new file and returns an output stream
     * for writing to it. The file must not already exist.
     *
     * For more details, see g_file_create() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_create_finish() to get the result
     * of the operation.
     * @virtual
     * @param flags a set of #GFileCreateFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    createAsync(
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file create operation started with
     * g_file_create_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a #GFileOutputStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    createFinish(res: AsyncResult): FileOutputStream
    /**
     * Creates a new file and returns a stream for reading and
     * writing to it. The file must not already exist.
     *
     * By default files created are generally readable by everyone,
     * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
     * will be made readable only to the current user, to the level
     * that is supported on the target filesystem.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled
     * by triggering the cancellable object from another thread. If the
     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
     * returned.
     *
     * If a file or directory with this name already exists, the
     * %G_IO_ERROR_EXISTS error will be returned. Some file systems don't
     * allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME
     * error, and if the name is too long, %G_IO_ERROR_FILENAME_TOO_LONG
     * will be returned. Other errors are possible too, and depend on what
     * kind of filesystem the file is on.
     *
     * Note that in many non-local file cases read and write streams are
     * not supported, so make sure you really need to do read and write
     * streaming, rather than just opening for reading or writing.
     * @virtual
     * @param flags a set of #GFileCreateFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileIOStream for the newly created   file, or %NULL on error.   Free the returned object with g_object_unref().
     */
    createReadwrite(
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ): FileIOStream
    /**
     * Asynchronously creates a new file and returns a stream
     * for reading and writing to it. The file must not already exist.
     *
     * For more details, see g_file_create_readwrite() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_create_readwrite_finish() to get
     * the result of the operation.
     * @virtual
     * @param flags a set of #GFileCreateFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    createReadwriteAsync(
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file create operation started with
     * g_file_create_readwrite_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a #GFileIOStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    createReadwriteFinish(res: AsyncResult): FileIOStream
    /**
     * Deletes a file. If the `file` is a directory, it will only be
     * deleted if it is empty. This has the same semantics as g_unlink().
     *
     * If `file` doesn’t exist, %G_IO_ERROR_NOT_FOUND will be returned. This allows
     * for deletion to be implemented avoiding
     * [time-of-check to time-of-use races](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use):
     *
     * ```
     * g_autoptr(GError) local_error = NULL;
     * if (!g_file_delete (my_file, my_cancellable, &local_error) &&
     *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
     *   {
     *     // deletion failed for some reason other than the file not existing:
     *     // so report the error
     *     g_warning ("Failed to delete %s: %s",
     *                g_file_peek_path (my_file), local_error->message);
     *   }
     * ```
     *
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the file was deleted. %FALSE otherwise.
     */
    deleteFile(cancellable: Cancellable | null): boolean
    /**
     * Asynchronously delete a file. If the `file` is a directory, it will
     * only be deleted if it is empty.  This has the same semantics as
     * g_unlink().
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
     */
    deleteFileAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes deleting a file started with g_file_delete_async().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the file was deleted. %FALSE otherwise.
     */
    deleteFileFinish(result: AsyncResult): boolean
    /**
     * Duplicates a #GFile handle. This operation does not duplicate
     * the actual file or directory represented by the #GFile; see
     * g_file_copy() if attempting to copy a file.
     *
     * g_file_dup() is useful when a second handle is needed to the same underlying
     * file, for use in a separate thread (#GFile is not thread-safe). For use
     * within the same thread, use g_object_ref() to increment the existing object’s
     * reference count.
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns a new #GFile that is a duplicate   of the given #GFile.
     */
    dup(): File
    /**
     * Starts an asynchronous eject on a mountable.
     * When this operation has completed, `callback` will be called with
     * `user_user` data, and the operation can be finalized with
     * g_file_eject_mountable_finish().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param flags flags affecting the operation
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    ejectMountable(
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous eject operation started by
     * g_file_eject_mountable().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the @file was ejected successfully.   %FALSE otherwise.
     */
    ejectMountableFinish(result: AsyncResult): boolean
    /**
     * Starts an asynchronous eject on a mountable.
     * When this operation has completed, `callback` will be called with
     * `user_user` data, and the operation can be finalized with
     * g_file_eject_mountable_with_operation_finish().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation,   or %NULL to avoid user interaction
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    ejectMountableWithOperation(
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous eject operation started by
     * g_file_eject_mountable_with_operation().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the @file was ejected successfully.   %FALSE otherwise.
     */
    ejectMountableWithOperationFinish(result: AsyncResult): boolean
    /**
     * Gets the requested information about the files in a directory.
     * The result is a #GFileEnumerator object that will give out
     * #GFileInfo objects for all the files in the directory.
     *
     * The `attributes` value is a string that specifies the file
     * attributes that should be gathered. It is not an error if
     * it's not possible to read a particular requested attribute
     * from a file - it just won't be set. `attributes` should
     * be a comma-separated list of attributes or attribute wildcards.
     * The wildcard "*" means all attributes, and a wildcard like
     * "standard::*" means all attributes in the standard namespace.
     * An example attribute query be "standard::*,owner::user".
     * The standard attributes are available as defines, like
     * %G_FILE_ATTRIBUTE_STANDARD_NAME. %G_FILE_ATTRIBUTE_STANDARD_NAME should
     * always be specified if you plan to call g_file_enumerator_get_child() or
     * g_file_enumerator_iterate() on the returned enumerator.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled
     * by triggering the cancellable object from another thread. If the
     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
     * returned.
     *
     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
     * be returned. If the file is not a directory, the %G_IO_ERROR_NOT_DIRECTORY
     * error will be returned. Other errors are possible too.
     * @virtual
     * @param attributes an attribute query string
     * @param flags a set of #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns A #GFileEnumerator if successful,   %NULL on error. Free the returned object with g_object_unref().
     */
    enumerateChildren(
      attributes: string,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): FileEnumerator
    /**
     * Asynchronously gets the requested information about the files
     * in a directory. The result is a #GFileEnumerator object that will
     * give out #GFileInfo objects for all the files in the directory.
     *
     * For more details, see g_file_enumerate_children() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called. You can
     * then call g_file_enumerate_children_finish() to get the result of
     * the operation.
     * @virtual
     * @param attributes an attribute query string
     * @param flags a set of #GFileQueryInfoFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    enumerateChildrenAsync(
      attributes: string,
      flags: FileQueryInfoFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async enumerate children operation.
     * See g_file_enumerate_children_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a #GFileEnumerator or %NULL   if an error occurred.   Free the returned object with g_object_unref().
     */
    enumerateChildrenFinish(res: AsyncResult): FileEnumerator
    /**
     * Checks if the two given #GFiles refer to the same file.
     *
     * Note that two #GFiles that differ can still refer to the same
     * file on the filesystem due to various forms of filename
     * aliasing.
     *
     * This call does no blocking I/O.
     * @virtual
     * @param file2 the second #GFile
     * @returns %TRUE if @file1 and @file2 are equal.
     */
    equal(file2: File): boolean
    /**
     * Gets a #GMount for the #GFile.
     *
     * #GMount is returned only for user interesting locations, see
     * #GVolumeMonitor. If the #GFileIface for `file` does not have a #mount,
     * `error` will be set to %G_IO_ERROR_NOT_FOUND and %NULL #will be returned.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GMount where the @file is located   or %NULL on error.   Free the returned object with g_object_unref().
     */
    findEnclosingMount(cancellable: Cancellable | null): Mount
    /**
     * Asynchronously gets the mount for the file.
     *
     * For more details, see g_file_find_enclosing_mount() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_find_enclosing_mount_finish() to
     * get the result of the operation.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    findEnclosingMountAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous find mount request.
     * See g_file_find_enclosing_mount_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns #GMount for given @file or %NULL on error.   Free the returned object with g_object_unref().
     */
    findEnclosingMountFinish(res: AsyncResult): Mount
    /**
     * Gets the base name (the last component of the path) for a given #GFile.
     *
     * If called for the top level of a system (such as the filesystem root
     * or a uri like sftp://host/) it will return a single directory separator
     * (and on Windows, possibly a drive letter).
     *
     * The base name is a byte string (not UTF-8). It has no defined encoding
     * or rules other than it may not contain zero bytes.  If you want to use
     * filenames in a user interface you should use the display name that you
     * can get by requesting the %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME
     * attribute with g_file_query_info().
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns string containing the #GFile's   base name, or %NULL if given #GFile is invalid. The returned string   should be freed with g_free() when no longer needed.
     */
    getBasename(): string | null
    /**
     * Gets the child of `file` for a given `display_name` (i.e. a UTF-8
     * version of the name). If this function fails, it returns %NULL
     * and `error` will be set. This is very useful when constructing a
     * #GFile for a new file and the user entered the filename in the
     * user interface, for instance when you select a directory and
     * type a filename in the file selector.
     *
     * This call does no blocking I/O.
     * @virtual
     * @param displayName string to a possible child
     * @returns a #GFile to the specified child, or   %NULL if the display name couldn't be converted.   Free the returned object with g_object_unref().
     */
    getChildForDisplayName(displayName: string): File
    /**
     * Gets the parent directory for the `file`.
     * If the `file` represents the root directory of the
     * file system, then %NULL will be returned.
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns a #GFile structure to the   parent of the given #GFile or %NULL if there is no parent. Free   the returned object with g_object_unref().
     */
    getParent(): File | null
    /**
     * Gets the parse name of the `file`.
     * A parse name is a UTF-8 string that describes the
     * file such that one can get the #GFile back using
     * g_file_parse_name().
     *
     * This is generally used to show the #GFile as a nice
     * full-pathname kind of string in a user interface,
     * like in a location entry.
     *
     * For local files with names that can safely be converted
     * to UTF-8 the pathname is used, otherwise the IRI is used
     * (a form of URI that allows UTF-8 characters unescaped).
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns a string containing the #GFile's parse name.   The returned string should be freed with g_free()   when no longer needed.
     */
    getParseName(): string | null
    /**
     * Gets the local pathname for #GFile, if one exists. If non-%NULL, this is
     * guaranteed to be an absolute, canonical path. It might contain symlinks.
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns string containing the #GFile's path,   or %NULL if no such path exists. The returned string should be freed   with g_free() when no longer needed.
     */
    getPath(): string | null
    /**
     * Gets the path for `descendant` relative to `parent`.
     *
     * This call does no blocking I/O.
     * @virtual
     * @param descendant input #GFile
     * @returns string with the relative path from   @descendant to @parent, or %NULL if @descendant doesn't have @parent as   prefix. The returned string should be freed with g_free() when   no longer needed.
     */
    getRelativePath(descendant: File): string | null
    /**
     * Gets the URI for the `file`.
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns a string containing the #GFile's URI. If the #GFile was constructed   with an invalid URI, an invalid URI is returned.   The returned string should be freed with g_free()   when no longer needed.
     */
    getUri(): string | null
    /**
     * Gets the URI scheme for a #GFile.
     * RFC 3986 decodes the scheme as:
     *
     * ```
     * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
     * ```
     *
     * Common schemes include "file", "http", "ftp", etc.
     *
     * The scheme can be different from the one used to construct the #GFile,
     * in that it might be replaced with one that is logically equivalent to the #GFile.
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns a string containing the URI scheme for the given   #GFile or %NULL if the #GFile was constructed with an invalid URI. The   returned string should be freed with g_free() when no longer needed.
     */
    getUriScheme(): string | null
    /**
     * Checks to see if a #GFile has a given URI scheme.
     *
     * This call does no blocking I/O.
     * @virtual
     * @param uriScheme a string containing a URI scheme
     * @returns %TRUE if #GFile's backend supports the   given URI scheme, %FALSE if URI scheme is %NULL,   not supported, or #GFile is invalid.
     */
    hasUriScheme(uriScheme: string): boolean
    /**
     * Creates a hash value for a #GFile.
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns 0 if @file is not a valid #GFile, otherwise an   integer that can be used as hash value for the #GFile.   This function is intended for easily hashing a #GFile to   add to a #GHashTable or similar data structure.
     */
    hash(): number
    /**
     * Checks to see if a file is native to the platform.
     *
     * A native file is one expressed in the platform-native filename format,
     * e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local,
     * as it might be on a locally mounted remote filesystem.
     *
     * On some systems non-native files may be available using the native
     * filesystem via a userspace filesystem (FUSE), in these cases this call
     * will return %FALSE, but g_file_get_path() will still return a native path.
     *
     * This call does no blocking I/O.
     * @virtual
     * @returns %TRUE if @file is native
     */
    isNative(): boolean
    /**
     * Creates a directory. Note that this will only create a child directory
     * of the immediate parent directory of the path or URI given by the #GFile.
     * To recursively create directories, see g_file_make_directory_with_parents().
     * This function will fail if the parent directory does not exist, setting
     * `error` to %G_IO_ERROR_NOT_FOUND. If the file system doesn't support
     * creating directories, this function will fail, setting `error` to
     * %G_IO_ERROR_NOT_SUPPORTED.
     *
     * For a local #GFile the newly created directory will have the default
     * (current) ownership and permissions of the current process.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE on successful creation, %FALSE otherwise.
     */
    makeDirectory(cancellable: Cancellable | null): boolean
    /**
     * Asynchronously creates a directory.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
     */
    makeDirectoryAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous directory creation, started with
     * g_file_make_directory_async().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE on successful directory creation, %FALSE otherwise.
     */
    makeDirectoryFinish(result: AsyncResult): boolean
    /**
     * Creates a symbolic link named `file` which contains the string
     * `symlink_value`.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param symlinkValue a string with the path for the target   of the new symlink
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE on the creation of a new symlink, %FALSE otherwise.
     */
    makeSymbolicLink(
      symlinkValue: string,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Asynchronously creates a symbolic link named `file` which contains the
     * string `symlink_value`.
     * @virtual
     * @param symlinkValue a string with the path for the target   of the new symlink
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
     */
    makeSymbolicLinkAsync(
      symlinkValue: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous symbolic link creation, started with
     * g_file_make_symbolic_link_async().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE on successful directory creation, %FALSE otherwise.
     */
    makeSymbolicLinkFinish(result: AsyncResult): boolean
    /**
     * Recursively measures the disk usage of `file`.
     *
     * This is essentially an analog of the 'du' command, but it also
     * reports the number of directories and non-directory files encountered
     * (including things like symbolic links).
     *
     * By default, errors are only reported against the toplevel file
     * itself.  Errors found while recursing are silently ignored, unless
     * %G_FILE_MEASURE_REPORT_ANY_ERROR is given in `flags`.
     *
     * The returned size, `disk_usage,` is in bytes and should be formatted
     * with g_format_size() in order to get something reasonable for showing
     * in a user interface.
     *
     * `progress_callback` and `progress_data` can be given to request
     * periodic progress updates while scanning.  See the documentation for
     * #GFileMeasureProgressCallback for information about when and how the
     * callback will be invoked.
     * @virtual
     * @param flags #GFileMeasureFlags
     * @param cancellable optional #GCancellable
     * @param progressCallback a #GFileMeasureProgressCallback
     * @returns %TRUE if successful, with the out parameters set.   %FALSE otherwise, with @error set.
     */
    measureDiskUsage(
      flags: FileMeasureFlags,
      cancellable: Cancellable | null,
      progressCallback: FileMeasureProgressCallback | null
    ): [
      /* returnType */ boolean,
      /* diskUsage */ number,
      /* numDirs */ number,
      /* numFiles */ number,
    ]
    /**
     * Collects the results from an earlier call to
     * g_file_measure_disk_usage_async().  See g_file_measure_disk_usage() for
     * more information.
     * @virtual
     * @param result the #GAsyncResult passed to your #GAsyncReadyCallback
     * @returns %TRUE if successful, with the out parameters set.   %FALSE otherwise, with @error set.
     */
    measureDiskUsageFinish(
      result: AsyncResult
    ): [
      /* returnType */ boolean,
      /* diskUsage */ number,
      /* numDirs */ number,
      /* numFiles */ number,
    ]
    /**
     * Obtains a directory monitor for the given file.
     * This may fail if directory monitoring is not supported.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * It does not make sense for `flags` to contain
     * %G_FILE_MONITOR_WATCH_HARD_LINKS, since hard links can not be made to
     * directories.  It is not possible to monitor all the files in a
     * directory for changes made via hard links; if you want to do this then
     * you must register individual watches with g_file_monitor().
     * @virtual
     * @param flags a set of #GFileMonitorFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileMonitor for the given @file,   or %NULL on error. Free the returned object with g_object_unref().
     */
    monitorDir(
      flags: FileMonitorFlags,
      cancellable: Cancellable | null
    ): FileMonitor
    /**
     * Obtains a file monitor for the given file. If no file notification
     * mechanism exists, then regular polling of the file is used.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * If `flags` contains %G_FILE_MONITOR_WATCH_HARD_LINKS then the monitor
     * will also attempt to report changes made to the file via another
     * filename (ie, a hard link). Without this flag, you can only rely on
     * changes made through the filename contained in `file` to be
     * reported. Using this flag may result in an increase in resource
     * usage, and may not have any effect depending on the #GFileMonitor
     * backend and/or filesystem type.
     * @virtual
     * @param flags a set of #GFileMonitorFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileMonitor for the given @file,   or %NULL on error.   Free the returned object with g_object_unref().
     */
    monitorFile(
      flags: FileMonitorFlags,
      cancellable: Cancellable | null
    ): FileMonitor
    /**
     * Starts a `mount_operation,` mounting the volume that contains
     * the file `location`.
     *
     * When this operation has completed, `callback` will be called with
     * `user_user` data, and the operation can be finalized with
     * g_file_mount_enclosing_volume_finish().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation   or %NULL to avoid user interaction
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
     */
    mountEnclosingVolume(
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a mount operation started by g_file_mount_enclosing_volume().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if successful. If an error has occurred,   this function will return %FALSE and set @error   appropriately if present.
     */
    mountEnclosingVolumeFinish(result: AsyncResult): boolean
    /**
     * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
     * Using `mount_operation,` you can request callbacks when, for instance,
     * passwords are needed during authentication.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_mount_mountable_finish() to get
     * the result of the operation.
     * @virtual
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation,   or %NULL to avoid user interaction
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    mountMountable(
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a mount operation. See g_file_mount_mountable() for details.
     *
     * Finish an asynchronous mount operation that was started
     * with g_file_mount_mountable().
     * @virtual
     * @param result a #GAsyncResult
     * @returns a #GFile or %NULL on error.   Free the returned object with g_object_unref().
     */
    mountMountableFinish(result: AsyncResult): File
    /**
     * Tries to move the file or directory `source` to the location specified
     * by `destination`. If native move operations are supported then this is
     * used, otherwise a copy + delete fallback is used. The native
     * implementation may support moving directories (for instance on moves
     * inside the same filesystem), but the fallback code does not.
     *
     * If the flag %G_FILE_COPY_OVERWRITE is specified an already
     * existing `destination` file is overwritten.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * If `progress_callback` is not %NULL, then the operation can be monitored
     * by setting this to a #GFileProgressCallback function.
     * `progress_callback_data` will be passed to this function. It is
     * guaranteed that this callback will be called after all data has been
     * transferred with the total number of bytes copied during the operation.
     *
     * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND
     * error is returned, independent on the status of the `destination`.
     *
     * If %G_FILE_COPY_OVERWRITE is not specified and the target exists,
     * then the error %G_IO_ERROR_EXISTS is returned.
     *
     * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
     * error is returned. If trying to overwrite a directory with a directory the
     * %G_IO_ERROR_WOULD_MERGE error is returned.
     *
     * If the source is a directory and the target does not exist, or
     * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then
     * the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native
     * move operation isn't available).
     * @virtual
     * @param destination #GFile pointing to the destination location
     * @param flags set of #GFileCopyFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param progressCallback #GFileProgressCallback   function for updates
     * @returns %TRUE on successful move, %FALSE otherwise.
     */
    move(
      destination: File,
      flags: FileCopyFlags,
      cancellable: Cancellable | null,
      progressCallback: FileProgressCallback | null
    ): boolean
    /**
     * Asynchronously moves a file `source` to the location of `destination`. For details of the behaviour, see g_file_move().
     *
     * If `progress_callback` is not %NULL, then that function that will be called
     * just like in g_file_move(). The callback will run in the default main context
     * of the thread calling g_file_move_async() — the same context as `callback` is
     * run in.
     *
     * When the operation is finished, `callback` will be called. You can then call
     * g_file_move_finish() to get the result of the operation.
     * @virtual
     * @param destination #GFile pointing to the destination location
     * @param flags set of #GFileCopyFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param progressCallback #GFileProgressCallback function for updates
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    moveAsync(
      destination: File,
      flags: FileCopyFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      progressCallback: FileProgressCallback | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file movement, started with
     * g_file_move_async().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE on successful file move, %FALSE otherwise.
     */
    moveFinish(result: AsyncResult): boolean
    /**
     * Opens an existing file for reading and writing. The result is
     * a #GFileIOStream that can be used to read and write the contents
     * of the file.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled
     * by triggering the cancellable object from another thread. If the
     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
     * returned.
     *
     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
     * be returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
     * error will be returned. Other errors are possible too, and depend on
     * what kind of filesystem the file is on. Note that in many non-local
     * file cases read and write streams are not supported, so make sure you
     * really need to do read and write streaming, rather than just opening
     * for reading or writing.
     * @virtual
     * @param cancellable a #GCancellable
     * @returns #GFileIOStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    openReadwrite(cancellable: Cancellable | null): FileIOStream
    /**
     * Asynchronously opens `file` for reading and writing.
     *
     * For more details, see g_file_open_readwrite() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_open_readwrite_finish() to get
     * the result of the operation.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    openReadwriteAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file read operation started with
     * g_file_open_readwrite_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a #GFileIOStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    openReadwriteFinish(res: AsyncResult): FileIOStream
    /**
     * Polls a file of type %G_FILE_TYPE_MOUNTABLE.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_mount_mountable_finish() to get
     * the result of the operation.
     * @virtual
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
     */
    pollMountable(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a poll operation. See g_file_poll_mountable() for details.
     *
     * Finish an asynchronous poll operation that was polled
     * with g_file_poll_mountable().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the operation finished successfully. %FALSE otherwise.
     */
    pollMountableFinish(result: AsyncResult): boolean
    /**
     * Checks whether `file` has the prefix specified by `prefix`.
     *
     * In other words, if the names of initial elements of `file'`s
     * pathname match `prefix`. Only full pathname elements are matched,
     * so a path like /foo is not considered a prefix of /foobar, only
     * of /foo/bar.
     *
     * A #GFile is not a prefix of itself. If you want to check for
     * equality, use g_file_equal().
     *
     * This call does no I/O, as it works purely on names. As such it can
     * sometimes return %FALSE even if `file` is inside a `prefix` (from a
     * filesystem point of view), because the prefix of `file` is an alias
     * of `prefix`.
     * @virtual
     * @param file input #GFile
     * @returns %TRUE if the @file's parent, grandparent, etc is @prefix,   %FALSE otherwise.
     */
    prefixMatches(file: File): boolean
    /**
     * Similar to g_file_query_info(), but obtains information
     * about the filesystem the `file` is on, rather than the file itself.
     * For instance the amount of space available and the type of
     * the filesystem.
     *
     * The `attributes` value is a string that specifies the attributes
     * that should be gathered. It is not an error if it's not possible
     * to read a particular requested attribute from a file - it just
     * won't be set. `attributes` should be a comma-separated list of
     * attributes or attribute wildcards. The wildcard "*" means all
     * attributes, and a wildcard like "filesystem::*" means all attributes
     * in the filesystem namespace. The standard namespace for filesystem
     * attributes is "filesystem". Common attributes of interest are
     * %G_FILE_ATTRIBUTE_FILESYSTEM_SIZE (the total size of the filesystem
     * in bytes), %G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of bytes available),
     * and %G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled
     * by triggering the cancellable object from another thread. If the
     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
     * returned.
     *
     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
     * be returned. Other errors are possible too, and depend on what
     * kind of filesystem the file is on.
     * @virtual
     * @param attributes an attribute query string
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileInfo or %NULL if there was an error.   Free the returned object with g_object_unref().
     */
    queryFilesystemInfo(
      attributes: string,
      cancellable: Cancellable | null
    ): FileInfo
    /**
     * Asynchronously gets the requested information about the filesystem
     * that the specified `file` is on. The result is a #GFileInfo object
     * that contains key-value attributes (such as type or size for the
     * file).
     *
     * For more details, see g_file_query_filesystem_info() which is the
     * synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called. You can
     * then call g_file_query_info_finish() to get the result of the
     * operation.
     * @virtual
     * @param attributes an attribute query string
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    queryFilesystemInfoAsync(
      attributes: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous filesystem info query.
     * See g_file_query_filesystem_info_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns #GFileInfo for given @file   or %NULL on error.   Free the returned object with g_object_unref().
     */
    queryFilesystemInfoFinish(res: AsyncResult): FileInfo
    /**
     * Gets the requested information about specified `file`.
     * The result is a #GFileInfo object that contains key-value
     * attributes (such as the type or size of the file).
     *
     * The `attributes` value is a string that specifies the file
     * attributes that should be gathered. It is not an error if
     * it's not possible to read a particular requested attribute
     * from a file - it just won't be set. `attributes` should be a
     * comma-separated list of attributes or attribute wildcards.
     * The wildcard "*" means all attributes, and a wildcard like
     * "standard::*" means all attributes in the standard namespace.
     * An example attribute query be "standard::*,owner::user".
     * The standard attributes are available as defines, like
     * %G_FILE_ATTRIBUTE_STANDARD_NAME.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled
     * by triggering the cancellable object from another thread. If the
     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
     * returned.
     *
     * For symlinks, normally the information about the target of the
     * symlink is returned, rather than information about the symlink
     * itself. However if you pass %G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS
     * in `flags` the information about the symlink itself will be returned.
     * Also, for symlinks that point to non-existing files the information
     * about the symlink itself will be returned.
     *
     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be
     * returned. Other errors are possible too, and depend on what kind of
     * filesystem the file is on.
     * @virtual
     * @param attributes an attribute query string
     * @param flags a set of #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileInfo for the given @file, or %NULL   on error. Free the returned object with g_object_unref().
     */
    queryInfo(
      attributes: string,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): FileInfo
    /**
     * Asynchronously gets the requested information about specified `file`.
     * The result is a #GFileInfo object that contains key-value attributes
     * (such as type or size for the file).
     *
     * For more details, see g_file_query_info() which is the synchronous
     * version of this call.
     *
     * When the operation is finished, `callback` will be called. You can
     * then call g_file_query_info_finish() to get the result of the operation.
     * @virtual
     * @param attributes an attribute query string
     * @param flags a set of #GFileQueryInfoFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    queryInfoAsync(
      attributes: string,
      flags: FileQueryInfoFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file info query.
     * See g_file_query_info_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns #GFileInfo for given @file   or %NULL on error. Free the returned object with   g_object_unref().
     */
    queryInfoFinish(res: AsyncResult): FileInfo
    /**
     * Obtain the list of settable attributes for the file.
     *
     * Returns the type and full attribute name of all the attributes
     * that can be set on this file. This doesn't mean setting it will
     * always succeed though, you might get an access failure, or some
     * specific file may not support a specific attribute.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileAttributeInfoList describing the settable attributes.   When you are done with it, release it with   g_file_attribute_info_list_unref()
     */
    querySettableAttributes(
      cancellable: Cancellable | null
    ): FileAttributeInfoList
    /**
     * Obtain the list of attribute namespaces where new attributes
     * can be created by a user. An example of this is extended
     * attributes (in the "xattr" namespace).
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileAttributeInfoList describing the writable namespaces.   When you are done with it, release it with   g_file_attribute_info_list_unref()
     */
    queryWritableNamespaces(
      cancellable: Cancellable | null
    ): FileAttributeInfoList
    /**
     * Asynchronously opens `file` for reading.
     *
     * For more details, see g_file_read() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_read_finish() to get the result
     * of the operation.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    readAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file read operation started with
     * g_file_read_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a #GFileInputStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    readFinish(res: AsyncResult): FileInputStream
    /**
     * Opens a file for reading. The result is a #GFileInputStream that
     * can be used to read the contents of the file.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be
     * returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
     * error will be returned. Other errors are possible too, and depend
     * on what kind of filesystem the file is on.
     * @virtual
     * @param cancellable a #GCancellable
     * @returns #GFileInputStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    readFn(cancellable: Cancellable | null): FileInputStream
    /**
     * Returns an output stream for overwriting the file, possibly
     * creating a backup copy of the file first. If the file doesn't exist,
     * it will be created.
     *
     * This will try to replace the file in the safest way possible so
     * that any errors during the writing will not affect an already
     * existing copy of the file. For instance, for local files it
     * may write to a temporary file and then atomically rename over
     * the destination when the stream is closed.
     *
     * By default files created are generally readable by everyone,
     * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
     * will be made readable only to the current user, to the level that
     * is supported on the target filesystem.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled
     * by triggering the cancellable object from another thread. If the
     * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
     * returned.
     *
     * If you pass in a non-%NULL `etag` value and `file` already exists, then
     * this value is compared to the current entity tag of the file, and if
     * they differ an %G_IO_ERROR_WRONG_ETAG error is returned. This
     * generally means that the file has been changed since you last read
     * it. You can get the new etag from g_file_output_stream_get_etag()
     * after you've finished writing and closed the #GFileOutputStream. When
     * you load a new file you can use g_file_input_stream_query_info() to
     * get the etag of the file.
     *
     * If `make_backup` is %TRUE, this function will attempt to make a
     * backup of the current file before overwriting it. If this fails
     * a %G_IO_ERROR_CANT_CREATE_BACKUP error will be returned. If you
     * want to replace anyway, try again with `make_backup` set to %FALSE.
     *
     * If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will
     * be returned, and if the file is some other form of non-regular file
     * then a %G_IO_ERROR_NOT_REGULAR_FILE error will be returned. Some
     * file systems don't allow all file names, and may return an
     * %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long
     * %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are
     * possible too, and depend on what kind of filesystem the file is on.
     * @virtual
     * @param etag an optional [entity tag](#entity-tags)   for the current #GFile, or #NULL to ignore
     * @param makeBackup %TRUE if a backup should be created
     * @param flags a set of #GFileCreateFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileOutputStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    replace(
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ): FileOutputStream
    /**
     * Asynchronously overwrites the file, replacing the contents,
     * possibly creating a backup copy of the file first.
     *
     * For more details, see g_file_replace() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_replace_finish() to get the result
     * of the operation.
     * @virtual
     * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
     * @param makeBackup %TRUE if a backup should be created
     * @param flags a set of #GFileCreateFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    replaceAsync(
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file replace operation started with
     * g_file_replace_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a #GFileOutputStream, or %NULL on error.   Free the returned object with g_object_unref().
     */
    replaceFinish(res: AsyncResult): FileOutputStream
    /**
     * Returns an output stream for overwriting the file in readwrite mode,
     * possibly creating a backup copy of the file first. If the file doesn't
     * exist, it will be created.
     *
     * For details about the behaviour, see g_file_replace() which does the
     * same thing but returns an output stream only.
     *
     * Note that in many non-local file cases read and write streams are not
     * supported, so make sure you really need to do read and write streaming,
     * rather than just opening for reading or writing.
     * @virtual
     * @param etag an optional [entity tag](#entity-tags)   for the current #GFile, or #NULL to ignore
     * @param makeBackup %TRUE if a backup should be created
     * @param flags a set of #GFileCreateFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFileIOStream or %NULL on error.   Free the returned object with g_object_unref().
     */
    replaceReadwrite(
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ): FileIOStream
    /**
     * Asynchronously overwrites the file in read-write mode,
     * replacing the contents, possibly creating a backup copy
     * of the file first.
     *
     * For more details, see g_file_replace_readwrite() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_replace_readwrite_finish() to get
     * the result of the operation.
     * @virtual
     * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
     * @param makeBackup %TRUE if a backup should be created
     * @param flags a set of #GFileCreateFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    replaceReadwriteAsync(
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file replace operation started with
     * g_file_replace_readwrite_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a #GFileIOStream, or %NULL on error.   Free the returned object with g_object_unref().
     */
    replaceReadwriteFinish(res: AsyncResult): FileIOStream
    /**
     * Resolves a relative path for `file` to an absolute path.
     *
     * This call does no blocking I/O.
     *
     * If the `relative_path` is an absolute path name, the resolution
     * is done absolutely (without taking `file` path as base).
     * @virtual
     * @param relativePath a given relative path string
     * @returns a #GFile for the resolved path.
     */
    resolveRelativePath(relativePath: string): File
    /**
     * Sets an attribute in the file with attribute name `attribute` to `value_p`.
     *
     * Some attributes can be unset by setting `type` to
     * %G_FILE_ATTRIBUTE_TYPE_INVALID and `value_p` to %NULL.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param attribute a string containing the attribute's name
     * @param type The type of the attribute
     * @param valueP a pointer to the value (or the pointer   itself if the type is a pointer type)
     * @param flags a set of #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE if the attribute was set, %FALSE otherwise.
     */
    setAttribute(
      attribute: string,
      type: FileAttributeType,
      valueP: any | null,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Asynchronously sets the attributes of `file` with `info`.
     *
     * For more details, see g_file_set_attributes_from_info(),
     * which is the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_set_attributes_finish() to get
     * the result of the operation.
     * @virtual
     * @param info a #GFileInfo
     * @param flags a #GFileQueryInfoFlags
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    setAttributesAsync(
      info: FileInfo,
      flags: FileQueryInfoFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes setting an attribute started in g_file_set_attributes_async().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the attributes were set correctly, %FALSE otherwise.
     */
    setAttributesFinish(
      result: AsyncResult
    ): [/* returnType */ boolean, /* info */ FileInfo]
    /**
     * Tries to set all attributes in the #GFileInfo on the target
     * values, not stopping on the first error.
     *
     * If there is any error during this operation then `error` will
     * be set to the first error. Error on particular fields are flagged
     * by setting the "status" field in the attribute value to
     * %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can
     * also detect further errors.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param info a #GFileInfo
     * @param flags #GFileQueryInfoFlags
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %FALSE if there was any error, %TRUE otherwise.
     */
    setAttributesFromInfo(
      info: FileInfo,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Renames `file` to the specified display name.
     *
     * The display name is converted from UTF-8 to the correct encoding
     * for the target filesystem if possible and the `file` is renamed to this.
     *
     * If you want to implement a rename operation in the user interface the
     * edit name (%G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the
     * initial value in the rename widget, and then the result after editing
     * should be passed to g_file_set_display_name().
     *
     * On success the resulting converted filename is returned.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param displayName a string
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns a #GFile specifying what @file was renamed to,   or %NULL if there was an error.   Free the returned object with g_object_unref().
     */
    setDisplayName(displayName: string, cancellable: Cancellable | null): File
    /**
     * Asynchronously sets the display name for a given #GFile.
     *
     * For more details, see g_file_set_display_name() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_set_display_name_finish() to get
     * the result of the operation.
     * @virtual
     * @param displayName a string
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    setDisplayNameAsync(
      displayName: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes setting a display name started with
     * g_file_set_display_name_async().
     * @virtual
     * @param res a #GAsyncResult
     * @returns a #GFile or %NULL on error.   Free the returned object with g_object_unref().
     */
    setDisplayNameFinish(res: AsyncResult): File
    /**
     * Starts a file of type %G_FILE_TYPE_MOUNTABLE.
     * Using `start_operation,` you can request callbacks when, for instance,
     * passwords are needed during authentication.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_mount_mountable_finish() to get
     * the result of the operation.
     * @virtual
     * @param flags flags affecting the operation
     * @param startOperation a #GMountOperation, or %NULL to avoid user interaction
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is satisfied, or %NULL
     */
    startMountable(
      flags: DriveStartFlags,
      startOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a start operation. See g_file_start_mountable() for details.
     *
     * Finish an asynchronous start operation that was started
     * with g_file_start_mountable().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the operation finished successfully. %FALSE otherwise.
     */
    startMountableFinish(result: AsyncResult): boolean
    /**
     * Stops a file of type %G_FILE_TYPE_MOUNTABLE.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_stop_mountable_finish() to get
     * the result of the operation.
     * @virtual
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation,   or %NULL to avoid user interaction.
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
     */
    stopMountable(
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a stop operation, see g_file_stop_mountable() for details.
     *
     * Finish an asynchronous stop operation that was started
     * with g_file_stop_mountable().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the operation finished successfully.   %FALSE otherwise.
     */
    stopMountableFinish(result: AsyncResult): boolean
    /**
     * Sends `file` to the "Trashcan", if possible. This is similar to
     * deleting it, but the user can recover it before emptying the trashcan.
     * Not all file systems support trashing, so this call can return the
     * %G_IO_ERROR_NOT_SUPPORTED error. Since GLib 2.66, the `x-gvfs-notrash` unix
     * mount option can be used to disable g_file_trash() support for certain
     * mounts, the %G_IO_ERROR_NOT_SUPPORTED error will be returned in that case.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @returns %TRUE on successful trash, %FALSE otherwise.
     */
    trash(cancellable: Cancellable | null): boolean
    /**
     * Asynchronously sends `file` to the Trash location, if possible.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
     */
    trashAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous file trashing operation, started with
     * g_file_trash_async().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE on successful trash, %FALSE otherwise.
     */
    trashFinish(result: AsyncResult): boolean
    /**
     * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_unmount_mountable_finish() to get
     * the result of the operation.
     * @virtual
     * @param flags flags affecting the operation
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    unmountMountable(
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an unmount operation, see g_file_unmount_mountable() for details.
     *
     * Finish an asynchronous unmount operation that was started
     * with g_file_unmount_mountable().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the operation finished successfully.   %FALSE otherwise.
     */
    unmountMountableFinish(result: AsyncResult): boolean
    /**
     * Unmounts a file of type %G_FILE_TYPE_MOUNTABLE.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_file_unmount_mountable_finish() to get
     * the result of the operation.
     * @virtual
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation,   or %NULL to avoid user interaction
     * @param cancellable optional #GCancellable object,   %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    unmountMountableWithOperation(
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an unmount operation,
     * see g_file_unmount_mountable_with_operation() for details.
     *
     * Finish an asynchronous unmount operation that was started
     * with g_file_unmount_mountable_with_operation().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the operation finished successfully.   %FALSE otherwise.
     */
    unmountMountableWithOperationFinish(result: AsyncResult): boolean

    // Class property signals of Gio-2.0.Gio.File

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GFile` is a high level abstraction for manipulating files on a
   * virtual file system. `GFile`s are lightweight, immutable objects
   * that do no I/O upon creation. It is necessary to understand that
   * `GFile` objects do not represent files, merely an identifier for a
   * file. All file content I/O is implemented as streaming operations
   * (see [class`Gio`.InputStream] and [class`Gio`.OutputStream]).
   *
   * To construct a `GFile`, you can use:
   *
   * - [func`Gio`.File.new_for_path] if you have a path.
   * - [func`Gio`.File.new_for_uri] if you have a URI.
   * - [func`Gio`.File.new_for_commandline_arg] or
   *   [func`Gio`.File.new_for_commandline_arg_and_cwd] for a command line
   *   argument.
   * - [func`Gio`.File.new_tmp] to create a temporary file from a template.
   * - [func`Gio`.File.new_tmp_async] to asynchronously create a temporary file.
   * - [func`Gio`.File.new_tmp_dir_async] to asynchronously create a temporary
   *   directory.
   * - [func`Gio`.File.parse_name] from a UTF-8 string gotten from
   *   [method`Gio`.File.get_parse_name].
   * - [func`Gio`.File.new_build_filename] or [func`Gio`.File.new_build_filenamev]
   *   to create a file from path elements.
   *
   * One way to think of a `GFile` is as an abstraction of a pathname. For
   * normal files the system pathname is what is stored internally, but as
   * `GFile`s are extensible it could also be something else that corresponds
   * to a pathname in a userspace implementation of a filesystem.
   *
   * `GFile`s make up hierarchies of directories and files that correspond to
   * the files on a filesystem. You can move through the file system with
   * `GFile` using [method`Gio`.File.get_parent] to get an identifier for the
   * parent directory, [method`Gio`.File.get_child] to get a child within a
   * directory, and [method`Gio`.File.resolve_relative_path] to resolve a relative
   * path between two `GFile`s. There can be multiple hierarchies, so you may not
   * end up at the same root if you repeatedly call [method`Gio`.File.get_parent]
   * on two different files.
   *
   * All `GFile`s have a basename (get with [method`Gio`.File.get_basename]). These
   * names are byte strings that are used to identify the file on the filesystem
   * (relative to its parent directory) and there is no guarantees that they
   * have any particular charset encoding or even make any sense at all. If
   * you want to use filenames in a user interface you should use the display
   * name that you can get by requesting the
   * `G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME` attribute with
   * [method`Gio`.File.query_info]. This is guaranteed to be in UTF-8 and can be
   * used in a user interface. But always store the real basename or the `GFile`
   * to use to actually access the file, because there is no way to go from a
   * display name to the actual name.
   *
   * Using `GFile` as an identifier has the same weaknesses as using a path
   * in that there may be multiple aliases for the same file. For instance,
   * hard or soft links may cause two different `GFile`s to refer to the same
   * file. Other possible causes for aliases are: case insensitive filesystems,
   * short and long names on FAT/NTFS, or bind mounts in Linux. If you want to
   * check if two `GFile`s point to the same file you can query for the
   * `G_FILE_ATTRIBUTE_ID_FILE` attribute. Note that `GFile` does some trivial
   * canonicalization of pathnames passed in, so that trivial differences in
   * the path string used at creation (duplicated slashes, slash at end of
   * path, `.` or `..` path segments, etc) does not create different `GFile`s.
   *
   * Many `GFile` operations have both synchronous and asynchronous versions
   * to suit your application. Asynchronous versions of synchronous functions
   * simply have `_async()` appended to their function names. The asynchronous
   * I/O functions call a [callback`Gio`.AsyncReadyCallback] which is then used to
   * finalize the operation, producing a [iface`Gio`.AsyncResult] which is then
   * passed to the function’s matching `_finish()` operation.
   *
   * It is highly recommended to use asynchronous calls when running within a
   * shared main loop, such as in the main thread of an application. This avoids
   * I/O operations blocking other sources on the main loop from being dispatched.
   * Synchronous I/O operations should be performed from worker threads. See the
   * [introduction to asynchronous programming section](overview.html#asynchronous-programming)
   * for more.
   *
   * Some `GFile` operations almost always take a noticeable amount of time, and
   * so do not have synchronous analogs. Notable cases include:
   *
   * - [method`Gio`.File.mount_mountable] to mount a mountable file.
   * - [method`Gio`.File.unmount_mountable_with_operation] to unmount a mountable
   *   file.
   * - [method`Gio`.File.eject_mountable_with_operation] to eject a mountable file.
   *
   * ## Entity Tags
   *
   * One notable feature of `GFile`s are entity tags, or ‘etags’ for
   * short. Entity tags are somewhat like a more abstract version of the
   * traditional mtime, and can be used to quickly determine if the file
   * has been modified from the version on the file system. See the
   * HTTP 1.1
   * [specification](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html)
   * for HTTP `ETag` headers, which are a very similar concept.
   * @interface
   */
  class File extends GObject.Object {
    // Own properties of Gio-2.0.Gio.File

    static name: string

    // Constructors of Gio-2.0.Gio.File

    constructor(config?: File.ConstructorProperties)
    _init(config?: File.ConstructorProperties): void
    /**
     * Constructs a #GFile from a vector of elements using the correct
     * separator for filenames.
     *
     * Using this function is equivalent to calling g_build_filenamev(),
     * followed by g_file_new_for_path() on the result.
     * @param args %NULL-terminated   array of strings containing the path elements.
     * @returns a new #GFile
     */
    static newBuildFilenamev(args: string[]): File
    /**
     * Creates a #GFile with the given argument from the command line.
     * The value of `arg` can be either a URI, an absolute path or a
     * relative path resolved relative to the current working directory.
     * This operation never fails, but the returned object might not
     * support any I/O operation if `arg` points to a malformed path.
     *
     * Note that on Windows, this function expects its argument to be in
     * UTF-8 -- not the system code page.  This means that you
     * should not use this function with string from argv as it is passed
     * to main().  g_win32_get_command_line() will return a UTF-8 version of
     * the commandline.  #GApplication also uses UTF-8 but
     * g_application_command_line_create_file_for_arg() may be more useful
     * for you there.  It is also always possible to use this function with
     * #GOptionContext arguments of type %G_OPTION_ARG_FILENAME.
     * @param arg a command line string
     * @returns a new #GFile.   Free the returned object with g_object_unref().
     */
    static newForCommandlineArg(arg: string): File
    /**
     * Creates a #GFile with the given argument from the command line.
     *
     * This function is similar to g_file_new_for_commandline_arg() except
     * that it allows for passing the current working directory as an
     * argument instead of using the current working directory of the
     * process.
     *
     * This is useful if the commandline argument was given in a context
     * other than the invocation of the current process.
     *
     * See also g_application_command_line_create_file_for_arg().
     * @param arg a command line string
     * @param cwd the current working directory of the commandline
     * @returns a new #GFile
     */
    static newForCommandlineArgAndCwd(arg: string, cwd: string): File
    /**
     * Constructs a #GFile for a given path. This operation never
     * fails, but the returned object might not support any I/O
     * operation if `path` is malformed.
     * @param path a string containing a relative or absolute path.   The string must be encoded in the glib filename encoding.
     * @returns a new #GFile for the given @path.   Free the returned object with g_object_unref().
     */
    static newForPath(path: string): File
    /**
     * Constructs a #GFile for a given URI. This operation never
     * fails, but the returned object might not support any I/O
     * operation if `uri` is malformed or if the uri type is
     * not supported.
     * @param uri a UTF-8 string containing a URI
     * @returns a new #GFile for the given @uri.   Free the returned object with g_object_unref().
     */
    static newForUri(uri: string): File
    /**
     * Opens a file in the preferred directory for temporary files (as
     * returned by g_get_tmp_dir()) and returns a #GFile and
     * #GFileIOStream pointing to it.
     *
     * `tmpl` should be a string in the GLib file name encoding
     * containing a sequence of six 'X' characters, and containing no
     * directory components. If it is %NULL, a default template is used.
     *
     * Unlike the other #GFile constructors, this will return %NULL if
     * a temporary file could not be created.
     * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
     * @returns a new #GFile.   Free the returned object with g_object_unref().
     */
    static newTmp(
      tmpl: string | null
    ): [/* returnType */ File, /* iostream */ FileIOStream]
    /**
     * Asynchronously opens a file in the preferred directory for temporary files
     *  (as returned by g_get_tmp_dir()) as g_file_new_tmp().
     *
     * `tmpl` should be a string in the GLib file name encoding
     * containing a sequence of six 'X' characters, and containing no
     * directory components. If it is %NULL, a default template is used.
     * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is done
     */
    static newTmpAsync(
      tmpl: string | null,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Asynchronously creates a directory in the preferred directory for
     * temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
     *
     * `tmpl` should be a string in the GLib file name encoding
     * containing a sequence of six 'X' characters, and containing no
     * directory components. If it is %NULL, a default template is used.
     * @param tmpl Template for the file   name, as in g_dir_make_tmp(), or %NULL for a default template
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback to call when the request is done
     */
    static newTmpDirAsync(
      tmpl: string | null,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a temporary directory creation started by
     * g_file_new_tmp_dir_async().
     * @param result a #GAsyncResult
     * @returns a new #GFile.   Free the returned object with g_object_unref().
     */
    static newTmpDirFinish(result: AsyncResult): File
    /**
     * Finishes a temporary file creation started by g_file_new_tmp_async().
     * @param result a #GAsyncResult
     * @returns a new #GFile.   Free the returned object with g_object_unref().
     */
    static newTmpFinish(
      result: AsyncResult
    ): [/* returnType */ File, /* iostream */ FileIOStream]
    /**
     * Constructs a #GFile with the given `parse_name` (i.e. something
     * given by g_file_get_parse_name()). This operation never fails,
     * but the returned object might not support any I/O operation if
     * the `parse_name` cannot be parsed.
     * @param parseName a file name or path to be parsed
     * @returns a new #GFile.
     */
    static parseName(parseName: string): File
  }

  module FileDescriptorBased {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface FileDescriptorBased {
    // Own properties of Gio-2.0.Gio.FileDescriptorBased

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.FileDescriptorBased

    // Has conflict: getFd(): number

    // Own virtual methods of Gio-2.0.Gio.FileDescriptorBased

    /**
     * Gets the underlying file descriptor.
     * @virtual
     * @returns The file descriptor
     */
    getFd(): number

    // Class property signals of Gio-2.0.Gio.FileDescriptorBased

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GFileDescriptorBased` is an interface for file descriptor based IO.
   *
   * It is implemented by streams (implementations of [class`Gio`.InputStream] or
   * [class`Gio`.OutputStream]) that are based on file descriptors.
   *
   * Note that `<gio/gfiledescriptorbased.h>` belongs to the UNIX-specific
   * GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
   * file or the `GioUnix-2.0` GIR namespace when using it.
   * @interface
   */
  class FileDescriptorBased extends GObject.Object {
    // Own properties of Gio-2.0.Gio.FileDescriptorBased

    static name: string

    // Constructors of Gio-2.0.Gio.FileDescriptorBased

    constructor(config?: FileDescriptorBased.ConstructorProperties)
    _init(config?: FileDescriptorBased.ConstructorProperties): void
  }

  module Icon {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Icon {
    // Own properties of Gio-2.0.Gio.Icon

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Icon

    // Has conflict: equal(icon2: Icon | null): boolean
    // Has conflict: hash(): number
    // Has conflict: serialize(): GLib.Variant | null
    /**
     * Generates a textual representation of `icon` that can be used for
     * serialization such as when passing `icon` to a different process or
     * saving it to persistent storage. Use g_icon_new_for_string() to
     * get `icon` back from the returned string.
     *
     * The encoding of the returned string is proprietary to #GIcon except
     * in the following two cases
     *
     * - If `icon` is a #GFileIcon, the returned string is a native path
     *   (such as `/path/to/my icon.png`) without escaping
     *   if the #GFile for `icon` is a native file.  If the file is not
     *   native, the returned string is the result of g_file_get_uri()
     *   (such as `sftp://path/to/my%20icon.png`).
     *
     * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
     *   the encoding is simply the name (such as `network-server`).
     * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
     */
    toString(): string | null

    // Own virtual methods of Gio-2.0.Gio.Icon

    /**
     * Checks if two icons are equal.
     * @virtual
     * @param icon2 pointer to the second #GIcon.
     * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
     */
    equal(icon2: Icon | null): boolean
    /**
     * Gets a hash for an icon.
     * @virtual
     * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
     */
    hash(): number
    /**
     * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
     * back by calling g_icon_deserialize() on the returned value.
     * As serialization will avoid using raw icon data when possible, it only
     * makes sense to transfer the #GVariant between processes on the same machine,
     * (as opposed to over the network), and within the same file system namespace.
     * @virtual
     * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
     */
    serialize(): GLib.Variant | null
    /**
     * Serializes the `icon` into string tokens.
     * This is can be invoked when g_icon_new_for_string() is called.
     * @virtual
     * @returns %TRUE if serialization took place, %FALSE otherwise
     */
    toTokens(): [
      /* returnType */ boolean,
      /* tokens */ string[],
      /* outVersion */ number,
    ]

    // Class property signals of Gio-2.0.Gio.Icon

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GIcon` is a very minimal interface for icons. It provides functions
   * for checking the equality of two icons, hashing of icons and
   * serializing an icon to and from strings.
   *
   * `GIcon` does not provide the actual pixmap for the icon as this is out
   * of GIO's scope, however implementations of `GIcon` may contain the name
   * of an icon (see [class`Gio`.ThemedIcon]), or the path to an icon
   * (see [iface`Gio`.LoadableIcon]).
   *
   * To obtain a hash of a `GIcon`, see [method`Gio`.Icon.hash].
   *
   * To check if two `GIcon`s are equal, see [method`Gio`.Icon.equal].
   *
   * For serializing a `GIcon`, use [method`Gio`.Icon.serialize] and
   * [func`Gio`.Icon.deserialize].
   *
   * If you want to consume `GIcon` (for example, in a toolkit) you must
   * be prepared to handle at least the three following cases:
   * [iface`Gio`.LoadableIcon], [class`Gio`.ThemedIcon] and [class`Gio`.EmblemedIcon].
   * It may also make sense to have fast-paths for other cases (like handling
   * [`GdkPixbuf`](https://docs.gtk.org/gdk-pixbuf/class.Pixbuf.html) directly,
   * for example) but all compliant `GIcon` implementations outside of GIO must
   * implement [iface`Gio`.LoadableIcon].
   *
   * If your application or library provides one or more `GIcon`
   * implementations you need to ensure that your new implementation also
   * implements [iface`Gio`.LoadableIcon].  Additionally, you must provide an
   * implementation of [method`Gio`.Icon.serialize] that gives a result that is
   * understood by [func`Gio`.Icon.deserialize], yielding one of the built-in
   * icon types.
   * @interface
   */
  class Icon extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Icon

    static name: string

    // Constructors of Gio-2.0.Gio.Icon

    constructor(config?: Icon.ConstructorProperties)
    _init(config?: Icon.ConstructorProperties): void
    /**
     * Generate a #GIcon instance from `str`. This function can fail if
     * `str` is not valid - see g_icon_to_string() for discussion.
     *
     * If your application or library provides one or more #GIcon
     * implementations you need to ensure that each #GType is registered
     * with the type system prior to calling g_icon_new_for_string().
     * @param str A string obtained via g_icon_to_string().
     * @returns An object implementing the #GIcon          interface or %NULL if @error is set.
     */
    static newForString(str: string): Icon
    /**
     * Deserializes a #GIcon previously serialized using g_icon_serialize().
     * @param value a #GVariant created with g_icon_serialize()
     * @returns a #GIcon, or %NULL when deserialization fails.
     */
    static deserialize(value: GLib.Variant): Icon | null
  }

  module Initable {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Initable {
    // Own properties of Gio-2.0.Gio.Initable

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Initable

    // Has conflict: init(cancellable: Cancellable | null): boolean

    // Own virtual methods of Gio-2.0.Gio.Initable

    /**
     * Initializes the object implementing the interface.
     *
     * This method is intended for language bindings. If writing in C,
     * g_initable_new() should typically be used instead.
     *
     * The object must be initialized before any real use after initial
     * construction, either with this function or g_async_initable_init_async().
     *
     * Implementations may also support cancellation. If `cancellable` is not %NULL,
     * then initialization can be cancelled by triggering the cancellable object
     * from another thread. If the operation was cancelled, the error
     * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
     * the object doesn't support cancellable initialization the error
     * %G_IO_ERROR_NOT_SUPPORTED will be returned.
     *
     * If the object is not initialized, or initialization returns with an
     * error, then all operations on the object except g_object_ref() and
     * g_object_unref() are considered to be invalid, and have undefined
     * behaviour. See the [introduction][ginitable] for more details.
     *
     * Callers should not assume that a class which implements #GInitable can be
     * initialized multiple times, unless the class explicitly documents itself as
     * supporting this. Generally, a class’ implementation of init() can assume
     * (and assert) that it will only be called once. Previously, this documentation
     * recommended all #GInitable implementations should be idempotent; that
     * recommendation was relaxed in GLib 2.54.
     *
     * If a class explicitly supports being initialized multiple times, it is
     * recommended that the method is idempotent: multiple calls with the same
     * arguments should return the same results. Only the first call initializes
     * the object; further calls return the result of the first call.
     *
     * One reason why a class might need to support idempotent initialization is if
     * it is designed to be used via the singleton pattern, with a
     * #GObjectClass.constructor that sometimes returns an existing instance.
     * In this pattern, a caller would expect to be able to call g_initable_init()
     * on the result of g_object_new(), regardless of whether it is in fact a new
     * instance.
     * @virtual
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
     */
    init(cancellable: Cancellable | null): boolean

    // Class property signals of Gio-2.0.Gio.Initable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GInitable` is implemented by objects that can fail during
   * initialization. If an object implements this interface then
   * it must be initialized as the first thing after construction,
   * either via [method`Gio`.Initable.init] or [method`Gio`.AsyncInitable.init_async]
   * (the latter is only available if it also implements [iface`Gio`.AsyncInitable]).
   *
   * If the object is not initialized, or initialization returns with an
   * error, then all operations on the object except `g_object_ref()` and
   * `g_object_unref()` are considered to be invalid, and have undefined
   * behaviour. They will often fail with [func`GLib`.critical] or
   * [func`GLib`.warning], but this must not be relied on.
   *
   * Users of objects implementing this are not intended to use
   * the interface method directly, instead it will be used automatically
   * in various ways. For C applications you generally just call
   * [func`Gio`.Initable.new] directly, or indirectly via a `foo_thing_new()` wrapper.
   * This will call [method`Gio`.Initable.init] under the cover, returning `NULL`
   * and setting a `GError` on failure (at which point the instance is
   * unreferenced).
   *
   * For bindings in languages where the native constructor supports
   * exceptions the binding could check for objects implementing `GInitable`
   * during normal construction and automatically initialize them, throwing
   * an exception on failure.
   * @interface
   */
  class Initable extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Initable

    static name: string

    // Constructors of Gio-2.0.Gio.Initable

    constructor(config?: Initable.ConstructorProperties)
    _init(config?: Initable.ConstructorProperties): void
    // Has conflict: static newv(objectType: GObject.GType, parameters: GObject.Parameter[], cancellable: Cancellable | null): GObject.Object

    // Overloads of newv

    /**
     * Creates a new instance of a #GObject subtype and sets its properties.
     *
     * Construction parameters (see %G_PARAM_CONSTRUCT, %G_PARAM_CONSTRUCT_ONLY)
     * which are not explicitly specified are set to their default values.
     * @constructor
     * @param objectType the type id of the #GObject subtype to instantiate
     * @param parameters an array of #GParameter
     * @returns a new instance of @object_type
     */
    static newv(
      objectType: GObject.GType,
      parameters: GObject.Parameter[]
    ): GObject.Object
  }

  module ListModel {
    // Signal callback interfaces

    /**
     * Signal callback interface for `items-changed`
     */
    interface ItemsChangedSignalCallback {
      (position: number, removed: number, added: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ListModel {
    // Own properties of Gio-2.0.Gio.ListModel

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ListModel

    // Has conflict: getItemType(): GObject.GType
    // Has conflict: getNItems(): number
    // Has conflict: getItem(position: number): GObject.Object | null
    /**
     * Emits the #GListModel::items-changed signal on `list`.
     *
     * This function should only be called by classes implementing
     * #GListModel. It has to be called after the internal representation
     * of `list` has been updated, because handlers connected to this signal
     * might query the new state of the list.
     *
     * Implementations must only make changes to the model (as visible to
     * its consumer) in places that will not cause problems for that
     * consumer.  For models that are driven directly by a write API (such
     * as #GListStore), changes can be reported in response to uses of that
     * API.  For models that represent remote data, changes should only be
     * made from a fresh mainloop dispatch.  It is particularly not
     * permitted to make changes in response to a call to the #GListModel
     * consumer API.
     *
     * Stated another way: in general, it is assumed that code making a
     * series of accesses to the model via the API, without returning to the
     * mainloop, and without calling other code, will continue to view the
     * same contents of the model.
     * @param position the position at which `list` changed
     * @param removed the number of items removed
     * @param added the number of items added
     */
    itemsChanged(position: number, removed: number, added: number): void

    // Own virtual methods of Gio-2.0.Gio.ListModel

    /**
     * Get the item at `position`. If `position` is greater than the number of
     * items in `list,` %NULL is returned.
     *
     * %NULL is never returned for an index that is smaller than the length
     * of the list.  See g_list_model_get_n_items().
     *
     * The same #GObject instance may not appear more than once in a #GListModel.
     * @virtual
     * @param position the position of the item to fetch
     * @returns the object at @position.
     */
    getItem(position: number): GObject.Object | null
    /**
     * Gets the type of the items in `list`.
     *
     * All items returned from g_list_model_get_item() are of the type
     * returned by this function, or a subtype, or if the type is an
     * interface, they are an implementation of that interface.
     *
     * The item type of a #GListModel can not change during the life of the
     * model.
     * @virtual
     * @returns the #GType of the items contained in @list.
     */
    getItemType(): GObject.GType
    /**
     * Gets the number of items in `list`.
     *
     * Depending on the model implementation, calling this function may be
     * less efficient than iterating the list with increasing values for
     * `position` until g_list_model_get_item() returns %NULL.
     * @virtual
     * @returns the number of items in @list.
     */
    getNItems(): number

    // Own signals of Gio-2.0.Gio.ListModel

    connect(
      sigName: "items-changed",
      callback: ListModel.ItemsChangedSignalCallback
    ): number
    on(
      sigName: "items-changed",
      callback: ListModel.ItemsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "items-changed",
      callback: ListModel.ItemsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "items-changed",
      callback: ListModel.ItemsChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "items-changed",
      removed: number,
      added: number,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.ListModel

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GListModel` is an interface that represents a mutable list of
   * [class`GObject`.Object]. Its main intention is as a model for various widgets
   * in user interfaces, such as list views, but it can also be used as a
   * convenient method of returning lists of data, with support for
   * updates.
   *
   * Each object in the list may also report changes in itself via some
   * mechanism (normally the [signal`GObject`.Object::notify] signal).  Taken
   * together with the [signal`Gio`.ListModel::items-changed] signal, this provides
   * for a list that can change its membership, and in which the members can
   * change their individual properties.
   *
   * A good example would be the list of visible wireless network access
   * points, where each access point can report dynamic properties such as
   * signal strength.
   *
   * It is important to note that the `GListModel` itself does not report
   * changes to the individual items.  It only reports changes to the list
   * membership.  If you want to observe changes to the objects themselves
   * then you need to connect signals to the objects that you are
   * interested in.
   *
   * All items in a `GListModel` are of (or derived from) the same type.
   * [method`Gio`.ListModel.get_item_type] returns that type.  The type may be an
   * interface, in which case all objects in the list must implement it.
   *
   * The semantics are close to that of an array:
   * [method`Gio`.ListModel.get_n_items] returns the number of items in the list
   * and [method`Gio`.ListModel.get_item] returns an item at a (0-based) position.
   * In order to allow implementations to calculate the list length lazily,
   * you can also iterate over items: starting from 0, repeatedly call
   * [method`Gio`.ListModel.get_item] until it returns `NULL`.
   *
   * An implementation may create objects lazily, but must take care to
   * return the same object for a given position until all references to
   * it are gone.
   *
   * On the other side, a consumer is expected only to hold references on
   * objects that are currently ‘user visible’, in order to facilitate the
   * maximum level of laziness in the implementation of the list and to
   * reduce the required number of signal connections at a given time.
   *
   * This interface is intended only to be used from a single thread.  The
   * thread in which it is appropriate to use it depends on the particular
   * implementation, but typically it will be from the thread that owns
   * the thread-default main context (see
   * [method`GLib`.MainContext.push_thread_default]) in effect at the time that the
   * model was created.
   *
   * Over time, it has established itself as good practice for list model
   * implementations to provide properties `item-type` and `n-items` to
   * ease working with them. While it is not required, it is recommended
   * that implementations provide these two properties. They should return
   * the values of [method`Gio`.ListModel.get_item_type] and
   * [method`Gio`.ListModel.get_n_items] respectively and be defined as such:
   *
   * ```c
   * properties[PROP_ITEM_TYPE] =
   *   g_param_spec_gtype ("item-type", NULL, NULL, G_TYPE_OBJECT,
   *                       G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
   * properties[PROP_N_ITEMS] =
   *   g_param_spec_uint ("n-items", NULL, NULL, 0, G_MAXUINT, 0,
   *                      G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
   * ```
   * @interface
   */
  class ListModel extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ListModel

    static name: string

    // Constructors of Gio-2.0.Gio.ListModel

    constructor(config?: ListModel.ConstructorProperties)
    _init(config?: ListModel.ConstructorProperties): void
  }

  module LoadableIcon {
    // Constructor properties interface

    interface ConstructorProperties
      extends Icon.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface LoadableIcon extends Icon {
    // Own properties of Gio-2.0.Gio.LoadableIcon

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.LoadableIcon

    // Has conflict: load(size: number, cancellable: Cancellable | null): [ /* returnType */ InputStream, /* type */ string ]
    // Has conflict: loadAsync(size: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: loadFinish(res: AsyncResult): [ /* returnType */ InputStream, /* type */ string ]

    // Own virtual methods of Gio-2.0.Gio.LoadableIcon

    /**
     * Loads a loadable icon. For the asynchronous version of this function,
     * see g_loadable_icon_load_async().
     * @virtual
     * @param size an integer.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #GInputStream to read the icon from.
     */
    load(
      size: number,
      cancellable: Cancellable | null
    ): [/* returnType */ InputStream, /* type */ string]
    /**
     * Loads an icon asynchronously. To finish this function, see
     * g_loadable_icon_load_finish(). For the synchronous, blocking
     * version of this function, see g_loadable_icon_load().
     * @virtual
     * @param size an integer.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    loadAsync(
      size: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
     * @virtual
     * @param res a #GAsyncResult.
     * @returns a #GInputStream to read the icon from.
     */
    loadFinish(
      res: AsyncResult
    ): [/* returnType */ InputStream, /* type */ string]

    // Class property signals of Gio-2.0.Gio.LoadableIcon

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GLoadableIcon` extends the [iface`Gio`.Icon] interface and adds the ability
   * to load icons from streams.
   * @interface
   */
  class LoadableIcon extends GObject.Object {
    // Own properties of Gio-2.0.Gio.LoadableIcon

    static name: string

    // Constructors of Gio-2.0.Gio.LoadableIcon

    constructor(config?: LoadableIcon.ConstructorProperties)
    _init(config?: LoadableIcon.ConstructorProperties): void
  }

  module MemoryMonitor {
    // Signal callback interfaces

    /**
     * Signal callback interface for `low-memory-warning`
     */
    interface LowMemoryWarningSignalCallback {
      (level: MemoryMonitorWarningLevel): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface MemoryMonitor extends Initable {
    // Own properties of Gio-2.0.Gio.MemoryMonitor

    __gtype__: number

    // Own virtual methods of Gio-2.0.Gio.MemoryMonitor

    /**
     * the virtual function pointer for the
     *  #GMemoryMonitor::low-memory-warning signal.
     * @virtual
     * @param level
     */
    lowMemoryWarning(level: MemoryMonitorWarningLevel): void

    // Own signals of Gio-2.0.Gio.MemoryMonitor

    connect(
      sigName: "low-memory-warning",
      callback: MemoryMonitor.LowMemoryWarningSignalCallback
    ): number
    on(
      sigName: "low-memory-warning",
      callback: MemoryMonitor.LowMemoryWarningSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "low-memory-warning",
      callback: MemoryMonitor.LowMemoryWarningSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "low-memory-warning",
      callback: MemoryMonitor.LowMemoryWarningSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "low-memory-warning", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.MemoryMonitor

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GMemoryMonitor` will monitor system memory and suggest to the application
   * when to free memory so as to leave more room for other applications.
   * It is implemented on Linux using the
   * [Low Memory Monitor](https://gitlab.freedesktop.org/hadess/low-memory-monitor/)
   * ([API documentation](https://hadess.pages.freedesktop.org/low-memory-monitor/)).
   *
   * There is also an implementation for use inside Flatpak sandboxes.
   *
   * Possible actions to take when the signal is received are:
   *
   *  - Free caches
   *  - Save files that haven’t been looked at in a while to disk, ready to be reopened when needed
   *  - Run a garbage collection cycle
   *  - Try and compress fragmented allocations
   *  - Exit on idle if the process has no reason to stay around
   *  - Call [`malloc_trim(3)`](man:malloc_trim(3)) to return cached heap pages to
   *    the kernel (if supported by your libc)
   *
   * Note that some actions may not always improve system performance, and so
   * should be profiled for your application. `malloc_trim()`, for example, may
   * make future heap allocations slower (due to releasing cached heap pages back
   * to the kernel).
   *
   * See [type`Gio`.MemoryMonitorWarningLevel] for details on the various warning
   * levels.
   *
   * ```c
   * static void
   * warning_cb (GMemoryMonitor *m, GMemoryMonitorWarningLevel level)
   * {
   *   g_debug ("Warning level: %d", level);
   *   if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
   *     drop_caches ();
   * }
   *
   * static GMemoryMonitor *
   * monitor_low_memory (void)
   * {
   *   GMemoryMonitor *m;
   *   m = g_memory_monitor_dup_default ();
   *   g_signal_connect (G_OBJECT (m), "low-memory-warning",
   *                     G_CALLBACK (warning_cb), NULL);
   *   return m;
   * }
   * ```
   *
   * Don’t forget to disconnect the [signal`Gio`.MemoryMonitor::low-memory-warning]
   * signal, and unref the `GMemoryMonitor` itself when exiting.
   * @interface
   */
  class MemoryMonitor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.MemoryMonitor

    static name: string

    // Constructors of Gio-2.0.Gio.MemoryMonitor

    constructor(config?: MemoryMonitor.ConstructorProperties)
    _init(config?: MemoryMonitor.ConstructorProperties): void
    /**
     * Gets a reference to the default #GMemoryMonitor for the system.
     * @returns a new reference to the default #GMemoryMonitor
     */
    static dupDefault(): MemoryMonitor
  }

  module Mount {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `pre-unmount`
     */
    interface PreUnmountSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `unmounted`
     */
    interface UnmountedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Mount {
    // Own properties of Gio-2.0.Gio.Mount

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Mount

    // Has conflict: canEject(): boolean
    // Has conflict: canUnmount(): boolean
    // Has conflict: eject(flags: MountUnmountFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: ejectFinish(result: AsyncResult): boolean
    // Has conflict: ejectWithOperation(flags: MountUnmountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: ejectWithOperationFinish(result: AsyncResult): boolean
    // Has conflict: getDefaultLocation(): File
    // Has conflict: getDrive(): Drive | null
    // Has conflict: getIcon(): Icon
    // Has conflict: getName(): string | null
    // Has conflict: getRoot(): File
    // Has conflict: getSortKey(): string | null
    // Has conflict: getSymbolicIcon(): Icon
    // Has conflict: getUuid(): string | null
    // Has conflict: getVolume(): Volume | null
    // Has conflict: guessContentType(forceRescan: boolean, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: guessContentTypeFinish(result: AsyncResult): string[]
    // Has conflict: guessContentTypeSync(forceRescan: boolean, cancellable: Cancellable | null): string[]
    /**
     * Determines if `mount` is shadowed. Applications or libraries should
     * avoid displaying `mount` in the user interface if it is shadowed.
     *
     * A mount is said to be shadowed if there exists one or more user
     * visible objects (currently #GMount objects) with a root that is
     * inside the root of `mount`.
     *
     * One application of shadow mounts is when exposing a single file
     * system that is used to address several logical volumes. In this
     * situation, a #GVolumeMonitor implementation would create two
     * #GVolume objects (for example, one for the camera functionality of
     * the device and one for a SD card reader on the device) with
     * activation URIs `gphoto2://[usb:001,002]/store1/`
     * and `gphoto2://[usb:001,002]/store2/`. When the
     * underlying mount (with root
     * `gphoto2://[usb:001,002]/`) is mounted, said
     * #GVolumeMonitor implementation would create two #GMount objects
     * (each with their root matching the corresponding volume activation
     * root) that would shadow the original mount.
     *
     * The proxy monitor in GVfs 2.26 and later, automatically creates and
     * manage shadow mounts (and shadows the underlying mount) if the
     * activation root on a #GVolume is set.
     * @returns %TRUE if @mount is shadowed.
     */
    isShadowed(): boolean
    // Has conflict: remount(flags: MountMountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: remountFinish(result: AsyncResult): boolean
    /**
     * Increments the shadow count on `mount`. Usually used by
     * #GVolumeMonitor implementations when creating a shadow mount for
     * `mount,` see g_mount_is_shadowed() for more information. The caller
     * will need to emit the #GMount::changed signal on `mount` manually.
     */
    shadow(): void
    // Has conflict: unmount(flags: MountUnmountFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: unmountFinish(result: AsyncResult): boolean
    // Has conflict: unmountWithOperation(flags: MountUnmountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: unmountWithOperationFinish(result: AsyncResult): boolean
    /**
     * Decrements the shadow count on `mount`. Usually used by
     * #GVolumeMonitor implementations when destroying a shadow mount for
     * `mount,` see g_mount_is_shadowed() for more information. The caller
     * will need to emit the #GMount::changed signal on `mount` manually.
     */
    unshadow(): void

    // Own virtual methods of Gio-2.0.Gio.Mount

    /**
     * Checks if `mount` can be ejected.
     * @virtual
     * @returns %TRUE if the @mount can be ejected.
     */
    canEject(): boolean
    /**
     * Checks if `mount` can be unmounted.
     * @virtual
     * @returns %TRUE if the @mount can be unmounted.
     */
    canUnmount(): boolean
    /**
     * Changed signal that is emitted when the mount's state has changed.
     * @virtual
     */
    changed(): void
    /**
     * Ejects a mount. This is an asynchronous operation, and is
     * finished by calling g_mount_eject_finish() with the `mount`
     * and #GAsyncResult data returned in the `callback`.
     * @virtual
     * @param flags flags affecting the unmount if required for eject
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    eject(
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes ejecting a mount. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the mount was successfully ejected. %FALSE otherwise.
     */
    ejectFinish(result: AsyncResult): boolean
    /**
     * Ejects a mount. This is an asynchronous operation, and is
     * finished by calling g_mount_eject_with_operation_finish() with the `mount`
     * and #GAsyncResult data returned in the `callback`.
     * @virtual
     * @param flags flags affecting the unmount if required for eject
     * @param mountOperation a #GMountOperation or %NULL to avoid     user interaction.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    ejectWithOperation(
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes ejecting a mount. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the mount was successfully ejected. %FALSE otherwise.
     */
    ejectWithOperationFinish(result: AsyncResult): boolean
    /**
     * Gets the default location of `mount`. The default location of the given
     * `mount` is a path that reflects the main entry point for the user (e.g.
     * the home directory, or the root of the volume).
     * @virtual
     * @returns a #GFile.      The returned object should be unreffed with      g_object_unref() when no longer needed.
     */
    getDefaultLocation(): File
    /**
     * Gets the drive for the `mount`.
     *
     * This is a convenience method for getting the #GVolume and then
     * using that object to get the #GDrive.
     * @virtual
     * @returns a #GDrive or %NULL if @mount is not      associated with a volume or a drive.      The returned object should be unreffed with      g_object_unref() when no longer needed.
     */
    getDrive(): Drive | null
    /**
     * Gets the icon for `mount`.
     * @virtual
     * @returns a #GIcon.      The returned object should be unreffed with      g_object_unref() when no longer needed.
     */
    getIcon(): Icon
    /**
     * Gets the name of `mount`.
     * @virtual
     * @returns the name for the given @mount.     The returned string should be freed with g_free()     when no longer needed.
     */
    getName(): string | null
    /**
     * Gets the root directory on `mount`.
     * @virtual
     * @returns a #GFile.      The returned object should be unreffed with      g_object_unref() when no longer needed.
     */
    getRoot(): File
    /**
     * Gets the sort key for `mount,` if any.
     * @virtual
     * @returns Sorting key for @mount or %NULL if no such key is available.
     */
    getSortKey(): string | null
    /**
     * Gets the symbolic icon for `mount`.
     * @virtual
     * @returns a #GIcon.      The returned object should be unreffed with      g_object_unref() when no longer needed.
     */
    getSymbolicIcon(): Icon
    /**
     * Gets the UUID for the `mount`. The reference is typically based on
     * the file system UUID for the mount in question and should be
     * considered an opaque string. Returns %NULL if there is no UUID
     * available.
     * @virtual
     * @returns the UUID for @mount or %NULL if no UUID     can be computed.     The returned string should be freed with g_free()     when no longer needed.
     */
    getUuid(): string | null
    /**
     * Gets the volume for the `mount`.
     * @virtual
     * @returns a #GVolume or %NULL if @mount is not      associated with a volume.      The returned object should be unreffed with      g_object_unref() when no longer needed.
     */
    getVolume(): Volume | null
    /**
     * Tries to guess the type of content stored on `mount`. Returns one or
     * more textual identifiers of well-known content types (typically
     * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
     * memory cards. See the
     * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
     * specification for more on x-content types.
     *
     * This is an asynchronous operation (see
     * g_mount_guess_content_type_sync() for the synchronous version), and
     * is finished by calling g_mount_guess_content_type_finish() with the
     * `mount` and #GAsyncResult data returned in the `callback`.
     * @virtual
     * @param forceRescan Whether to force a rescan of the content.     Otherwise a cached result will be used if available
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback
     */
    guessContentType(
      forceRescan: boolean,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes guessing content types of `mount`. If any errors occurred
     * during the operation, `error` will be set to contain the errors and
     * %FALSE will be returned. In particular, you may get an
     * %G_IO_ERROR_NOT_SUPPORTED if the mount does not support content
     * guessing.
     * @virtual
     * @param result a #GAsyncResult
     * @returns a %NULL-terminated array of content types or %NULL on error.     Caller should free this array with g_strfreev() when done with it.
     */
    guessContentTypeFinish(result: AsyncResult): string[]
    /**
     * Tries to guess the type of content stored on `mount`. Returns one or
     * more textual identifiers of well-known content types (typically
     * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
     * memory cards. See the
     * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
     * specification for more on x-content types.
     *
     * This is a synchronous operation and as such may block doing IO;
     * see g_mount_guess_content_type() for the asynchronous version.
     * @virtual
     * @param forceRescan Whether to force a rescan of the content.     Otherwise a cached result will be used if available
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns a %NULL-terminated array of content types or %NULL on error.     Caller should free this array with g_strfreev() when done with it.
     */
    guessContentTypeSync(
      forceRescan: boolean,
      cancellable: Cancellable | null
    ): string[]
    /**
     * The ::pre-unmount signal that is emitted when the #GMount will soon be emitted. If the recipient is somehow holding the mount open by keeping an open file on it it should close the file.
     * @virtual
     */
    preUnmount(): void
    /**
     * Remounts a mount. This is an asynchronous operation, and is
     * finished by calling g_mount_remount_finish() with the `mount`
     * and #GAsyncResults data returned in the `callback`.
     *
     * Remounting is useful when some setting affecting the operation
     * of the volume has been changed, as these may need a remount to
     * take affect. While this is semantically equivalent with unmounting
     * and then remounting not all backends might need to actually be
     * unmounted.
     * @virtual
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation or %NULL to avoid     user interaction.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    remount(
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes remounting a mount. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the mount was successfully remounted. %FALSE otherwise.
     */
    remountFinish(result: AsyncResult): boolean
    /**
     * Unmounts a mount. This is an asynchronous operation, and is
     * finished by calling g_mount_unmount_finish() with the `mount`
     * and #GAsyncResult data returned in the `callback`.
     * @virtual
     * @param flags flags affecting the operation
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    unmount(
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes unmounting a mount. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the mount was successfully unmounted. %FALSE otherwise.
     */
    unmountFinish(result: AsyncResult): boolean
    /**
     * Unmounts a mount. This is an asynchronous operation, and is
     * finished by calling g_mount_unmount_with_operation_finish() with the `mount`
     * and #GAsyncResult data returned in the `callback`.
     * @virtual
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation or %NULL to avoid     user interaction.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback, or %NULL.
     */
    unmountWithOperation(
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes unmounting a mount. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the mount was successfully unmounted. %FALSE otherwise.
     */
    unmountWithOperationFinish(result: AsyncResult): boolean
    /**
     * The unmounted signal that is emitted when the #GMount have been unmounted. If the recipient is holding references to the object they should release them so the object can be finalized.
     * @virtual
     */
    unmounted(): void

    // Own signals of Gio-2.0.Gio.Mount

    connect(sigName: "changed", callback: Mount.ChangedSignalCallback): number
    on(
      sigName: "changed",
      callback: Mount.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Mount.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Mount.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "pre-unmount",
      callback: Mount.PreUnmountSignalCallback
    ): number
    on(
      sigName: "pre-unmount",
      callback: Mount.PreUnmountSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "pre-unmount",
      callback: Mount.PreUnmountSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "pre-unmount",
      callback: Mount.PreUnmountSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "pre-unmount", ...args: any[]): void
    connect(
      sigName: "unmounted",
      callback: Mount.UnmountedSignalCallback
    ): number
    on(
      sigName: "unmounted",
      callback: Mount.UnmountedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unmounted",
      callback: Mount.UnmountedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unmounted",
      callback: Mount.UnmountedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unmounted", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.Mount

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GMount` interface represents user-visible mounts. Note, when
   * [porting from GnomeVFS](migrating-gnome-vfs.html), `GMount` is the moral
   * equivalent of `GnomeVFSVolume`.
   *
   * `GMount` is a ‘mounted’ filesystem that you can access. Mounted is in
   * quotes because it’s not the same as a UNIX mount, it might be a GVFS
   * mount, but you can still access the files on it if you use GIO. Might or
   * might not be related to a volume object.
   *
   * Unmounting a `GMount` instance is an asynchronous operation. For
   * more information about asynchronous operations, see [iface`Gio`.AsyncResult]
   * and [class`Gio`.Task]. To unmount a `GMount` instance, first call
   * [method`Gio`.Mount.unmount_with_operation] with (at least) the `GMount`
   * instance and a [type`Gio`.AsyncReadyCallback].  The callback will be fired
   * when the operation has resolved (either with success or failure), and a
   * [iface`Gio`.AsyncResult] structure will be passed to the callback.  That
   * callback should then call [method`Gio`.Mount.unmount_with_operation_finish]
   * with the `GMount` and the [iface`Gio`.AsyncResult] data to see if the
   * operation was completed successfully.  If an `error` is present when
   * [method`Gio`.Mount.unmount_with_operation_finish] is called, then it will be
   * filled with any error information.
   * @interface
   */
  class Mount extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Mount

    static name: string

    // Constructors of Gio-2.0.Gio.Mount

    constructor(config?: Mount.ConstructorProperties)
    _init(config?: Mount.ConstructorProperties): void
  }

  module NetworkMonitor {
    // Signal callback interfaces

    /**
     * Signal callback interface for `network-changed`
     */
    interface NetworkChangedSignalCallback {
      (networkAvailable: boolean): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface NetworkMonitor extends Initable {
    // Own properties of Gio-2.0.Gio.NetworkMonitor

    /**
     * More detailed information about the host's network connectivity.
     * See g_network_monitor_get_connectivity() and
     * #GNetworkConnectivity for more details.
     */
    readonly connectivity: NetworkConnectivity
    /**
     * Whether the network is considered available. That is, whether the
     * system has a default route for at least one of IPv4 or IPv6.
     *
     * Real-world networks are of course much more complicated than
     * this; the machine may be connected to a wifi hotspot that
     * requires payment before allowing traffic through, or may be
     * connected to a functioning router that has lost its own upstream
     * connectivity. Some hosts might only be accessible when a VPN is
     * active. Other hosts might only be accessible when the VPN is
     * not active. Thus, it is best to use g_network_monitor_can_reach()
     * or g_network_monitor_can_reach_async() to test for reachability
     * on a host-by-host basis. (On the other hand, when the property is
     * %FALSE, the application can reasonably expect that no remote
     * hosts at all are reachable, and should indicate this to the user
     * in its UI.)
     *
     * See also #GNetworkMonitor::network-changed.
     */
    readonly networkAvailable: boolean
    /**
     * Whether the network is considered metered.
     *
     * That is, whether the
     * system has traffic flowing through the default connection that is
     * subject to limitations set by service providers. For example, traffic
     * might be billed by the amount of data transmitted, or there might be a
     * quota on the amount of traffic per month. This is typical with tethered
     * connections (3G and 4G) and in such situations, bandwidth intensive
     * applications may wish to avoid network activity where possible if it will
     * cost the user money or use up their limited quota. Anything more than a
     * few hundreds of kilobytes of data usage per hour should be avoided without
     * asking permission from the user.
     *
     * If more information is required about specific devices then the
     * system network management API should be used instead (for example,
     * NetworkManager or ConnMan).
     *
     * If this information is not available then no networks will be
     * marked as metered.
     *
     * See also #GNetworkMonitor:network-available.
     */
    readonly networkMetered: boolean
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.NetworkMonitor

    // Has conflict: canReach(connectable: SocketConnectable, cancellable: Cancellable | null): boolean
    // Has conflict: canReachAsync(connectable: SocketConnectable, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: canReachFinish(result: AsyncResult): boolean
    /**
     * Gets a more detailed networking state than
     * g_network_monitor_get_network_available().
     *
     * If #GNetworkMonitor:network-available is %FALSE, then the
     * connectivity state will be %G_NETWORK_CONNECTIVITY_LOCAL.
     *
     * If #GNetworkMonitor:network-available is %TRUE, then the
     * connectivity state will be %G_NETWORK_CONNECTIVITY_FULL (if there
     * is full Internet connectivity), %G_NETWORK_CONNECTIVITY_LIMITED (if
     * the host has a default route, but appears to be unable to actually
     * reach the full Internet), or %G_NETWORK_CONNECTIVITY_PORTAL (if the
     * host is trapped behind a "captive portal" that requires some sort
     * of login or acknowledgement before allowing full Internet access).
     *
     * Note that in the case of %G_NETWORK_CONNECTIVITY_LIMITED and
     * %G_NETWORK_CONNECTIVITY_PORTAL, it is possible that some sites are
     * reachable but others are not. In this case, applications can
     * attempt to connect to remote servers, but should gracefully fall
     * back to their "offline" behavior if the connection attempt fails.
     * @returns the network connectivity state
     */
    getConnectivity(): NetworkConnectivity
    /**
     * Checks if the network is available. "Available" here means that the
     * system has a default route available for at least one of IPv4 or
     * IPv6. It does not necessarily imply that the public Internet is
     * reachable. See #GNetworkMonitor:network-available for more details.
     * @returns whether the network is available
     */
    getNetworkAvailable(): boolean
    /**
     * Checks if the network is metered.
     * See #GNetworkMonitor:network-metered for more details.
     * @returns whether the connection is metered
     */
    getNetworkMetered(): boolean

    // Own virtual methods of Gio-2.0.Gio.NetworkMonitor

    /**
     * Attempts to determine whether or not the host pointed to by
     * `connectable` can be reached, without actually trying to connect to
     * it.
     *
     * This may return %TRUE even when #GNetworkMonitor:network-available
     * is %FALSE, if, for example, `monitor` can determine that
     * `connectable` refers to a host on a local network.
     *
     * If `monitor` believes that an attempt to connect to `connectable`
     * will succeed, it will return %TRUE. Otherwise, it will return
     * %FALSE and set `error` to an appropriate error (such as
     * %G_IO_ERROR_HOST_UNREACHABLE).
     *
     * Note that although this does not attempt to connect to
     * `connectable,` it may still block for a brief period of time (eg,
     * trying to do multicast DNS on the local network), so if you do not
     * want to block, you should use g_network_monitor_can_reach_async().
     * @virtual
     * @param connectable a #GSocketConnectable
     * @param cancellable a #GCancellable, or %NULL
     * @returns %TRUE if @connectable is reachable, %FALSE if not.
     */
    canReach(
      connectable: SocketConnectable,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Asynchronously attempts to determine whether or not the host
     * pointed to by `connectable` can be reached, without actually
     * trying to connect to it.
     *
     * For more details, see g_network_monitor_can_reach().
     *
     * When the operation is finished, `callback` will be called.
     * You can then call g_network_monitor_can_reach_finish()
     * to get the result of the operation.
     * @virtual
     * @param connectable a #GSocketConnectable
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
     */
    canReachAsync(
      connectable: SocketConnectable,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async network connectivity test.
     * See g_network_monitor_can_reach_async().
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if network is reachable, %FALSE if not.
     */
    canReachFinish(result: AsyncResult): boolean
    /**
     * the virtual function pointer for the
     *  GNetworkMonitor::network-changed signal.
     * @virtual
     * @param networkAvailable
     */
    networkChanged(networkAvailable: boolean): void

    // Own signals of Gio-2.0.Gio.NetworkMonitor

    connect(
      sigName: "network-changed",
      callback: NetworkMonitor.NetworkChangedSignalCallback
    ): number
    on(
      sigName: "network-changed",
      callback: NetworkMonitor.NetworkChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "network-changed",
      callback: NetworkMonitor.NetworkChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "network-changed",
      callback: NetworkMonitor.NetworkChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "network-changed", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.NetworkMonitor

    connect(
      sigName: "notify::connectivity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::connectivity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::connectivity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::connectivity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::connectivity", ...args: any[]): void
    connect(
      sigName: "notify::network-available",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::network-available",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::network-available",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::network-available",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::network-available", ...args: any[]): void
    connect(
      sigName: "notify::network-metered",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::network-metered",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::network-metered",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::network-metered",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::network-metered", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GNetworkMonitor` provides an easy-to-use cross-platform API
   * for monitoring network connectivity. On Linux, the available
   * implementations are based on the kernel's netlink interface and
   * on NetworkManager.
   *
   * There is also an implementation for use inside Flatpak sandboxes.
   * @interface
   */
  class NetworkMonitor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.NetworkMonitor

    static name: string

    // Constructors of Gio-2.0.Gio.NetworkMonitor

    constructor(config?: NetworkMonitor.ConstructorProperties)
    _init(config?: NetworkMonitor.ConstructorProperties): void
    /**
     * Gets the default #GNetworkMonitor for the system.
     * @returns a #GNetworkMonitor, which will be     a dummy object if no network monitor is available
     */
    static getDefault(): NetworkMonitor
  }

  module PollableInputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends InputStream.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface PollableInputStream extends InputStream {
    // Own properties of Gio-2.0.Gio.PollableInputStream

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.PollableInputStream

    // Has conflict: canPoll(): boolean
    // Has conflict: createSource(cancellable: Cancellable | null): GLib.Source
    // Has conflict: isReadable(): boolean
    // Has conflict: readNonblocking(cancellable: Cancellable | null): [ /* returnType */ number, /* buffer */ number[] ]

    // Own virtual methods of Gio-2.0.Gio.PollableInputStream

    /**
     * Checks if `stream` is actually pollable. Some classes may implement
     * #GPollableInputStream but have only certain instances of that class
     * be pollable. If this method returns %FALSE, then the behavior of
     * other #GPollableInputStream methods is undefined.
     *
     * For any given stream, the value returned by this method is constant;
     * a stream cannot switch from pollable to non-pollable or vice versa.
     * @virtual
     * @returns %TRUE if @stream is pollable, %FALSE if not.
     */
    canPoll(): boolean
    /**
     * Creates a #GSource that triggers when `stream` can be read, or
     * `cancellable` is triggered or an error occurs. The callback on the
     * source is of the #GPollableSourceFunc type.
     *
     * As with g_pollable_input_stream_is_readable(), it is possible that
     * the stream may not actually be readable even after the source
     * triggers, so you should use g_pollable_input_stream_read_nonblocking()
     * rather than g_input_stream_read() from the callback.
     *
     * The behaviour of this method is undefined if
     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
     * @virtual
     * @param cancellable a #GCancellable, or %NULL
     * @returns a new #GSource
     */
    createSource(cancellable: Cancellable | null): GLib.Source
    /**
     * Checks if `stream` can be read.
     *
     * Note that some stream types may not be able to implement this 100%
     * reliably, and it is possible that a call to g_input_stream_read()
     * after this returns %TRUE would still block. To guarantee
     * non-blocking behavior, you should always use
     * g_pollable_input_stream_read_nonblocking(), which will return a
     * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
     *
     * The behaviour of this method is undefined if
     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
     * @virtual
     * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
     */
    isReadable(): boolean
    /**
     * Attempts to read up to `count` bytes from `stream` into `buffer,` as
     * with g_input_stream_read(). If `stream` is not currently readable,
     * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
     * use g_pollable_input_stream_create_source() to create a #GSource
     * that will be triggered when `stream` is readable.
     *
     * Note that since this method never blocks, you cannot actually
     * use `cancellable` to cancel it. However, it will return an error
     * if `cancellable` has already been cancelled when you call, which
     * may happen if you call this method after a source triggers due
     * to having been cancelled.
     *
     * The behaviour of this method is undefined if
     * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
     * @virtual
     * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
     */
    readNonblocking(): [/* returnType */ number, /* buffer */ number[] | null]

    // Class property signals of Gio-2.0.Gio.PollableInputStream

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GPollableInputStream` is implemented by [class`Gio`.InputStream]s that
   * can be polled for readiness to read. This can be used when
   * interfacing with a non-GIO API that expects
   * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
   *
   * Some classes may implement `GPollableInputStream` but have only certain
   * instances of that class be pollable. If [method`Gio`.PollableInputStream.can_poll]
   * returns false, then the behavior of other `GPollableInputStream` methods is
   * undefined.
   * @interface
   */
  class PollableInputStream extends GObject.Object {
    // Own properties of Gio-2.0.Gio.PollableInputStream

    static name: string

    // Constructors of Gio-2.0.Gio.PollableInputStream

    constructor(config?: PollableInputStream.ConstructorProperties)
    _init(config?: PollableInputStream.ConstructorProperties): void
  }

  module PollableOutputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends OutputStream.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface PollableOutputStream extends OutputStream {
    // Own properties of Gio-2.0.Gio.PollableOutputStream

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.PollableOutputStream

    // Has conflict: canPoll(): boolean
    // Has conflict: createSource(cancellable: Cancellable | null): GLib.Source
    // Has conflict: isWritable(): boolean
    // Has conflict: writeNonblocking(buffer: number[], cancellable: Cancellable | null): number
    // Has conflict: writevNonblocking(vectors: OutputVector[], cancellable: Cancellable | null): [ /* returnType */ PollableReturn, /* bytesWritten */ number ]

    // Own virtual methods of Gio-2.0.Gio.PollableOutputStream

    /**
     * Checks if `stream` is actually pollable. Some classes may implement
     * #GPollableOutputStream but have only certain instances of that
     * class be pollable. If this method returns %FALSE, then the behavior
     * of other #GPollableOutputStream methods is undefined.
     *
     * For any given stream, the value returned by this method is constant;
     * a stream cannot switch from pollable to non-pollable or vice versa.
     * @virtual
     * @returns %TRUE if @stream is pollable, %FALSE if not.
     */
    canPoll(): boolean
    /**
     * Creates a #GSource that triggers when `stream` can be written, or
     * `cancellable` is triggered or an error occurs. The callback on the
     * source is of the #GPollableSourceFunc type.
     *
     * As with g_pollable_output_stream_is_writable(), it is possible that
     * the stream may not actually be writable even after the source
     * triggers, so you should use g_pollable_output_stream_write_nonblocking()
     * rather than g_output_stream_write() from the callback.
     *
     * The behaviour of this method is undefined if
     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
     * @virtual
     * @param cancellable a #GCancellable, or %NULL
     * @returns a new #GSource
     */
    createSource(cancellable: Cancellable | null): GLib.Source
    /**
     * Checks if `stream` can be written.
     *
     * Note that some stream types may not be able to implement this 100%
     * reliably, and it is possible that a call to g_output_stream_write()
     * after this returns %TRUE would still block. To guarantee
     * non-blocking behavior, you should always use
     * g_pollable_output_stream_write_nonblocking(), which will return a
     * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
     *
     * The behaviour of this method is undefined if
     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
     * @virtual
     * @returns %TRUE if @stream is writable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_output_stream_is_writable() returning %TRUE, and the   next attempt to write will return the error.
     */
    isWritable(): boolean
    /**
     * Attempts to write up to `count` bytes from `buffer` to `stream,` as
     * with g_output_stream_write(). If `stream` is not currently writable,
     * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
     * use g_pollable_output_stream_create_source() to create a #GSource
     * that will be triggered when `stream` is writable.
     *
     * Note that since this method never blocks, you cannot actually
     * use `cancellable` to cancel it. However, it will return an error
     * if `cancellable` has already been cancelled when you call, which
     * may happen if you call this method after a source triggers due
     * to having been cancelled.
     *
     * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
     * transports like D/TLS require that you re-send the same `buffer` and
     * `count` in the next write call.
     *
     * The behaviour of this method is undefined if
     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
     * @virtual
     * @param buffer a buffer to write     data from
     * @returns the number of bytes written, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
     */
    writeNonblocking(buffer: number[] | null): number
    /**
     * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
     * as with g_output_stream_writev(). If `stream` is not currently writable,
     * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
     * use g_pollable_output_stream_create_source() to create a #GSource
     * that will be triggered when `stream` is writable. `error` will *not* be
     * set in that case.
     *
     * Note that since this method never blocks, you cannot actually
     * use `cancellable` to cancel it. However, it will return an error
     * if `cancellable` has already been cancelled when you call, which
     * may happen if you call this method after a source triggers due
     * to having been cancelled.
     *
     * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
     * transports like D/TLS require that you re-send the same `vectors` and
     * `n_vectors` in the next write call.
     *
     * The behaviour of this method is undefined if
     * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
     * @virtual
     * @param vectors the buffer containing the #GOutputVectors to write.
     * @returns %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set.
     */
    writevNonblocking(
      vectors: OutputVector[]
    ): [/* returnType */ PollableReturn, /* bytesWritten */ number]

    // Class property signals of Gio-2.0.Gio.PollableOutputStream

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GPollableOutputStream` is implemented by [class`Gio`.OutputStream]s that
   * can be polled for readiness to write. This can be used when
   * interfacing with a non-GIO API that expects
   * UNIX-file-descriptor-style asynchronous I/O rather than GIO-style.
   *
   * Some classes may implement `GPollableOutputStream` but have only certain
   * instances of that class be pollable. If [method`Gio`.PollableOutputStream.can_poll]
   * returns false, then the behavior of other `GPollableOutputStream` methods is
   * undefined.
   * @interface
   */
  class PollableOutputStream extends GObject.Object {
    // Own properties of Gio-2.0.Gio.PollableOutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.PollableOutputStream

    constructor(config?: PollableOutputStream.ConstructorProperties)
    _init(config?: PollableOutputStream.ConstructorProperties): void
  }

  module PowerProfileMonitor {
    // Constructor properties interface

    interface ConstructorProperties
      extends Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface PowerProfileMonitor extends Initable {
    // Own properties of Gio-2.0.Gio.PowerProfileMonitor

    /**
     * Whether “Power Saver” mode is enabled on the system.
     */
    readonly powerSaverEnabled: boolean
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.PowerProfileMonitor

    /**
     * Gets whether the system is in “Power Saver” mode.
     *
     * You are expected to listen to the
     * #GPowerProfileMonitor::notify::power-saver-enabled signal to know when the profile has
     * changed.
     * @returns Whether the system is in “Power Saver” mode.
     */
    getPowerSaverEnabled(): boolean

    // Class property signals of Gio-2.0.Gio.PowerProfileMonitor

    connect(
      sigName: "notify::power-saver-enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::power-saver-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::power-saver-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::power-saver-enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::power-saver-enabled", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GPowerProfileMonitor` makes it possible for applications as well as OS
   * components to monitor system power profiles and act upon them. It currently
   * only exports whether the system is in “Power Saver” mode (known as
   * “Low Power” mode on some systems).
   *
   * When in “Low Power” mode, it is recommended that applications:
   * - disable automatic downloads;
   * - reduce the rate of refresh from online sources such as calendar or
   *   email synchronisation;
   * - reduce the use of expensive visual effects.
   *
   * It is also likely that OS components providing services to applications will
   * lower their own background activity, for the sake of the system.
   *
   * There are a variety of tools that exist for power consumption analysis, but those
   * usually depend on the OS and hardware used. On Linux, one could use `upower` to
   * monitor the battery discharge rate, `powertop` to check on the background activity
   * or activity at all), `sysprof` to inspect CPU usage, and `intel_gpu_time` to
   * profile GPU usage.
   *
   * Don’t forget to disconnect the [signal`GObject`.Object::notify] signal for
   * [property`Gio`.PowerProfileMonitor:power-saver-enabled], and unref the
   * `GPowerProfileMonitor` itself when exiting.
   * @interface
   */
  class PowerProfileMonitor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.PowerProfileMonitor

    static name: string

    // Constructors of Gio-2.0.Gio.PowerProfileMonitor

    constructor(config?: PowerProfileMonitor.ConstructorProperties)
    _init(config?: PowerProfileMonitor.ConstructorProperties): void
    /**
     * Gets a reference to the default #GPowerProfileMonitor for the system.
     * @returns a new reference to the default #GPowerProfileMonitor
     */
    static dupDefault(): PowerProfileMonitor
  }

  module Proxy {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Proxy {
    // Own properties of Gio-2.0.Gio.Proxy

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Proxy

    // Has conflict: connect(connection: IOStream, proxyAddress: ProxyAddress, cancellable: Cancellable | null): IOStream
    // Has conflict: connectAsync(connection: IOStream, proxyAddress: ProxyAddress, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: connectFinish(result: AsyncResult): IOStream
    // Has conflict: supportsHostname(): boolean

    // Own virtual methods of Gio-2.0.Gio.Proxy

    /**
     * Given `connection` to communicate with a proxy (eg, a
     * #GSocketConnection that is connected to the proxy server), this
     * does the necessary handshake to connect to `proxy_address,` and if
     * required, wraps the #GIOStream to handle proxy payload.
     * @virtual
     * @param connection a #GIOStream
     * @param proxyAddress a #GProxyAddress
     * @param cancellable a #GCancellable
     * @returns a #GIOStream that will replace @connection. This might               be the same as @connection, in which case a reference               will be added.
     */
    connect(
      connection: IOStream,
      proxyAddress: ProxyAddress,
      cancellable: Cancellable | null
    ): IOStream
    /**
     * Asynchronous version of g_proxy_connect().
     * @virtual
     * @param connection a #GIOStream
     * @param proxyAddress a #GProxyAddress
     * @param cancellable a #GCancellable
     * @param callback a #GAsyncReadyCallback
     */
    connectAsync(
      connection: IOStream,
      proxyAddress: ProxyAddress,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * See g_proxy_connect().
     * @virtual
     * @param result a #GAsyncResult
     * @returns a #GIOStream.
     */
    connectFinish(result: AsyncResult): IOStream
    /**
     * Some proxy protocols expect to be passed a hostname, which they
     * will resolve to an IP address themselves. Others, like SOCKS4, do
     * not allow this. This function will return %FALSE if `proxy` is
     * implementing such a protocol. When %FALSE is returned, the caller
     * should resolve the destination hostname first, and then pass a
     * #GProxyAddress containing the stringified IP address to
     * g_proxy_connect() or g_proxy_connect_async().
     * @virtual
     * @returns %TRUE if hostname resolution is supported.
     */
    supportsHostname(): boolean

    // Class property signals of Gio-2.0.Gio.Proxy

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GProxy` handles connecting to a remote host via a given type of
   * proxy server. It is implemented by the `gio-proxy` extension point.
   * The extensions are named after their proxy protocol name. As an
   * example, a SOCKS5 proxy implementation can be retrieved with the
   * name `socks5` using the function
   * [method`Gio`.IOExtensionPoint.get_extension_by_name].
   * @interface
   */
  class Proxy extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Proxy

    static name: string

    // Constructors of Gio-2.0.Gio.Proxy

    constructor(config?: Proxy.ConstructorProperties)
    _init(config?: Proxy.ConstructorProperties): void
    /**
     * Find the `gio-proxy` extension point for a proxy implementation that supports
     * the specified protocol.
     * @param protocol the proxy protocol name (e.g. http, socks, etc)
     * @returns return a #GProxy or NULL if protocol               is not supported.
     */
    static getDefaultForProtocol(protocol: string): Proxy | null
  }

  module ProxyResolver {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ProxyResolver {
    // Own properties of Gio-2.0.Gio.ProxyResolver

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ProxyResolver

    // Has conflict: isSupported(): boolean
    // Has conflict: lookup(uri: string, cancellable: Cancellable | null): string[]
    // Has conflict: lookupAsync(uri: string, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupFinish(result: AsyncResult): string[]

    // Own virtual methods of Gio-2.0.Gio.ProxyResolver

    /**
     * Checks if `resolver` can be used on this system. (This is used
     * internally; g_proxy_resolver_get_default() will only return a proxy
     * resolver that returns %TRUE for this method.)
     * @virtual
     * @returns %TRUE if @resolver is supported.
     */
    isSupported(): boolean
    /**
     * Looks into the system proxy configuration to determine what proxy,
     * if any, to use to connect to `uri`. The returned proxy URIs are of
     * the form `<protocol>://[user[:password]`]`host[:port]` or
     * `direct://`, where <protocol> could be http, rtsp, socks
     * or other proxying protocol.
     *
     * If you don't know what network protocol is being used on the
     * socket, you should use `none` as the URI protocol.
     * In this case, the resolver might still return a generic proxy type
     * (such as SOCKS), but would not return protocol-specific proxy types
     * (such as http).
     *
     * `direct://` is used when no proxy is needed.
     * Direct connection should not be attempted unless it is part of the
     * returned array of proxies.
     * @virtual
     * @param uri a URI representing the destination to connect to
     * @param cancellable a #GCancellable, or %NULL
     * @returns A               NULL-terminated array of proxy URIs. Must be freed               with g_strfreev().
     */
    lookup(uri: string, cancellable: Cancellable | null): string[]
    /**
     * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
     * details.
     * @virtual
     * @param uri a URI representing the destination to connect to
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call after resolution completes
     */
    lookupAsync(
      uri: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Call this function to obtain the array of proxy URIs when
     * g_proxy_resolver_lookup_async() is complete. See
     * g_proxy_resolver_lookup() for more details.
     * @virtual
     * @param result the result passed to your #GAsyncReadyCallback
     * @returns A               NULL-terminated array of proxy URIs. Must be freed               with g_strfreev().
     */
    lookupFinish(result: AsyncResult): string[]

    // Class property signals of Gio-2.0.Gio.ProxyResolver

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GProxyResolver` provides synchronous and asynchronous network proxy
   * resolution. `GProxyResolver` is used within [class`Gio`.SocketClient] through
   * the method [method`Gio`.SocketConnectable.proxy_enumerate].
   *
   * Implementations of `GProxyResolver` based on
   * [libproxy](https://github.com/libproxy/libproxy) and GNOME settings can be
   * found in [glib-networking](https://gitlab.gnome.org/GNOME/glib-networking).
   * GIO comes with an implementation for use inside Flatpak portals.
   * @interface
   */
  class ProxyResolver extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ProxyResolver

    static name: string

    // Constructors of Gio-2.0.Gio.ProxyResolver

    constructor(config?: ProxyResolver.ConstructorProperties)
    _init(config?: ProxyResolver.ConstructorProperties): void
    /**
     * Gets the default #GProxyResolver for the system.
     * @returns the default #GProxyResolver, which     will be a dummy object if no proxy resolver is available
     */
    static getDefault(): ProxyResolver
  }

  module RemoteActionGroup {
    // Constructor properties interface

    interface ConstructorProperties
      extends ActionGroup.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface RemoteActionGroup extends ActionGroup {
    // Own properties of Gio-2.0.Gio.RemoteActionGroup

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.RemoteActionGroup

    // Has conflict: activateActionFull(actionName: string, parameter: GLib.Variant | null, platformData: GLib.Variant): void
    // Has conflict: changeActionStateFull(actionName: string, value: GLib.Variant, platformData: GLib.Variant): void

    // Own virtual methods of Gio-2.0.Gio.RemoteActionGroup

    /**
     * Activates the remote action.
     *
     * This is the same as g_action_group_activate_action() except that it
     * allows for provision of "platform data" to be sent along with the
     * activation request.  This typically contains details such as the user
     * interaction timestamp or startup notification information.
     *
     * `platform_data` must be non-%NULL and must have the type
     * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
     * @virtual
     * @param actionName the name of the action to activate
     * @param parameter the optional parameter to the activation
     * @param platformData the platform data to send
     */
    activateActionFull(
      actionName: string,
      parameter: GLib.Variant | null,
      platformData: GLib.Variant
    ): void
    /**
     * Changes the state of a remote action.
     *
     * This is the same as g_action_group_change_action_state() except that
     * it allows for provision of "platform data" to be sent along with the
     * state change request.  This typically contains details such as the
     * user interaction timestamp or startup notification information.
     *
     * `platform_data` must be non-%NULL and must have the type
     * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
     * @virtual
     * @param actionName the name of the action to change the state of
     * @param value the new requested value for the state
     * @param platformData the platform data to send
     */
    changeActionStateFull(
      actionName: string,
      value: GLib.Variant,
      platformData: GLib.Variant
    ): void

    // Class property signals of Gio-2.0.Gio.RemoteActionGroup

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GRemoteActionGroup` interface is implemented by [iface`Gio`.ActionGroup]
   * instances that either transmit action invocations to other processes
   * or receive action invocations in the local process from other
   * processes.
   *
   * The interface has `_full` variants of the two
   * methods on [iface`Gio`.ActionGroup] used to activate actions:
   * [method`Gio`.ActionGroup.activate_action] and
   * [method`Gio`.ActionGroup.change_action_state]. These variants allow a
   * ‘platform data’ [struct`GLib`.Variant] to be specified: a dictionary providing
   * context for the action invocation (for example: timestamps, startup
   * notification IDs, etc).
   *
   * [class`Gio`.DBusActionGroup] implements `GRemoteActionGroup`.  This provides a
   * mechanism to send platform data for action invocations over D-Bus.
   *
   * Additionally, [method`Gio`.DBusConnection.export_action_group] will check if
   * the exported [iface`Gio`.ActionGroup] implements `GRemoteActionGroup` and use
   * the `_full` variants of the calls if available.  This
   * provides a mechanism by which to receive platform data for action
   * invocations that arrive by way of D-Bus.
   * @interface
   */
  class RemoteActionGroup extends GObject.Object {
    // Own properties of Gio-2.0.Gio.RemoteActionGroup

    static name: string

    // Constructors of Gio-2.0.Gio.RemoteActionGroup

    constructor(config?: RemoteActionGroup.ConstructorProperties)
    _init(config?: RemoteActionGroup.ConstructorProperties): void
  }

  module Seekable {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Seekable {
    // Own properties of Gio-2.0.Gio.Seekable

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Seekable

    // Has conflict: canSeek(): boolean
    // Has conflict: canTruncate(): boolean
    // Has conflict: seek(offset: number, type: GLib.SeekType, cancellable: Cancellable | null): boolean
    // Has conflict: tell(): number
    /**
     * Sets the length of the stream to `offset`. If the stream was previously
     * larger than `offset,` the extra data is discarded. If the stream was
     * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     * @param offset new length for `seekable,` in bytes.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
     */
    truncate(offset: number, cancellable: Cancellable | null): boolean

    // Own virtual methods of Gio-2.0.Gio.Seekable

    /**
     * Tests if the stream supports the #GSeekableIface.
     * @virtual
     * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
     */
    canSeek(): boolean
    /**
     * Tests if the length of the stream can be adjusted with
     * g_seekable_truncate().
     * @virtual
     * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
     */
    canTruncate(): boolean
    /**
     * Seeks in the stream by the given `offset,` modified by `type`.
     *
     * Attempting to seek past the end of the stream will have different
     * results depending on if the stream is fixed-sized or resizable.  If
     * the stream is resizable then seeking past the end and then writing
     * will result in zeros filling the empty space.  Seeking past the end
     * of a resizable stream and reading will result in EOF.  Seeking past
     * the end of a fixed-sized stream will fail.
     *
     * Any operation that would result in a negative offset will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param offset a #goffset.
     * @param type a #GSeekType.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
     */
    seek(
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Tells the current position within the stream.
     * @virtual
     * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
     */
    tell(): number
    /**
     * Sets the length of the stream to `offset`. If the stream was previously
     * larger than `offset,` the extra data is discarded. If the stream was
     * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     * @virtual
     * @param offset new length for `seekable,` in bytes.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
     */
    truncateFn(offset: number, cancellable: Cancellable | null): boolean

    // Class property signals of Gio-2.0.Gio.Seekable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSeekable` is implemented by streams (implementations of
   * [class`Gio`.InputStream] or [class`Gio`.OutputStream]) that support seeking.
   *
   * Seekable streams largely fall into two categories: resizable and
   * fixed-size.
   *
   * `GSeekable` on fixed-sized streams is approximately the same as POSIX
   * [`lseek()`](man:lseek(2)) on a block device (for example: attempting to seek
   * past the end of the device is an error).  Fixed streams typically cannot be
   * truncated.
   *
   * `GSeekable` on resizable streams is approximately the same as POSIX
   * [`lseek()`](man:lseek(2)) on a normal file.  Seeking past the end and writing
   * data will usually cause the stream to resize by introducing zero bytes.
   * @interface
   */
  class Seekable extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Seekable

    static name: string

    // Constructors of Gio-2.0.Gio.Seekable

    constructor(config?: Seekable.ConstructorProperties)
    _init(config?: Seekable.ConstructorProperties): void
  }

  module SocketConnectable {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface SocketConnectable {
    // Own properties of Gio-2.0.Gio.SocketConnectable

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.SocketConnectable

    // Has conflict: enumerate(): SocketAddressEnumerator
    // Has conflict: proxyEnumerate(): SocketAddressEnumerator
    // Has conflict: toString(): string | null

    // Own virtual methods of Gio-2.0.Gio.SocketConnectable

    /**
     * Creates a #GSocketAddressEnumerator for `connectable`.
     * @virtual
     * @returns a new #GSocketAddressEnumerator.
     */
    enumerate(): SocketAddressEnumerator
    /**
     * Creates a #GSocketAddressEnumerator for `connectable` that will
     * return a #GProxyAddress for each of its addresses that you must connect
     * to via a proxy.
     *
     * If `connectable` does not implement
     * g_socket_connectable_proxy_enumerate(), this will fall back to
     * calling g_socket_connectable_enumerate().
     * @virtual
     * @returns a new #GSocketAddressEnumerator.
     */
    proxyEnumerate(): SocketAddressEnumerator
    /**
     * Format a #GSocketConnectable as a string. This is a human-readable format for
     * use in debugging output, and is not a stable serialization format. It is not
     * suitable for use in user interfaces as it exposes too much information for a
     * user.
     *
     * If the #GSocketConnectable implementation does not support string formatting,
     * the implementation’s type name will be returned as a fallback.
     * @virtual
     * @returns the formatted string
     */
    toString(): string | null

    // Class property signals of Gio-2.0.Gio.SocketConnectable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Objects that describe one or more potential socket endpoints
   * implement `GSocketConnectable`. Callers can then use
   * [method`Gio`.SocketConnectable.enumerate] to get a
   * [class`Gio`.SocketAddressEnumerator] to try out each socket address in turn
   * until one succeeds, as shown in the sample code below.
   *
   * ```c
   * MyConnectionType *
   * connect_to_host (const char    *hostname,
   *                  guint16        port,
   *                  GCancellable  *cancellable,
   *                  GError       **error)
   * {
   *   MyConnection *conn = NULL;
   *   GSocketConnectable *addr;
   *   GSocketAddressEnumerator *enumerator;
   *   GSocketAddress *sockaddr;
   *   GError *conn_error = NULL;
   *
   *   addr = g_network_address_new (hostname, port);
   *   enumerator = g_socket_connectable_enumerate (addr);
   *   g_object_unref (addr);
   *
   *   // Try each sockaddr until we succeed. Record the first connection error,
   *   // but not any further ones (since they'll probably be basically the same
   *   // as the first).
   *   while (!conn && (sockaddr = g_socket_address_enumerator_next (enumerator, cancellable, error))
   *     {
   *       conn = connect_to_sockaddr (sockaddr, conn_error ? NULL : &conn_error);
   *       g_object_unref (sockaddr);
   *     }
   *   g_object_unref (enumerator);
   *
   *   if (conn)
   *     {
   *       if (conn_error)
   *         {
   *           // We couldn't connect to the first address, but we succeeded
   *           // in connecting to a later address.
   *           g_error_free (conn_error);
   *         }
   *       return conn;
   *     }
   *   else if (error)
   *     {
   *       /// Either initial lookup failed, or else the caller cancelled us.
   *       if (conn_error)
   *         g_error_free (conn_error);
   *       return NULL;
   *     }
   *   else
   *     {
   *       g_error_propagate (error, conn_error);
   *       return NULL;
   *     }
   * }
   * ```
   * @interface
   */
  class SocketConnectable extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SocketConnectable

    static name: string

    // Constructors of Gio-2.0.Gio.SocketConnectable

    constructor(config?: SocketConnectable.ConstructorProperties)
    _init(config?: SocketConnectable.ConstructorProperties): void
  }

  module TlsBackend {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface TlsBackend {
    // Own properties of Gio-2.0.Gio.TlsBackend

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.TlsBackend

    /**
     * Gets the #GType of `backend'`s #GTlsCertificate implementation.
     * @returns the #GType of @backend's #GTlsCertificate   implementation.
     */
    getCertificateType(): GObject.GType
    /**
     * Gets the #GType of `backend'`s #GTlsClientConnection implementation.
     * @returns the #GType of @backend's #GTlsClientConnection   implementation.
     */
    getClientConnectionType(): GObject.GType
    // Has conflict: getDefaultDatabase(): TlsDatabase
    /**
     * Gets the #GType of `backend’`s #GDtlsClientConnection implementation.
     * @returns the #GType of @backend’s #GDtlsClientConnection   implementation, or %G_TYPE_INVALID if this backend doesn’t support DTLS.
     */
    getDtlsClientConnectionType(): GObject.GType
    /**
     * Gets the #GType of `backend’`s #GDtlsServerConnection implementation.
     * @returns the #GType of @backend’s #GDtlsServerConnection   implementation, or %G_TYPE_INVALID if this backend doesn’t support DTLS.
     */
    getDtlsServerConnectionType(): GObject.GType
    /**
     * Gets the #GType of `backend'`s #GTlsFileDatabase implementation.
     * @returns the #GType of backend's #GTlsFileDatabase implementation.
     */
    getFileDatabaseType(): GObject.GType
    /**
     * Gets the #GType of `backend'`s #GTlsServerConnection implementation.
     * @returns the #GType of @backend's #GTlsServerConnection   implementation.
     */
    getServerConnectionType(): GObject.GType
    /**
     * Set the default #GTlsDatabase used to verify TLS connections
     *
     * Any subsequent call to g_tls_backend_get_default_database() will return
     * the database set in this call.  Existing databases and connections are not
     * modified.
     *
     * Setting a %NULL default database will reset to using the system default
     * database as if g_tls_backend_set_default_database() had never been called.
     * @param database the #GTlsDatabase
     */
    setDefaultDatabase(database: TlsDatabase | null): void
    // Has conflict: supportsDtls(): boolean
    // Has conflict: supportsTls(): boolean

    // Own virtual methods of Gio-2.0.Gio.TlsBackend

    /**
     * Gets the default #GTlsDatabase used to verify TLS connections.
     * @virtual
     * @returns the default database, which should be               unreffed when done.
     */
    getDefaultDatabase(): TlsDatabase
    /**
     * Checks if DTLS is supported. DTLS support may not be available even if TLS
     * support is available, and vice-versa.
     * @virtual
     * @returns whether DTLS is supported
     */
    supportsDtls(): boolean
    /**
     * Checks if TLS is supported; if this returns %FALSE for the default
     * #GTlsBackend, it means no "real" TLS backend is available.
     * @virtual
     * @returns whether or not TLS is supported
     */
    supportsTls(): boolean

    // Class property signals of Gio-2.0.Gio.TlsBackend

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * TLS (Transport Layer Security, aka SSL) and DTLS backend. This is an
   * internal type used to coordinate the different classes implemented
   * by a TLS backend.
   * @interface
   */
  class TlsBackend extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TlsBackend

    static name: string

    // Constructors of Gio-2.0.Gio.TlsBackend

    constructor(config?: TlsBackend.ConstructorProperties)
    _init(config?: TlsBackend.ConstructorProperties): void
    /**
     * Gets the default #GTlsBackend for the system.
     * @returns a #GTlsBackend, which will be a     dummy object if no TLS backend is available
     */
    static getDefault(): TlsBackend
  }

  module TlsClientConnection {
    // Constructor properties interface

    interface ConstructorProperties
      extends TlsConnection.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TlsClientConnection

      /**
       * A #GSocketConnectable describing the identity of the server that
       * is expected on the other end of the connection.
       *
       * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
       * #GTlsClientConnection:validation-flags, this object will be used
       * to determine the expected identify of the remote end of the
       * connection; if #GTlsClientConnection:server-identity is not set,
       * or does not match the identity presented by the server, then the
       * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
       *
       * In addition to its use in verifying the server certificate,
       * this is also used to give a hint to the server about what
       * certificate we expect, which is useful for servers that serve
       * virtual hosts.
       */
      server_identity?: SocketConnectable | null
      /**
       * SSL 3.0 is no longer supported. See
       * g_tls_client_connection_set_use_ssl3() for details.
       */
      use_ssl3?: boolean | null
      /**
       * What steps to perform when validating a certificate received from
       * a server. Server certificates that fail to validate in any of the
       * ways indicated here will be rejected unless the application
       * overrides the default via #GTlsConnection::accept-certificate.
       *
       * GLib guarantees that if certificate verification fails, at least one
       * flag will be set, but it does not guarantee that all possible flags
       * will be set. Accordingly, you may not safely decide to ignore any
       * particular type of error. For example, it would be incorrect to mask
       * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
       * because this could potentially be the only error flag set even if
       * other problems exist with the certificate. Therefore, there is no
       * safe way to use this property. This is not a horrible problem,
       * though, because you should not be attempting to ignore validation
       * errors anyway. If you really must ignore TLS certificate errors,
       * connect to #GTlsConnection::accept-certificate.
       */
      validation_flags?: TlsCertificateFlags | null
    }
  }

  interface TlsClientConnection extends TlsConnection {
    // Own properties of Gio-2.0.Gio.TlsClientConnection

    /**
     * A list of the distinguished names of the Certificate Authorities
     * that the server will accept client certificates signed by. If the
     * server requests a client certificate during the handshake, then
     * this property will be set after the handshake completes.
     *
     * Each item in the list is a #GByteArray which contains the complete
     * subject DN of the certificate authority.
     */
    readonly acceptedCas: any[]
    /**
     * A #GSocketConnectable describing the identity of the server that
     * is expected on the other end of the connection.
     *
     * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
     * #GTlsClientConnection:validation-flags, this object will be used
     * to determine the expected identify of the remote end of the
     * connection; if #GTlsClientConnection:server-identity is not set,
     * or does not match the identity presented by the server, then the
     * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
     *
     * In addition to its use in verifying the server certificate,
     * this is also used to give a hint to the server about what
     * certificate we expect, which is useful for servers that serve
     * virtual hosts.
     */
    serverIdentity: SocketConnectable
    /**
     * SSL 3.0 is no longer supported. See
     * g_tls_client_connection_set_use_ssl3() for details.
     */
    useSsl3: boolean
    /**
     * What steps to perform when validating a certificate received from
     * a server. Server certificates that fail to validate in any of the
     * ways indicated here will be rejected unless the application
     * overrides the default via #GTlsConnection::accept-certificate.
     *
     * GLib guarantees that if certificate verification fails, at least one
     * flag will be set, but it does not guarantee that all possible flags
     * will be set. Accordingly, you may not safely decide to ignore any
     * particular type of error. For example, it would be incorrect to mask
     * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
     * because this could potentially be the only error flag set even if
     * other problems exist with the certificate. Therefore, there is no
     * safe way to use this property. This is not a horrible problem,
     * though, because you should not be attempting to ignore validation
     * errors anyway. If you really must ignore TLS certificate errors,
     * connect to #GTlsConnection::accept-certificate.
     */
    validationFlags: TlsCertificateFlags
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.TlsClientConnection

    // Has conflict: copySessionState(source: TlsClientConnection): void
    /**
     * Gets the list of distinguished names of the Certificate Authorities
     * that the server will accept certificates from. This will be set
     * during the TLS handshake if the server requests a certificate.
     * Otherwise, it will be %NULL.
     *
     * Each item in the list is a #GByteArray which contains the complete
     * subject DN of the certificate authority.
     * @returns the list of CA DNs. You should unref each element with g_byte_array_unref() and then the free the list with g_list_free().
     */
    getAcceptedCas(): GLib.List[]
    /**
     * Gets `conn'`s expected server identity
     * @returns a #GSocketConnectable describing the expected server identity, or %NULL if the expected identity is not known.
     */
    getServerIdentity(): SocketConnectable | null
    /**
     * SSL 3.0 is no longer supported. See
     * g_tls_client_connection_set_use_ssl3() for details.
     * @returns %FALSE
     */
    getUseSsl3(): boolean
    /**
     * Gets `conn'`s validation flags
     *
     * This function does not work as originally designed and is impossible
     * to use correctly. See #GTlsClientConnection:validation-flags for more
     * information.
     * @returns the validation flags
     */
    getValidationFlags(): TlsCertificateFlags
    /**
     * Sets `conn'`s expected server identity, which is used both to tell
     * servers on virtual hosts which certificate to present, and also
     * to let `conn` know what name to look for in the certificate when
     * performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled.
     * @param identity a #GSocketConnectable describing the expected server identity
     */
    setServerIdentity(identity: SocketConnectable): void
    /**
     * Since GLib 2.42.1, SSL 3.0 is no longer supported.
     *
     * From GLib 2.42.1 through GLib 2.62, this function could be used to
     * force use of TLS 1.0, the lowest-supported TLS protocol version at
     * the time. In the past, this was needed to connect to broken TLS
     * servers that exhibited protocol version intolerance. Such servers
     * are no longer common, and using TLS 1.0 is no longer considered
     * acceptable.
     *
     * Since GLib 2.64, this function does nothing.
     * @param useSsl3 a #gboolean, ignored
     */
    setUseSsl3(useSsl3: boolean): void
    /**
     * Sets `conn'`s validation flags, to override the default set of
     * checks performed when validating a server certificate. By default,
     * %G_TLS_CERTIFICATE_VALIDATE_ALL is used.
     *
     * This function does not work as originally designed and is impossible
     * to use correctly. See #GTlsClientConnection:validation-flags for more
     * information.
     * @param flags the #GTlsCertificateFlags to use
     */
    setValidationFlags(flags: TlsCertificateFlags): void

    // Own virtual methods of Gio-2.0.Gio.TlsClientConnection

    /**
     * Possibly copies session state from one connection to another, for use
     * in TLS session resumption. This is not normally needed, but may be
     * used when the same session needs to be used between different
     * endpoints, as is required by some protocols, such as FTP over TLS.
     * `source` should have already completed a handshake and, since TLS 1.3,
     * it should have been used to read data at least once. `conn` should not
     * have completed a handshake.
     *
     * It is not possible to know whether a call to this function will
     * actually do anything. Because session resumption is normally used
     * only for performance benefit, the TLS backend might not implement
     * this function. Even if implemented, it may not actually succeed in
     * allowing `conn` to resume `source'`s TLS session, because the server
     * may not have sent a session resumption token to `source,` or it may
     * refuse to accept the token from `conn`. There is no way to know
     * whether a call to this function is actually successful.
     *
     * Using this function is not required to benefit from session
     * resumption. If the TLS backend supports session resumption, the
     * session will be resumed automatically if it is possible to do so
     * without weakening the privacy guarantees normally provided by TLS,
     * without need to call this function. For example, with TLS 1.3,
     * a session ticket will be automatically copied from any
     * #GTlsClientConnection that has previously received session tickets
     * from the server, provided a ticket is available that has not
     * previously been used for session resumption, since session ticket
     * reuse would be a privacy weakness. Using this function causes the
     * ticket to be copied without regard for privacy considerations.
     * @virtual
     * @param source a #GTlsClientConnection
     */
    copySessionState(source: TlsClientConnection): void

    // Class property signals of Gio-2.0.Gio.TlsClientConnection

    connect(
      sigName: "notify::accepted-cas",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accepted-cas",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accepted-cas",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accepted-cas",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accepted-cas", ...args: any[]): void
    connect(
      sigName: "notify::server-identity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::server-identity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::server-identity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::server-identity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::server-identity", ...args: any[]): void
    connect(
      sigName: "notify::use-ssl3",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-ssl3",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-ssl3",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-ssl3",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-ssl3", ...args: any[]): void
    connect(
      sigName: "notify::validation-flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::validation-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::validation-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::validation-flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::validation-flags", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::advertised-protocols", ...args: any[]): void
    connect(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::base-io-stream", ...args: any[]): void
    connect(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::certificate", ...args: any[]): void
    connect(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ciphersuite-name", ...args: any[]): void
    connect(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::database", ...args: any[]): void
    connect(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::interaction", ...args: any[]): void
    connect(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::negotiated-protocol", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate-errors", ...args: any[]): void
    connect(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol-version", ...args: any[]): void
    connect(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rehandshake-mode", ...args: any[]): void
    connect(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::require-close-notify", ...args: any[]): void
    connect(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-system-certdb", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GTlsClientConnection` is the client-side subclass of
   * [class`Gio`.TlsConnection], representing a client-side TLS connection.
   * @interface
   */
  class TlsClientConnection extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TlsClientConnection

    static name: string

    // Constructors of Gio-2.0.Gio.TlsClientConnection

    constructor(config?: TlsClientConnection.ConstructorProperties)
    _init(config?: TlsClientConnection.ConstructorProperties): void
    /**
     * Creates a new #GTlsClientConnection wrapping `base_io_stream` (which
     * must have pollable input and output streams) which is assumed to
     * communicate with the server identified by `server_identity`.
     *
     * See the documentation for #GTlsConnection:base-io-stream for restrictions
     * on when application code can run operations on the `base_io_stream` after
     * this function has returned.
     * @param baseIoStream the #GIOStream to wrap
     * @param serverIdentity the expected identity of the server
     * @returns the new #GTlsClientConnection, or %NULL on error
     */
    static new(
      baseIoStream: IOStream,
      serverIdentity: SocketConnectable | null
    ): TlsClientConnection
  }

  module TlsFileDatabase {
    // Constructor properties interface

    interface ConstructorProperties
      extends TlsDatabase.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TlsFileDatabase

      /**
       * The path to a file containing PEM encoded certificate authority
       * root anchors. The certificates in this file will be treated as
       * root authorities for the purpose of verifying other certificates
       * via the g_tls_database_verify_chain() operation.
       */
      anchors?: string | null
    }
  }

  interface TlsFileDatabase extends TlsDatabase {
    // Own properties of Gio-2.0.Gio.TlsFileDatabase

    /**
     * The path to a file containing PEM encoded certificate authority
     * root anchors. The certificates in this file will be treated as
     * root authorities for the purpose of verifying other certificates
     * via the g_tls_database_verify_chain() operation.
     */
    anchors: string | null
    __gtype__: number

    // Class property signals of Gio-2.0.Gio.TlsFileDatabase

    connect(
      sigName: "notify::anchors",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::anchors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::anchors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::anchors",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::anchors", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GTlsFileDatabase` is implemented by [class`Gio`.TlsDatabase] objects which
   * load their certificate information from a file. It is an interface which
   * TLS library specific subtypes implement.
   * @interface
   */
  class TlsFileDatabase extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TlsFileDatabase

    static name: string

    // Constructors of Gio-2.0.Gio.TlsFileDatabase

    constructor(config?: TlsFileDatabase.ConstructorProperties)
    _init(config?: TlsFileDatabase.ConstructorProperties): void
    /**
     * Creates a new #GTlsFileDatabase which uses anchor certificate authorities
     * in `anchors` to verify certificate chains.
     *
     * The certificates in `anchors` must be PEM encoded.
     * @param anchors filename of anchor certificate authorities.
     * @returns the new #GTlsFileDatabase, or %NULL on error
     */
    static new(anchors: string): TlsFileDatabase
  }

  module TlsServerConnection {
    // Constructor properties interface

    interface ConstructorProperties
      extends TlsConnection.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TlsServerConnection

      /**
       * The #GTlsAuthenticationMode for the server. This can be changed
       * before calling g_tls_connection_handshake() if you want to
       * rehandshake with a different mode from the initial handshake.
       */
      authentication_mode?: TlsAuthenticationMode | null
    }
  }

  interface TlsServerConnection extends TlsConnection {
    // Own properties of Gio-2.0.Gio.TlsServerConnection

    /**
     * The #GTlsAuthenticationMode for the server. This can be changed
     * before calling g_tls_connection_handshake() if you want to
     * rehandshake with a different mode from the initial handshake.
     */
    authenticationMode: TlsAuthenticationMode
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Class property signals of Gio-2.0.Gio.TlsServerConnection

    connect(
      sigName: "notify::authentication-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::authentication-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::authentication-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::authentication-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::authentication-mode", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::advertised-protocols", ...args: any[]): void
    connect(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::base-io-stream", ...args: any[]): void
    connect(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::certificate", ...args: any[]): void
    connect(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ciphersuite-name", ...args: any[]): void
    connect(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::database", ...args: any[]): void
    connect(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::interaction", ...args: any[]): void
    connect(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::negotiated-protocol", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate-errors", ...args: any[]): void
    connect(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol-version", ...args: any[]): void
    connect(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rehandshake-mode", ...args: any[]): void
    connect(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::require-close-notify", ...args: any[]): void
    connect(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-system-certdb", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GTlsServerConnection` is the server-side subclass of
   * [class`Gio`.TlsConnection], representing a server-side TLS connection.
   * @interface
   */
  class TlsServerConnection extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TlsServerConnection

    static name: string

    // Constructors of Gio-2.0.Gio.TlsServerConnection

    constructor(config?: TlsServerConnection.ConstructorProperties)
    _init(config?: TlsServerConnection.ConstructorProperties): void
    /**
     * Creates a new #GTlsServerConnection wrapping `base_io_stream` (which
     * must have pollable input and output streams).
     *
     * See the documentation for #GTlsConnection:base-io-stream for restrictions
     * on when application code can run operations on the `base_io_stream` after
     * this function has returned.
     * @param baseIoStream the #GIOStream to wrap
     * @param certificate the default server certificate, or %NULL
     * @returns the new #GTlsServerConnection, or %NULL on error
     */
    static new(
      baseIoStream: IOStream,
      certificate: TlsCertificate | null
    ): TlsServerConnection
  }

  module Volume {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `removed`
     */
    interface RemovedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Volume {
    // Own properties of Gio-2.0.Gio.Volume

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Volume

    // Has conflict: canEject(): boolean
    // Has conflict: canMount(): boolean
    // Has conflict: eject(flags: MountUnmountFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: ejectFinish(result: AsyncResult): boolean
    // Has conflict: ejectWithOperation(flags: MountUnmountFlags, mountOperation: MountOperation | null, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: ejectWithOperationFinish(result: AsyncResult): boolean
    // Has conflict: enumerateIdentifiers(): string[]
    // Has conflict: getActivationRoot(): File | null
    // Has conflict: getDrive(): Drive | null
    // Has conflict: getIcon(): Icon
    // Has conflict: getIdentifier(kind: string): string | null
    // Has conflict: getMount(): Mount | null
    // Has conflict: getName(): string | null
    // Has conflict: getSortKey(): string | null
    // Has conflict: getSymbolicIcon(): Icon
    // Has conflict: getUuid(): string | null
    /**
     * Mounts a volume. This is an asynchronous operation, and is
     * finished by calling g_volume_mount_finish() with the `volume`
     * and #GAsyncResult returned in the `callback`.
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation or %NULL to avoid user interaction
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback, or %NULL
     */
    mount(
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    // Has conflict: mountFinish(result: AsyncResult): boolean
    // Has conflict: shouldAutomount(): boolean

    // Own virtual methods of Gio-2.0.Gio.Volume

    /**
     * Checks if a volume can be ejected.
     * @virtual
     * @returns %TRUE if the @volume can be ejected. %FALSE otherwise
     */
    canEject(): boolean
    /**
     * Checks if a volume can be mounted.
     * @virtual
     * @returns %TRUE if the @volume can be mounted. %FALSE otherwise
     */
    canMount(): boolean
    /**
     * Changed signal that is emitted when the volume's state has changed.
     * @virtual
     */
    changed(): void
    /**
     * Ejects a volume. This is an asynchronous operation, and is
     * finished by calling g_volume_eject_finish() with the `volume`
     * and #GAsyncResult returned in the `callback`.
     * @virtual
     * @param flags flags affecting the unmount if required for eject
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback, or %NULL
     */
    eject(
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes ejecting a volume. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE, %FALSE if operation failed
     */
    ejectFinish(result: AsyncResult): boolean
    /**
     * Ejects a volume. This is an asynchronous operation, and is
     * finished by calling g_volume_eject_with_operation_finish() with the `volume`
     * and #GAsyncResult data returned in the `callback`.
     * @virtual
     * @param flags flags affecting the unmount if required for eject
     * @param mountOperation a #GMountOperation or %NULL to     avoid user interaction
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback, or %NULL
     */
    ejectWithOperation(
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes ejecting a volume. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if the volume was successfully ejected. %FALSE otherwise
     */
    ejectWithOperationFinish(result: AsyncResult): boolean
    /**
     * Gets the kinds of [identifiers](#volume-identifiers) that `volume` has.
     * Use g_volume_get_identifier() to obtain the identifiers themselves.
     * @virtual
     * @returns a %NULL-terminated array   of strings containing kinds of identifiers. Use g_strfreev() to free.
     */
    enumerateIdentifiers(): string[]
    /**
     * Gets the activation root for a #GVolume if it is known ahead of
     * mount time. Returns %NULL otherwise. If not %NULL and if `volume`
     * is mounted, then the result of g_mount_get_root() on the
     * #GMount object obtained from g_volume_get_mount() will always
     * either be equal or a prefix of what this function returns. In
     * other words, in code
     *
     *
     * ```c
     *   GMount *mount;
     *   GFile *mount_root
     *   GFile *volume_activation_root;
     *
     *   mount = g_volume_get_mount (volume); // mounted, so never NULL
     *   mount_root = g_mount_get_root (mount);
     *   volume_activation_root = g_volume_get_activation_root (volume); // assume not NULL
     * ```
     *
     * then the expression
     *
     * ```c
     *   (g_file_has_prefix (volume_activation_root, mount_root) ||
     *    g_file_equal (volume_activation_root, mount_root))
     * ```
     *
     * will always be %TRUE.
     *
     * Activation roots are typically used in #GVolumeMonitor
     * implementations to find the underlying mount to shadow, see
     * g_mount_is_shadowed() for more details.
     * @virtual
     * @returns the activation root of @volume     or %NULL. Use g_object_unref() to free.
     */
    getActivationRoot(): File | null
    /**
     * Gets the drive for the `volume`.
     * @virtual
     * @returns a #GDrive or %NULL if @volume is not     associated with a drive. The returned object should be unreffed     with g_object_unref() when no longer needed.
     */
    getDrive(): Drive | null
    /**
     * Gets the icon for `volume`.
     * @virtual
     * @returns a #GIcon.     The returned object should be unreffed with g_object_unref()     when no longer needed.
     */
    getIcon(): Icon
    /**
     * Gets the identifier of the given kind for `volume`.
     * See the [introduction](#volume-identifiers) for more
     * information about volume identifiers.
     * @virtual
     * @param kind the kind of identifier to return
     * @returns a newly allocated string containing the     requested identifier, or %NULL if the #GVolume     doesn't have this kind of identifier
     */
    getIdentifier(kind: string): string | null
    /**
     * Gets the mount for the `volume`.
     * @virtual
     * @returns a #GMount or %NULL if @volume isn't mounted.     The returned object should be unreffed with g_object_unref()     when no longer needed.
     */
    getMount(): Mount | null
    /**
     * Gets the name of `volume`.
     * @virtual
     * @returns the name for the given @volume. The returned string should     be freed with g_free() when no longer needed.
     */
    getName(): string | null
    /**
     * Gets the sort key for `volume,` if any.
     * @virtual
     * @returns Sorting key for @volume or %NULL if no such key is available
     */
    getSortKey(): string | null
    /**
     * Gets the symbolic icon for `volume`.
     * @virtual
     * @returns a #GIcon.     The returned object should be unreffed with g_object_unref()     when no longer needed.
     */
    getSymbolicIcon(): Icon
    /**
     * Gets the UUID for the `volume`. The reference is typically based on
     * the file system UUID for the volume in question and should be
     * considered an opaque string. Returns %NULL if there is no UUID
     * available.
     * @virtual
     * @returns the UUID for @volume or %NULL if no UUID     can be computed.     The returned string should be freed with g_free()     when no longer needed.
     */
    getUuid(): string | null
    /**
     * Finishes mounting a volume. If any errors occurred during the operation,
     * `error` will be set to contain the errors and %FALSE will be returned.
     *
     * If the mount operation succeeded, g_volume_get_mount() on `volume`
     * is guaranteed to return the mount right after calling this
     * function; there's no need to listen for the 'mount-added' signal on
     * #GVolumeMonitor.
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE, %FALSE if operation failed
     */
    mountFinish(result: AsyncResult): boolean
    /**
     * Mounts a volume. This is an asynchronous operation, and is
     * finished by calling g_volume_mount_finish() with the `volume`
     * and #GAsyncResult returned in the `callback`.
     * @virtual
     * @param flags flags affecting the operation
     * @param mountOperation a #GMountOperation or %NULL to avoid user interaction
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback, or %NULL
     */
    mountFn(
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * The removed signal that is emitted when the #GVolume have been removed. If the recipient is holding references to the object they should release them so the object can be finalized.
     * @virtual
     */
    removed(): void
    /**
     * Returns whether the volume should be automatically mounted.
     * @virtual
     * @returns %TRUE if the volume should be automatically mounted
     */
    shouldAutomount(): boolean

    // Own signals of Gio-2.0.Gio.Volume

    connect(sigName: "changed", callback: Volume.ChangedSignalCallback): number
    on(
      sigName: "changed",
      callback: Volume.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Volume.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Volume.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(sigName: "removed", callback: Volume.RemovedSignalCallback): number
    on(
      sigName: "removed",
      callback: Volume.RemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "removed",
      callback: Volume.RemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "removed",
      callback: Volume.RemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "removed", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.Volume

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GVolume` interface represents user-visible objects that can be
   * mounted. Note, when [porting from GnomeVFS](migrating-gnome-vfs.html),
   * `GVolume` is the moral equivalent of `GnomeVFSDrive`.
   *
   * Mounting a `GVolume` instance is an asynchronous operation. For more
   * information about asynchronous operations, see [iface`Gio`.AsyncResult] and
   * [class`Gio`.Task]. To mount a `GVolume`, first call [method`Gio`.Volume.mount]
   * with (at least) the `GVolume` instance, optionally a
   * [class`Gio`.MountOperation] object and a [type`Gio`.AsyncReadyCallback].
   *
   * Typically, one will only want to pass `NULL` for the
   * [class`Gio`.MountOperation] if automounting all volumes when a desktop session
   * starts since it’s not desirable to put up a lot of dialogs asking
   * for credentials.
   *
   * The callback will be fired when the operation has resolved (either
   * with success or failure), and a [iface`Gio`.AsyncResult] instance will be
   * passed to the callback.  That callback should then call
   * [method`Gio`.Volume.mount_finish] with the `GVolume` instance and the
   * [iface`Gio`.AsyncResult] data to see if the operation was completed
   * successfully.  If a [type`GLib`.Error] is present when
   * [method`Gio`.Volume.mount_finish] is called, then it will be filled with any
   * error information.
   *
   * ## Volume Identifiers
   *
   * It is sometimes necessary to directly access the underlying
   * operating system object behind a volume (e.g. for passing a volume
   * to an application via the command line). For this purpose, GIO
   * allows to obtain an ‘identifier’ for the volume. There can be
   * different kinds of identifiers, such as Hal UDIs, filesystem labels,
   * traditional Unix devices (e.g. `/dev/sda2`), UUIDs. GIO uses predefined
   * strings as names for the different kinds of identifiers:
   * `G_VOLUME_IDENTIFIER_KIND_UUID`, `G_VOLUME_IDENTIFIER_KIND_LABEL`, etc.
   * Use [method`Gio`.Volume.get_identifier] to obtain an identifier for a volume.
   *
   * Note that `G_VOLUME_IDENTIFIER_KIND_HAL_UDI` will only be available
   * when the GVFS hal volume monitor is in use. Other volume monitors
   * will generally be able to provide the `G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE`
   * identifier, which can be used to obtain a hal device by means of
   * `libhal_manager_find_device_string_match()`.
   * @interface
   */
  class Volume extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Volume

    static name: string

    // Constructors of Gio-2.0.Gio.Volume

    constructor(config?: Volume.ConstructorProperties)
    _init(config?: Volume.ConstructorProperties): void
  }

  module AppInfoMonitor {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface AppInfoMonitor {
    // Own properties of Gio-2.0.Gio.AppInfoMonitor

    __gtype__: number

    // Own signals of Gio-2.0.Gio.AppInfoMonitor

    connect(
      sigName: "changed",
      callback: AppInfoMonitor.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: AppInfoMonitor.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: AppInfoMonitor.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: AppInfoMonitor.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.AppInfoMonitor

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GAppInfoMonitor` monitors application information for changes.
   *
   * `GAppInfoMonitor` is a very simple object used for monitoring the app
   * info database for changes (newly installed or removed applications).
   *
   * Call [func`Gio`.AppInfoMonitor.get] to get a `GAppInfoMonitor` and connect
   * to the [signal`Gio`.AppInfoMonitor::changed] signal. The signal will be emitted once when
   * the app info database changes, and will not be emitted again until after the
   * next call to [func`Gio`.AppInfo.get_all] or another `g_app_info_*()` function.
   * This is because monitoring the app info database for changes is expensive.
   *
   * The following functions will re-arm the [signal`Gio`.AppInfoMonitor::changed]
   * signal so it can be emitted again:
   *
   *  - [func`Gio`.AppInfo.get_all]
   *  - [func`Gio`.AppInfo.get_all_for_type]
   *  - [func`Gio`.AppInfo.get_default_for_type]
   *  - [func`Gio`.AppInfo.get_fallback_for_type]
   *  - [func`Gio`.AppInfo.get_recommended_for_type]
   *  - [`g_desktop_app_info_get_implementations()`](../gio-unix/type_func.DesktopAppInfo.get_implementation.html)
   *  - [`g_desktop_app_info_new()`](../gio-unix/ctor.DesktopAppInfo.new.html)
   *  - [`g_desktop_app_info_new_from_filename()`](../gio-unix/ctor.DesktopAppInfo.new_from_filename.html)
   *  - [`g_desktop_app_info_new_from_keyfile()`](../gio-unix/ctor.DesktopAppInfo.new_from_keyfile.html)
   *  - [`g_desktop_app_info_search()`](../gio-unix/type_func.DesktopAppInfo.search.html)
   *
   * The latter functions are available if using
   * [`GDesktopAppInfo`](../gio-unix/class.DesktopAppInfo.html) from
   * `gio-unix-2.0.pc` (GIR namespace `GioUnix-2.0`).
   *
   * In the usual case, applications should try to make note of the change
   * (doing things like invalidating caches) but not act on it. In
   * particular, applications should avoid making calls to `GAppInfo` APIs
   * in response to the change signal, deferring these until the time that
   * the updated data is actually required. The exception to this case is when
   * application information is actually being displayed on the screen
   * (for example, during a search or when the list of all applications is shown).
   * The reason for this is that changes to the list of installed applications
   * often come in groups (like during system updates) and rescanning the list
   * on every change is pointless and expensive.
   * @class
   */
  class AppInfoMonitor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.AppInfoMonitor

    static name: string

    // Constructors of Gio-2.0.Gio.AppInfoMonitor

    constructor(config?: AppInfoMonitor.ConstructorProperties)
    _init(config?: AppInfoMonitor.ConstructorProperties): void
    /**
     * Gets the #GAppInfoMonitor for the current thread-default main
     * context.
     *
     * The #GAppInfoMonitor will emit a "changed" signal in the
     * thread-default main context whenever the list of installed
     * applications (as reported by g_app_info_get_all()) may have changed.
     *
     * The #GAppInfoMonitor::changed signal will only be emitted once until
     * g_app_info_get_all() (or another `g_app_info_*()` function) is called. Doing
     * so will re-arm the signal ready to notify about the next change.
     *
     * You must only call g_object_unref() on the return value from under
     * the same main context as you created it.
     * @returns a reference to a #GAppInfoMonitor
     */
    static get(): AppInfoMonitor
  }

  module AppLaunchContext {
    // Signal callback interfaces

    /**
     * Signal callback interface for `launch-failed`
     */
    interface LaunchFailedSignalCallback {
      (startupNotifyId: string | null): void
    }

    /**
     * Signal callback interface for `launch-started`
     */
    interface LaunchStartedSignalCallback {
      (info: AppInfo, platformData: GLib.Variant | null): void
    }

    /**
     * Signal callback interface for `launched`
     */
    interface LaunchedSignalCallback {
      (info: AppInfo, platformData: GLib.Variant): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface AppLaunchContext {
    // Own properties of Gio-2.0.Gio.AppLaunchContext

    __gtype__: number

    // Own fields of Gio-2.0.Gio.AppLaunchContext

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.AppLaunchContext

    // Has conflict: getDisplay(info: AppInfo, files: File[]): string | null
    /**
     * Gets the complete environment variable list to be passed to
     * the child process when `context` is used to launch an application.
     * This is a %NULL-terminated array of strings, where each string has
     * the form `KEY=VALUE`.
     * @returns the child's environment
     */
    getEnvironment(): string[]
    // Has conflict: getStartupNotifyId(info: AppInfo, files: File[]): string | null
    // Has conflict: launchFailed(startupNotifyId: string): void
    /**
     * Arranges for `variable` to be set to `value` in the child's
     * environment when `context` is used to launch an application.
     * @param variable the environment variable to set
     * @param value the value for to set the variable to.
     */
    setenv(variable: string, value: string): void
    /**
     * Arranges for `variable` to be unset in the child's environment
     * when `context` is used to launch an application.
     * @param variable the environment variable to remove
     */
    unsetenv(variable: string): void

    // Own virtual methods of Gio-2.0.Gio.AppLaunchContext

    /**
     * Gets the display string for the `context`. This is used to ensure new
     * applications are started on the same display as the launching
     * application, by setting the `DISPLAY` environment variable.
     * @virtual
     * @param info a #GAppInfo
     * @param files a #GList of #GFile objects
     * @returns a display string for the display.
     */
    getDisplay(info: AppInfo, files: File[]): string | null
    /**
     * Initiates startup notification for the application and returns the
     * `XDG_ACTIVATION_TOKEN` or `DESKTOP_STARTUP_ID` for the launched operation,
     * if supported.
     *
     * The returned token may be referred to equivalently as an ‘activation token’
     * (using Wayland terminology) or a ‘startup sequence ID’ (using X11 terminology).
     * The two [are interoperable](https://gitlab.freedesktop.org/wayland/wayland-protocols/-/blob/main/staging/xdg-activation/x11-interoperation.rst).
     *
     * Activation tokens are defined in the [XDG Activation Protocol](https://wayland.app/protocols/xdg-activation-v1),
     * and startup notification IDs are defined in the
     * [freedesktop.org Startup Notification Protocol](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt).
     *
     * Support for the XDG Activation Protocol was added in GLib 2.76.
     * @virtual
     * @param info a #GAppInfo
     * @param files a #GList of #GFile objects
     * @returns a startup notification ID for the application, or %NULL if     not supported.
     */
    getStartupNotifyId(info: AppInfo, files: File[]): string | null
    /**
     * Called when an application has failed to launch, so that it can cancel
     * the application startup notification started in g_app_launch_context_get_startup_notify_id().
     * @virtual
     * @param startupNotifyId the startup notification id that was returned by g_app_launch_context_get_startup_notify_id().
     */
    launchFailed(startupNotifyId: string): void
    launchStarted(info: AppInfo, platformData: GLib.Variant): void
    launched(info: AppInfo, platformData: GLib.Variant): void

    // Own signals of Gio-2.0.Gio.AppLaunchContext

    connect(
      sigName: "launch-failed",
      callback: AppLaunchContext.LaunchFailedSignalCallback
    ): number
    on(
      sigName: "launch-failed",
      callback: AppLaunchContext.LaunchFailedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "launch-failed",
      callback: AppLaunchContext.LaunchFailedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "launch-failed",
      callback: AppLaunchContext.LaunchFailedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "launch-failed", ...args: any[]): void
    connect(
      sigName: "launch-started",
      callback: AppLaunchContext.LaunchStartedSignalCallback
    ): number
    on(
      sigName: "launch-started",
      callback: AppLaunchContext.LaunchStartedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "launch-started",
      callback: AppLaunchContext.LaunchStartedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "launch-started",
      callback: AppLaunchContext.LaunchStartedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "launch-started",
      platformData: GLib.Variant | null,
      ...args: any[]
    ): void
    connect(
      sigName: "launched",
      callback: AppLaunchContext.LaunchedSignalCallback
    ): number
    on(
      sigName: "launched",
      callback: AppLaunchContext.LaunchedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "launched",
      callback: AppLaunchContext.LaunchedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "launched",
      callback: AppLaunchContext.LaunchedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "launched", platformData: GLib.Variant, ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.AppLaunchContext

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Integrating the launch with the launching application. This is used to
   * handle for instance startup notification and launching the new application
   * on the same screen as the launching window.
   * @class
   */
  class AppLaunchContext extends GObject.Object {
    // Own properties of Gio-2.0.Gio.AppLaunchContext

    static name: string

    // Constructors of Gio-2.0.Gio.AppLaunchContext

    constructor(config?: AppLaunchContext.ConstructorProperties)
    /**
     * Creates a new application launch context. This is not normally used,
     * instead you instantiate a subclass of this, such as #GdkAppLaunchContext.
     * @constructor
     * @returns a #GAppLaunchContext.
     */
    constructor()
    /**
     * Creates a new application launch context. This is not normally used,
     * instead you instantiate a subclass of this, such as #GdkAppLaunchContext.
     * @constructor
     * @returns a #GAppLaunchContext.
     */
    static new(): AppLaunchContext
    _init(config?: AppLaunchContext.ConstructorProperties): void
  }

  module Application {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `command-line`
     */
    interface CommandLineSignalCallback {
      (commandLine: ApplicationCommandLine): number
    }

    /**
     * Signal callback interface for `handle-local-options`
     */
    interface HandleLocalOptionsSignalCallback {
      (options: GLib.VariantDict): number
    }

    /**
     * Signal callback interface for `name-lost`
     */
    interface NameLostSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `open`
     */
    interface OpenSignalCallback {
      (files: File[], hint: string | null): void
    }

    /**
     * Signal callback interface for `shutdown`
     */
    interface ShutdownSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `startup`
     */
    interface StartupSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends ActionGroup.ConstructorProperties,
        ActionMap.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.Application

      /**
       * The group of actions that the application exports.
       */
      action_group?: ActionGroup | null
      /**
       * The unique identifier for the application.
       */
      application_id?: string | null
      /**
       * Flags specifying the behaviour of the application.
       */
      flags?: ApplicationFlags | null
      /**
       * Time (in milliseconds) to stay alive after becoming idle.
       */
      inactivity_timeout?: number | null
      /**
       * The base resource path for the application.
       */
      resource_base_path?: string | null
      /**
       * The human-readable version number of the application.
       */
      version?: string | null
    }
  }

  interface Application extends ActionGroup, ActionMap {
    // Own properties of Gio-2.0.Gio.Application

    /**
     * The group of actions that the application exports.
     */
    actionGroup: ActionGroup
    /**
     * The unique identifier for the application.
     */
    applicationId: string | null
    /**
     * Flags specifying the behaviour of the application.
     */
    flags: ApplicationFlags
    /**
     * Time (in milliseconds) to stay alive after becoming idle.
     */
    inactivityTimeout: number
    /**
     * Whether the application is currently marked as busy through
     * g_application_mark_busy() or g_application_bind_busy_property().
     */
    readonly isBusy: boolean
    /**
     * Whether [method`Gio`.Application.register] has been called.
     */
    readonly isRegistered: boolean
    /**
     * Whether this application instance is remote.
     */
    readonly isRemote: boolean
    /**
     * The base resource path for the application.
     */
    resourceBasePath: string | null
    /**
     * The human-readable version number of the application.
     */
    version: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Application

    // Has conflict: activate(): void
    /**
     * Add an option to be handled by `application`.
     *
     * Calling this function is the equivalent of calling
     * g_application_add_main_option_entries() with a single #GOptionEntry
     * that has its arg_data member set to %NULL.
     *
     * The parsed arguments will be packed into a #GVariantDict which
     * is passed to #GApplication::handle-local-options. If
     * %G_APPLICATION_HANDLES_COMMAND_LINE is set, then it will also
     * be sent to the primary instance. See
     * g_application_add_main_option_entries() for more details.
     *
     * See #GOptionEntry for more documentation of the arguments.
     * @param longName the long name of an option used to specify it in a commandline
     * @param shortName the short name of an option
     * @param flags flags from #GOptionFlags
     * @param arg the type of the option, as a #GOptionArg
     * @param description the description for the option in `--help` output
     * @param argDescription the placeholder to use for the extra argument    parsed by the option in `--help` output
     */
    addMainOption(
      longName: string,
      shortName: number,
      flags: GLib.OptionFlags,
      arg: GLib.OptionArg,
      description: string,
      argDescription: string | null
    ): void
    /**
     * Adds main option entries to be handled by `application`.
     *
     * This function is comparable to g_option_context_add_main_entries().
     *
     * After the commandline arguments are parsed, the
     * #GApplication::handle-local-options signal will be emitted.  At this
     * point, the application can inspect the values pointed to by `arg_data`
     * in the given #GOptionEntrys.
     *
     * Unlike #GOptionContext, #GApplication supports giving a %NULL
     * `arg_data` for a non-callback #GOptionEntry.  This results in the
     * argument in question being packed into a #GVariantDict which is also
     * passed to #GApplication::handle-local-options, where it can be
     * inspected and modified.  If %G_APPLICATION_HANDLES_COMMAND_LINE is
     * set, then the resulting dictionary is sent to the primary instance,
     * where g_application_command_line_get_options_dict() will return it.
     * As it has been passed outside the process at this point, the types of all
     * values in the options dict must be checked before being used.
     * This "packing" is done according to the type of the argument --
     * booleans for normal flags, strings for strings, bytestrings for
     * filenames, etc.  The packing only occurs if the flag is given (ie: we
     * do not pack a "false" #GVariant in the case that a flag is missing).
     *
     * In general, it is recommended that all commandline arguments are
     * parsed locally.  The options dictionary should then be used to
     * transmit the result of the parsing to the primary instance, where
     * g_variant_dict_lookup() can be used.  For local options, it is
     * possible to either use `arg_data` in the usual way, or to consult (and
     * potentially remove) the option from the options dictionary.
     *
     * This function is new in GLib 2.40.  Before then, the only real choice
     * was to send all of the commandline arguments (options and all) to the
     * primary instance for handling.  #GApplication ignored them completely
     * on the local side.  Calling this function "opts in" to the new
     * behaviour, and in particular, means that unrecognised options will be
     * treated as errors.  Unrecognised options have never been ignored when
     * %G_APPLICATION_HANDLES_COMMAND_LINE is unset.
     *
     * If #GApplication::handle-local-options needs to see the list of
     * filenames, then the use of %G_OPTION_REMAINING is recommended.  If
     * `arg_data` is %NULL then %G_OPTION_REMAINING can be used as a key into
     * the options dictionary.  If you do use %G_OPTION_REMAINING then you
     * need to handle these arguments for yourself because once they are
     * consumed, they will no longer be visible to the default handling
     * (which treats them as filenames to be opened).
     *
     * It is important to use the proper GVariant format when retrieving
     * the options with g_variant_dict_lookup():
     * - for %G_OPTION_ARG_NONE, use `b`
     * - for %G_OPTION_ARG_STRING, use `&s`
     * - for %G_OPTION_ARG_INT, use `i`
     * - for %G_OPTION_ARG_INT64, use `x`
     * - for %G_OPTION_ARG_DOUBLE, use `d`
     * - for %G_OPTION_ARG_FILENAME, use `^&ay`
     * - for %G_OPTION_ARG_STRING_ARRAY, use `^a&s`
     * - for %G_OPTION_ARG_FILENAME_ARRAY, use `^a&ay`
     * @param entries the   main options for the application
     */
    addMainOptionEntries(entries: GLib.OptionEntry[]): void
    /**
     * Adds a #GOptionGroup to the commandline handling of `application`.
     *
     * This function is comparable to g_option_context_add_group().
     *
     * Unlike g_application_add_main_option_entries(), this function does
     * not deal with %NULL `arg_data` and never transmits options to the
     * primary instance.
     *
     * The reason for that is because, by the time the options arrive at the
     * primary instance, it is typically too late to do anything with them.
     * Taking the GTK option group as an example: GTK will already have been
     * initialised by the time the #GApplication::command-line handler runs.
     * In the case that this is not the first-running instance of the
     * application, the existing instance may already have been running for
     * a very long time.
     *
     * This means that the options from #GOptionGroup are only really usable
     * in the case that the instance of the application being run is the
     * first instance.  Passing options like `--display=` or `--gdk-debug=`
     * on future runs will have no effect on the existing primary instance.
     *
     * Calling this function will cause the options in the supplied option
     * group to be parsed, but it does not cause you to be "opted in" to the
     * new functionality whereby unrecognised options are rejected even if
     * %G_APPLICATION_HANDLES_COMMAND_LINE was given.
     * @param group a #GOptionGroup
     */
    addOptionGroup(group: GLib.OptionGroup): void
    /**
     * Marks `application` as busy (see g_application_mark_busy()) while
     * `property` on `object` is %TRUE.
     *
     * The binding holds a reference to `application` while it is active, but
     * not to `object`. Instead, the binding is destroyed when `object` is
     * finalized.
     * @param object a #GObject
     * @param property the name of a boolean property of `object`
     */
    bindBusyProperty(object: GObject.Object, property: string): void
    /**
     * Gets the unique identifier for `application`.
     * @returns the identifier for @application, owned by @application
     */
    getApplicationId(): string | null
    /**
     * Gets the #GDBusConnection being used by the application, or %NULL.
     *
     * If #GApplication is using its D-Bus backend then this function will
     * return the #GDBusConnection being used for uniqueness and
     * communication with the desktop environment and other instances of the
     * application.
     *
     * If #GApplication is not using D-Bus then this function will return
     * %NULL.  This includes the situation where the D-Bus backend would
     * normally be in use but we were unable to connect to the bus.
     *
     * This function must not be called before the application has been
     * registered.  See g_application_get_is_registered().
     * @returns a #GDBusConnection, or %NULL
     */
    getDbusConnection(): DBusConnection | null
    /**
     * Gets the D-Bus object path being used by the application, or %NULL.
     *
     * If #GApplication is using its D-Bus backend then this function will
     * return the D-Bus object path that #GApplication is using.  If the
     * application is the primary instance then there is an object published
     * at this path.  If the application is not the primary instance then
     * the result of this function is undefined.
     *
     * If #GApplication is not using D-Bus then this function will return
     * %NULL.  This includes the situation where the D-Bus backend would
     * normally be in use but we were unable to connect to the bus.
     *
     * This function must not be called before the application has been
     * registered.  See g_application_get_is_registered().
     * @returns the object path, or %NULL
     */
    getDbusObjectPath(): string | null
    /**
     * Gets the flags for `application`.
     *
     * See #GApplicationFlags.
     * @returns the flags for @application
     */
    getFlags(): ApplicationFlags
    /**
     * Gets the current inactivity timeout for the application.
     *
     * This is the amount of time (in milliseconds) after the last call to
     * g_application_release() before the application stops running.
     * @returns the timeout, in milliseconds
     */
    getInactivityTimeout(): number
    /**
     * Gets the application's current busy state, as set through
     * g_application_mark_busy() or g_application_bind_busy_property().
     * @returns %TRUE if @application is currently marked as busy
     */
    getIsBusy(): boolean
    /**
     * Checks if `application` is registered.
     *
     * An application is registered if g_application_register() has been
     * successfully called.
     * @returns %TRUE if @application is registered
     */
    getIsRegistered(): boolean
    /**
     * Checks if `application` is remote.
     *
     * If `application` is remote then it means that another instance of
     * application already exists (the 'primary' instance).  Calls to
     * perform actions on `application` will result in the actions being
     * performed by the primary instance.
     *
     * The value of this property cannot be accessed before
     * g_application_register() has been called.  See
     * g_application_get_is_registered().
     * @returns %TRUE if @application is remote
     */
    getIsRemote(): boolean
    /**
     * Gets the resource base path of `application`.
     *
     * See g_application_set_resource_base_path() for more information.
     * @returns the base resource path, if one is set
     */
    getResourceBasePath(): string | null
    /**
     * Gets the version of `application`.
     * @returns the version of @application
     */
    getVersion(): string | null
    /**
     * Increases the use count of `application`.
     *
     * Use this function to indicate that the application has a reason to
     * continue to run.  For example, g_application_hold() is called by GTK
     * when a toplevel window is on the screen.
     *
     * To cancel the hold, call g_application_release().
     */
    hold(): void
    /**
     * Increases the busy count of `application`.
     *
     * Use this function to indicate that the application is busy, for instance
     * while a long running operation is pending.
     *
     * The busy state will be exposed to other processes, so a session shell will
     * use that information to indicate the state to the user (e.g. with a
     * spinner).
     *
     * To cancel the busy indication, use g_application_unmark_busy().
     *
     * The application must be registered before calling this function.
     */
    markBusy(): void
    // Has conflict: open(files: File[], hint: string): void
    /**
     * Immediately quits the application.
     *
     * Upon return to the mainloop, g_application_run() will return,
     * calling only the 'shutdown' function before doing so.
     *
     * The hold count is ignored.
     * Take care if your code has called g_application_hold() on the application and
     * is therefore still expecting it to exist.
     * (Note that you may have called g_application_hold() indirectly, for example
     * through gtk_application_add_window().)
     *
     * The result of calling g_application_run() again after it returns is
     * unspecified.
     */
    quit(): void
    /**
     * Attempts registration of the application.
     *
     * This is the point at which the application discovers if it is the
     * primary instance or merely acting as a remote for an already-existing
     * primary instance.  This is implemented by attempting to acquire the
     * application identifier as a unique bus name on the session bus using
     * GDBus.
     *
     * If there is no application ID or if %G_APPLICATION_NON_UNIQUE was
     * given, then this process will always become the primary instance.
     *
     * Due to the internal architecture of GDBus, method calls can be
     * dispatched at any time (even if a main loop is not running).  For
     * this reason, you must ensure that any object paths that you wish to
     * register are registered before calling this function.
     *
     * If the application has already been registered then %TRUE is
     * returned with no work performed.
     *
     * The #GApplication::startup signal is emitted if registration succeeds
     * and `application` is the primary instance (including the non-unique
     * case).
     *
     * In the event of an error (such as `cancellable` being cancelled, or a
     * failure to connect to the session bus), %FALSE is returned and `error`
     * is set appropriately.
     *
     * Note: the return value of this function is not an indicator that this
     * instance is or is not the primary instance of the application.  See
     * g_application_get_is_remote() for that.
     * @param cancellable a #GCancellable, or %NULL
     * @returns %TRUE if registration succeeded
     */
    register(cancellable: Cancellable | null): boolean
    /**
     * Decrease the use count of `application`.
     *
     * When the use count reaches zero, the application will stop running.
     *
     * Never call this function except to cancel the effect of a previous
     * call to g_application_hold().
     */
    release(): void
    /**
     * Runs the application.
     *
     * This function is intended to be run from main() and its return value
     * is intended to be returned by main(). Although you are expected to pass
     * the `argc,` `argv` parameters from main() to this function, it is possible
     * to pass %NULL if `argv` is not available or commandline handling is not
     * required.  Note that on Windows, `argc` and `argv` are ignored, and
     * g_win32_get_command_line() is called internally (for proper support
     * of Unicode commandline arguments).
     *
     * #GApplication will attempt to parse the commandline arguments.  You
     * can add commandline flags to the list of recognised options by way of
     * g_application_add_main_option_entries().  After this, the
     * #GApplication::handle-local-options signal is emitted, from which the
     * application can inspect the values of its #GOptionEntrys.
     *
     * #GApplication::handle-local-options is a good place to handle options
     * such as `--version`, where an immediate reply from the local process is
     * desired (instead of communicating with an already-running instance).
     * A #GApplication::handle-local-options handler can stop further processing
     * by returning a non-negative value, which then becomes the exit status of
     * the process.
     *
     * What happens next depends on the flags: if
     * %G_APPLICATION_HANDLES_COMMAND_LINE was specified then the remaining
     * commandline arguments are sent to the primary instance, where a
     * #GApplication::command-line signal is emitted.  Otherwise, the
     * remaining commandline arguments are assumed to be a list of files.
     * If there are no files listed, the application is activated via the
     * #GApplication::activate signal.  If there are one or more files, and
     * %G_APPLICATION_HANDLES_OPEN was specified then the files are opened
     * via the #GApplication::open signal.
     *
     * If you are interested in doing more complicated local handling of the
     * commandline then you should implement your own #GApplication subclass
     * and override local_command_line(). In this case, you most likely want
     * to return %TRUE from your local_command_line() implementation to
     * suppress the default handling. See
     * [gapplication-example-cmdline2.c][https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline2.c]
     * for an example.
     *
     * If, after the above is done, the use count of the application is zero
     * then the exit status is returned immediately.  If the use count is
     * non-zero then the default main context is iterated until the use count
     * falls to zero, at which point 0 is returned.
     *
     * If the %G_APPLICATION_IS_SERVICE flag is set, then the service will
     * run for as much as 10 seconds with a use count of zero while waiting
     * for the message that caused the activation to arrive.  After that,
     * if the use count falls to zero the application will exit immediately,
     * except in the case that g_application_set_inactivity_timeout() is in
     * use.
     *
     * This function sets the prgname (g_set_prgname()), if not already set,
     * to the basename of argv[0].
     *
     * Much like g_main_loop_run(), this function will acquire the main context
     * for the duration that the application is running.
     *
     * Since 2.40, applications that are not explicitly flagged as services
     * or launchers (ie: neither %G_APPLICATION_IS_SERVICE or
     * %G_APPLICATION_IS_LAUNCHER are given as flags) will check (from the
     * default handler for local_command_line) if "--gapplication-service"
     * was given in the command line.  If this flag is present then normal
     * commandline processing is interrupted and the
     * %G_APPLICATION_IS_SERVICE flag is set.  This provides a "compromise"
     * solution whereby running an application directly from the commandline
     * will invoke it in the normal way (which can be useful for debugging)
     * while still allowing applications to be D-Bus activated in service
     * mode.  The D-Bus service file should invoke the executable with
     * "--gapplication-service" as the sole commandline argument.  This
     * approach is suitable for use by most graphical applications but
     * should not be used from applications like editors that need precise
     * control over when processes invoked via the commandline will exit and
     * what their exit status will be.
     * @param argv the argv from main(), or %NULL
     * @returns the exit status
     */
    run(argv: string[] | null): number
    /**
     * Sends a notification on behalf of `application` to the desktop shell.
     * There is no guarantee that the notification is displayed immediately,
     * or even at all.
     *
     * Notifications may persist after the application exits. It will be
     * D-Bus-activated when the notification or one of its actions is
     * activated.
     *
     * Modifying `notification` after this call has no effect. However, the
     * object can be reused for a later call to this function.
     *
     * `id` may be any string that uniquely identifies the event for the
     * application. It does not need to be in any special format. For
     * example, "new-message" might be appropriate for a notification about
     * new messages.
     *
     * If a previous notification was sent with the same `id,` it will be
     * replaced with `notification` and shown again as if it was a new
     * notification. This works even for notifications sent from a previous
     * execution of the application, as long as `id` is the same string.
     *
     * `id` may be %NULL, but it is impossible to replace or withdraw
     * notifications without an id.
     *
     * If `notification` is no longer relevant, it can be withdrawn with
     * g_application_withdraw_notification().
     *
     * It is an error to call this function if `application` has no
     * application ID.
     * @param id id of the notification, or %NULL
     * @param notification the #GNotification to send
     */
    sendNotification(id: string | null, notification: Notification): void
    /**
     * This used to be how actions were associated with a #GApplication.
     * Now there is #GActionMap for that.
     * @param actionGroup a #GActionGroup, or %NULL
     */
    setActionGroup(actionGroup: ActionGroup | null): void
    /**
     * Sets the unique identifier for `application`.
     *
     * The application id can only be modified if `application` has not yet
     * been registered.
     *
     * If non-%NULL, the application id must be valid.  See
     * g_application_id_is_valid().
     * @param applicationId the identifier for `application`
     */
    setApplicationId(applicationId: string | null): void
    /**
     * Sets or unsets the default application for the process, as returned
     * by g_application_get_default().
     *
     * This function does not take its own reference on `application`.  If
     * `application` is destroyed then the default application will revert
     * back to %NULL.
     */
    setDefault(): void
    /**
     * Sets the flags for `application`.
     *
     * The flags can only be modified if `application` has not yet been
     * registered.
     *
     * See #GApplicationFlags.
     * @param flags the flags for `application`
     */
    setFlags(flags: ApplicationFlags): void
    /**
     * Sets the current inactivity timeout for the application.
     *
     * This is the amount of time (in milliseconds) after the last call to
     * g_application_release() before the application stops running.
     *
     * This call has no side effects of its own.  The value set here is only
     * used for next time g_application_release() drops the use count to
     * zero.  Any timeouts currently in progress are not impacted.
     * @param inactivityTimeout the timeout, in milliseconds
     */
    setInactivityTimeout(inactivityTimeout: number): void
    /**
     * Adds a description to the `application` option context.
     *
     * See g_option_context_set_description() for more information.
     * @param description a string to be shown in `--help` output  after the list of options, or %NULL
     */
    setOptionContextDescription(description: string | null): void
    /**
     * Sets the parameter string to be used by the commandline handling of `application`.
     *
     * This function registers the argument to be passed to g_option_context_new()
     * when the internal #GOptionContext of `application` is created.
     *
     * See g_option_context_new() for more information about `parameter_string`.
     * @param parameterString a string which is displayed   in the first line of `--help` output, after the usage summary `programname [OPTION...]`.
     */
    setOptionContextParameterString(parameterString: string | null): void
    /**
     * Adds a summary to the `application` option context.
     *
     * See g_option_context_set_summary() for more information.
     * @param summary a string to be shown in `--help` output  before the list of options, or %NULL
     */
    setOptionContextSummary(summary: string | null): void
    /**
     * Sets (or unsets) the base resource path of `application`.
     *
     * The path is used to automatically load various [application
     * resources][gresource] such as menu layouts and action descriptions.
     * The various types of resources will be found at fixed names relative
     * to the given base path.
     *
     * By default, the resource base path is determined from the application
     * ID by prefixing '/' and replacing each '.' with '/'.  This is done at
     * the time that the #GApplication object is constructed.  Changes to
     * the application ID after that point will not have an impact on the
     * resource base path.
     *
     * As an example, if the application has an ID of "org.example.app" then
     * the default resource base path will be "/org/example/app".  If this
     * is a #GtkApplication (and you have not manually changed the path)
     * then Gtk will then search for the menus of the application at
     * "/org/example/app/gtk/menus.ui".
     *
     * See #GResource for more information about adding resources to your
     * application.
     *
     * You can disable automatic resource loading functionality by setting
     * the path to %NULL.
     *
     * Changing the resource base path once the application is running is
     * not recommended.  The point at which the resource path is consulted
     * for forming paths for various purposes is unspecified.  When writing
     * a sub-class of #GApplication you should either set the
     * #GApplication:resource-base-path property at construction time, or call
     * this function during the instance initialization. Alternatively, you
     * can call this function in the #GApplicationClass.startup virtual function,
     * before chaining up to the parent implementation.
     * @param resourcePath the resource path to use
     */
    setResourceBasePath(resourcePath: string | null): void
    /**
     * Sets the version number of `application`. This will be used to implement
     * a `--version` command line argument
     *
     * The application version can only be modified if `application` has not yet
     * been registered.
     * @param version the version of `application`
     */
    setVersion(version: string): void
    /**
     * Destroys a binding between `property` and the busy state of
     * `application` that was previously created with
     * g_application_bind_busy_property().
     * @param object a #GObject
     * @param property the name of a boolean property of `object`
     */
    unbindBusyProperty(object: GObject.Object, property: string): void
    /**
     * Decreases the busy count of `application`.
     *
     * When the busy count reaches zero, the new state will be propagated
     * to other processes.
     *
     * This function must only be called to cancel the effect of a previous
     * call to g_application_mark_busy().
     */
    unmarkBusy(): void
    /**
     * Withdraws a notification that was sent with
     * g_application_send_notification().
     *
     * This call does nothing if a notification with `id` doesn't exist or
     * the notification was never sent.
     *
     * This function works even for notifications sent in previous
     * executions of this application, as long `id` is the same as it was for
     * the sent notification.
     *
     * Note that notifications are dismissed when the user clicks on one
     * of the buttons in a notification or triggers its default action, so
     * there is no need to explicitly withdraw the notification in that case.
     * @param id id of a previously sent notification
     */
    withdrawNotification(id: string): void

    // Own virtual methods of Gio-2.0.Gio.Application

    /**
     * Activates the application.
     *
     * In essence, this results in the #GApplication::activate signal being
     * emitted in the primary instance.
     *
     * The application must be registered before calling this function.
     * @virtual
     */
    activate(): void
    /**
     * invoked (locally) to add 'platform data' to be sent to
     *     the primary instance when activating, opening or invoking actions
     * @virtual
     * @param builder
     */
    addPlatformData(builder: GLib.VariantBuilder): void
    /**
     * invoked on the primary instance after 'activate', 'open',
     *     'command-line' or any action invocation, gets the 'platform data' from
     *     the calling instance
     * @virtual
     * @param platformData
     */
    afterEmit(platformData: GLib.Variant): void
    /**
     * invoked on the primary instance before 'activate', 'open',
     *     'command-line' or any action invocation, gets the 'platform data' from
     *     the calling instance
     * @virtual
     * @param platformData
     */
    beforeEmit(platformData: GLib.Variant): void
    /**
     * invoked on the primary instance when a command-line is
     *   not handled locally
     * @virtual
     * @param commandLine
     */
    commandLine(commandLine: ApplicationCommandLine): number
    /**
     * invoked locally during registration, if the application is
     *     using its D-Bus backend. You can use this to export extra objects on the
     *     bus, that need to exist before the application tries to own the bus name.
     *     The function is passed the #GDBusConnection to to session bus, and the
     *     object path that #GApplication will use to export its D-Bus API.
     *     If this function returns %TRUE, registration will proceed; otherwise
     *     registration will abort. Since: 2.34
     * @virtual
     * @param connection
     * @param objectPath
     */
    dbusRegister(connection: DBusConnection, objectPath: string): boolean
    /**
     * invoked locally during unregistration, if the application
     *     is using its D-Bus backend. Use this to undo anything done by
     *     the `dbus_register` vfunc. Since: 2.34
     * @virtual
     * @param connection
     * @param objectPath
     */
    dbusUnregister(connection: DBusConnection, objectPath: string): void
    /**
     * invoked locally after the parsing of the commandline
     *  options has occurred. Since: 2.40
     * @virtual
     * @param options
     */
    handleLocalOptions(options: GLib.VariantDict): number
    /**
     * This virtual function is always invoked in the local instance. It
     * gets passed a pointer to a %NULL-terminated copy of `argv` and is
     * expected to remove arguments that it handled (shifting up remaining
     * arguments).
     *
     * The last argument to local_command_line() is a pointer to the `status`
     * variable which can used to set the exit status that is returned from
     * g_application_run().
     *
     * See g_application_run() for more details on #GApplication startup.
     * @virtual
     * @param arguments_ array of command line arguments
     * @returns %TRUE if the commandline has been completely handled
     */
    localCommandLine(
      arguments_: string[]
    ): [
      /* returnType */ boolean,
      /* arguments_ */ string[],
      /* exitStatus */ number,
    ]
    /**
     * invoked when another instance is taking over the name. Since: 2.60
     * @virtual
     */
    nameLost(): boolean
    /**
     * Opens the given files.
     *
     * In essence, this results in the #GApplication::open signal being emitted
     * in the primary instance.
     *
     * `n_files` must be greater than zero.
     *
     * `hint` is simply passed through to the ::open signal.  It is
     * intended to be used by applications that have multiple modes for
     * opening files (eg: "view" vs "edit", etc).  Unless you have a need
     * for this functionality, you should use "".
     *
     * The application must be registered before calling this function
     * and it must have the %G_APPLICATION_HANDLES_OPEN flag set.
     * @virtual
     * @param files an array of #GFiles to open
     * @param hint a hint (or ""), but never %NULL
     */
    open(files: File[], hint: string): void
    /**
     * Used to be invoked on the primary instance when the use
     *     count of the application drops to zero (and after any inactivity
     *     timeout, if requested). Not used anymore since 2.32
     * @virtual
     */
    quitMainloop(): void
    /**
     * Used to be invoked on the primary instance from
     *     g_application_run() if the use-count is non-zero. Since 2.32,
     *     GApplication is iterating the main context directly and is not
     *     using `run_mainloop` anymore
     * @virtual
     */
    runMainloop(): void
    /**
     * invoked only on the registered primary instance immediately
     *      after the main loop terminates
     * @virtual
     */
    shutdown(): void
    /**
     * invoked on the primary instance immediately after registration
     * @virtual
     */
    startup(): void

    // Own signals of Gio-2.0.Gio.Application

    connect(
      sigName: "activate",
      callback: Application.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: Application.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: Application.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: Application.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "command-line",
      callback: Application.CommandLineSignalCallback
    ): number
    on(
      sigName: "command-line",
      callback: Application.CommandLineSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "command-line",
      callback: Application.CommandLineSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "command-line",
      callback: Application.CommandLineSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "command-line", ...args: any[]): void
    connect(
      sigName: "handle-local-options",
      callback: Application.HandleLocalOptionsSignalCallback
    ): number
    on(
      sigName: "handle-local-options",
      callback: Application.HandleLocalOptionsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "handle-local-options",
      callback: Application.HandleLocalOptionsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "handle-local-options",
      callback: Application.HandleLocalOptionsSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "handle-local-options", ...args: any[]): void
    connect(
      sigName: "name-lost",
      callback: Application.NameLostSignalCallback
    ): number
    on(
      sigName: "name-lost",
      callback: Application.NameLostSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "name-lost",
      callback: Application.NameLostSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "name-lost",
      callback: Application.NameLostSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "name-lost", ...args: any[]): void
    connect(sigName: "open", callback: Application.OpenSignalCallback): number
    on(
      sigName: "open",
      callback: Application.OpenSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "open",
      callback: Application.OpenSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "open",
      callback: Application.OpenSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "open", hint: string | null, ...args: any[]): void
    connect(
      sigName: "shutdown",
      callback: Application.ShutdownSignalCallback
    ): number
    on(
      sigName: "shutdown",
      callback: Application.ShutdownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "shutdown",
      callback: Application.ShutdownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "shutdown",
      callback: Application.ShutdownSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "shutdown", ...args: any[]): void
    connect(
      sigName: "startup",
      callback: Application.StartupSignalCallback
    ): number
    on(
      sigName: "startup",
      callback: Application.StartupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "startup",
      callback: Application.StartupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "startup",
      callback: Application.StartupSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "startup", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.Application

    connect(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-group", ...args: any[]): void
    connect(
      sigName: "notify::application-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application-id", ...args: any[]): void
    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::inactivity-timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inactivity-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inactivity-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inactivity-timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inactivity-timeout", ...args: any[]): void
    connect(
      sigName: "notify::is-busy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-busy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-busy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-busy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-busy", ...args: any[]): void
    connect(
      sigName: "notify::is-registered",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-registered",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-registered",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-registered",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-registered", ...args: any[]): void
    connect(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-remote", ...args: any[]): void
    connect(
      sigName: "notify::resource-base-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resource-base-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resource-base-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resource-base-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resource-base-path", ...args: any[]): void
    connect(
      sigName: "notify::version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::version", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GApplication` is the core class for application support.
   *
   * A `GApplication` is the foundation of an application. It wraps some
   * low-level platform-specific services and is intended to act as the
   * foundation for higher-level application classes such as
   * `GtkApplication` or `MxApplication`. In general, you should not use
   * this class outside of a higher level framework.
   *
   * `GApplication` provides convenient life-cycle management by maintaining
   * a "use count" for the primary application instance. The use count can
   * be changed using [method`Gio`.Application.hold] and
   * [method`Gio`.Application.release]. If it drops to zero, the application
   * exits. Higher-level classes such as `GtkApplication` employ the use count
   * to ensure that the application stays alive as long as it has any opened
   * windows.
   *
   * Another feature that `GApplication` (optionally) provides is process
   * uniqueness. Applications can make use of this functionality by
   * providing a unique application ID. If given, only one application
   * with this ID can be running at a time per session. The session
   * concept is platform-dependent, but corresponds roughly to a graphical
   * desktop login. When your application is launched again, its
   * arguments are passed through platform communication to the already
   * running program. The already running instance of the program is
   * called the "primary instance"; for non-unique applications this is
   * always the current instance. On Linux, the D-Bus session bus
   * is used for communication.
   *
   * The use of `GApplication` differs from some other commonly-used
   * uniqueness libraries (such as libunique) in important ways. The
   * application is not expected to manually register itself and check
   * if it is the primary instance. Instead, the main() function of a
   * `GApplication` should do very little more than instantiating the
   * application instance, possibly connecting signal handlers, then
   * calling [method`Gio`.Application.run]. All checks for uniqueness are done
   * internally. If the application is the primary instance then the
   * startup signal is emitted and the mainloop runs. If the application
   * is not the primary instance then a signal is sent to the primary
   * instance and [method`Gio`.Application.run] promptly returns. See the code
   * examples below.
   *
   * If used, the expected form of an application identifier is the
   * same as that of a
   * [D-Bus well-known bus name](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
   * Examples include: `com.example.MyApp`, `org.example.internal_apps.Calculator`,
   * `org._7_zip.Archiver`.
   * For details on valid application identifiers, see [func`Gio`.Application.id_is_valid].
   *
   * On Linux, the application identifier is claimed as a well-known bus name
   * on the user's session bus. This means that the uniqueness of your
   * application is scoped to the current session. It also means that your
   * application may provide additional services (through registration of other
   * object paths) at that bus name. The registration of these object paths
   * should be done with the shared GDBus session bus. Note that due to the
   * internal architecture of GDBus, method calls can be dispatched at any time
   * (even if a main loop is not running). For this reason, you must ensure that
   * any object paths that you wish to register are registered before #GApplication
   * attempts to acquire the bus name of your application (which happens in
   * [method`Gio`.Application.register]). Unfortunately, this means that you cannot
   * use [property`Gio`.Application:is-remote] to decide if you want to register
   * object paths.
   *
   * `GApplication` also implements the [iface`Gio`.ActionGroup] and [iface`Gio`.ActionMap]
   * interfaces and lets you easily export actions by adding them with
   * [method`Gio`.ActionMap.add_action]. When invoking an action by calling
   * [method`Gio`.ActionGroup.activate_action] on the application, it is always
   * invoked in the primary instance. The actions are also exported on
   * the session bus, and GIO provides the [class`Gio`.DBusActionGroup] wrapper to
   * conveniently access them remotely. GIO provides a [class`Gio`.DBusMenuModel] wrapper
   * for remote access to exported [class`Gio`.MenuModel]s.
   *
   * Note: Due to the fact that actions are exported on the session bus,
   * using `maybe` parameters is not supported, since D-Bus does not support
   * `maybe` types.
   *
   * There is a number of different entry points into a `GApplication`:
   *
   * - via 'Activate' (i.e. just starting the application)
   *
   * - via 'Open' (i.e. opening some files)
   *
   * - by handling a command-line
   *
   * - via activating an action
   *
   * The [signal`Gio`.Application::startup] signal lets you handle the application
   * initialization for all of these in a single place.
   *
   * Regardless of which of these entry points is used to start the
   * application, `GApplication` passes some ‘platform data’ from the
   * launching instance to the primary instance, in the form of a
   * [struct`GLib`.Variant] dictionary mapping strings to variants. To use platform
   * data, override the [vfunc`Gio`.Application.before_emit] or
   * [vfunc`Gio`.Application.after_emit] virtual functions
   * in your `GApplication` subclass. When dealing with
   * [class`Gio`.ApplicationCommandLine] objects, the platform data is
   * directly available via [method`Gio`.ApplicationCommandLine.get_cwd],
   * [method`Gio`.ApplicationCommandLine.get_environ] and
   * [method`Gio`.ApplicationCommandLine.get_platform_data].
   *
   * As the name indicates, the platform data may vary depending on the
   * operating system, but it always includes the current directory (key
   * `cwd`), and optionally the environment (ie the set of environment
   * variables and their values) of the calling process (key `environ`).
   * The environment is only added to the platform data if the
   * `G_APPLICATION_SEND_ENVIRONMENT` flag is set. `GApplication` subclasses
   * can add their own platform data by overriding the
   * [vfunc`Gio`.Application.add_platform_data] virtual function. For instance,
   * `GtkApplication` adds startup notification data in this way.
   *
   * To parse commandline arguments you may handle the
   * [signal`Gio`.Application::command-line] signal or override the
   * [vfunc`Gio`.Application.local_command_line] virtual funcion, to parse them in
   * either the primary instance or the local instance, respectively.
   *
   * For an example of opening files with a `GApplication`, see
   * [gapplication-example-open.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-open.c).
   *
   * For an example of using actions with `GApplication`, see
   * [gapplication-example-actions.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-actions.c).
   *
   * For an example of using extra D-Bus hooks with `GApplication`, see
   * [gapplication-example-dbushooks.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-dbushooks.c).
   * @class
   */
  class Application extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Application

    static name: string

    // Constructors of Gio-2.0.Gio.Application

    constructor(config?: Application.ConstructorProperties)
    /**
     * Creates a new #GApplication instance.
     *
     * If non-%NULL, the application id must be valid.  See
     * g_application_id_is_valid().
     *
     * If no application ID is given then some features of #GApplication
     * (most notably application uniqueness) will be disabled.
     * @constructor
     * @param applicationId the application id
     * @param flags the application flags
     * @returns a new #GApplication instance
     */
    constructor(applicationId: string | null, flags: ApplicationFlags)
    /**
     * Creates a new #GApplication instance.
     *
     * If non-%NULL, the application id must be valid.  See
     * g_application_id_is_valid().
     *
     * If no application ID is given then some features of #GApplication
     * (most notably application uniqueness) will be disabled.
     * @constructor
     * @param applicationId the application id
     * @param flags the application flags
     * @returns a new #GApplication instance
     */
    static new(
      applicationId: string | null,
      flags: ApplicationFlags
    ): Application
    _init(config?: Application.ConstructorProperties): void
    /**
     * Returns the default #GApplication instance for this process.
     *
     * Normally there is only one #GApplication per process and it becomes
     * the default when it is created.  You can exercise more control over
     * this by using g_application_set_default().
     *
     * If there is no default application then %NULL is returned.
     * @returns the default application for this process, or %NULL
     */
    static getDefault(): Application | null
    /**
     * Checks if `application_id` is a valid application identifier.
     *
     * A valid ID is required for calls to g_application_new() and
     * g_application_set_application_id().
     *
     * Application identifiers follow the same format as
     * [D-Bus well-known bus names](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
     * For convenience, the restrictions on application identifiers are
     * reproduced here:
     *
     * - Application identifiers are composed of 1 or more elements separated by a
     *   period (`.`) character. All elements must contain at least one character.
     *
     * - Each element must only contain the ASCII characters `[A-Z][a-z][0-9]_-`,
     *   with `-` discouraged in new application identifiers. Each element must not
     *   begin with a digit.
     *
     * - Application identifiers must contain at least one `.` (period) character
     *   (and thus at least two elements).
     *
     * - Application identifiers must not begin with a `.` (period) character.
     *
     * - Application identifiers must not exceed 255 characters.
     *
     * Note that the hyphen (`-`) character is allowed in application identifiers,
     * but is problematic or not allowed in various specifications and APIs that
     * refer to D-Bus, such as
     * [Flatpak application IDs](http://docs.flatpak.org/en/latest/introduction.html#identifiers),
     * the
     * [`DBusActivatable` interface in the Desktop Entry Specification](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#dbus),
     * and the convention that an application's "main" interface and object path
     * resemble its application identifier and bus name. To avoid situations that
     * require special-case handling, it is recommended that new application
     * identifiers consistently replace hyphens with underscores.
     *
     * Like D-Bus interface names, application identifiers should start with the
     * reversed DNS domain name of the author of the interface (in lower-case), and
     * it is conventional for the rest of the application identifier to consist of
     * words run together, with initial capital letters.
     *
     * As with D-Bus interface names, if the author's DNS domain name contains
     * hyphen/minus characters they should be replaced by underscores, and if it
     * contains leading digits they should be escaped by prepending an underscore.
     * For example, if the owner of 7-zip.org used an application identifier for an
     * archiving application, it might be named `org._7_zip.Archiver`.
     * @param applicationId a potential application identifier
     * @returns %TRUE if @application_id is valid
     */
    static idIsValid(applicationId: string): boolean
  }

  module ApplicationCommandLine {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ApplicationCommandLine

      /**
       * The commandline that caused this [signal`Gio`.Application::command-line]
       * signal emission.
       */
      arguments?: GLib.Variant | null
      /**
       * The options sent along with the commandline.
       */
      options?: GLib.Variant | null
      /**
       * Platform-specific data for the commandline.
       */
      platform_data?: GLib.Variant | null
    }
  }

  interface ApplicationCommandLine {
    // Own properties of Gio-2.0.Gio.ApplicationCommandLine

    /**
     * The commandline that caused this [signal`Gio`.Application::command-line]
     * signal emission.
     */
    readonly arguments: GLib.Variant
    /**
     * Whether this is a remote commandline.
     */
    readonly isRemote: boolean
    /**
     * The options sent along with the commandline.
     */
    readonly options: GLib.Variant
    /**
     * Platform-specific data for the commandline.
     */
    readonly platformData: GLib.Variant
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ApplicationCommandLine

    /**
     * Creates a #GFile corresponding to a filename that was given as part
     * of the invocation of `cmdline`.
     *
     * This differs from g_file_new_for_commandline_arg() in that it
     * resolves relative pathnames using the current working directory of
     * the invoking process rather than the local process.
     * @param arg an argument from `cmdline`
     * @returns a new #GFile
     */
    createFileForArg(arg: string): File
    // Has conflict: done(): void
    /**
     * Gets the list of arguments that was passed on the command line.
     *
     * The strings in the array may contain non-UTF-8 data on UNIX (such as
     * filenames or arguments given in the system locale) but are always in
     * UTF-8 on Windows.
     *
     * If you wish to use the return value with #GOptionContext, you must
     * use g_option_context_parse_strv().
     *
     * The return value is %NULL-terminated and should be freed using
     * g_strfreev().
     * @returns the string array containing the arguments (the argv)
     */
    getArguments(): string[]
    /**
     * Gets the working directory of the command line invocation.
     * The string may contain non-utf8 data.
     *
     * It is possible that the remote application did not send a working
     * directory, so this may be %NULL.
     *
     * The return value should not be modified or freed and is valid for as
     * long as `cmdline` exists.
     * @returns the current directory, or %NULL
     */
    getCwd(): string | null
    /**
     * Gets the contents of the 'environ' variable of the command line
     * invocation, as would be returned by g_get_environ(), ie as a
     * %NULL-terminated list of strings in the form 'NAME=VALUE'.
     * The strings may contain non-utf8 data.
     *
     * The remote application usually does not send an environment.  Use
     * %G_APPLICATION_SEND_ENVIRONMENT to affect that.  Even with this flag
     * set it is possible that the environment is still not available (due
     * to invocation messages from other applications).
     *
     * The return value should not be modified or freed and is valid for as
     * long as `cmdline` exists.
     *
     * See g_application_command_line_getenv() if you are only interested
     * in the value of a single environment variable.
     * @returns the environment strings, or %NULL if they were not sent
     */
    getEnviron(): string[]
    /**
     * Gets the exit status of `cmdline`.  See
     * g_application_command_line_set_exit_status() for more information.
     * @returns the exit status
     */
    getExitStatus(): number
    /**
     * Determines if `cmdline` represents a remote invocation.
     * @returns %TRUE if the invocation was remote
     */
    getIsRemote(): boolean
    /**
     * Gets the options that were passed to g_application_command_line().
     *
     * If you did not override local_command_line() then these are the same
     * options that were parsed according to the #GOptionEntrys added to the
     * application with g_application_add_main_option_entries() and possibly
     * modified from your GApplication::handle-local-options handler.
     *
     * If no options were sent then an empty dictionary is returned so that
     * you don't need to check for %NULL.
     *
     * The data has been passed via an untrusted external process, so the types of
     * all values must be checked before being used.
     * @returns a #GVariantDict with the options
     */
    getOptionsDict(): GLib.VariantDict
    /**
     * Gets the platform data associated with the invocation of `cmdline`.
     *
     * This is a #GVariant dictionary containing information about the
     * context in which the invocation occurred.  It typically contains
     * information like the current working directory and the startup
     * notification ID.
     *
     * It comes from an untrusted external process and hence the types of all
     * values must be validated before being used.
     *
     * For local invocation, it will be %NULL.
     * @returns the platform data, or %NULL
     */
    getPlatformData(): GLib.Variant | null
    // Has conflict: getStdin(): InputStream | null
    /**
     * Gets the value of a particular environment variable of the command
     * line invocation, as would be returned by g_getenv().  The strings may
     * contain non-utf8 data.
     *
     * The remote application usually does not send an environment.  Use
     * %G_APPLICATION_SEND_ENVIRONMENT to affect that.  Even with this flag
     * set it is possible that the environment is still not available (due
     * to invocation messages from other applications).
     *
     * The return value should not be modified or freed and is valid for as
     * long as `cmdline` exists.
     * @param name the environment variable to get
     * @returns the value of the variable, or %NULL if unset or unsent
     */
    getenv(name: string): string | null
    // Has conflict: printLiteral(message: string): void
    // Has conflict: printerrLiteral(message: string): void
    /**
     * Sets the exit status that will be used when the invoking process
     * exits.
     *
     * The return value of the #GApplication::command-line signal is
     * passed to this function when the handler returns.  This is the usual
     * way of setting the exit status.
     *
     * In the event that you want the remote invocation to continue running
     * and want to decide on the exit status in the future, you can use this
     * call.  For the case of a remote invocation, the remote process will
     * typically exit when the last reference is dropped on `cmdline`.  The
     * exit status of the remote process will be equal to the last value
     * that was set with this function.
     *
     * In the case that the commandline invocation is local, the situation
     * is slightly more complicated.  If the commandline invocation results
     * in the mainloop running (ie: because the use-count of the application
     * increased to a non-zero value) then the application is considered to
     * have been 'successful' in a certain sense, and the exit status is
     * always zero.  If the application use count is zero, though, the exit
     * status of the local #GApplicationCommandLine is used.
     *
     * This method is a no-op if g_application_command_line_done() has
     * been called.
     * @param exitStatus the exit status
     */
    setExitStatus(exitStatus: number): void

    // Own virtual methods of Gio-2.0.Gio.ApplicationCommandLine

    /**
     * Signals that command line processing is completed.
     *
     * For remote invocation, it causes the invoking process to terminate.
     *
     * For local invocation, it does nothing.
     *
     * This method should be called in the [signal`Gio`.Application::command-line]
     * handler, after the exit status is set and all messages are printed.
     *
     * After this call, g_application_command_line_set_exit_status() has no effect.
     * Subsequent calls to this method are no-ops.
     *
     * This method is automatically called when the #GApplicationCommandLine
     * object is disposed — so you can omit the call in non-garbage collected
     * languages.
     * @virtual
     */
    done(): void
    /**
     * Gets the stdin of the invoking process.
     *
     * The #GInputStream can be used to read data passed to the standard
     * input of the invoking process.
     * This doesn't work on all platforms.  Presently, it is only available
     * on UNIX when using a D-Bus daemon capable of passing file descriptors.
     * If stdin is not available then %NULL will be returned.  In the
     * future, support may be expanded to other platforms.
     *
     * You must only call this function once per commandline invocation.
     * @virtual
     * @returns a #GInputStream for stdin
     */
    getStdin(): InputStream | null
    /**
     * Prints a message using the stdout print handler in the invoking process.
     *
     * Unlike g_application_command_line_print(), `message` is not a `printf()`-style
     * format string. Use this function if `message` contains text you don't have
     * control over, that could include `printf()` escape sequences.
     * @virtual
     * @param message the message
     */
    printLiteral(message: string): void
    /**
     * Prints a message using the stderr print handler in the invoking process.
     *
     * Unlike g_application_command_line_printerr(), `message` is not
     * a `printf()`-style format string. Use this function if `message` contains text
     * you don't have control over, that could include `printf()` escape sequences.
     * @virtual
     * @param message the message
     */
    printerrLiteral(message: string): void

    // Class property signals of Gio-2.0.Gio.ApplicationCommandLine

    connect(
      sigName: "notify::arguments",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::arguments",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::arguments",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::arguments",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::arguments", ...args: any[]): void
    connect(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-remote", ...args: any[]): void
    connect(
      sigName: "notify::options",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::options",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::options",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::options",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::options", ...args: any[]): void
    connect(
      sigName: "notify::platform-data",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::platform-data",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::platform-data",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::platform-data",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::platform-data", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GApplicationCommandLine` represents a command-line invocation of
   * an application.
   *
   * It is created by [class`Gio`.Application] and emitted
   * in the [signal`Gio`.Application::command-line] signal and virtual function.
   *
   * The class contains the list of arguments that the program was invoked
   * with. It is also possible to query if the commandline invocation was
   * local (ie: the current process is running in direct response to the
   * invocation) or remote (ie: some other process forwarded the
   * commandline to this process).
   *
   * The `GApplicationCommandLine` object can provide the `argc` and `argv`
   * parameters for use with the [struct`GLib`.OptionContext] command-line parsing API,
   * with the [method`Gio`.ApplicationCommandLine.get_arguments] function. See
   * [gapplication-example-cmdline3.c][gapplication-example-cmdline3]
   * for an example.
   *
   * The exit status of the originally-invoked process may be set and
   * messages can be printed to stdout or stderr of that process.
   *
   * For remote invocation, the originally-invoked process exits when
   * [method`Gio`.ApplicationCommandLine.done] method is called. This method is
   * also automatically called when the object is disposed.
   *
   * The main use for `GApplicationCommandLine` (and the
   * [signal`Gio`.Application::command-line] signal) is 'Emacs server' like use cases:
   * You can set the `EDITOR` environment variable to have e.g. git use
   * your favourite editor to edit commit messages, and if you already
   * have an instance of the editor running, the editing will happen
   * in the running instance, instead of opening a new one. An important
   * aspect of this use case is that the process that gets started by git
   * does not return until the editing is done.
   *
   * Normally, the commandline is completely handled in the
   * [signal`Gio`.Application::command-line] handler. The launching instance exits
   * once the signal handler in the primary instance has returned, and
   * the return value of the signal handler becomes the exit status
   * of the launching instance.
   *
   * ```c
   * static int
   * command_line (GApplication            *application,
   *               GApplicationCommandLine *cmdline)
   * {
   *   gchar **argv;
   *   gint argc;
   *   gint i;
   *
   *   argv = g_application_command_line_get_arguments (cmdline, &argc);
   *
   *   g_application_command_line_print (cmdline,
   *                                     "This text is written back\n"
   *                                     "to stdout of the caller\n");
   *
   *   for (i = 0; i < argc; i++)
   *     g_print ("argument %d: %s\n", i, argv[i]);
   *
   *   g_strfreev (argv);
   *
   *   return 0;
   * }
   * ```
   *
   * The complete example can be found here:
   * [gapplication-example-cmdline.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline.c)
   *
   * In more complicated cases, the handling of the commandline can be
   * split between the launcher and the primary instance.
   *
   * ```c
   * static gboolean
   *  test_local_cmdline (GApplication   *application,
   *                      gchar        ***arguments,
   *                      gint           *exit_status)
   * {
   *   gint i, j;
   *   gchar **argv;
   *
   *   argv = *arguments;
   *
   *   if (argv[0] == NULL)
   *     {
   *       *exit_status = 0;
   *       return FALSE;
   *     }
   *
   *   i = 1;
   *   while (argv[i])
   *     {
   *       if (g_str_has_prefix (argv[i], "--local-"))
   *         {
   *           g_print ("handling argument %s locally\n", argv[i]);
   *           g_free (argv[i]);
   *           for (j = i; argv[j]; j++)
   *             argv[j] = argv[j + 1];
   *         }
   *       else
   *         {
   *           g_print ("not handling argument %s locally\n", argv[i]);
   *           i++;
   *         }
   *     }
   *
   *   *exit_status = 0;
   *
   *   return FALSE;
   * }
   *
   * static void
   * test_application_class_init (TestApplicationClass *class)
   * {
   *   G_APPLICATION_CLASS (class)->local_command_line = test_local_cmdline;
   *
   *   ...
   * }
   * ```
   *
   * In this example of split commandline handling, options that start
   * with `--local-` are handled locally, all other options are passed
   * to the [signal`Gio`.Application::command-line] handler which runs in the primary
   * instance.
   *
   * The complete example can be found here:
   * [gapplication-example-cmdline2.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline2.c)
   *
   * If handling the commandline requires a lot of work, it may be better to defer it.
   *
   * ```c
   * static gboolean
   * my_cmdline_handler (gpointer data)
   * {
   *   GApplicationCommandLine *cmdline = data;
   *
   *   // do the heavy lifting in an idle
   *
   *   g_application_command_line_set_exit_status (cmdline, 0);
   *   g_object_unref (cmdline); // this releases the application
   *
   *   return G_SOURCE_REMOVE;
   * }
   *
   * static int
   * command_line (GApplication            *application,
   *               GApplicationCommandLine *cmdline)
   * {
   *   // keep the application running until we are done with this commandline
   *   g_application_hold (application);
   *
   *   g_object_set_data_full (G_OBJECT (cmdline),
   *                           "application", application,
   *                           (GDestroyNotify)g_application_release);
   *
   *   g_object_ref (cmdline);
   *   g_idle_add (my_cmdline_handler, cmdline);
   *
   *   return 0;
   * }
   * ```
   *
   * In this example the commandline is not completely handled before
   * the [signal`Gio`.Application::command-line] handler returns. Instead, we keep
   * a reference to the `GApplicationCommandLine` object and handle it
   * later (in this example, in an idle). Note that it is necessary to
   * hold the application until you are done with the commandline.
   *
   * The complete example can be found here:
   * [gapplication-example-cmdline3.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline3.c)
   * @class
   */
  class ApplicationCommandLine extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ApplicationCommandLine

    static name: string

    // Constructors of Gio-2.0.Gio.ApplicationCommandLine

    constructor(config?: ApplicationCommandLine.ConstructorProperties)
    _init(config?: ApplicationCommandLine.ConstructorProperties): void
  }

  module BufferedInputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends Seekable.ConstructorProperties,
        FilterInputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.BufferedInputStream

      /**
       * The size of the backend buffer, in bytes.
       */
      buffer_size?: number | null
    }
  }

  interface BufferedInputStream extends Seekable {
    // Own properties of Gio-2.0.Gio.BufferedInputStream

    /**
     * The size of the backend buffer, in bytes.
     */
    bufferSize: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.BufferedInputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.BufferedInputStream

    // Has conflict: fill(count: number, cancellable: Cancellable | null): number
    // Has conflict: fillAsync(count: number, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: fillFinish(result: AsyncResult): number
    /**
     * Gets the size of the available data within the stream.
     * @returns size of the available stream.
     */
    getAvailable(): number
    /**
     * Gets the size of the input buffer.
     * @returns the current buffer size.
     */
    getBufferSize(): number
    /**
     * Peeks in the buffer, copying data of size `count` into `buffer,`
     * offset `offset` bytes.
     * @param buffer a pointer to   an allocated chunk of memory
     * @param offset a #gsize
     * @returns a #gsize of the number of bytes peeked, or -1 on error.
     */
    peek(buffer: number[], offset: number): number
    /**
     * Returns the buffer with the currently available bytes. The returned
     * buffer must not be modified and will become invalid when reading from
     * the stream or filling the buffer.
     * @returns read-only buffer
     */
    peekBuffer(): number[]
    /**
     * Tries to read a single byte from the stream or the buffer. Will block
     * during this read.
     *
     * On success, the byte read from the stream is returned. On end of stream
     * -1 is returned but it's not an exceptional error and `error` is not set.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     *
     * On error -1 is returned and `error` is set accordingly.
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns the byte read from the @stream, or -1 on end of stream or error.
     */
    readByte(cancellable: Cancellable | null): number
    /**
     * Sets the size of the internal buffer of `stream` to `size,` or to the
     * size of the contents of the buffer. The buffer can never be resized
     * smaller than its current contents.
     * @param size a #gsize
     */
    setBufferSize(size: number): void

    // Own virtual methods of Gio-2.0.Gio.BufferedInputStream

    /**
     * Tries to read `count` bytes from the stream into the buffer.
     * Will block during this read.
     *
     * If `count` is zero, returns zero and does nothing. A value of `count`
     * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, the number of bytes read into the buffer is returned.
     * It is not an error if this is not the same as the requested size, as it
     * can happen e.g. near the end of a file. Zero is returned on end of file
     * (or if `count` is zero),  but never otherwise.
     *
     * If `count` is -1 then the attempted read size is equal to the number of
     * bytes that are required to fill the buffer.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     *
     * On error -1 is returned and `error` is set accordingly.
     *
     * For the asynchronous, non-blocking, version of this function, see
     * g_buffered_input_stream_fill_async().
     * @virtual
     * @param count the number of bytes that will be read from the stream
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns the number of bytes read into @stream's buffer, up to @count,     or -1 on error.
     */
    fill(count: number, cancellable: Cancellable | null): number
    /**
     * Reads data into `stream'`s buffer asynchronously, up to `count` size.
     * `io_priority` can be used to prioritize reads. For the synchronous
     * version of this function, see g_buffered_input_stream_fill().
     *
     * If `count` is -1 then the attempted read size is equal to the number
     * of bytes that are required to fill the buffer.
     * @virtual
     * @param count the number of bytes that will be read from the stream
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object
     * @param callback a #GAsyncReadyCallback
     */
    fillAsync(
      count: number,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous read.
     * @virtual
     * @param result a #GAsyncResult
     * @returns a #gssize of the read stream, or `-1` on an error.
     */
    fillFinish(result: AsyncResult): number

    // Class property signals of Gio-2.0.Gio.BufferedInputStream

    connect(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::buffer-size", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-base-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Buffered input stream implements #GFilterInputStream and provides
   * for buffered reads.
   *
   * By default, `GBufferedInputStream`'s buffer size is set at 4 kilobytes.
   *
   * To create a buffered input stream, use [ctor`Gio`.BufferedInputStream.new],
   * or [ctor`Gio`.BufferedInputStream.new_sized] to specify the buffer's size at
   * construction.
   *
   * To get the size of a buffer within a buffered input stream, use
   * [method`Gio`.BufferedInputStream.get_buffer_size]. To change the size of a
   * buffered input stream's buffer, use [method`Gio`.BufferedInputStream.set_buffer_size].
   * Note that the buffer's size cannot be reduced below the size of the data within the buffer.
   * @class
   */
  class BufferedInputStream extends FilterInputStream {
    // Own properties of Gio-2.0.Gio.BufferedInputStream

    static name: string

    // Constructors of Gio-2.0.Gio.BufferedInputStream

    constructor(config?: BufferedInputStream.ConstructorProperties)
    /**
     * Creates a new #GInputStream from the given `base_stream,` with
     * a buffer set to the default size (4 kilobytes).
     * @constructor
     * @param baseStream a #GInputStream
     * @returns a #GInputStream for the given @base_stream.
     */
    constructor(baseStream: InputStream)
    /**
     * Creates a new #GInputStream from the given `base_stream,` with
     * a buffer set to the default size (4 kilobytes).
     * @constructor
     * @param baseStream a #GInputStream
     * @returns a #GInputStream for the given @base_stream.
     */
    static new(baseStream: InputStream): BufferedInputStream
    /**
     * Creates a new #GBufferedInputStream from the given `base_stream,`
     * with a buffer set to `size`.
     * @constructor
     * @param baseStream a #GInputStream
     * @param size a #gsize
     * @returns a #GInputStream.
     */
    static newSized(baseStream: InputStream, size: number): BufferedInputStream
    _init(config?: BufferedInputStream.ConstructorProperties): void
  }

  module BufferedOutputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends Seekable.ConstructorProperties,
        FilterOutputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.BufferedOutputStream

      /**
       * Whether the buffer should automatically grow.
       */
      auto_grow?: boolean | null
      /**
       * The size of the backend buffer, in bytes.
       */
      buffer_size?: number | null
    }
  }

  interface BufferedOutputStream extends Seekable {
    // Own properties of Gio-2.0.Gio.BufferedOutputStream

    /**
     * Whether the buffer should automatically grow.
     */
    autoGrow: boolean
    /**
     * The size of the backend buffer, in bytes.
     */
    bufferSize: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.BufferedOutputStream

    parentInstance: any
    priv: BufferedOutputStreamPrivate

    // Owm methods of Gio-2.0.Gio.BufferedOutputStream

    /**
     * Checks if the buffer automatically grows as data is added.
     * @returns %TRUE if the @stream's buffer automatically grows, %FALSE otherwise.
     */
    getAutoGrow(): boolean
    /**
     * Gets the size of the buffer in the `stream`.
     * @returns the current size of the buffer.
     */
    getBufferSize(): number
    /**
     * Sets whether or not the `stream'`s buffer should automatically grow.
     * If `auto_grow` is true, then each write will just make the buffer
     * larger, and you must manually flush the buffer to actually write out
     * the data to the underlying stream.
     * @param autoGrow a #gboolean.
     */
    setAutoGrow(autoGrow: boolean): void
    /**
     * Sets the size of the internal buffer to `size`.
     * @param size a #gsize.
     */
    setBufferSize(size: number): void

    // Class property signals of Gio-2.0.Gio.BufferedOutputStream

    connect(
      sigName: "notify::auto-grow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::auto-grow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::auto-grow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::auto-grow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::auto-grow", ...args: any[]): void
    connect(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::buffer-size", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-base-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Buffered output stream implements [class`Gio`.FilterOutputStream] and provides
   * for buffered writes.
   *
   * By default, `GBufferedOutputStream`'s buffer size is set at 4 kilobytes.
   *
   * To create a buffered output stream, use [ctor`Gio`.BufferedOutputStream.new],
   * or [ctor`Gio`.BufferedOutputStream.new_sized] to specify the buffer's size
   * at construction.
   *
   * To get the size of a buffer within a buffered input stream, use
   * [method`Gio`.BufferedOutputStream.get_buffer_size]. To change the size of a
   * buffered output stream's buffer, use [method`Gio`.BufferedOutputStream.set_buffer_size].
   * Note that the buffer's size cannot be reduced below the size of the data within the buffer.
   * @class
   */
  class BufferedOutputStream extends FilterOutputStream {
    // Own properties of Gio-2.0.Gio.BufferedOutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.BufferedOutputStream

    constructor(config?: BufferedOutputStream.ConstructorProperties)
    /**
     * Creates a new buffered output stream for a base stream.
     * @constructor
     * @param baseStream a #GOutputStream.
     * @returns a #GOutputStream for the given @base_stream.
     */
    constructor(baseStream: OutputStream)
    /**
     * Creates a new buffered output stream for a base stream.
     * @constructor
     * @param baseStream a #GOutputStream.
     * @returns a #GOutputStream for the given @base_stream.
     */
    static new(baseStream: OutputStream): BufferedOutputStream
    /**
     * Creates a new buffered output stream with a given buffer size.
     * @constructor
     * @param baseStream a #GOutputStream.
     * @param size a #gsize.
     * @returns a #GOutputStream with an internal buffer set to @size.
     */
    static newSized(
      baseStream: OutputStream,
      size: number
    ): BufferedOutputStream
    _init(config?: BufferedOutputStream.ConstructorProperties): void
  }

  module BytesIcon {
    // Constructor properties interface

    interface ConstructorProperties
      extends Icon.ConstructorProperties,
        LoadableIcon.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.BytesIcon

      /**
       * The bytes containing the icon.
       */
      bytes?: any | null
    }
  }

  interface BytesIcon extends Icon, LoadableIcon {
    // Own properties of Gio-2.0.Gio.BytesIcon

    /**
     * The bytes containing the icon.
     */
    readonly bytes: any
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.BytesIcon

    /**
     * Gets the #GBytes associated with the given `icon`.
     * @returns a #GBytes.
     */
    getBytes(): any

    // Class property signals of Gio-2.0.Gio.BytesIcon

    connect(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::bytes", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GBytesIcon` specifies an image held in memory in a common format (usually
   * PNG) to be used as icon.
   * @class
   */
  class BytesIcon extends GObject.Object {
    // Own properties of Gio-2.0.Gio.BytesIcon

    static name: string

    // Constructors of Gio-2.0.Gio.BytesIcon

    constructor(config?: BytesIcon.ConstructorProperties)
    /**
     * Creates a new icon for a bytes.
     *
     * This cannot fail, but loading and interpreting the bytes may fail later on
     * (for example, if g_loadable_icon_load() is called) if the image is invalid.
     * @constructor
     * @param bytes a #GBytes.
     * @returns a #GIcon for the given   @bytes.
     */
    constructor(bytes: any)
    /**
     * Creates a new icon for a bytes.
     *
     * This cannot fail, but loading and interpreting the bytes may fail later on
     * (for example, if g_loadable_icon_load() is called) if the image is invalid.
     * @constructor
     * @param bytes a #GBytes.
     * @returns a #GIcon for the given   @bytes.
     */
    static new(bytes: any): BytesIcon
    _init(config?: BytesIcon.ConstructorProperties): void
  }

  module Cancellable {
    // Signal callback interfaces

    /**
     * Signal callback interface for `cancelled`
     */
    interface CancelledSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Cancellable {
    // Own properties of Gio-2.0.Gio.Cancellable

    __gtype__: number

    // Own fields of Gio-2.0.Gio.Cancellable

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.Cancellable

    /**
     * Will set `cancellable` to cancelled, and will emit the
     * #GCancellable::cancelled signal. (However, see the warning about
     * race conditions in the documentation for that signal if you are
     * planning to connect to it.)
     *
     * This function is thread-safe. In other words, you can safely call
     * it from a thread other than the one running the operation that was
     * passed the `cancellable`.
     *
     * If `cancellable` is %NULL, this function returns immediately for convenience.
     *
     * The convention within GIO is that cancelling an asynchronous
     * operation causes it to complete asynchronously. That is, if you
     * cancel the operation from the same thread in which it is running,
     * then the operation's #GAsyncReadyCallback will not be invoked until
     * the application returns to the main loop.
     */
    cancel(): void
    /**
     * Convenience function to connect to the #GCancellable::cancelled
     * signal. Also handles the race condition that may happen
     * if the cancellable is cancelled right before connecting.
     *
     * `callback` is called at most once, either directly at the
     * time of the connect if `cancellable` is already cancelled,
     * or when `cancellable` is cancelled in some thread.
     *
     * `data_destroy_func` will be called when the handler is
     * disconnected, or immediately if the cancellable is already
     * cancelled.
     *
     * See #GCancellable::cancelled for details on how to use this.
     *
     * Since GLib 2.40, the lock protecting `cancellable` is not held when
     * `callback` is invoked.  This lifts a restriction in place for
     * earlier GLib versions which now makes it easier to write cleanup
     * code that unconditionally invokes e.g. g_cancellable_cancel().
     * @param callback The #GCallback to connect.
     * @returns The id of the signal handler or 0 if @cancellable has already          been cancelled.
     */
    connect(callback: GObject.Callback): number
    /**
     * Disconnects a handler from a cancellable instance similar to
     * g_signal_handler_disconnect().  Additionally, in the event that a
     * signal handler is currently running, this call will block until the
     * handler has finished.  Calling this function from a
     * #GCancellable::cancelled signal handler will therefore result in a
     * deadlock.
     *
     * This avoids a race condition where a thread cancels at the
     * same time as the cancellable operation is finished and the
     * signal handler is removed. See #GCancellable::cancelled for
     * details on how to use this.
     *
     * If `cancellable` is %NULL or `handler_id` is `0` this function does
     * nothing.
     * @param handlerId Handler id of the handler to be disconnected, or `0`.
     */
    disconnect(handlerId: number): void
    /**
     * Gets the file descriptor for a cancellable job. This can be used to
     * implement cancellable operations on Unix systems. The returned fd will
     * turn readable when `cancellable` is cancelled.
     *
     * You are not supposed to read from the fd yourself, just check for
     * readable status. Reading to unset the readable status is done
     * with g_cancellable_reset().
     *
     * After a successful return from this function, you should use
     * g_cancellable_release_fd() to free up resources allocated for
     * the returned file descriptor.
     *
     * See also g_cancellable_make_pollfd().
     * @returns A valid file descriptor. `-1` if the file descriptor is not supported, or on errors.
     */
    getFd(): number
    /**
     * Checks if a cancellable job has been cancelled.
     * @returns %TRUE if @cancellable is cancelled, FALSE if called with %NULL or if item is not cancelled.
     */
    isCancelled(): boolean
    /**
     * Creates a #GPollFD corresponding to `cancellable;` this can be passed
     * to g_poll() and used to poll for cancellation. This is useful both
     * for unix systems without a native poll and for portability to
     * windows.
     *
     * When this function returns %TRUE, you should use
     * g_cancellable_release_fd() to free up resources allocated for the
     * `pollfd`. After a %FALSE return, do not call g_cancellable_release_fd().
     *
     * If this function returns %FALSE, either no `cancellable` was given or
     * resource limits prevent this function from allocating the necessary
     * structures for polling. (On Linux, you will likely have reached
     * the maximum number of file descriptors.) The suggested way to handle
     * these cases is to ignore the `cancellable`.
     *
     * You are not supposed to read from the fd yourself, just check for
     * readable status. Reading to unset the readable status is done
     * with g_cancellable_reset().
     * @param pollfd a pointer to a #GPollFD
     * @returns %TRUE if @pollfd was successfully initialized, %FALSE on          failure to prepare the cancellable.
     */
    makePollfd(pollfd: GLib.PollFD): boolean
    /**
     * Pops `cancellable` off the cancellable stack (verifying that `cancellable`
     * is on the top of the stack).
     */
    popCurrent(): void
    /**
     * Pushes `cancellable` onto the cancellable stack. The current
     * cancellable can then be received using g_cancellable_get_current().
     *
     * This is useful when implementing cancellable operations in
     * code that does not allow you to pass down the cancellable object.
     *
     * This is typically called automatically by e.g. #GFile operations,
     * so you rarely have to call this yourself.
     */
    pushCurrent(): void
    /**
     * Releases a resources previously allocated by g_cancellable_get_fd()
     * or g_cancellable_make_pollfd().
     *
     * For compatibility reasons with older releases, calling this function
     * is not strictly required, the resources will be automatically freed
     * when the `cancellable` is finalized. However, the `cancellable` will
     * block scarce file descriptors until it is finalized if this function
     * is not called. This can cause the application to run out of file
     * descriptors when many #GCancellables are used at the same time.
     */
    releaseFd(): void
    /**
     * Resets `cancellable` to its uncancelled state.
     *
     * If cancellable is currently in use by any cancellable operation
     * then the behavior of this function is undefined.
     *
     * Note that it is generally not a good idea to reuse an existing
     * cancellable for more operations after it has been cancelled once,
     * as this function might tempt you to do. The recommended practice
     * is to drop the reference to a cancellable after cancelling it,
     * and let it die with the outstanding async operations. You should
     * create a fresh cancellable for further async operations.
     */
    reset(): void
    /**
     * If the `cancellable` is cancelled, sets the error to notify
     * that the operation was cancelled.
     * @returns %TRUE if @cancellable was cancelled, %FALSE if it was not
     */
    setErrorIfCancelled(): boolean
    /**
     * Creates a source that triggers if `cancellable` is cancelled and
     * calls its callback of type #GCancellableSourceFunc. This is
     * primarily useful for attaching to another (non-cancellable) source
     * with g_source_add_child_source() to add cancellability to it.
     *
     * For convenience, you can call this with a %NULL #GCancellable,
     * in which case the source will never trigger.
     *
     * The new #GSource will hold a reference to the #GCancellable.
     * @returns the new #GSource.
     */
    sourceNew(): GLib.Source

    // Own virtual methods of Gio-2.0.Gio.Cancellable

    cancelled(): void

    // Own signals of Gio-2.0.Gio.Cancellable

    connect(
      sigName: "cancelled",
      callback: Cancellable.CancelledSignalCallback
    ): number
    on(
      sigName: "cancelled",
      callback: Cancellable.CancelledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cancelled",
      callback: Cancellable.CancelledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cancelled",
      callback: Cancellable.CancelledSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cancelled", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.Cancellable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GCancellable` allows operations to be cancelled.
   *
   * `GCancellable` is a thread-safe operation cancellation stack used
   * throughout GIO to allow for cancellation of synchronous and
   * asynchronous operations.
   * @class
   */
  class Cancellable extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Cancellable

    static name: string

    // Constructors of Gio-2.0.Gio.Cancellable

    constructor(config?: Cancellable.ConstructorProperties)
    /**
     * Creates a new #GCancellable object.
     *
     * Applications that want to start one or more operations
     * that should be cancellable should create a #GCancellable
     * and pass it to the operations.
     *
     * One #GCancellable can be used in multiple consecutive
     * operations or in multiple concurrent operations.
     * @constructor
     * @returns a #GCancellable.
     */
    constructor()
    /**
     * Creates a new #GCancellable object.
     *
     * Applications that want to start one or more operations
     * that should be cancellable should create a #GCancellable
     * and pass it to the operations.
     *
     * One #GCancellable can be used in multiple consecutive
     * operations or in multiple concurrent operations.
     * @constructor
     * @returns a #GCancellable.
     */
    static new(): Cancellable
    _init(config?: Cancellable.ConstructorProperties): void
    /**
     * Gets the top cancellable from the stack.
     * @returns a #GCancellable from the top of the stack, or %NULL if the stack is empty.
     */
    static getCurrent(): Cancellable | null
  }

  module CharsetConverter {
    // Constructor properties interface

    interface ConstructorProperties
      extends Converter.ConstructorProperties,
        Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.CharsetConverter

      /**
       * The character encoding to convert from.
       */
      from_charset?: string | null
      /**
       * The character encoding to convert to.
       */
      to_charset?: string | null
      /**
       * Use fallback (of form `\<hexval>`) for invalid bytes.
       */
      use_fallback?: boolean | null
    }
  }

  interface CharsetConverter extends Converter, Initable {
    // Own properties of Gio-2.0.Gio.CharsetConverter

    /**
     * The character encoding to convert from.
     */
    readonly fromCharset: string | null
    /**
     * The character encoding to convert to.
     */
    readonly toCharset: string | null
    /**
     * Use fallback (of form `\<hexval>`) for invalid bytes.
     */
    useFallback: boolean
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.CharsetConverter

    /**
     * Gets the number of fallbacks that `converter` has applied so far.
     * @returns the number of fallbacks that @converter has applied
     */
    getNumFallbacks(): number
    /**
     * Gets the #GCharsetConverter:use-fallback property.
     * @returns %TRUE if fallbacks are used by @converter
     */
    getUseFallback(): boolean
    /**
     * Sets the #GCharsetConverter:use-fallback property.
     * @param useFallback %TRUE to use fallbacks
     */
    setUseFallback(useFallback: boolean): void

    // Class property signals of Gio-2.0.Gio.CharsetConverter

    connect(
      sigName: "notify::from-charset",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::from-charset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::from-charset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::from-charset",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::from-charset", ...args: any[]): void
    connect(
      sigName: "notify::to-charset",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::to-charset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::to-charset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::to-charset",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::to-charset", ...args: any[]): void
    connect(
      sigName: "notify::use-fallback",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-fallback",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-fallback", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GCharsetConverter` is an implementation of [iface`Gio`.Converter] based on
   * [struct`GLib`.IConv].
   * @class
   */
  class CharsetConverter extends GObject.Object {
    // Own properties of Gio-2.0.Gio.CharsetConverter

    static name: string

    // Constructors of Gio-2.0.Gio.CharsetConverter

    constructor(config?: CharsetConverter.ConstructorProperties)
    /**
     * Creates a new #GCharsetConverter.
     * @constructor
     * @param toCharset destination charset
     * @param fromCharset source charset
     * @returns a new #GCharsetConverter or %NULL on error.
     */
    constructor(toCharset: string, fromCharset: string)
    /**
     * Creates a new #GCharsetConverter.
     * @constructor
     * @param toCharset destination charset
     * @param fromCharset source charset
     * @returns a new #GCharsetConverter or %NULL on error.
     */
    static new(toCharset: string, fromCharset: string): CharsetConverter
    _init(config?: CharsetConverter.ConstructorProperties): void
  }

  module ConverterInputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends PollableInputStream.ConstructorProperties,
        FilterInputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ConverterInputStream

      /**
       * The converter object.
       */
      converter?: Converter | null
    }
  }

  interface ConverterInputStream extends PollableInputStream {
    // Own properties of Gio-2.0.Gio.ConverterInputStream

    /**
     * The converter object.
     */
    readonly converter: Converter
    __gtype__: number

    // Own fields of Gio-2.0.Gio.ConverterInputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.ConverterInputStream

    /**
     * Gets the #GConverter that is used by `converter_stream`.
     * @returns the converter of the converter input stream
     */
    getConverter(): Converter

    // Class property signals of Gio-2.0.Gio.ConverterInputStream

    connect(
      sigName: "notify::converter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::converter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::converter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::converter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::converter", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-base-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Converter input stream implements [class`Gio`.InputStream] and allows
   * conversion of data of various types during reading.
   *
   * As of GLib 2.34, `GConverterInputStream` implements
   * [iface`Gio`.PollableInputStream].
   * @class
   */
  class ConverterInputStream extends FilterInputStream {
    // Own properties of Gio-2.0.Gio.ConverterInputStream

    static name: string

    // Constructors of Gio-2.0.Gio.ConverterInputStream

    constructor(config?: ConverterInputStream.ConstructorProperties)
    /**
     * Creates a new converter input stream for the `base_stream`.
     * @constructor
     * @param baseStream a #GInputStream
     * @param converter a #GConverter
     * @returns a new #GInputStream.
     */
    constructor(baseStream: InputStream, converter: Converter)
    /**
     * Creates a new converter input stream for the `base_stream`.
     * @constructor
     * @param baseStream a #GInputStream
     * @param converter a #GConverter
     * @returns a new #GInputStream.
     */
    static new(
      baseStream: InputStream,
      converter: Converter
    ): ConverterInputStream
    _init(config?: ConverterInputStream.ConstructorProperties): void
  }

  module ConverterOutputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends PollableOutputStream.ConstructorProperties,
        FilterOutputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ConverterOutputStream

      /**
       * The converter object.
       */
      converter?: Converter | null
    }
  }

  interface ConverterOutputStream extends PollableOutputStream {
    // Own properties of Gio-2.0.Gio.ConverterOutputStream

    /**
     * The converter object.
     */
    readonly converter: Converter
    __gtype__: number

    // Own fields of Gio-2.0.Gio.ConverterOutputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.ConverterOutputStream

    /**
     * Gets the #GConverter that is used by `converter_stream`.
     * @returns the converter of the converter output stream
     */
    getConverter(): Converter

    // Class property signals of Gio-2.0.Gio.ConverterOutputStream

    connect(
      sigName: "notify::converter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::converter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::converter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::converter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::converter", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-base-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Converter output stream implements [class`Gio`.OutputStream] and allows
   * conversion of data of various types during reading.
   *
   * As of GLib 2.34, `GConverterOutputStream` implements
   * [iface`Gio`.PollableOutputStream].
   * @class
   */
  class ConverterOutputStream extends FilterOutputStream {
    // Own properties of Gio-2.0.Gio.ConverterOutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.ConverterOutputStream

    constructor(config?: ConverterOutputStream.ConstructorProperties)
    /**
     * Creates a new converter output stream for the `base_stream`.
     * @constructor
     * @param baseStream a #GOutputStream
     * @param converter a #GConverter
     * @returns a new #GOutputStream.
     */
    constructor(baseStream: OutputStream, converter: Converter)
    /**
     * Creates a new converter output stream for the `base_stream`.
     * @constructor
     * @param baseStream a #GOutputStream
     * @param converter a #GConverter
     * @returns a new #GOutputStream.
     */
    static new(
      baseStream: OutputStream,
      converter: Converter
    ): ConverterOutputStream
    _init(config?: ConverterOutputStream.ConstructorProperties): void
  }

  module Credentials {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Credentials {
    // Own properties of Gio-2.0.Gio.Credentials

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Credentials

    /**
     * Tries to get the UNIX process identifier from `credentials`. This
     * method is only available on UNIX platforms.
     *
     * This operation can fail if #GCredentials is not supported on the
     * OS or if the native credentials type does not contain information
     * about the UNIX process ID.
     * @returns The UNIX process ID, or `-1` if @error is set.
     */
    getUnixPid(): number
    /**
     * Tries to get the UNIX user identifier from `credentials`. This
     * method is only available on UNIX platforms.
     *
     * This operation can fail if #GCredentials is not supported on the
     * OS or if the native credentials type does not contain information
     * about the UNIX user.
     * @returns The UNIX user identifier or `-1` if @error is set.
     */
    getUnixUser(): number
    /**
     * Checks if `credentials` and `other_credentials` is the same user.
     *
     * This operation can fail if #GCredentials is not supported on the
     * the OS.
     * @param otherCredentials A #GCredentials.
     * @returns %TRUE if @credentials and @other_credentials has the same user, %FALSE otherwise or if @error is set.
     */
    isSameUser(otherCredentials: Credentials): boolean
    /**
     * Copies the native credentials of type `native_type` from `native`
     * into `credentials`.
     *
     * It is a programming error (which will cause a warning to be
     * logged) to use this method if there is no #GCredentials support for
     * the OS or if `native_type` isn't supported by the OS.
     * @param nativeType The type of native credentials to set.
     * @param native A pointer to native credentials.
     */
    setNative(nativeType: CredentialsType, native: any): void
    /**
     * Tries to set the UNIX user identifier on `credentials`. This method
     * is only available on UNIX platforms.
     *
     * This operation can fail if #GCredentials is not supported on the
     * OS or if the native credentials type does not contain information
     * about the UNIX user. It can also fail if the OS does not allow the
     * use of "spoofed" credentials.
     * @param uid The UNIX user identifier to set.
     * @returns %TRUE if @uid was set, %FALSE if error is set.
     */
    setUnixUser(uid: number): boolean
    /**
     * Creates a human-readable textual representation of `credentials`
     * that can be used in logging and debug messages. The format of the
     * returned string may change in future GLib release.
     * @returns A string that should be freed with g_free().
     */
    toString(): string | null

    // Class property signals of Gio-2.0.Gio.Credentials

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GCredentials` type is a reference-counted wrapper for native
   * credentials.
   *
   * The information in `GCredentials` is typically used for identifying,
   * authenticating and authorizing other processes.
   *
   * Some operating systems supports looking up the credentials of the remote
   * peer of a communication endpoint - see e.g. [method`Gio`.Socket.get_credentials].
   *
   * Some operating systems supports securely sending and receiving
   * credentials over a Unix Domain Socket, see [class`Gio`.UnixCredentialsMessage],
   * [method`Gio`.UnixConnection.send_credentials] and
   * [method`Gio`.UnixConnection.receive_credentials] for details.
   *
   * On Linux, the native credential type is a `struct ucred` - see the
   * [`unix(7)` man page](man:unix(7)) for details. This corresponds to
   * `G_CREDENTIALS_TYPE_LINUX_UCRED`.
   *
   * On Apple operating systems (including iOS, tvOS, and macOS), the native credential
   * type is a `struct xucred`. This corresponds to `G_CREDENTIALS_TYPE_APPLE_XUCRED`.
   *
   * On FreeBSD, Debian GNU/kFreeBSD, and GNU/Hurd, the native credential type is a
   * `struct cmsgcred`. This corresponds to `G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED`.
   *
   * On NetBSD, the native credential type is a `struct unpcbid`.
   * This corresponds to `G_CREDENTIALS_TYPE_NETBSD_UNPCBID`.
   *
   * On OpenBSD, the native credential type is a `struct sockpeercred`.
   * This corresponds to `G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED`.
   *
   * On Solaris (including OpenSolaris and its derivatives), the native credential type
   * is a `ucred_t`. This corresponds to `G_CREDENTIALS_TYPE_SOLARIS_UCRED`.
   *
   * Since GLib 2.72, on Windows, the native credentials may contain the PID of a
   * process. This corresponds to `G_CREDENTIALS_TYPE_WIN32_PID`.
   * @class
   */
  class Credentials extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Credentials

    static name: string

    // Constructors of Gio-2.0.Gio.Credentials

    constructor(config?: Credentials.ConstructorProperties)
    /**
     * Creates a new #GCredentials object with credentials matching the
     * the current process.
     * @constructor
     * @returns A #GCredentials. Free with g_object_unref().
     */
    constructor()
    /**
     * Creates a new #GCredentials object with credentials matching the
     * the current process.
     * @constructor
     * @returns A #GCredentials. Free with g_object_unref().
     */
    static new(): Credentials
    _init(config?: Credentials.ConstructorProperties): void
  }

  module DBusActionGroup {
    // Constructor properties interface

    interface ConstructorProperties
      extends ActionGroup.ConstructorProperties,
        RemoteActionGroup.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface DBusActionGroup extends ActionGroup, RemoteActionGroup {
    // Own properties of Gio-2.0.Gio.DBusActionGroup

    __gtype__: number

    // Class property signals of Gio-2.0.Gio.DBusActionGroup

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDBusActionGroup` is an implementation of the [iface`Gio`.ActionGroup]
   * interface.
   *
   * `GDBusActionGroup` can be used as a proxy for an action group
   * that is exported over D-Bus with [method`Gio`.DBusConnection.export_action_group].
   * @class
   */
  class DBusActionGroup extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusActionGroup

    static name: string

    // Constructors of Gio-2.0.Gio.DBusActionGroup

    constructor(config?: DBusActionGroup.ConstructorProperties)
    _init(config?: DBusActionGroup.ConstructorProperties): void
    /**
     * Obtains a #GDBusActionGroup for the action group which is exported at
     * the given `bus_name` and `object_path`.
     *
     * The thread default main context is taken at the time of this call.
     * All signals on the menu model (and any linked models) are reported
     * with respect to this context.  All calls on the returned menu model
     * (and linked models) must also originate from this same context, with
     * the thread default main context unchanged.
     *
     * This call is non-blocking.  The returned action group may or may not
     * already be filled in.  The correct thing to do is connect the signals
     * for the action group to monitor for changes and then to call
     * g_action_group_list_actions() to get the initial list.
     * @param connection A #GDBusConnection
     * @param busName the bus name which exports the action     group or %NULL if `connection` is not a message bus connection
     * @param objectPath the object path at which the action group is exported
     * @returns a #GDBusActionGroup
     */
    static get(
      connection: DBusConnection,
      busName: string | null,
      objectPath: string
    ): DBusActionGroup
  }

  module DBusAuthObserver {
    // Signal callback interfaces

    /**
     * Signal callback interface for `allow-mechanism`
     */
    interface AllowMechanismSignalCallback {
      (mechanism: string | null): boolean
    }

    /**
     * Signal callback interface for `authorize-authenticated-peer`
     */
    interface AuthorizeAuthenticatedPeerSignalCallback {
      (stream: IOStream, credentials: Credentials | null): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface DBusAuthObserver {
    // Own properties of Gio-2.0.Gio.DBusAuthObserver

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusAuthObserver

    /**
     * Emits the #GDBusAuthObserver::allow-mechanism signal on `observer`.
     * @param mechanism The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`.
     * @returns %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not.
     */
    allowMechanism(mechanism: string): boolean
    /**
     * Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on `observer`.
     * @param stream A #GIOStream for the #GDBusConnection.
     * @param credentials Credentials received from the peer or %NULL.
     * @returns %TRUE if the peer is authorized, %FALSE if not.
     */
    authorizeAuthenticatedPeer(
      stream: IOStream,
      credentials: Credentials | null
    ): boolean

    // Own signals of Gio-2.0.Gio.DBusAuthObserver

    connect(
      sigName: "allow-mechanism",
      callback: DBusAuthObserver.AllowMechanismSignalCallback
    ): number
    on(
      sigName: "allow-mechanism",
      callback: DBusAuthObserver.AllowMechanismSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "allow-mechanism",
      callback: DBusAuthObserver.AllowMechanismSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "allow-mechanism",
      callback: DBusAuthObserver.AllowMechanismSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "allow-mechanism", ...args: any[]): void
    connect(
      sigName: "authorize-authenticated-peer",
      callback: DBusAuthObserver.AuthorizeAuthenticatedPeerSignalCallback
    ): number
    on(
      sigName: "authorize-authenticated-peer",
      callback: DBusAuthObserver.AuthorizeAuthenticatedPeerSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "authorize-authenticated-peer",
      callback: DBusAuthObserver.AuthorizeAuthenticatedPeerSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "authorize-authenticated-peer",
      callback: DBusAuthObserver.AuthorizeAuthenticatedPeerSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "authorize-authenticated-peer",
      credentials: Credentials | null,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.DBusAuthObserver

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDBusAuthObserver` provides a mechanism for participating
   * in how a [class`Gio`.DBusServer] (or a [class`Gio`.DBusConnection])
   * authenticates remote peers.
   *
   * Simply instantiate a `GDBusAuthObserver` and connect to the
   * signals you are interested in. Note that new signals may be added
   * in the future.
   *
   * ## Controlling Authentication Mechanisms
   *
   * By default, a `GDBusServer` or server-side `GDBusConnection` will allow
   * any authentication mechanism to be used. If you only want to allow D-Bus
   * connections with the `EXTERNAL` mechanism, which makes use of credentials
   * passing and is the recommended mechanism for modern Unix platforms such
   * as Linux and the BSD family, you would use a signal handler like this:
   *
   * ```c
   * static gboolean
   * on_allow_mechanism (GDBusAuthObserver *observer,
   *                     const gchar       *mechanism,
   *                     gpointer           user_data)
   * {
   *   if (g_strcmp0 (mechanism, "EXTERNAL") == 0)
   *     {
   *       return TRUE;
   *     }
   *
   *   return FALSE;
   * }
   * ```
   *
   * ## Controlling Authorization
   *
   * By default, a `GDBusServer` or server-side `GDBusConnection` will accept
   * connections from any successfully authenticated user (but not from
   * anonymous connections using the `ANONYMOUS` mechanism). If you only
   * want to allow D-Bus connections from processes owned by the same uid
   * as the server, since GLib 2.68, you should use the
   * `G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER` flag. It’s equivalent
   * to the following signal handler:
   *
   * ```c
   * static gboolean
   * on_authorize_authenticated_peer (GDBusAuthObserver *observer,
   *                                  GIOStream         *stream,
   *                                  GCredentials      *credentials,
   *                                  gpointer           user_data)
   * {
   *   gboolean authorized;
   *
   *   authorized = FALSE;
   *   if (credentials != NULL)
   *     {
   *       GCredentials *own_credentials;
   *       own_credentials = g_credentials_new ();
   *       if (g_credentials_is_same_user (credentials, own_credentials, NULL))
   *         authorized = TRUE;
   *       g_object_unref (own_credentials);
   *     }
   *
   *   return authorized;
   * }
   * ```
   * @class
   */
  class DBusAuthObserver extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusAuthObserver

    static name: string

    // Constructors of Gio-2.0.Gio.DBusAuthObserver

    constructor(config?: DBusAuthObserver.ConstructorProperties)
    /**
     * Creates a new #GDBusAuthObserver object.
     * @constructor
     * @returns A #GDBusAuthObserver. Free with g_object_unref().
     */
    constructor()
    /**
     * Creates a new #GDBusAuthObserver object.
     * @constructor
     * @returns A #GDBusAuthObserver. Free with g_object_unref().
     */
    static new(): DBusAuthObserver
    _init(config?: DBusAuthObserver.ConstructorProperties): void
  }

  module DBusConnection {
    // Signal callback interfaces

    /**
     * Signal callback interface for `closed`
     */
    interface ClosedSignalCallback {
      (remotePeerVanished: boolean, error: GLib.Error | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends AsyncInitable.ConstructorProperties,
        Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DBusConnection

      /**
       * A D-Bus address specifying potential endpoints that can be used
       * when establishing the connection.
       */
      address?: string | null
      /**
       * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
       */
      authentication_observer?: DBusAuthObserver | null
      /**
       * A boolean specifying whether the process will be terminated (by
       * calling `raise(SIGTERM)`) if the connection is closed by the
       * remote peer.
       *
       * Note that #GDBusConnection objects returned by g_bus_get_finish()
       * and g_bus_get_sync() will (usually) have this property set to %TRUE.
       */
      exit_on_close?: boolean | null
      /**
       * Flags from the #GDBusConnectionFlags enumeration.
       */
      flags?: DBusConnectionFlags | null
      /**
       * The GUID of the peer performing the role of server when
       * authenticating.
       *
       * If you are constructing a #GDBusConnection and pass
       * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER in the
       * #GDBusConnection:flags property then you **must** also set this
       * property to a valid guid.
       *
       * If you are constructing a #GDBusConnection and pass
       * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT in the
       * #GDBusConnection:flags property you will be able to read the GUID
       * of the other peer here after the connection has been successfully
       * initialized.
       *
       * Note that the
       * [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses)
       * uses the term ‘UUID’ to refer to this, whereas GLib consistently uses the
       * term ‘GUID’ for historical reasons.
       *
       * Despite its name, the format of #GDBusConnection:guid does not follow
       * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122) or the Microsoft
       * GUID format.
       */
      guid?: string | null
      /**
       * The underlying #GIOStream used for I/O.
       *
       * If this is passed on construction and is a #GSocketConnection,
       * then the corresponding #GSocket will be put into non-blocking mode.
       *
       * While the #GDBusConnection is active, it will interact with this
       * stream from a worker thread, so it is not safe to interact with
       * the stream directly.
       */
      stream?: IOStream | null
    }
  }

  interface DBusConnection extends AsyncInitable, Initable {
    // Own properties of Gio-2.0.Gio.DBusConnection

    /**
     * A D-Bus address specifying potential endpoints that can be used
     * when establishing the connection.
     */
    readonly address: string | null
    /**
     * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
     */
    readonly authenticationObserver: DBusAuthObserver
    /**
     * Flags from the #GDBusCapabilityFlags enumeration
     * representing connection features negotiated with the other peer.
     */
    readonly capabilities: DBusCapabilityFlags
    /**
     * A boolean specifying whether the connection has been closed.
     */
    readonly closed: boolean
    /**
     * A boolean specifying whether the process will be terminated (by
     * calling `raise(SIGTERM)`) if the connection is closed by the
     * remote peer.
     *
     * Note that #GDBusConnection objects returned by g_bus_get_finish()
     * and g_bus_get_sync() will (usually) have this property set to %TRUE.
     */
    exitOnClose: boolean
    /**
     * Flags from the #GDBusConnectionFlags enumeration.
     */
    readonly flags: DBusConnectionFlags
    /**
     * The GUID of the peer performing the role of server when
     * authenticating.
     *
     * If you are constructing a #GDBusConnection and pass
     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER in the
     * #GDBusConnection:flags property then you **must** also set this
     * property to a valid guid.
     *
     * If you are constructing a #GDBusConnection and pass
     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT in the
     * #GDBusConnection:flags property you will be able to read the GUID
     * of the other peer here after the connection has been successfully
     * initialized.
     *
     * Note that the
     * [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses)
     * uses the term ‘UUID’ to refer to this, whereas GLib consistently uses the
     * term ‘GUID’ for historical reasons.
     *
     * Despite its name, the format of #GDBusConnection:guid does not follow
     * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122) or the Microsoft
     * GUID format.
     */
    readonly guid: string | null
    /**
     * The underlying #GIOStream used for I/O.
     *
     * If this is passed on construction and is a #GSocketConnection,
     * then the corresponding #GSocket will be put into non-blocking mode.
     *
     * While the #GDBusConnection is active, it will interact with this
     * stream from a worker thread, so it is not safe to interact with
     * the stream directly.
     */
    readonly stream: IOStream
    /**
     * The unique name as assigned by the message bus or %NULL if the
     * connection is not open or not a message bus connection.
     */
    readonly uniqueName: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusConnection

    /**
     * Adds a message filter. Filters are handlers that are run on all
     * incoming and outgoing messages, prior to standard dispatch. Filters
     * are run in the order that they were added.  The same handler can be
     * added as a filter more than once, in which case it will be run more
     * than once.  Filters added during a filter callback won't be run on
     * the message being processed. Filter functions are allowed to modify
     * and even drop messages.
     *
     * Note that filters are run in a dedicated message handling thread so
     * they can't block and, generally, can't do anything but signal a
     * worker thread. Also note that filters are rarely needed - use API
     * such as g_dbus_connection_send_message_with_reply(),
     * g_dbus_connection_signal_subscribe() or g_dbus_connection_call() instead.
     *
     * If a filter consumes an incoming message the message is not
     * dispatched anywhere else - not even the standard dispatch machinery
     * (that API such as g_dbus_connection_signal_subscribe() and
     * g_dbus_connection_send_message_with_reply() relies on) will see the
     * message. Similarly, if a filter consumes an outgoing message, the
     * message will not be sent to the other peer.
     *
     * If `user_data_free_func` is non-%NULL, it will be called (in the
     * thread-default main context of the thread you are calling this
     * method from) at some point after `user_data` is no longer
     * needed. (It is not guaranteed to be called synchronously when the
     * filter is removed, and may be called after `connection` has been
     * destroyed.)
     * @param filterFunction a filter function
     * @returns a filter identifier that can be used with     g_dbus_connection_remove_filter()
     */
    addFilter(filterFunction: DBusMessageFilterFunction): number
    /**
     * Asynchronously invokes the `method_name` method on the
     * `interface_name` D-Bus interface on the remote object at
     * `object_path` owned by `bus_name`.
     *
     * If `connection` is closed then the operation will fail with
     * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
     * fail with %G_IO_ERROR_CANCELLED. If `parameters` contains a value
     * not compatible with the D-Bus protocol, the operation fails with
     * %G_IO_ERROR_INVALID_ARGUMENT.
     *
     * If `reply_type` is non-%NULL then the reply will be checked for having this type and an
     * error will be raised if it does not match.  Said another way, if you give a `reply_type`
     * then any non-%NULL return value will be of this type. Unless it’s
     * %G_VARIANT_TYPE_UNIT, the `reply_type` will be a tuple containing one or more
     * values.
     *
     * If the `parameters` #GVariant is floating, it is consumed. This allows
     * convenient 'inline' use of g_variant_new(), e.g.:
     *
     * ```c
     *  g_dbus_connection_call (connection,
     *                          "org.freedesktop.StringThings",
     *                          "/org/freedesktop/StringThings",
     *                          "org.freedesktop.StringThings",
     *                          "TwoStrings",
     *                          g_variant_new ("(ss)",
     *                                         "Thing One",
     *                                         "Thing Two"),
     *                          NULL,
     *                          G_DBUS_CALL_FLAGS_NONE,
     *                          -1,
     *                          NULL,
     *                          (GAsyncReadyCallback) two_strings_done,
     *                          NULL);
     * ```
     *
     *
     * This is an asynchronous method. When the operation is finished,
     * `callback` will be invoked in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread you are calling this method from. You can then call
     * g_dbus_connection_call_finish() to get the result of the operation.
     * See g_dbus_connection_call_sync() for the synchronous version of this
     * function.
     *
     * If `callback` is %NULL then the D-Bus method call message will be sent with
     * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
     * @param busName a unique or well-known bus name or %NULL if     `connection` is not a message bus connection
     * @param objectPath path of remote object
     * @param interfaceName D-Bus interface to invoke method on
     * @param methodName the name of the method to invoke
     * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
     * @param replyType the expected type of the reply (which will be a     tuple), or %NULL
     * @param flags flags from the #GDBusCallFlags enumeration
     * @param timeoutMsec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
     * @param cancellable a #GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result of the     method invocation
     */
    call(
      busName: string | null,
      objectPath: string,
      interfaceName: string,
      methodName: string,
      parameters: GLib.Variant | null,
      replyType: GLib.VariantType | null,
      flags: DBusCallFlags,
      timeoutMsec: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an operation started with g_dbus_connection_call().
     * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call()
     * @returns %NULL if @error is set. Otherwise a non-floating     #GVariant tuple with return values. Free with g_variant_unref().
     */
    callFinish(res: AsyncResult): GLib.Variant
    /**
     * Synchronously invokes the `method_name` method on the
     * `interface_name` D-Bus interface on the remote object at
     * `object_path` owned by `bus_name`.
     *
     * If `connection` is closed then the operation will fail with
     * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the
     * operation will fail with %G_IO_ERROR_CANCELLED. If `parameters`
     * contains a value not compatible with the D-Bus protocol, the operation
     * fails with %G_IO_ERROR_INVALID_ARGUMENT.
     *
     * If `reply_type` is non-%NULL then the reply will be checked for having
     * this type and an error will be raised if it does not match.  Said
     * another way, if you give a `reply_type` then any non-%NULL return
     * value will be of this type.
     *
     * If the `parameters` #GVariant is floating, it is consumed.
     * This allows convenient 'inline' use of g_variant_new(), e.g.:
     *
     * ```c
     *  g_dbus_connection_call_sync (connection,
     *                               "org.freedesktop.StringThings",
     *                               "/org/freedesktop/StringThings",
     *                               "org.freedesktop.StringThings",
     *                               "TwoStrings",
     *                               g_variant_new ("(ss)",
     *                                              "Thing One",
     *                                              "Thing Two"),
     *                               NULL,
     *                               G_DBUS_CALL_FLAGS_NONE,
     *                               -1,
     *                               NULL,
     *                               &error);
     * ```
     *
     *
     * The calling thread is blocked until a reply is received. See
     * g_dbus_connection_call() for the asynchronous version of
     * this method.
     * @param busName a unique or well-known bus name or %NULL if     `connection` is not a message bus connection
     * @param objectPath path of remote object
     * @param interfaceName D-Bus interface to invoke method on
     * @param methodName the name of the method to invoke
     * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
     * @param replyType the expected type of the reply, or %NULL
     * @param flags flags from the #GDBusCallFlags enumeration
     * @param timeoutMsec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
     * @param cancellable a #GCancellable or %NULL
     * @returns %NULL if @error is set. Otherwise a non-floating     #GVariant tuple with return values. Free with g_variant_unref().
     */
    callSync(
      busName: string | null,
      objectPath: string,
      interfaceName: string,
      methodName: string,
      parameters: GLib.Variant | null,
      replyType: GLib.VariantType | null,
      flags: DBusCallFlags,
      timeoutMsec: number,
      cancellable: Cancellable | null
    ): GLib.Variant
    /**
     * Like g_dbus_connection_call() but also takes a #GUnixFDList object.
     *
     * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
     * values in the body of the message. For example, if a message contains
     * two file descriptors, `fd_list` would have length 2, and
     * `g_variant_new_handle (0)` and `g_variant_new_handle (1)` would appear
     * somewhere in the body of the message (not necessarily in that order!)
     * to represent the file descriptors at indexes 0 and 1 respectively.
     *
     * When designing D-Bus APIs that are intended to be interoperable,
     * please note that non-GDBus implementations of D-Bus can usually only
     * access file descriptors if they are referenced in this way by a
     * value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
     *
     * This method is only available on UNIX.
     * @param busName a unique or well-known bus name or %NULL if     `connection` is not a message bus connection
     * @param objectPath path of remote object
     * @param interfaceName D-Bus interface to invoke method on
     * @param methodName the name of the method to invoke
     * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
     * @param replyType the expected type of the reply, or %NULL
     * @param flags flags from the #GDBusCallFlags enumeration
     * @param timeoutMsec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
     * @param fdList a #GUnixFDList or %NULL
     * @param cancellable a #GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback to call when the request is     satisfied or %NULL if you don't * care about the result of the     method invocation
     */
    callWithUnixFdList(
      busName: string | null,
      objectPath: string,
      interfaceName: string,
      methodName: string,
      parameters: GLib.Variant | null,
      replyType: GLib.VariantType | null,
      flags: DBusCallFlags,
      timeoutMsec: number,
      fdList: UnixFDList | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an operation started with g_dbus_connection_call_with_unix_fd_list().
     *
     * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
     * values in the body of the message. For example,
     * if g_variant_get_handle() returns 5, that is intended to be a reference
     * to the file descriptor that can be accessed by
     * `g_unix_fd_list_get (*out_fd_list, 5, ...)`.
     *
     * When designing D-Bus APIs that are intended to be interoperable,
     * please note that non-GDBus implementations of D-Bus can usually only
     * access file descriptors if they are referenced in this way by a
     * value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
     * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed to     g_dbus_connection_call_with_unix_fd_list()
     * @returns %NULL if @error is set. Otherwise a non-floating     #GVariant tuple with return values. Free with g_variant_unref().
     */
    callWithUnixFdListFinish(
      res: AsyncResult
    ): [/* returnType */ GLib.Variant, /* outFdList */ UnixFDList]
    /**
     * Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
     * See g_dbus_connection_call_with_unix_fd_list() and
     * g_dbus_connection_call_with_unix_fd_list_finish() for more details.
     *
     * This method is only available on UNIX.
     * @param busName a unique or well-known bus name or %NULL     if `connection` is not a message bus connection
     * @param objectPath path of remote object
     * @param interfaceName D-Bus interface to invoke method on
     * @param methodName the name of the method to invoke
     * @param parameters a #GVariant tuple with parameters for     the method or %NULL if not passing parameters
     * @param replyType the expected type of the reply, or %NULL
     * @param flags flags from the #GDBusCallFlags enumeration
     * @param timeoutMsec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
     * @param fdList a #GUnixFDList or %NULL
     * @param cancellable a #GCancellable or %NULL
     * @returns %NULL if @error is set. Otherwise a non-floating     #GVariant tuple with return values. Free with g_variant_unref().
     */
    callWithUnixFdListSync(
      busName: string | null,
      objectPath: string,
      interfaceName: string,
      methodName: string,
      parameters: GLib.Variant | null,
      replyType: GLib.VariantType | null,
      flags: DBusCallFlags,
      timeoutMsec: number,
      fdList: UnixFDList | null,
      cancellable: Cancellable | null
    ): [/* returnType */ GLib.Variant, /* outFdList */ UnixFDList]
    /**
     * Closes `connection`. Note that this never causes the process to
     * exit (this might only happen if the other end of a shared message
     * bus connection disconnects, see #GDBusConnection:exit-on-close).
     *
     * Once the connection is closed, operations such as sending a message
     * will return with the error %G_IO_ERROR_CLOSED. Closing a connection
     * will not automatically flush the connection so queued messages may
     * be lost. Use g_dbus_connection_flush() if you need such guarantees.
     *
     * If `connection` is already closed, this method fails with
     * %G_IO_ERROR_CLOSED.
     *
     * When `connection` has been closed, the #GDBusConnection::closed
     * signal is emitted in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread that `connection` was constructed in.
     *
     * This is an asynchronous method. When the operation is finished,
     * `callback` will be invoked in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread you are calling this method from. You can
     * then call g_dbus_connection_close_finish() to get the result of the
     * operation. See g_dbus_connection_close_sync() for the synchronous
     * version.
     * @param cancellable a #GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback to call when the request is     satisfied or %NULL if you don't care about the result
     */
    close(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an operation started with g_dbus_connection_close().
     * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed     to g_dbus_connection_close()
     * @returns %TRUE if the operation succeeded, %FALSE if @error is set
     */
    closeFinish(res: AsyncResult): boolean
    /**
     * Synchronously closes `connection`. The calling thread is blocked
     * until this is done. See g_dbus_connection_close() for the
     * asynchronous version of this method and more details about what it
     * does.
     * @param cancellable a #GCancellable or %NULL
     * @returns %TRUE if the operation succeeded, %FALSE if @error is set
     */
    closeSync(cancellable: Cancellable | null): boolean
    /**
     * Emits a signal.
     *
     * If the parameters GVariant is floating, it is consumed.
     *
     * This can only fail if `parameters` is not compatible with the D-Bus protocol
     * (%G_IO_ERROR_INVALID_ARGUMENT), or if `connection` has been closed
     * (%G_IO_ERROR_CLOSED).
     * @param destinationBusName the unique bus name for the destination     for the signal or %NULL to emit to all listeners
     * @param objectPath path of remote object
     * @param interfaceName D-Bus interface to emit a signal on
     * @param signalName the name of the signal to emit
     * @param parameters a #GVariant tuple with parameters for the signal              or %NULL if not passing parameters
     * @returns %TRUE unless @error is set
     */
    emitSignal(
      destinationBusName: string | null,
      objectPath: string,
      interfaceName: string,
      signalName: string,
      parameters: GLib.Variant | null
    ): boolean
    /**
     * Exports `action_group` on `connection` at `object_path`.
     *
     * The implemented D-Bus API should be considered private.  It is
     * subject to change in the future.
     *
     * A given object path can only have one action group exported on it.
     * If this constraint is violated, the export will fail and 0 will be
     * returned (with `error` set accordingly).
     *
     * You can unexport the action group using
     * g_dbus_connection_unexport_action_group() with the return value of
     * this function.
     *
     * The thread default main context is taken at the time of this call.
     * All incoming action activations and state change requests are
     * reported from this context.  Any changes on the action group that
     * cause it to emit signals must also come from this same context.
     * Since incoming action activations and state change requests are
     * rather likely to cause changes on the action group, this effectively
     * limits a given action group to being exported from only one main
     * context.
     * @param objectPath a D-Bus object path
     * @param actionGroup a #GActionGroup
     * @returns the ID of the export (never zero), or 0 in case of failure
     */
    exportActionGroup(objectPath: string, actionGroup: ActionGroup): number
    /**
     * Exports `menu` on `connection` at `object_path`.
     *
     * The implemented D-Bus API should be considered private.
     * It is subject to change in the future.
     *
     * An object path can only have one menu model exported on it. If this
     * constraint is violated, the export will fail and 0 will be
     * returned (with `error` set accordingly).
     *
     * Exporting menus with sections containing more than
     * %G_MENU_EXPORTER_MAX_SECTION_SIZE items is not supported and results in
     * undefined behavior.
     *
     * You can unexport the menu model using
     * g_dbus_connection_unexport_menu_model() with the return value of
     * this function.
     * @param objectPath a D-Bus object path
     * @param menu a #GMenuModel
     * @returns the ID of the export (never zero), or 0 in case of failure
     */
    exportMenuModel(objectPath: string, menu: MenuModel): number
    /**
     * Asynchronously flushes `connection,` that is, writes all queued
     * outgoing message to the transport and then flushes the transport
     * (using g_output_stream_flush_async()). This is useful in programs
     * that wants to emit a D-Bus signal and then exit immediately. Without
     * flushing the connection, there is no guaranteed that the message has
     * been sent to the networking buffers in the OS kernel.
     *
     * This is an asynchronous method. When the operation is finished,
     * `callback` will be invoked in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread you are calling this method from. You can
     * then call g_dbus_connection_flush_finish() to get the result of the
     * operation. See g_dbus_connection_flush_sync() for the synchronous
     * version.
     * @param cancellable a #GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback to call when the     request is satisfied or %NULL if you don't care about the result
     */
    flush(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an operation started with g_dbus_connection_flush().
     * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed     to g_dbus_connection_flush()
     * @returns %TRUE if the operation succeeded, %FALSE if @error is set
     */
    flushFinish(res: AsyncResult): boolean
    /**
     * Synchronously flushes `connection`. The calling thread is blocked
     * until this is done. See g_dbus_connection_flush() for the
     * asynchronous version of this method and more details about what it
     * does.
     * @param cancellable a #GCancellable or %NULL
     * @returns %TRUE if the operation succeeded, %FALSE if @error is set
     */
    flushSync(cancellable: Cancellable | null): boolean
    /**
     * Gets the capabilities negotiated with the remote peer
     * @returns zero or more flags from the #GDBusCapabilityFlags enumeration
     */
    getCapabilities(): DBusCapabilityFlags
    /**
     * Gets whether the process is terminated when `connection` is
     * closed by the remote peer. See
     * #GDBusConnection:exit-on-close for more details.
     * @returns whether the process is terminated when @connection is     closed by the remote peer
     */
    getExitOnClose(): boolean
    /**
     * Gets the flags used to construct this connection
     * @returns zero or more flags from the #GDBusConnectionFlags enumeration
     */
    getFlags(): DBusConnectionFlags
    /**
     * The GUID of the peer performing the role of server when
     * authenticating. See #GDBusConnection:guid for more details.
     * @returns The GUID. Do not free this string, it is owned by     @connection.
     */
    getGuid(): string
    /**
     * Retrieves the last serial number assigned to a #GDBusMessage on
     * the current thread. This includes messages sent via both low-level
     * API such as g_dbus_connection_send_message() as well as
     * high-level API such as g_dbus_connection_emit_signal(),
     * g_dbus_connection_call() or g_dbus_proxy_call().
     * @returns the last used serial or zero when no message has been sent     within the current thread
     */
    getLastSerial(): number
    /**
     * Gets the credentials of the authenticated peer. This will always
     * return %NULL unless `connection` acted as a server
     * (e.g. %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER was passed)
     * when set up and the client passed credentials as part of the
     * authentication process.
     *
     * In a message bus setup, the message bus is always the server and
     * each application is a client. So this method will always return
     * %NULL for message bus clients.
     * @returns a #GCredentials or %NULL if not     available. Do not free this object, it is owned by @connection.
     */
    getPeerCredentials(): Credentials | null
    /**
     * Gets the underlying stream used for IO.
     *
     * While the #GDBusConnection is active, it will interact with this
     * stream from a worker thread, so it is not safe to interact with
     * the stream directly.
     * @returns the stream used for IO
     */
    getStream(): IOStream
    /**
     * Gets the unique name of `connection` as assigned by the message
     * bus. This can also be used to figure out if `connection` is a
     * message bus connection.
     * @returns the unique name or %NULL if @connection is not a message     bus connection. Do not free this string, it is owned by     @connection.
     */
    getUniqueName(): string | null
    /**
     * Gets whether `connection` is closed.
     * @returns %TRUE if the connection is closed, %FALSE otherwise
     */
    isClosed(): boolean
    /**
     * Version of g_dbus_connection_register_object() using closures instead of a
     * #GDBusInterfaceVTable for easier binding in other languages.
     * @param objectPath The object path to register at.
     * @param interfaceInfo Introspection data for the interface.
     * @param methodCallClosure #GClosure for handling incoming method calls.
     * @param getPropertyClosure #GClosure for getting a property.
     * @param setPropertyClosure #GClosure for setting a property.
     * @returns 0 if @error is set, otherwise a registration ID (never 0) that can be used with g_dbus_connection_unregister_object() .
     */
    registerObject(
      objectPath: string,
      interfaceInfo: DBusInterfaceInfo,
      methodCallClosure: GObject.TClosure | null,
      getPropertyClosure: GObject.TClosure | null,
      setPropertyClosure: GObject.TClosure | null
    ): number
    /**
     * Registers a whole subtree of dynamic objects.
     *
     * The `enumerate` and `introspection` functions in `vtable` are used to
     * convey, to remote callers, what nodes exist in the subtree rooted
     * by `object_path`.
     *
     * When handling remote calls into any node in the subtree, first the
     * `enumerate` function is used to check if the node exists. If the node exists
     * or the %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set
     * the `introspection` function is used to check if the node supports the
     * requested method. If so, the `dispatch` function is used to determine
     * where to dispatch the call. The collected #GDBusInterfaceVTable and
     * #gpointer will be used to call into the interface vtable for processing
     * the request.
     *
     * All calls into user-provided code will be invoked in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread you are calling this method from.
     *
     * If an existing subtree is already registered at `object_path` or
     * then `error` is set to %G_IO_ERROR_EXISTS.
     *
     * Note that it is valid to register regular objects (using
     * g_dbus_connection_register_object()) in a subtree registered with
     * g_dbus_connection_register_subtree() - if so, the subtree handler
     * is tried as the last resort. One way to think about a subtree
     * handler is to consider it a fallback handler for object paths not
     * registered via g_dbus_connection_register_object() or other bindings.
     *
     * Note that `vtable` will be copied so you cannot change it after
     * registration.
     *
     * See this [server][gdbus-subtree-server] for an example of how to use
     * this method.
     * @param objectPath the object path to register the subtree at
     * @param vtable a #GDBusSubtreeVTable to enumerate, introspect and     dispatch nodes in the subtree
     * @param flags flags used to fine tune the behavior of the subtree
     * @param userData data to pass to functions in `vtable`
     * @param userDataFreeFunc function to call when the subtree is unregistered
     * @returns 0 if @error is set, otherwise a subtree registration ID (never 0) that can be used with g_dbus_connection_unregister_subtree()
     */
    registerSubtree(
      objectPath: string,
      vtable: DBusSubtreeVTable,
      flags: DBusSubtreeFlags,
      userData: any | null,
      userDataFreeFunc: GLib.DestroyNotify
    ): number
    /**
     * Removes a filter.
     *
     * Note that since filters run in a different thread, there is a race
     * condition where it is possible that the filter will be running even
     * after calling g_dbus_connection_remove_filter(), so you cannot just
     * free data that the filter might be using. Instead, you should pass
     * a #GDestroyNotify to g_dbus_connection_add_filter(), which will be
     * called when it is guaranteed that the data is no longer needed.
     * @param filterId an identifier obtained from g_dbus_connection_add_filter()
     */
    removeFilter(filterId: number): void
    /**
     * Asynchronously sends `message` to the peer represented by `connection`.
     *
     * Unless `flags` contain the
     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
     * will be assigned by `connection` and set on `message` via
     * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
     * serial number used will be written to this location prior to
     * submitting the message to the underlying transport. While it has a `volatile`
     * qualifier, this is a historical artifact and the argument passed to it should
     * not be `volatile`.
     *
     * If `connection` is closed then the operation will fail with
     * %G_IO_ERROR_CLOSED. If `message` is not well-formed,
     * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
     *
     * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
     * for an example of how to use this low-level API to send and receive
     * UNIX file descriptors.
     *
     * Note that `message` must be unlocked, unless `flags` contain the
     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
     * @param message a #GDBusMessage
     * @param flags flags affecting how the message is sent
     * @returns %TRUE if the message was well-formed and queued for     transmission, %FALSE if @error is set
     */
    sendMessage(
      message: DBusMessage,
      flags: DBusSendMessageFlags
    ): [/* returnType */ boolean, /* outSerial */ number]
    /**
     * Asynchronously sends `message` to the peer represented by `connection`.
     *
     * Unless `flags` contain the
     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
     * will be assigned by `connection` and set on `message` via
     * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
     * serial number used will be written to this location prior to
     * submitting the message to the underlying transport. While it has a `volatile`
     * qualifier, this is a historical artifact and the argument passed to it should
     * not be `volatile`.
     *
     * If `connection` is closed then the operation will fail with
     * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
     * fail with %G_IO_ERROR_CANCELLED. If `message` is not well-formed,
     * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
     *
     * This is an asynchronous method. When the operation is finished, `callback`
     * will be invoked in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread you are calling this method from. You can then call
     * g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
     * See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
     *
     * Note that `message` must be unlocked, unless `flags` contain the
     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
     *
     * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
     * for an example of how to use this low-level API to send and receive
     * UNIX file descriptors.
     * @param message a #GDBusMessage
     * @param flags flags affecting how the message is sent
     * @param timeoutMsec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
     * @param cancellable a #GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result
     */
    sendMessageWithReply(
      message: DBusMessage,
      flags: DBusSendMessageFlags,
      timeoutMsec: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): /* outSerial */ number
    /**
     * Finishes an operation started with g_dbus_connection_send_message_with_reply().
     *
     * Note that `error` is only set if a local in-process error
     * occurred. That is to say that the returned #GDBusMessage object may
     * be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
     * g_dbus_message_to_gerror() to transcode this to a #GError.
     *
     * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
     * for an example of how to use this low-level API to send and receive
     * UNIX file descriptors.
     * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed to     g_dbus_connection_send_message_with_reply()
     * @returns a locked #GDBusMessage or %NULL if @error is set
     */
    sendMessageWithReplyFinish(res: AsyncResult): DBusMessage
    /**
     * Synchronously sends `message` to the peer represented by `connection`
     * and blocks the calling thread until a reply is received or the
     * timeout is reached. See g_dbus_connection_send_message_with_reply()
     * for the asynchronous version of this method.
     *
     * Unless `flags` contain the
     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
     * will be assigned by `connection` and set on `message` via
     * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
     * serial number used will be written to this location prior to
     * submitting the message to the underlying transport. While it has a `volatile`
     * qualifier, this is a historical artifact and the argument passed to it should
     * not be `volatile`.
     *
     * If `connection` is closed then the operation will fail with
     * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
     * fail with %G_IO_ERROR_CANCELLED. If `message` is not well-formed,
     * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
     *
     * Note that `error` is only set if a local in-process error
     * occurred. That is to say that the returned #GDBusMessage object may
     * be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
     * g_dbus_message_to_gerror() to transcode this to a #GError.
     *
     * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
     * for an example of how to use this low-level API to send and receive
     * UNIX file descriptors.
     *
     * Note that `message` must be unlocked, unless `flags` contain the
     * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
     * @param message a #GDBusMessage
     * @param flags flags affecting how the message is sent.
     * @param timeoutMsec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
     * @param cancellable a #GCancellable or %NULL
     * @returns a locked #GDBusMessage that is the reply     to @message or %NULL if @error is set
     */
    sendMessageWithReplySync(
      message: DBusMessage,
      flags: DBusSendMessageFlags,
      timeoutMsec: number,
      cancellable: Cancellable | null
    ): [/* returnType */ DBusMessage, /* outSerial */ number]
    /**
     * Sets whether the process should be terminated when `connection` is
     * closed by the remote peer. See #GDBusConnection:exit-on-close for
     * more details.
     *
     * Note that this function should be used with care. Most modern UNIX
     * desktops tie the notion of a user session with the session bus, and expect
     * all of a user's applications to quit when their bus connection goes away.
     * If you are setting `exit_on_close` to %FALSE for the shared session
     * bus connection, you should make sure that your application exits
     * when the user session ends.
     * @param exitOnClose whether the process should be terminated     when `connection` is closed by the remote peer
     */
    setExitOnClose(exitOnClose: boolean): void
    /**
     * Subscribes to signals on `connection` and invokes `callback` whenever
     * the signal is received. Note that `callback` will be invoked in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread you are calling this method from.
     *
     * If `connection` is not a message bus connection, `sender` must be
     * %NULL.
     *
     * If `sender` is a well-known name note that `callback` is invoked with
     * the unique name for the owner of `sender,` not the well-known name
     * as one would expect. This is because the message bus rewrites the
     * name. As such, to avoid certain race conditions, users should be
     * tracking the name owner of the well-known name and use that when
     * processing the received signal.
     *
     * If one of %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE or
     * %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH are given, `arg0` is
     * interpreted as part of a namespace or path.  The first argument
     * of a signal is matched against that part as specified by D-Bus.
     *
     * If `user_data_free_func` is non-%NULL, it will be called (in the
     * thread-default main context of the thread you are calling this
     * method from) at some point after `user_data` is no longer
     * needed. (It is not guaranteed to be called synchronously when the
     * signal is unsubscribed from, and may be called after `connection`
     * has been destroyed.)
     *
     * As `callback` is potentially invoked in a different thread from where it’s
     * emitted, it’s possible for this to happen after
     * g_dbus_connection_signal_unsubscribe() has been called in another thread.
     * Due to this, `user_data` should have a strong reference which is freed with
     * `user_data_free_func,` rather than pointing to data whose lifecycle is tied
     * to the signal subscription. For example, if a #GObject is used to store the
     * subscription ID from g_dbus_connection_signal_subscribe(), a strong reference
     * to that #GObject must be passed to `user_data,` and g_object_unref() passed to
     * `user_data_free_func`. You are responsible for breaking the resulting
     * reference count cycle by explicitly unsubscribing from the signal when
     * dropping the last external reference to the #GObject. Alternatively, a weak
     * reference may be used.
     *
     * It is guaranteed that if you unsubscribe from a signal using
     * g_dbus_connection_signal_unsubscribe() from the same thread which made the
     * corresponding g_dbus_connection_signal_subscribe() call, `callback` will not
     * be invoked after g_dbus_connection_signal_unsubscribe() returns.
     *
     * The returned subscription identifier is an opaque value which is guaranteed
     * to never be zero.
     *
     * This function can never fail.
     * @param sender sender name to match on (unique or well-known name)     or %NULL to listen from all senders
     * @param interfaceName D-Bus interface name to match on or %NULL to     match on all interfaces
     * @param member D-Bus signal name to match on or %NULL to match on     all signals
     * @param objectPath object path to match on or %NULL to match on     all object paths
     * @param arg0 contents of first string argument to match on or %NULL     to match on all kinds of arguments
     * @param flags #GDBusSignalFlags describing how arg0 is used in subscribing to the     signal
     * @param callback callback to invoke when there is a signal matching the requested data
     * @returns a subscription identifier that can be used with g_dbus_connection_signal_unsubscribe()
     */
    signalSubscribe(
      sender: string | null,
      interfaceName: string | null,
      member: string | null,
      objectPath: string | null,
      arg0: string | null,
      flags: DBusSignalFlags,
      callback: DBusSignalCallback
    ): number
    /**
     * Unsubscribes from signals.
     *
     * Note that there may still be D-Bus traffic to process (relating to this
     * signal subscription) in the current thread-default #GMainContext after this
     * function has returned. You should continue to iterate the #GMainContext
     * until the #GDestroyNotify function passed to
     * g_dbus_connection_signal_subscribe() is called, in order to avoid memory
     * leaks through callbacks queued on the #GMainContext after it’s stopped being
     * iterated.
     * Alternatively, any idle source with a priority lower than %G_PRIORITY_DEFAULT
     * that was scheduled after unsubscription, also indicates that all resources
     * of this subscription are released.
     * @param subscriptionId a subscription id obtained from     g_dbus_connection_signal_subscribe()
     */
    signalUnsubscribe(subscriptionId: number): void
    /**
     * If `connection` was created with
     * %G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method
     * starts processing messages. Does nothing on if `connection` wasn't
     * created with this flag or if the method has already been called.
     */
    startMessageProcessing(): void
    /**
     * Reverses the effect of a previous call to
     * g_dbus_connection_export_action_group().
     *
     * It is an error to call this function with an ID that wasn't returned
     * from g_dbus_connection_export_action_group() or to call it with the
     * same ID more than once.
     * @param exportId the ID from g_dbus_connection_export_action_group()
     */
    unexportActionGroup(exportId: number): void
    /**
     * Reverses the effect of a previous call to
     * g_dbus_connection_export_menu_model().
     *
     * It is an error to call this function with an ID that wasn't returned
     * from g_dbus_connection_export_menu_model() or to call it with the
     * same ID more than once.
     * @param exportId the ID from g_dbus_connection_export_menu_model()
     */
    unexportMenuModel(exportId: number): void
    /**
     * Unregisters an object.
     * @param registrationId a registration id obtained from     g_dbus_connection_register_object()
     * @returns %TRUE if the object was unregistered, %FALSE otherwise
     */
    unregisterObject(registrationId: number): boolean
    /**
     * Unregisters a subtree.
     * @param registrationId a subtree registration id obtained from     g_dbus_connection_register_subtree()
     * @returns %TRUE if the subtree was unregistered, %FALSE otherwise
     */
    unregisterSubtree(registrationId: number): boolean

    // Own signals of Gio-2.0.Gio.DBusConnection

    connect(
      sigName: "closed",
      callback: DBusConnection.ClosedSignalCallback
    ): number
    on(
      sigName: "closed",
      callback: DBusConnection.ClosedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "closed",
      callback: DBusConnection.ClosedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "closed",
      callback: DBusConnection.ClosedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "closed", error: GLib.Error | null, ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.DBusConnection

    connect(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::address", ...args: any[]): void
    connect(
      sigName: "notify::authentication-observer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::authentication-observer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::authentication-observer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::authentication-observer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::authentication-observer", ...args: any[]): void
    connect(
      sigName: "notify::capabilities",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::capabilities",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::capabilities",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::capabilities",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::capabilities", ...args: any[]): void
    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(
      sigName: "notify::exit-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exit-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exit-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exit-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exit-on-close", ...args: any[]): void
    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(sigName: "notify::guid", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::guid",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::guid",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::guid",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::guid", ...args: any[]): void
    connect(
      sigName: "notify::stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stream", ...args: any[]): void
    connect(
      sigName: "notify::unique-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::unique-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::unique-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::unique-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::unique-name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GDBusConnection` type is used for D-Bus connections to remote
   * peers such as a message buses.
   *
   * It is a low-level API that offers a lot of flexibility. For instance,
   * it lets you establish a connection over any transport that can by represented
   * as a [class`Gio`.IOStream].
   *
   * This class is rarely used directly in D-Bus clients. If you are writing
   * a D-Bus client, it is often easier to use the [func`Gio`.bus_own_name],
   * [func`Gio`.bus_watch_name] or [func`Gio`.DBusProxy.new_for_bus] APIs.
   *
   * As an exception to the usual GLib rule that a particular object must not
   * be used by two threads at the same time, `GDBusConnection`s methods may be
   * called from any thread. This is so that [func`Gio`.bus_get] and
   * [func`Gio`.bus_get_sync] can safely return the same `GDBusConnection` when
   * called from any thread.
   *
   * Most of the ways to obtain a `GDBusConnection` automatically initialize it
   * (i.e. connect to D-Bus): for instance, [func`Gio`.DBusConnection.new] and
   * [func`Gio`.bus_get], and the synchronous versions of those methods, give you
   * an initialized connection. Language bindings for GIO should use
   * [func`Gio`.Initable.new] or [func`Gio`.AsyncInitable.new_async], which also
   * initialize the connection.
   *
   * If you construct an uninitialized `GDBusConnection`, such as via
   * [ctor`GObject`.Object.new], you must initialize it via [method`Gio`.Initable.init] or
   * [method`Gio`.AsyncInitable.init_async] before using its methods or properties.
   * Calling methods or accessing properties on a `GDBusConnection` that has not
   * completed initialization successfully is considered to be invalid, and leads
   * to undefined behaviour. In particular, if initialization fails with a
   * `GError`, the only valid thing you can do with that `GDBusConnection` is to
   * free it with [method`GObject`.Object.unref].
   *
   * ## An example D-Bus server
   *
   * Here is an example for a D-Bus server:
   * [gdbus-example-server.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-server.c)
   *
   * ## An example for exporting a subtree
   *
   * Here is an example for exporting a subtree:
   * [gdbus-example-subtree.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-subtree.c)
   *
   * ## An example for file descriptor passing
   *
   * Here is an example for passing UNIX file descriptors:
   * [gdbus-unix-fd-client.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-unix-fd-client.c)
   *
   * ## An example for exporting a GObject
   *
   * Here is an example for exporting a #GObject:
   * [gdbus-example-export.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-export.c)
   * @class
   */
  class DBusConnection extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusConnection

    static name: string

    // Constructors of Gio-2.0.Gio.DBusConnection

    constructor(config?: DBusConnection.ConstructorProperties)
    /**
     * Finishes an operation started with g_dbus_connection_new().
     * @constructor
     * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback     passed to g_dbus_connection_new().
     * @returns a #GDBusConnection or %NULL if @error is set. Free     with g_object_unref().
     */
    static newFinish(res: AsyncResult): DBusConnection
    /**
     * Finishes an operation started with g_dbus_connection_new_for_address().
     * @constructor
     * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed     to g_dbus_connection_new()
     * @returns a #GDBusConnection or %NULL if @error is set.     Free with g_object_unref().
     */
    static newForAddressFinish(res: AsyncResult): DBusConnection
    /**
     * Synchronously connects and sets up a D-Bus client connection for
     * exchanging D-Bus messages with an endpoint specified by `address`
     * which must be in the
     * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
     *
     * This constructor can only be used to initiate client-side
     * connections - use g_dbus_connection_new_sync() if you need to act
     * as the server. In particular, `flags` cannot contain the
     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER,
     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS or
     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER flags.
     *
     * This is a synchronous failable constructor. See
     * g_dbus_connection_new_for_address() for the asynchronous version.
     *
     * If `observer` is not %NULL it may be used to control the
     * authentication process.
     * @constructor
     * @param address a D-Bus address
     * @param flags flags describing how to make the connection
     * @param observer a #GDBusAuthObserver or %NULL
     * @param cancellable a #GCancellable or %NULL
     * @returns a #GDBusConnection or %NULL if @error is set.     Free with g_object_unref().
     */
    static newForAddressSync(
      address: string,
      flags: DBusConnectionFlags,
      observer: DBusAuthObserver | null,
      cancellable: Cancellable | null
    ): DBusConnection
    /**
     * Synchronously sets up a D-Bus connection for exchanging D-Bus messages
     * with the end represented by `stream`.
     *
     * If `stream` is a #GSocketConnection, then the corresponding #GSocket
     * will be put into non-blocking mode.
     *
     * The D-Bus connection will interact with `stream` from a worker thread.
     * As a result, the caller should not interact with `stream` after this
     * method has been called, except by calling g_object_unref() on it.
     *
     * If `observer` is not %NULL it may be used to control the
     * authentication process.
     *
     * This is a synchronous failable constructor. See
     * g_dbus_connection_new() for the asynchronous version.
     * @constructor
     * @param stream a #GIOStream
     * @param guid the GUID to use if authenticating as a server or %NULL
     * @param flags flags describing how to make the connection
     * @param observer a #GDBusAuthObserver or %NULL
     * @param cancellable a #GCancellable or %NULL
     * @returns a #GDBusConnection or %NULL if @error is set.     Free with g_object_unref().
     */
    static newSync(
      stream: IOStream,
      guid: string | null,
      flags: DBusConnectionFlags,
      observer: DBusAuthObserver | null,
      cancellable: Cancellable | null
    ): DBusConnection
    _init(config?: DBusConnection.ConstructorProperties): void
    /**
     * Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
     * with the end represented by `stream`.
     *
     * If `stream` is a #GSocketConnection, then the corresponding #GSocket
     * will be put into non-blocking mode.
     *
     * The D-Bus connection will interact with `stream` from a worker thread.
     * As a result, the caller should not interact with `stream` after this
     * method has been called, except by calling g_object_unref() on it.
     *
     * If `observer` is not %NULL it may be used to control the
     * authentication process.
     *
     * When the operation is finished, `callback` will be invoked. You can
     * then call g_dbus_connection_new_finish() to get the result of the
     * operation.
     *
     * This is an asynchronous failable constructor. See
     * g_dbus_connection_new_sync() for the synchronous
     * version.
     * @param stream a #GIOStream
     * @param guid the GUID to use if authenticating as a server or %NULL
     * @param flags flags describing how to make the connection
     * @param observer a #GDBusAuthObserver or %NULL
     * @param cancellable a #GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback to call when the request is satisfied
     */
    static new(
      stream: IOStream,
      guid: string | null,
      flags: DBusConnectionFlags,
      observer: DBusAuthObserver | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Asynchronously connects and sets up a D-Bus client connection for
     * exchanging D-Bus messages with an endpoint specified by `address`
     * which must be in the
     * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
     *
     * This constructor can only be used to initiate client-side
     * connections - use g_dbus_connection_new() if you need to act as the
     * server. In particular, `flags` cannot contain the
     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER,
     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS or
     * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER flags.
     *
     * When the operation is finished, `callback` will be invoked. You can
     * then call g_dbus_connection_new_for_address_finish() to get the result of
     * the operation.
     *
     * If `observer` is not %NULL it may be used to control the
     * authentication process.
     *
     * This is an asynchronous failable constructor. See
     * g_dbus_connection_new_for_address_sync() for the synchronous
     * version.
     * @param address a D-Bus address
     * @param flags flags describing how to make the connection
     * @param observer a #GDBusAuthObserver or %NULL
     * @param cancellable a #GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback to call when the request is satisfied
     */
    static newForAddress(
      address: string,
      flags: DBusConnectionFlags,
      observer: DBusAuthObserver | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
  }

  module DBusInterfaceSkeleton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `g-authorize-method`
     */
    interface GAuthorizeMethodSignalCallback {
      (invocation: DBusMethodInvocation): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends DBusInterface.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DBusInterfaceSkeleton

      /**
       * Flags from the #GDBusInterfaceSkeletonFlags enumeration.
       */
      g_flags?: DBusInterfaceSkeletonFlags | null
    }
  }

  interface DBusInterfaceSkeleton extends DBusInterface {
    // Own properties of Gio-2.0.Gio.DBusInterfaceSkeleton

    /**
     * Flags from the #GDBusInterfaceSkeletonFlags enumeration.
     */
    gFlags: DBusInterfaceSkeletonFlags
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusInterfaceSkeleton

    /**
     * Exports `interface_` at `object_path` on `connection`.
     *
     * This can be called multiple times to export the same `interface_`
     * onto multiple connections however the `object_path` provided must be
     * the same for all connections.
     *
     * Use g_dbus_interface_skeleton_unexport() to unexport the object.
     * @param connection A #GDBusConnection to export `interface_` on.
     * @param objectPath The path to export the interface at.
     * @returns %TRUE if the interface was exported on @connection, otherwise %FALSE with @error set.
     */
    export(connection: DBusConnection, objectPath: string): boolean
    // Has conflict: flush(): void
    /**
     * Gets the first connection that `interface_` is exported on, if any.
     * @returns A #GDBusConnection or %NULL if @interface_ is not exported anywhere. Do not free, the object belongs to @interface_.
     */
    getConnection(): DBusConnection | null
    /**
     * Gets a list of the connections that `interface_` is exported on.
     * @returns A list of   all the connections that @interface_ is exported on. The returned   list should be freed with g_list_free() after each element has   been freed with g_object_unref().
     */
    getConnections(): DBusConnection[]
    /**
     * Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior
     * of `interface_`
     * @returns One or more flags from the #GDBusInterfaceSkeletonFlags enumeration.
     */
    getFlags(): DBusInterfaceSkeletonFlags
    // Has conflict: getInfo(): DBusInterfaceInfo
    /**
     * Gets the object path that `interface_` is exported on, if any.
     * @returns A string owned by @interface_ or %NULL if @interface_ is not exported anywhere. Do not free, the string belongs to @interface_.
     */
    getObjectPath(): string | null
    // Has conflict: getProperties(): GLib.Variant
    // Has conflict: getVtable(): DBusInterfaceVTable
    /**
     * Checks if `interface_` is exported on `connection`.
     * @param connection A #GDBusConnection.
     * @returns %TRUE if @interface_ is exported on @connection, %FALSE otherwise.
     */
    hasConnection(connection: DBusConnection): boolean
    /**
     * Sets flags describing what the behavior of `skeleton` should be.
     * @param flags Flags from the #GDBusInterfaceSkeletonFlags enumeration.
     */
    setFlags(flags: DBusInterfaceSkeletonFlags): void
    /**
     * Stops exporting `interface_` on all connections it is exported on.
     *
     * To unexport `interface_` from only a single connection, use
     * g_dbus_interface_skeleton_unexport_from_connection()
     */
    unexport(): void
    /**
     * Stops exporting `interface_` on `connection`.
     *
     * To stop exporting on all connections the interface is exported on,
     * use g_dbus_interface_skeleton_unexport().
     * @param connection A #GDBusConnection.
     */
    unexportFromConnection(connection: DBusConnection): void

    // Own virtual methods of Gio-2.0.Gio.DBusInterfaceSkeleton

    /**
     * If `interface_` has outstanding changes, request for these changes to be
     * emitted immediately.
     *
     * For example, an exported D-Bus interface may queue up property
     * changes and emit the
     * `org.freedesktop.DBus.Properties.PropertiesChanged`
     * signal later (e.g. in an idle handler). This technique is useful
     * for collapsing multiple property changes into one.
     * @virtual
     */
    flush(): void
    /**
     * Signal class handler for the #GDBusInterfaceSkeleton::g-authorize-method signal.
     * @virtual
     * @param invocation
     */
    gAuthorizeMethod(invocation: DBusMethodInvocation): boolean
    /**
     * Gets D-Bus introspection information for the D-Bus interface
     * implemented by `interface_`.
     * @virtual
     * @returns A #GDBusInterfaceInfo (never %NULL). Do not free.
     */
    getInfo(): DBusInterfaceInfo

    // Overloads of getInfo

    /**
     * Gets D-Bus introspection information for the D-Bus interface
     * implemented by `interface_`.
     * @virtual
     * @returns A #GDBusInterfaceInfo. Do not free.
     */
    getInfo(): DBusInterfaceInfo
    /**
     * Gets all D-Bus properties for `interface_`.
     * @virtual
     * @returns A #GVariant of type ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS]. Free with g_variant_unref().
     */
    getProperties(): GLib.Variant
    /**
     * Gets the interface vtable for the D-Bus interface implemented by
     * `interface_`. The returned function pointers should expect `interface_`
     * itself to be passed as `user_data`.
     * @virtual
     * @returns the vtable of the D-Bus interface implemented by the skeleton
     */
    getVtable(): DBusInterfaceVTable

    // Own signals of Gio-2.0.Gio.DBusInterfaceSkeleton

    connect(
      sigName: "g-authorize-method",
      callback: DBusInterfaceSkeleton.GAuthorizeMethodSignalCallback
    ): number
    on(
      sigName: "g-authorize-method",
      callback: DBusInterfaceSkeleton.GAuthorizeMethodSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "g-authorize-method",
      callback: DBusInterfaceSkeleton.GAuthorizeMethodSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "g-authorize-method",
      callback: DBusInterfaceSkeleton.GAuthorizeMethodSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "g-authorize-method", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.DBusInterfaceSkeleton

    connect(
      sigName: "notify::g-flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-flags", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Abstract base class for D-Bus interfaces on the service side.
   * @class
   */
  class DBusInterfaceSkeleton extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusInterfaceSkeleton

    static name: string

    // Constructors of Gio-2.0.Gio.DBusInterfaceSkeleton

    constructor(config?: DBusInterfaceSkeleton.ConstructorProperties)
    _init(config?: DBusInterfaceSkeleton.ConstructorProperties): void
  }

  module DBusMenuModel {
    // Constructor properties interface

    interface ConstructorProperties extends MenuModel.ConstructorProperties {}
  }

  interface DBusMenuModel {
    // Own properties of Gio-2.0.Gio.DBusMenuModel

    __gtype__: number

    // Class property signals of Gio-2.0.Gio.DBusMenuModel

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDBusMenuModel` is an implementation of [class`Gio`.MenuModel] that can be
   * used as a proxy for a menu model that is exported over D-Bus with
   * [method`Gio`.DBusConnection.export_menu_model].
   * @class
   */
  class DBusMenuModel extends MenuModel {
    // Own properties of Gio-2.0.Gio.DBusMenuModel

    static name: string

    // Constructors of Gio-2.0.Gio.DBusMenuModel

    constructor(config?: DBusMenuModel.ConstructorProperties)
    _init(config?: DBusMenuModel.ConstructorProperties): void
    /**
     * Obtains a #GDBusMenuModel for the menu model which is exported
     * at the given `bus_name` and `object_path`.
     *
     * The thread default main context is taken at the time of this call.
     * All signals on the menu model (and any linked models) are reported
     * with respect to this context.  All calls on the returned menu model
     * (and linked models) must also originate from this same context, with
     * the thread default main context unchanged.
     * @param connection a #GDBusConnection
     * @param busName the bus name which exports the menu model     or %NULL if `connection` is not a message bus connection
     * @param objectPath the object path at which the menu model is exported
     * @returns a #GDBusMenuModel object. Free with     g_object_unref().
     */
    static get(
      connection: DBusConnection,
      busName: string | null,
      objectPath: string
    ): DBusMenuModel
  }

  module DBusMessage {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface DBusMessage {
    // Own properties of Gio-2.0.Gio.DBusMessage

    readonly locked: boolean
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusMessage

    /**
     * Copies `message`. The copy is a deep copy and the returned
     * #GDBusMessage is completely identical except that it is guaranteed
     * to not be locked.
     *
     * This operation can fail if e.g. `message` contains file descriptors
     * and the per-process or system-wide open files limit is reached.
     * @returns A new #GDBusMessage or %NULL if @error is set.     Free with g_object_unref().
     */
    copy(): DBusMessage
    /**
     * Convenience to get the first item in the body of `message`.
     *
     * See [method`Gio`.DBusMessage.get_arg0_path] for returning object-path-typed
     * arg0 values.
     * @returns The string item or %NULL if the first item in the body of @message is not a string.
     */
    getArg0(): string | null
    /**
     * Convenience to get the first item in the body of `message`.
     *
     * See [method`Gio`.DBusMessage.get_arg0] for returning string-typed arg0 values.
     * @returns The object path item or `NULL` if the first item in the   body of @message is not an object path.
     */
    getArg0Path(): string | null
    /**
     * Gets the body of a message.
     * @returns A #GVariant or %NULL if the body is empty. Do not free, it is owned by @message.
     */
    getBody(): GLib.Variant | null
    /**
     * Gets the byte order of `message`.
     * @returns The byte order.
     */
    getByteOrder(): DBusMessageByteOrder
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
     * @returns The value.
     */
    getDestination(): string | null
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
     * @returns The value.
     */
    getErrorName(): string | null
    /**
     * Gets the flags for `message`.
     * @returns Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
     */
    getFlags(): DBusMessageFlags
    /**
     * Gets a header field on `message`.
     *
     * The caller is responsible for checking the type of the returned #GVariant
     * matches what is expected.
     * @param headerField A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
     * @returns A #GVariant with the value if the header was found, %NULL otherwise. Do not free, it is owned by @message.
     */
    getHeader(headerField: DBusMessageHeaderField): GLib.Variant | null
    /**
     * Gets an array of all header fields on `message` that are set.
     * @returns An array of header fields terminated by %G_DBUS_MESSAGE_HEADER_FIELD_INVALID.  Each element is a #guchar. Free with g_free().
     */
    getHeaderFields(): number[]
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
     * @returns The value.
     */
    getInterface(): string | null
    /**
     * Checks whether `message` is locked. To monitor changes to this
     * value, conncet to the #GObject::notify signal to listen for changes
     * on the #GDBusMessage:locked property.
     * @returns %TRUE if @message is locked, %FALSE otherwise.
     */
    getLocked(): boolean
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
     * @returns The value.
     */
    getMember(): string | null
    /**
     * Gets the type of `message`.
     * @returns A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
     */
    getMessageType(): DBusMessageType
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
     * @returns The value.
     */
    getNumUnixFds(): number
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
     * @returns The value.
     */
    getPath(): string | null
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
     * @returns The value.
     */
    getReplySerial(): number
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
     * @returns The value.
     */
    getSender(): string | null
    /**
     * Gets the serial for `message`.
     * @returns A #guint32.
     */
    getSerial(): number
    /**
     * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
     *
     * This will always be non-%NULL, but may be an empty string.
     * @returns The value.
     */
    getSignature(): string
    /**
     * Gets the UNIX file descriptors associated with `message,` if any.
     *
     * This method is only available on UNIX.
     *
     * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
     * values in the body of the message. For example,
     * if g_variant_get_handle() returns 5, that is intended to be a reference
     * to the file descriptor that can be accessed by
     * `g_unix_fd_list_get (list, 5, ...)`.
     * @returns A #GUnixFDList or %NULL if no file descriptors are associated. Do not free, this object is owned by @message.
     */
    getUnixFdList(): UnixFDList | null
    /**
     * If `message` is locked, does nothing. Otherwise locks the message.
     */
    lock(): void
    /**
     * Creates a new #GDBusMessage that is an error reply to `method_call_message`.
     * @param errorName A valid D-Bus error name.
     * @param errorMessage The D-Bus error message.
     * @returns A #GDBusMessage. Free with g_object_unref().
     */
    newMethodErrorLiteral(errorName: string, errorMessage: string): DBusMessage
    /**
     * Creates a new #GDBusMessage that is a reply to `method_call_message`.
     * @returns #GDBusMessage. Free with g_object_unref().
     */
    newMethodReply(): DBusMessage
    /**
     * Produces a human-readable multi-line description of `message`.
     *
     * The contents of the description has no ABI guarantees, the contents
     * and formatting is subject to change at any time. Typical output
     * looks something like this:
     * ```
     * Flags:   none
     * Version: 0
     * Serial:  4
     * Headers:
     *   path -> objectpath '/org/gtk/GDBus/TestObject'
     *   interface -> 'org.gtk.GDBus.TestInterface'
     *   member -> 'GimmeStdout'
     *   destination -> ':1.146'
     * Body: ()
     * UNIX File Descriptors:
     *   (none)
     * ```
     * or
     * ```
     * Flags:   no-reply-expected
     * Version: 0
     * Serial:  477
     * Headers:
     *   reply-serial -> uint32 4
     *   destination -> ':1.159'
     *   sender -> ':1.146'
     *   num-unix-fds -> uint32 1
     * Body: ()
     * UNIX File Descriptors:
     *   fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
     * ```
     * @param indent Indentation level.
     * @returns A string that should be freed with [func@GLib.free].
     */
    print(indent: number): string | null
    /**
     * Sets the body `message`. As a side-effect the
     * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
     * type string of `body` (or cleared if `body` is %NULL).
     *
     * If `body` is floating, `message` assumes ownership of `body`.
     * @param body Either %NULL or a #GVariant that is a tuple.
     */
    setBody(body: GLib.Variant): void
    /**
     * Sets the byte order of `message`.
     * @param byteOrder The byte order.
     */
    setByteOrder(byteOrder: DBusMessageByteOrder): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
     * @param value The value to set.
     */
    setDestination(value: string | null): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
     * @param value The value to set.
     */
    setErrorName(value: string): void
    /**
     * Sets the flags to set on `message`.
     * @param flags Flags for `message` that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
     */
    setFlags(flags: DBusMessageFlags): void
    /**
     * Sets a header field on `message`.
     *
     * If `value` is floating, `message` assumes ownership of `value`.
     * @param headerField A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
     * @param value A #GVariant to set the header field or %NULL to clear the header field.
     */
    setHeader(
      headerField: DBusMessageHeaderField,
      value: GLib.Variant | null
    ): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
     * @param value The value to set.
     */
    setInterface(value: string | null): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
     * @param value The value to set.
     */
    setMember(value: string | null): void
    /**
     * Sets `message` to be of `type`.
     * @param type A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
     */
    setMessageType(type: DBusMessageType): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
     * @param value The value to set.
     */
    setNumUnixFds(value: number): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
     * @param value The value to set.
     */
    setPath(value: string | null): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
     * @param value The value to set.
     */
    setReplySerial(value: number): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
     * @param value The value to set.
     */
    setSender(value: string | null): void
    /**
     * Sets the serial for `message`.
     * @param serial A #guint32.
     */
    setSerial(serial: number): void
    /**
     * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
     * @param value The value to set.
     */
    setSignature(value: string | null): void
    /**
     * Sets the UNIX file descriptors associated with `message`. As a
     * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
     * field is set to the number of fds in `fd_list` (or cleared if
     * `fd_list` is %NULL).
     *
     * This method is only available on UNIX.
     *
     * When designing D-Bus APIs that are intended to be interoperable,
     * please note that non-GDBus implementations of D-Bus can usually only
     * access file descriptors if they are referenced by a value of type
     * %G_VARIANT_TYPE_HANDLE in the body of the message.
     * @param fdList A #GUnixFDList or %NULL.
     */
    setUnixFdList(fdList: UnixFDList | null): void
    /**
     * Serializes `message` to a blob. The byte order returned by
     * g_dbus_message_get_byte_order() will be used.
     * @param capabilities A #GDBusCapabilityFlags describing what protocol features are supported.
     * @returns A pointer to a valid binary D-Bus message of @out_size bytes generated by @message or %NULL if @error is set. Free with g_free().
     */
    toBlob(capabilities: DBusCapabilityFlags): number[]
    /**
     * If `message` is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
     * nothing and returns %FALSE.
     *
     * Otherwise this method encodes the error in `message` as a #GError
     * using g_dbus_error_set_dbus_error() using the information in the
     * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of `message` as
     * well as the first string item in `message'`s body.
     * @returns %TRUE if @error was set, %FALSE otherwise.
     */
    toGerror(): boolean

    // Class property signals of Gio-2.0.Gio.DBusMessage

    connect(
      sigName: "notify::locked",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::locked",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::locked",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::locked",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::locked", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A type for representing D-Bus messages that can be sent or received
   * on a [class`Gio`.DBusConnection].
   * @class
   */
  class DBusMessage extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusMessage

    static name: string

    // Constructors of Gio-2.0.Gio.DBusMessage

    constructor(config?: DBusMessage.ConstructorProperties)
    /**
     * Creates a new empty #GDBusMessage.
     * @constructor
     * @returns A #GDBusMessage. Free with g_object_unref().
     */
    constructor()
    /**
     * Creates a new empty #GDBusMessage.
     * @constructor
     * @returns A #GDBusMessage. Free with g_object_unref().
     */
    static new(): DBusMessage
    /**
     * Creates a new #GDBusMessage from the data stored at `blob`. The byte
     * order that the message was in can be retrieved using
     * g_dbus_message_get_byte_order().
     *
     * If the `blob` cannot be parsed, contains invalid fields, or contains invalid
     * headers, %G_IO_ERROR_INVALID_ARGUMENT will be returned.
     * @constructor
     * @param blob A blob representing a binary D-Bus message.
     * @param capabilities A #GDBusCapabilityFlags describing what protocol features are supported.
     * @returns A new #GDBusMessage or %NULL if @error is set. Free with g_object_unref().
     */
    static newFromBlob(
      blob: number[],
      capabilities: DBusCapabilityFlags
    ): DBusMessage
    /**
     * Creates a new #GDBusMessage for a method call.
     * @constructor
     * @param name A valid D-Bus name or %NULL.
     * @param path A valid object path.
     * @param interface A valid D-Bus interface name or %NULL.
     * @param method A valid method name.
     * @returns A #GDBusMessage. Free with g_object_unref().
     */
    static newMethodCall(
      name: string | null,
      path: string,
      interface: string | null,
      method: string
    ): DBusMessage
    /**
     * Creates a new #GDBusMessage for a signal emission.
     * @constructor
     * @param path A valid object path.
     * @param interface A valid D-Bus interface name.
     * @param signal A valid signal name.
     * @returns A #GDBusMessage. Free with g_object_unref().
     */
    static newSignal(
      path: string,
      interface: string,
      signal: string
    ): DBusMessage
    _init(config?: DBusMessage.ConstructorProperties): void
    /**
     * Utility function to calculate how many bytes are needed to
     * completely deserialize the D-Bus message stored at `blob`.
     * @param blob A blob representing a binary D-Bus message.
     * @returns Number of bytes needed or -1 if @error is set (e.g. if @blob contains invalid data or not enough data is available to determine the size).
     */
    static bytesNeeded(blob: number[]): number
  }

  module DBusMethodInvocation {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface DBusMethodInvocation {
    // Own properties of Gio-2.0.Gio.DBusMethodInvocation

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusMethodInvocation

    /**
     * Gets the #GDBusConnection the method was invoked on.
     * @returns A #GDBusConnection. Do not free, it is owned by @invocation.
     */
    getConnection(): DBusConnection
    /**
     * Gets the name of the D-Bus interface the method was invoked on.
     *
     * If this method call is a property Get, Set or GetAll call that has
     * been redirected to the method call handler then
     * "org.freedesktop.DBus.Properties" will be returned.  See
     * #GDBusInterfaceVTable for more information.
     * @returns A string. Do not free, it is owned by @invocation.
     */
    getInterfaceName(): string
    /**
     * Gets the #GDBusMessage for the method invocation. This is useful if
     * you need to use low-level protocol features, such as UNIX file
     * descriptor passing, that cannot be properly expressed in the
     * #GVariant API.
     *
     * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
     * for an example of how to use this low-level API to send and receive
     * UNIX file descriptors.
     * @returns #GDBusMessage. Do not free, it is owned by @invocation.
     */
    getMessage(): DBusMessage
    /**
     * Gets information about the method call, if any.
     *
     * If this method invocation is a property Get, Set or GetAll call that
     * has been redirected to the method call handler then %NULL will be
     * returned.  See g_dbus_method_invocation_get_property_info() and
     * #GDBusInterfaceVTable for more information.
     * @returns A #GDBusMethodInfo or %NULL. Do not free, it is owned by @invocation.
     */
    getMethodInfo(): DBusMethodInfo | null
    /**
     * Gets the name of the method that was invoked.
     * @returns A string. Do not free, it is owned by @invocation.
     */
    getMethodName(): string
    /**
     * Gets the object path the method was invoked on.
     * @returns A string. Do not free, it is owned by @invocation.
     */
    getObjectPath(): string
    /**
     * Gets the parameters of the method invocation. If there are no input
     * parameters then this will return a GVariant with 0 children rather than NULL.
     * @returns A #GVariant tuple. Do not unref this because it is owned by @invocation.
     */
    getParameters(): GLib.Variant
    /**
     * Gets information about the property that this method call is for, if
     * any.
     *
     * This will only be set in the case of an invocation in response to a
     * property Get or Set call that has been directed to the method call
     * handler for an object on account of its property_get() or
     * property_set() vtable pointers being unset.
     *
     * See #GDBusInterfaceVTable for more information.
     *
     * If the call was GetAll, %NULL will be returned.
     * @returns a #GDBusPropertyInfo or %NULL
     */
    getPropertyInfo(): DBusPropertyInfo | null
    /**
     * Gets the bus name that invoked the method.
     * @returns A string. Do not free, it is owned by @invocation.
     */
    getSender(): string
    /**
     * Finishes handling a D-Bus method call by returning an error.
     *
     * This method will take ownership of `invocation`. See
     * #GDBusInterfaceVTable for more information about the ownership of
     * `invocation`.
     * @param errorName A valid D-Bus error name.
     * @param errorMessage A valid D-Bus error message.
     */
    returnDbusError(errorName: string, errorMessage: string): void
    /**
     * Like g_dbus_method_invocation_return_error() but without printf()-style formatting.
     *
     * This method will take ownership of `invocation`. See
     * #GDBusInterfaceVTable for more information about the ownership of
     * `invocation`.
     * @param domain A #GQuark for the #GError error domain.
     * @param code The error code.
     * @param message The error message.
     */
    returnErrorLiteral(domain: GLib.Quark, code: number, message: string): void
    /**
     * Like g_dbus_method_invocation_return_error() but takes a #GError
     * instead of the error domain, error code and message.
     *
     * This method will take ownership of `invocation`. See
     * #GDBusInterfaceVTable for more information about the ownership of
     * `invocation`.
     * @param error A #GError.
     */
    returnGerror(error: GLib.Error): void
    /**
     * Finishes handling a D-Bus method call by returning `parameters`.
     * If the `parameters` GVariant is floating, it is consumed.
     *
     * It is an error if `parameters` is not of the right format: it must be a tuple
     * containing the out-parameters of the D-Bus method. Even if the method has a
     * single out-parameter, it must be contained in a tuple. If the method has no
     * out-parameters, `parameters` may be %NULL or an empty tuple.
     *
     *
     * ```c
     * GDBusMethodInvocation *invocation = some_invocation;
     * g_autofree gchar *result_string = NULL;
     * g_autoptr (GError) error = NULL;
     *
     * result_string = calculate_result (&error);
     *
     * if (error != NULL)
     *   g_dbus_method_invocation_return_gerror (invocation, error);
     * else
     *   g_dbus_method_invocation_return_value (invocation,
     *                                          g_variant_new ("(s)", result_string));
     *
     * // Do not free `invocation` here; returning a value does that
     * ```
     *
     *
     * This method will take ownership of `invocation`. See
     * #GDBusInterfaceVTable for more information about the ownership of
     * `invocation`.
     *
     * Since 2.48, if the method call requested for a reply not to be sent
     * then this call will sink `parameters` and free `invocation,` but
     * otherwise do nothing (as per the recommendations of the D-Bus
     * specification).
     * @param parameters A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters.
     */
    returnValue(parameters: GLib.Variant | null): void
    /**
     * Like g_dbus_method_invocation_return_value() but also takes a #GUnixFDList.
     *
     * This method is only available on UNIX.
     *
     * This method will take ownership of `invocation`. See
     * #GDBusInterfaceVTable for more information about the ownership of
     * `invocation`.
     * @param parameters A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters.
     * @param fdList A #GUnixFDList or %NULL.
     */
    returnValueWithUnixFdList(
      parameters: GLib.Variant | null,
      fdList: UnixFDList | null
    ): void

    // Class property signals of Gio-2.0.Gio.DBusMethodInvocation

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Instances of the `GDBusMethodInvocation` class are used when
   * handling D-Bus method calls. It provides a way to asynchronously
   * return results and errors.
   *
   * The normal way to obtain a `GDBusMethodInvocation` object is to receive
   * it as an argument to the `handle_method_call()` function in a
   * [type`Gio`.DBusInterfaceVTable] that was passed to
   * [method`Gio`.DBusConnection.register_object].
   * @class
   */
  class DBusMethodInvocation extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusMethodInvocation

    static name: string

    // Constructors of Gio-2.0.Gio.DBusMethodInvocation

    constructor(config?: DBusMethodInvocation.ConstructorProperties)
    _init(config?: DBusMethodInvocation.ConstructorProperties): void
  }

  module DBusObjectManagerClient {
    // Signal callback interfaces

    /**
     * Signal callback interface for `interface-proxy-properties-changed`
     */
    interface InterfaceProxyPropertiesChangedSignalCallback {
      (
        objectProxy: DBusObjectProxy,
        interfaceProxy: DBusProxy,
        changedProperties: GLib.Variant,
        invalidatedProperties: string[]
      ): void
    }

    /**
     * Signal callback interface for `interface-proxy-signal`
     */
    interface InterfaceProxySignalSignalCallback {
      (
        objectProxy: DBusObjectProxy,
        interfaceProxy: DBusProxy,
        senderName: string | null,
        signalName: string | null,
        parameters: GLib.Variant
      ): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends AsyncInitable.ConstructorProperties,
        DBusObjectManager.ConstructorProperties,
        Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DBusObjectManagerClient

      /**
       * If this property is not %G_BUS_TYPE_NONE, then
       * #GDBusObjectManagerClient:connection must be %NULL and will be set to the
       * #GDBusConnection obtained by calling g_bus_get() with the value
       * of this property.
       */
      bus_type?: BusType | null
      /**
       * The #GDBusConnection to use.
       */
      connection?: DBusConnection | null
      /**
       * Flags from the #GDBusObjectManagerClientFlags enumeration.
       */
      flags?: DBusObjectManagerClientFlags | null
      /**
       * A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data.
       */
      get_proxy_type_destroy_notify?: any | null
      /**
       * The #GDBusProxyTypeFunc to use when determining what #GType to
       * use for interface proxies or %NULL.
       */
      get_proxy_type_func?: any | null
      /**
       * The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func.
       */
      get_proxy_type_user_data?: any | null
      /**
       * The well-known name or unique name that the manager is for.
       */
      name?: string | null
      /**
       * The object path the manager is for.
       */
      object_path?: string | null
    }
  }

  interface DBusObjectManagerClient
    extends AsyncInitable,
      DBusObjectManager,
      Initable {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerClient

    /**
     * If this property is not %G_BUS_TYPE_NONE, then
     * #GDBusObjectManagerClient:connection must be %NULL and will be set to the
     * #GDBusConnection obtained by calling g_bus_get() with the value
     * of this property.
     */
    readonly busType: BusType
    /**
     * The #GDBusConnection to use.
     */
    readonly connection: DBusConnection
    /**
     * Flags from the #GDBusObjectManagerClientFlags enumeration.
     */
    readonly flags: DBusObjectManagerClientFlags
    /**
     * A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data.
     */
    readonly getProxyTypeDestroyNotify: any
    /**
     * The #GDBusProxyTypeFunc to use when determining what #GType to
     * use for interface proxies or %NULL.
     */
    readonly getProxyTypeFunc: any
    /**
     * The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func.
     */
    readonly getProxyTypeUserData: any
    /**
     * The well-known name or unique name that the manager is for.
     */
    readonly name: string | null
    /**
     * The unique name that owns #GDBusObjectManagerClient:name or %NULL if
     * no-one is currently owning the name. Connect to the
     * #GObject::notify signal to track changes to this property.
     */
    readonly nameOwner: string | null
    /**
     * The object path the manager is for.
     */
    readonly objectPath: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusObjectManagerClient

    /**
     * Gets the #GDBusConnection used by `manager`.
     * @returns A #GDBusConnection object. Do not free,   the object belongs to @manager.
     */
    getConnection(): DBusConnection
    /**
     * Gets the flags that `manager` was constructed with.
     * @returns Zero of more flags from the #GDBusObjectManagerClientFlags enumeration.
     */
    getFlags(): DBusObjectManagerClientFlags
    /**
     * Gets the name that `manager` is for, or %NULL if not a message bus
     * connection.
     * @returns A unique or well-known name. Do not free, the string belongs to @manager.
     */
    getName(): string
    /**
     * The unique name that owns the name that `manager` is for or %NULL if
     * no-one currently owns that name. You can connect to the
     * #GObject::notify signal to track changes to the
     * #GDBusObjectManagerClient:name-owner property.
     * @returns The name owner or %NULL if no name owner exists. Free with g_free().
     */
    getNameOwner(): string | null

    // Own virtual methods of Gio-2.0.Gio.DBusObjectManagerClient

    /**
     * Signal class handler for the #GDBusObjectManagerClient::interface-proxy-properties-changed signal.
     * @virtual
     * @param objectProxy
     * @param interfaceProxy
     * @param changedProperties
     * @param invalidatedProperties
     */
    interfaceProxyPropertiesChanged(
      objectProxy: DBusObjectProxy,
      interfaceProxy: DBusProxy,
      changedProperties: GLib.Variant,
      invalidatedProperties: string
    ): void
    /**
     * Signal class handler for the #GDBusObjectManagerClient::interface-proxy-signal signal.
     * @virtual
     * @param objectProxy
     * @param interfaceProxy
     * @param senderName
     * @param signalName
     * @param parameters
     */
    interfaceProxySignal(
      objectProxy: DBusObjectProxy,
      interfaceProxy: DBusProxy,
      senderName: string,
      signalName: string,
      parameters: GLib.Variant
    ): void

    // Own signals of Gio-2.0.Gio.DBusObjectManagerClient

    connect(
      sigName: "interface-proxy-properties-changed",
      callback: DBusObjectManagerClient.InterfaceProxyPropertiesChangedSignalCallback
    ): number
    on(
      sigName: "interface-proxy-properties-changed",
      callback: DBusObjectManagerClient.InterfaceProxyPropertiesChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "interface-proxy-properties-changed",
      callback: DBusObjectManagerClient.InterfaceProxyPropertiesChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "interface-proxy-properties-changed",
      callback: DBusObjectManagerClient.InterfaceProxyPropertiesChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "interface-proxy-properties-changed",
      interfaceProxy: DBusProxy,
      changedProperties: GLib.Variant,
      invalidatedProperties: string[],
      ...args: any[]
    ): void
    connect(
      sigName: "interface-proxy-signal",
      callback: DBusObjectManagerClient.InterfaceProxySignalSignalCallback
    ): number
    on(
      sigName: "interface-proxy-signal",
      callback: DBusObjectManagerClient.InterfaceProxySignalSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "interface-proxy-signal",
      callback: DBusObjectManagerClient.InterfaceProxySignalSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "interface-proxy-signal",
      callback: DBusObjectManagerClient.InterfaceProxySignalSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "interface-proxy-signal",
      interfaceProxy: DBusProxy,
      senderName: string | null,
      signalName: string | null,
      parameters: GLib.Variant,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.DBusObjectManagerClient

    connect(
      sigName: "notify::bus-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::bus-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::bus-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::bus-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::bus-type", ...args: any[]): void
    connect(
      sigName: "notify::connection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::connection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::connection", ...args: any[]): void
    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::get-proxy-type-destroy-notify",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::get-proxy-type-destroy-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::get-proxy-type-destroy-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::get-proxy-type-destroy-notify",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::get-proxy-type-destroy-notify", ...args: any[]): void
    connect(
      sigName: "notify::get-proxy-type-func",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::get-proxy-type-func",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::get-proxy-type-func",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::get-proxy-type-func",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::get-proxy-type-func", ...args: any[]): void
    connect(
      sigName: "notify::get-proxy-type-user-data",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::get-proxy-type-user-data",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::get-proxy-type-user-data",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::get-proxy-type-user-data",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::get-proxy-type-user-data", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::name-owner",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::name-owner",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name-owner",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name-owner",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name-owner", ...args: any[]): void
    connect(
      sigName: "notify::object-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::object-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::object-path", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDBusObjectManagerClient` is used to create, monitor and delete object
   * proxies for remote objects exported by a [class`Gio`.DBusObjectManagerServer]
   * (or any code implementing the
   * [org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
   * interface).
   *
   * Once an instance of this type has been created, you can connect to
   * the [signal`Gio`.DBusObjectManager::object-added] and
   * [signal`Gio`.DBusObjectManager::object-removed signals] and inspect the
   * [class`Gio`.DBusObjectProxy] objects returned by
   * [method`Gio`.DBusObjectManager.get_objects].
   *
   * If the name for a `GDBusObjectManagerClient` is not owned by anyone at
   * object construction time, the default behavior is to request the
   * message bus to launch an owner for the name. This behavior can be
   * disabled using the `G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START`
   * flag. It’s also worth noting that this only works if the name of
   * interest is activatable in the first place. E.g. in some cases it
   * is not possible to launch an owner for the requested name. In this
   * case, `GDBusObjectManagerClient` object construction still succeeds but
   * there will be no object proxies
   * (e.g. [method`Gio`.DBusObjectManager.get_objects] returns the empty list) and
   * the [property`Gio`.DBusObjectManagerClient:name-owner] property is `NULL`.
   *
   * The owner of the requested name can come and go (for example
   * consider a system service being restarted) – `GDBusObjectManagerClient`
   * handles this case too; simply connect to the [signal`GObject`.Object::notify]
   * signal to watch for changes on the
   * [property`Gio`.DBusObjectManagerClient:name-owner] property. When the name
   * owner vanishes, the behavior is that
   * [property`Gio`.DBusObjectManagerClient:name-owner] is set to `NULL` (this
   * includes emission of the [signal`GObject`.Object::notify] signal) and then
   * [signal`Gio`.DBusObjectManager::object-removed] signals are synthesized
   * for all currently existing object proxies. Since
   * [property`Gio`.DBusObjectManagerClient:name-owner] is `NULL` when this
   * happens, you can use this information to disambiguate a synthesized signal
   * from a genuine signal caused by object removal on the remote
   * [iface`Gio`.DBusObjectManager]. Similarly, when a new name owner appears,
   * [signal`Gio`.DBusObjectManager::object-added] signals are synthesized
   * while [property`Gio`.DBusObjectManagerClient:name-owner] is still `NULL`. Only
   * when all object proxies have been added, the
   * [property`Gio`.DBusObjectManagerClient:name-owner] is set to the new name
   * owner (this includes emission of the [signal`GObject`.Object::notify] signal).
   * Furthermore, you are guaranteed that
   * [property`Gio`.DBusObjectManagerClient:name-owner] will alternate between a
   * name owner (e.g. `:1.42`) and `NULL` even in the case where
   * the name of interest is atomically replaced
   *
   * Ultimately, `GDBusObjectManagerClient` is used to obtain
   * [class`Gio`.DBusProxy] instances. All signals (including the
   * `org.freedesktop.DBus.Properties::PropertiesChanged` signal)
   * delivered to [class`Gio`.DBusProxy] instances are guaranteed to originate
   * from the name owner. This guarantee along with the behavior
   * described above, means that certain race conditions including the
   * “half the proxy is from the old owner and the other half is from
   * the new owner” problem cannot happen.
   *
   * To avoid having the application connect to signals on the returned
   * [class`Gio`.DBusObjectProxy] and [class`Gio`.DBusProxy] objects, the
   * [signal`Gio`.DBusObject::interface-added],
   * [signal`Gio`.DBusObject::interface-removed],
   * [signal`Gio`.DBusProxy::g-properties-changed] and
   * [signal`Gio`.DBusProxy::g-signal] signals
   * are also emitted on the `GDBusObjectManagerClient` instance managing these
   * objects. The signals emitted are
   * [signal`Gio`.DBusObjectManager::interface-added],
   * [signal`Gio`.DBusObjectManager::interface-removed],
   * [signal`Gio`.DBusObjectManagerClient::interface-proxy-properties-changed] and
   * [signal`Gio`.DBusObjectManagerClient::interface-proxy-signal].
   *
   * Note that all callbacks and signals are emitted in the
   * thread-default main context (see
   * [method`GLib`.MainContext.push_thread_default]) that the
   * `GDBusObjectManagerClient` object was constructed in. Additionally, the
   * [class`Gio`.DBusObjectProxy] and [class`Gio`.DBusProxy] objects
   * originating from the `GDBusObjectManagerClient` object will be created in
   * the same context and, consequently, will deliver signals in the
   * same main loop.
   * @class
   */
  class DBusObjectManagerClient extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerClient

    static name: string

    // Constructors of Gio-2.0.Gio.DBusObjectManagerClient

    constructor(config?: DBusObjectManagerClient.ConstructorProperties)
    /**
     * Finishes an operation started with g_dbus_object_manager_client_new().
     * @constructor
     * @param res A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new().
     * @returns A   #GDBusObjectManagerClient object or %NULL if @error is set. Free   with g_object_unref().
     */
    static newFinish(res: AsyncResult): DBusObjectManagerClient
    /**
     * Finishes an operation started with g_dbus_object_manager_client_new_for_bus().
     * @constructor
     * @param res A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_object_manager_client_new_for_bus().
     * @returns A   #GDBusObjectManagerClient object or %NULL if @error is set. Free   with g_object_unref().
     */
    static newForBusFinish(res: AsyncResult): DBusObjectManagerClient
    /**
     * Like g_dbus_object_manager_client_new_sync() but takes a #GBusType instead
     * of a #GDBusConnection.
     *
     * This is a synchronous failable constructor - the calling thread is
     * blocked until a reply is received. See g_dbus_object_manager_client_new_for_bus()
     * for the asynchronous version.
     * @constructor
     * @param busType A #GBusType.
     * @param flags Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
     * @param name The owner of the control object (unique or well-known name).
     * @param objectPath The object path of the control object.
     * @param getProxyTypeFunc A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
     * @param cancellable A #GCancellable or %NULL
     * @returns A   #GDBusObjectManagerClient object or %NULL if @error is set. Free   with g_object_unref().
     */
    static newForBusSync(
      busType: BusType,
      flags: DBusObjectManagerClientFlags,
      name: string,
      objectPath: string,
      getProxyTypeFunc: DBusProxyTypeFunc | null,
      cancellable: Cancellable | null
    ): DBusObjectManagerClient
    /**
     * Creates a new #GDBusObjectManagerClient object.
     *
     * This is a synchronous failable constructor - the calling thread is
     * blocked until a reply is received. See g_dbus_object_manager_client_new()
     * for the asynchronous version.
     * @constructor
     * @param connection A #GDBusConnection.
     * @param flags Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
     * @param name The owner of the control object (unique or well-known name), or %NULL when not using a message bus connection.
     * @param objectPath The object path of the control object.
     * @param getProxyTypeFunc A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
     * @param cancellable A #GCancellable or %NULL
     * @returns A   #GDBusObjectManagerClient object or %NULL if @error is set. Free   with g_object_unref().
     */
    static newSync(
      connection: DBusConnection,
      flags: DBusObjectManagerClientFlags,
      name: string | null,
      objectPath: string,
      getProxyTypeFunc: DBusProxyTypeFunc | null,
      cancellable: Cancellable | null
    ): DBusObjectManagerClient
    _init(config?: DBusObjectManagerClient.ConstructorProperties): void
    /**
     * Asynchronously creates a new #GDBusObjectManagerClient object.
     *
     * This is an asynchronous failable constructor. When the result is
     * ready, `callback` will be invoked in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread you are calling this method from. You can
     * then call g_dbus_object_manager_client_new_finish() to get the result. See
     * g_dbus_object_manager_client_new_sync() for the synchronous version.
     * @param connection A #GDBusConnection.
     * @param flags Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
     * @param name The owner of the control object (unique or well-known name).
     * @param objectPath The object path of the control object.
     * @param getProxyTypeFunc A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
     * @param cancellable A #GCancellable or %NULL
     * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
     */
    static new(
      connection: DBusConnection,
      flags: DBusObjectManagerClientFlags,
      name: string,
      objectPath: string,
      getProxyTypeFunc: DBusProxyTypeFunc | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a
     * #GDBusConnection.
     *
     * This is an asynchronous failable constructor. When the result is
     * ready, `callback` will be invoked in the
     * [thread-default main loop][g-main-context-push-thread-default]
     * of the thread you are calling this method from. You can
     * then call g_dbus_object_manager_client_new_for_bus_finish() to get the result. See
     * g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
     * @param busType A #GBusType.
     * @param flags Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
     * @param name The owner of the control object (unique or well-known name).
     * @param objectPath The object path of the control object.
     * @param getProxyTypeFunc A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
     * @param cancellable A #GCancellable or %NULL
     * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
     */
    static newForBus(
      busType: BusType,
      flags: DBusObjectManagerClientFlags,
      name: string,
      objectPath: string,
      getProxyTypeFunc: DBusProxyTypeFunc | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
  }

  module DBusObjectManagerServer {
    // Constructor properties interface

    interface ConstructorProperties
      extends DBusObjectManager.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DBusObjectManagerServer

      /**
       * The #GDBusConnection to export objects on.
       */
      connection?: DBusConnection | null
      /**
       * The object path to register the manager object at.
       */
      object_path?: string | null
    }
  }

  interface DBusObjectManagerServer extends DBusObjectManager {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerServer

    /**
     * The #GDBusConnection to export objects on.
     */
    connection: DBusConnection
    /**
     * The object path to register the manager object at.
     */
    readonly objectPath: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusObjectManagerServer

    /**
     * Exports `object` on `manager`.
     *
     * If there is already a #GDBusObject exported at the object path,
     * then the old object is removed.
     *
     * The object path for `object` must be in the hierarchy rooted by the
     * object path for `manager`.
     *
     * Note that `manager` will take a reference on `object` for as long as
     * it is exported.
     * @param object A #GDBusObjectSkeleton.
     */
    export(object: DBusObjectSkeleton): void
    /**
     * Like g_dbus_object_manager_server_export() but appends a string of
     * the form _N (with N being a natural number) to `object'`s object path
     * if an object with the given path already exists. As such, the
     * #GDBusObjectProxy:g-object-path property of `object` may be modified.
     * @param object An object.
     */
    exportUniquely(object: DBusObjectSkeleton): void
    /**
     * Gets the #GDBusConnection used by `manager`.
     * @returns A #GDBusConnection object or %NULL if   @manager isn't exported on a connection. The returned object should   be freed with g_object_unref().
     */
    getConnection(): DBusConnection | null
    /**
     * Returns whether `object` is currently exported on `manager`.
     * @param object An object.
     * @returns %TRUE if @object is exported
     */
    isExported(object: DBusObjectSkeleton): boolean
    /**
     * Exports all objects managed by `manager` on `connection`. If
     * `connection` is %NULL, stops exporting objects.
     * @param connection A #GDBusConnection or %NULL.
     */
    setConnection(connection: DBusConnection | null): void
    /**
     * If `manager` has an object at `path,` removes the object. Otherwise
     * does nothing.
     *
     * Note that `object_path` must be in the hierarchy rooted by the
     * object path for `manager`.
     * @param objectPath An object path.
     * @returns %TRUE if object at @object_path was removed, %FALSE otherwise.
     */
    unexport(objectPath: string): boolean

    // Class property signals of Gio-2.0.Gio.DBusObjectManagerServer

    connect(
      sigName: "notify::connection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::connection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::connection", ...args: any[]): void
    connect(
      sigName: "notify::object-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::object-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::object-path", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDBusObjectManagerServer` is used to export [iface`Gio`.DBusObject] instances
   * using the standardized
   * [`org.freedesktop.DBus.ObjectManager`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
   * interface. For example, remote D-Bus clients can get all objects
   * and properties in a single call. Additionally, any change in the
   * object hierarchy is broadcast using signals. This means that D-Bus
   * clients can keep caches up to date by only listening to D-Bus
   * signals.
   *
   * The recommended path to export an object manager at is the path form of the
   * well-known name of a D-Bus service, or below. For example, if a D-Bus service
   * is available at the well-known name `net.example.ExampleService1`, the object
   * manager should typically be exported at `/net/example/ExampleService1`, or
   * below (to allow for multiple object managers in a service).
   *
   * It is supported, but not recommended, to export an object manager at the root
   * path, `/`.
   *
   * See [class`Gio`.DBusObjectManagerClient] for the client-side code that is
   * intended to be used with `GDBusObjectManagerServer` or any D-Bus
   * object implementing the `org.freedesktop.DBus.ObjectManager` interface.
   * @class
   */
  class DBusObjectManagerServer extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerServer

    static name: string

    // Constructors of Gio-2.0.Gio.DBusObjectManagerServer

    constructor(config?: DBusObjectManagerServer.ConstructorProperties)
    /**
     * Creates a new #GDBusObjectManagerServer object.
     *
     * The returned server isn't yet exported on any connection. To do so,
     * use g_dbus_object_manager_server_set_connection(). Normally you
     * want to export all of your objects before doing so to avoid
     * [InterfacesAdded](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
     * signals being emitted.
     * @constructor
     * @param objectPath The object path to export the manager object at.
     * @returns A #GDBusObjectManagerServer object. Free with g_object_unref().
     */
    constructor(objectPath: string)
    /**
     * Creates a new #GDBusObjectManagerServer object.
     *
     * The returned server isn't yet exported on any connection. To do so,
     * use g_dbus_object_manager_server_set_connection(). Normally you
     * want to export all of your objects before doing so to avoid
     * [InterfacesAdded](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
     * signals being emitted.
     * @constructor
     * @param objectPath The object path to export the manager object at.
     * @returns A #GDBusObjectManagerServer object. Free with g_object_unref().
     */
    static new(objectPath: string): DBusObjectManagerServer
    _init(config?: DBusObjectManagerServer.ConstructorProperties): void
  }

  module DBusObjectProxy {
    // Constructor properties interface

    interface ConstructorProperties
      extends DBusObject.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DBusObjectProxy

      /**
       * The connection of the proxy.
       */
      g_connection?: DBusConnection | null
      /**
       * The object path of the proxy.
       */
      g_object_path?: string | null
    }
  }

  interface DBusObjectProxy extends DBusObject {
    // Own properties of Gio-2.0.Gio.DBusObjectProxy

    /**
     * The connection of the proxy.
     */
    readonly gConnection: DBusConnection
    /**
     * The object path of the proxy.
     */
    readonly gObjectPath: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusObjectProxy

    /**
     * Gets the connection that `proxy` is for.
     * @returns A #GDBusConnection. Do not free, the   object is owned by @proxy.
     */
    getConnection(): DBusConnection

    // Class property signals of Gio-2.0.Gio.DBusObjectProxy

    connect(
      sigName: "notify::g-connection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-connection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-connection", ...args: any[]): void
    connect(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-object-path", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GDBusObjectProxy` is an object used to represent a remote object
   * with one or more D-Bus interfaces. Normally, you don’t instantiate
   * a `GDBusObjectProxy` yourself — typically [class`Gio`.DBusObjectManagerClient]
   * is used to obtain it.
   * @class
   */
  class DBusObjectProxy extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusObjectProxy

    static name: string

    // Constructors of Gio-2.0.Gio.DBusObjectProxy

    constructor(config?: DBusObjectProxy.ConstructorProperties)
    /**
     * Creates a new #GDBusObjectProxy for the given connection and
     * object path.
     * @constructor
     * @param connection a #GDBusConnection
     * @param objectPath the object path
     * @returns a new #GDBusObjectProxy
     */
    constructor(connection: DBusConnection, objectPath: string)
    /**
     * Creates a new #GDBusObjectProxy for the given connection and
     * object path.
     * @constructor
     * @param connection a #GDBusConnection
     * @param objectPath the object path
     * @returns a new #GDBusObjectProxy
     */
    static new(connection: DBusConnection, objectPath: string): DBusObjectProxy
    _init(config?: DBusObjectProxy.ConstructorProperties): void
  }

  module DBusObjectSkeleton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `authorize-method`
     */
    interface AuthorizeMethodSignalCallback {
      (
        interface: DBusInterfaceSkeleton,
        invocation: DBusMethodInvocation
      ): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends DBusObject.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DBusObjectSkeleton

      /**
       * The object path where the object is exported.
       */
      g_object_path?: string | null
    }
  }

  interface DBusObjectSkeleton extends DBusObject {
    // Own properties of Gio-2.0.Gio.DBusObjectSkeleton

    /**
     * The object path where the object is exported.
     */
    gObjectPath: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusObjectSkeleton

    /**
     * Adds `interface_` to `object`.
     *
     * If `object` already contains a #GDBusInterfaceSkeleton with the same
     * interface name, it is removed before `interface_` is added.
     *
     * Note that `object` takes its own reference on `interface_` and holds
     * it until removed.
     * @param interface A #GDBusInterfaceSkeleton.
     */
    addInterface(interface: DBusInterfaceSkeleton): void
    /**
     * This method simply calls g_dbus_interface_skeleton_flush() on all
     * interfaces belonging to `object`. See that method for when flushing
     * is useful.
     */
    flush(): void
    /**
     * Removes `interface_` from `object`.
     * @param interface A #GDBusInterfaceSkeleton.
     */
    removeInterface(interface: DBusInterfaceSkeleton): void
    /**
     * Removes the #GDBusInterface with `interface_name` from `object`.
     *
     * If no D-Bus interface of the given interface exists, this function
     * does nothing.
     * @param interfaceName A D-Bus interface name.
     */
    removeInterfaceByName(interfaceName: string): void
    /**
     * Sets the object path for `object`.
     * @param objectPath A valid D-Bus object path.
     */
    setObjectPath(objectPath: string): void

    // Own virtual methods of Gio-2.0.Gio.DBusObjectSkeleton

    /**
     * Signal class handler for the #GDBusObjectSkeleton::authorize-method signal.
     * @virtual
     * @param interface
     * @param invocation
     */
    authorizeMethod(
      interface: DBusInterfaceSkeleton,
      invocation: DBusMethodInvocation
    ): boolean

    // Own signals of Gio-2.0.Gio.DBusObjectSkeleton

    connect(
      sigName: "authorize-method",
      callback: DBusObjectSkeleton.AuthorizeMethodSignalCallback
    ): number
    on(
      sigName: "authorize-method",
      callback: DBusObjectSkeleton.AuthorizeMethodSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "authorize-method",
      callback: DBusObjectSkeleton.AuthorizeMethodSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "authorize-method",
      callback: DBusObjectSkeleton.AuthorizeMethodSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "authorize-method",
      invocation: DBusMethodInvocation,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.DBusObjectSkeleton

    connect(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-object-path", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GDBusObjectSkeleton` instance is essentially a group of D-Bus
   * interfaces. The set of exported interfaces on the object may be
   * dynamic and change at runtime.
   *
   * This type is intended to be used with [iface`Gio`.DBusObjectManager].
   * @class
   */
  class DBusObjectSkeleton extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusObjectSkeleton

    static name: string

    // Constructors of Gio-2.0.Gio.DBusObjectSkeleton

    constructor(config?: DBusObjectSkeleton.ConstructorProperties)
    /**
     * Creates a new #GDBusObjectSkeleton.
     * @constructor
     * @param objectPath An object path.
     * @returns A #GDBusObjectSkeleton. Free with g_object_unref().
     */
    constructor(objectPath: string)
    /**
     * Creates a new #GDBusObjectSkeleton.
     * @constructor
     * @param objectPath An object path.
     * @returns A #GDBusObjectSkeleton. Free with g_object_unref().
     */
    static new(objectPath: string): DBusObjectSkeleton
    _init(config?: DBusObjectSkeleton.ConstructorProperties): void
  }

  module DBusProxy {
    // Signal callback interfaces

    /**
     * Signal callback interface for `g-properties-changed`
     */
    interface GPropertiesChangedSignalCallback {
      (changedProperties: GLib.Variant, invalidatedProperties: string[]): void
    }

    /**
     * Signal callback interface for `g-signal`
     */
    interface GSignalSignalCallback {
      (
        senderName: string | null,
        signalName: string | null,
        parameters: GLib.Variant
      ): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends AsyncInitable.ConstructorProperties,
        DBusInterface.ConstructorProperties,
        Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DBusProxy

      /**
       * If this property is not %G_BUS_TYPE_NONE, then
       * #GDBusProxy:g-connection must be %NULL and will be set to the
       * #GDBusConnection obtained by calling g_bus_get() with the value
       * of this property.
       */
      g_bus_type?: BusType | null
      /**
       * The #GDBusConnection the proxy is for.
       */
      g_connection?: DBusConnection | null
      /**
       * The timeout to use if -1 (specifying default timeout) is passed
       * as `timeout_msec` in the g_dbus_proxy_call() and
       * g_dbus_proxy_call_sync() functions.
       *
       * This allows applications to set a proxy-wide timeout for all
       * remote method invocations on the proxy. If this property is -1,
       * the default timeout (typically 25 seconds) is used. If set to
       * %G_MAXINT, then no timeout is used.
       */
      g_default_timeout?: number | null
      /**
       * Flags from the #GDBusProxyFlags enumeration.
       */
      g_flags?: DBusProxyFlags | null
      /**
       * Ensure that interactions with this proxy conform to the given
       * interface. This is mainly to ensure that malformed data received
       * from the other peer is ignored. The given #GDBusInterfaceInfo is
       * said to be the "expected interface".
       *
       * The checks performed are:
       * - When completing a method call, if the type signature of
       *   the reply message isn't what's expected, the reply is
       *   discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT.
       *
       * - Received signals that have a type signature mismatch are dropped and
       *   a warning is logged via g_warning().
       *
       * - Properties received via the initial `GetAll()` call or via the
       *   `::PropertiesChanged` signal (on the
       *   [org.freedesktop.DBus.Properties](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties)
       *   interface) or set using g_dbus_proxy_set_cached_property()
       *   with a type signature mismatch are ignored and a warning is
       *   logged via g_warning().
       *
       * Note that these checks are never done on methods, signals and
       * properties that are not referenced in the given
       * #GDBusInterfaceInfo, since extending a D-Bus interface on the
       * service-side is not considered an ABI break.
       */
      g_interface_info?: DBusInterfaceInfo | null
      /**
       * The D-Bus interface name the proxy is for.
       */
      g_interface_name?: string | null
      /**
       * The well-known or unique name that the proxy is for.
       */
      g_name?: string | null
      /**
       * The object path the proxy is for.
       */
      g_object_path?: string | null
    }
  }

  interface DBusProxy extends AsyncInitable, DBusInterface, Initable {
    // Own properties of Gio-2.0.Gio.DBusProxy

    /**
     * If this property is not %G_BUS_TYPE_NONE, then
     * #GDBusProxy:g-connection must be %NULL and will be set to the
     * #GDBusConnection obtained by calling g_bus_get() with the value
     * of this property.
     */
    readonly gBusType: BusType
    /**
     * The #GDBusConnection the proxy is for.
     */
    readonly gConnection: DBusConnection
    /**
     * The timeout to use if -1 (specifying default timeout) is passed
     * as `timeout_msec` in the g_dbus_proxy_call() and
     * g_dbus_proxy_call_sync() functions.
     *
     * This allows applications to set a proxy-wide timeout for all
     * remote method invocations on the proxy. If this property is -1,
     * the default timeout (typically 25 seconds) is used. If set to
     * %G_MAXINT, then no timeout is used.
     */
    gDefaultTimeout: number
    /**
     * Flags from the #GDBusProxyFlags enumeration.
     */
    readonly gFlags: DBusProxyFlags
    /**
     * Ensure that interactions with this proxy conform to the given
     * interface. This is mainly to ensure that malformed data received
     * from the other peer is ignored. The given #GDBusInterfaceInfo is
     * said to be the "expected interface".
     *
     * The checks performed are:
     * - When completing a method call, if the type signature of
     *   the reply message isn't what's expected, the reply is
     *   discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT.
     *
     * - Received signals that have a type signature mismatch are dropped and
     *   a warning is logged via g_warning().
     *
     * - Properties received via the initial `GetAll()` call or via the
     *   `::PropertiesChanged` signal (on the
     *   [org.freedesktop.DBus.Properties](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties)
     *   interface) or set using g_dbus_proxy_set_cached_property()
     *   with a type signature mismatch are ignored and a warning is
     *   logged via g_warning().
     *
     * Note that these checks are never done on methods, signals and
     * properties that are not referenced in the given
     * #GDBusInterfaceInfo, since extending a D-Bus interface on the
     * service-side is not considered an ABI break.
     */
    gInterfaceInfo: DBusInterfaceInfo
    /**
     * The D-Bus interface name the proxy is for.
     */
    readonly gInterfaceName: string | null
    /**
     * The well-known or unique name that the proxy is for.
     */
    readonly gName: string | null
    /**
     * The unique name that owns #GDBusProxy:g-name or %NULL if no-one
     * currently owns that name. You may connect to #GObject::notify signal to
     * track changes to this property.
     */
    readonly gNameOwner: string | null
    /**
     * The object path the proxy is for.
     */
    readonly gObjectPath: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusProxy

    /**
     * Asynchronously invokes the `method_name` method on `proxy`.
     *
     * If `method_name` contains any dots, then `name` is split into interface and
     * method name parts. This allows using `proxy` for invoking methods on
     * other interfaces.
     *
     * If the #GDBusConnection associated with `proxy` is closed then
     * the operation will fail with %G_IO_ERROR_CLOSED. If
     * `cancellable` is canceled, the operation will fail with
     * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
     * compatible with the D-Bus protocol, the operation fails with
     * %G_IO_ERROR_INVALID_ARGUMENT.
     *
     * If the `parameters` #GVariant is floating, it is consumed. This allows
     * convenient 'inline' use of g_variant_new(), e.g.:
     *
     * ```c
     *  g_dbus_proxy_call (proxy,
     *                     "TwoStrings",
     *                     g_variant_new ("(ss)",
     *                                    "Thing One",
     *                                    "Thing Two"),
     *                     G_DBUS_CALL_FLAGS_NONE,
     *                     -1,
     *                     NULL,
     *                     (GAsyncReadyCallback) two_strings_done,
     *                     &data);
     * ```
     *
     *
     * If `proxy` has an expected interface (see
     * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
     * then the return value is checked against the return type.
     *
     * This is an asynchronous method. When the operation is finished,
     * `callback` will be invoked in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread you are calling this method from.
     * You can then call g_dbus_proxy_call_finish() to get the result of
     * the operation. See g_dbus_proxy_call_sync() for the synchronous
     * version of this method.
     *
     * If `callback` is %NULL then the D-Bus method call message will be sent with
     * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
     * @param methodName Name of method to invoke.
     * @param parameters A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
     * @param flags Flags from the #GDBusCallFlags enumeration.
     * @param timeoutMsec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
     * @param cancellable A #GCancellable or %NULL.
     * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
     */
    call(
      methodName: string,
      parameters: GLib.Variant | null,
      flags: DBusCallFlags,
      timeoutMsec: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an operation started with g_dbus_proxy_call().
     * @param res A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call().
     * @returns %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref().
     */
    callFinish(res: AsyncResult): GLib.Variant
    /**
     * Synchronously invokes the `method_name` method on `proxy`.
     *
     * If `method_name` contains any dots, then `name` is split into interface and
     * method name parts. This allows using `proxy` for invoking methods on
     * other interfaces.
     *
     * If the #GDBusConnection associated with `proxy` is disconnected then
     * the operation will fail with %G_IO_ERROR_CLOSED. If
     * `cancellable` is canceled, the operation will fail with
     * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
     * compatible with the D-Bus protocol, the operation fails with
     * %G_IO_ERROR_INVALID_ARGUMENT.
     *
     * If the `parameters` #GVariant is floating, it is consumed. This allows
     * convenient 'inline' use of g_variant_new(), e.g.:
     *
     * ```c
     *  g_dbus_proxy_call_sync (proxy,
     *                          "TwoStrings",
     *                          g_variant_new ("(ss)",
     *                                         "Thing One",
     *                                         "Thing Two"),
     *                          G_DBUS_CALL_FLAGS_NONE,
     *                          -1,
     *                          NULL,
     *                          &error);
     * ```
     *
     *
     * The calling thread is blocked until a reply is received. See
     * g_dbus_proxy_call() for the asynchronous version of this
     * method.
     *
     * If `proxy` has an expected interface (see
     * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
     * then the return value is checked against the return type.
     * @param methodName Name of method to invoke.
     * @param parameters A #GVariant tuple with parameters for the signal              or %NULL if not passing parameters.
     * @param flags Flags from the #GDBusCallFlags enumeration.
     * @param timeoutMsec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
     * @param cancellable A #GCancellable or %NULL.
     * @returns %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref().
     */
    callSync(
      methodName: string,
      parameters: GLib.Variant | null,
      flags: DBusCallFlags,
      timeoutMsec: number,
      cancellable: Cancellable | null
    ): GLib.Variant
    /**
     * Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
     *
     * This method is only available on UNIX.
     * @param methodName Name of method to invoke.
     * @param parameters A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
     * @param flags Flags from the #GDBusCallFlags enumeration.
     * @param timeoutMsec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
     * @param fdList A #GUnixFDList or %NULL.
     * @param cancellable A #GCancellable or %NULL.
     * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
     */
    callWithUnixFdList(
      methodName: string,
      parameters: GLib.Variant | null,
      flags: DBusCallFlags,
      timeoutMsec: number,
      fdList: UnixFDList | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list().
     * @param res A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call_with_unix_fd_list().
     * @returns %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref().
     */
    callWithUnixFdListFinish(
      res: AsyncResult
    ): [/* returnType */ GLib.Variant, /* outFdList */ UnixFDList]
    /**
     * Like g_dbus_proxy_call_sync() but also takes and returns #GUnixFDList objects.
     *
     * This method is only available on UNIX.
     * @param methodName Name of method to invoke.
     * @param parameters A #GVariant tuple with parameters for the signal              or %NULL if not passing parameters.
     * @param flags Flags from the #GDBusCallFlags enumeration.
     * @param timeoutMsec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
     * @param fdList A #GUnixFDList or %NULL.
     * @param cancellable A #GCancellable or %NULL.
     * @returns %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref().
     */
    callWithUnixFdListSync(
      methodName: string,
      parameters: GLib.Variant | null,
      flags: DBusCallFlags,
      timeoutMsec: number,
      fdList: UnixFDList | null,
      cancellable: Cancellable | null
    ): [/* returnType */ GLib.Variant, /* outFdList */ UnixFDList]
    /**
     * Looks up the value for a property from the cache. This call does no
     * blocking IO.
     *
     * If `proxy` has an expected interface (see
     * #GDBusProxy:g-interface-info) and `property_name` is referenced by
     * it, then `value` is checked against the type of the property.
     * @param propertyName Property name.
     * @returns A reference to the #GVariant instance    that holds the value for @property_name or %NULL if the value is not in    the cache. The returned reference must be freed with g_variant_unref().
     */
    getCachedProperty(propertyName: string): GLib.Variant | null
    /**
     * Gets the names of all cached properties on `proxy`.
     * @returns A          %NULL-terminated array of strings or %NULL if          @proxy has no cached properties. Free the returned array with          g_strfreev().
     */
    getCachedPropertyNames(): string[] | null
    /**
     * Gets the connection `proxy` is for.
     * @returns A #GDBusConnection owned by @proxy. Do not free.
     */
    getConnection(): DBusConnection
    /**
     * Gets the timeout to use if -1 (specifying default timeout) is
     * passed as `timeout_msec` in the g_dbus_proxy_call() and
     * g_dbus_proxy_call_sync() functions.
     *
     * See the #GDBusProxy:g-default-timeout property for more details.
     * @returns Timeout to use for @proxy.
     */
    getDefaultTimeout(): number
    /**
     * Gets the flags that `proxy` was constructed with.
     * @returns Flags from the #GDBusProxyFlags enumeration.
     */
    getFlags(): DBusProxyFlags
    /**
     * Returns the #GDBusInterfaceInfo, if any, specifying the interface
     * that `proxy` conforms to. See the #GDBusProxy:g-interface-info
     * property for more details.
     * @returns A #GDBusInterfaceInfo or %NULL.    Do not unref the returned object, it is owned by @proxy.
     */
    getInterfaceInfo(): DBusInterfaceInfo | null
    /**
     * Gets the D-Bus interface name `proxy` is for.
     * @returns A string owned by @proxy. Do not free.
     */
    getInterfaceName(): string
    /**
     * Gets the name that `proxy` was constructed for.
     *
     * When connected to a message bus, this will usually be non-%NULL.
     * However, it may be %NULL for a proxy that communicates using a peer-to-peer
     * pattern.
     * @returns A string owned by @proxy. Do not free.
     */
    getName(): string | null
    /**
     * The unique name that owns the name that `proxy` is for or %NULL if
     * no-one currently owns that name. You may connect to the
     * #GObject::notify signal to track changes to the
     * #GDBusProxy:g-name-owner property.
     * @returns The name owner or %NULL if no name    owner exists. Free with g_free().
     */
    getNameOwner(): string | null
    /**
     * Gets the object path `proxy` is for.
     * @returns A string owned by @proxy. Do not free.
     */
    getObjectPath(): string
    /**
     * If `value` is not %NULL, sets the cached value for the property with
     * name `property_name` to the value in `value`.
     *
     * If `value` is %NULL, then the cached value is removed from the
     * property cache.
     *
     * If `proxy` has an expected interface (see
     * #GDBusProxy:g-interface-info) and `property_name` is referenced by
     * it, then `value` is checked against the type of the property.
     *
     * If the `value` #GVariant is floating, it is consumed. This allows
     * convenient 'inline' use of g_variant_new(), e.g.
     *
     * ```c
     *  g_dbus_proxy_set_cached_property (proxy,
     *                                    "SomeProperty",
     *                                    g_variant_new ("(si)",
     *                                                  "A String",
     *                                                  42));
     * ```
     *
     *
     * Normally you will not need to use this method since `proxy`
     * is tracking changes using the
     * `org.freedesktop.DBus.Properties.PropertiesChanged`
     * D-Bus signal. However, for performance reasons an object may
     * decide to not use this signal for some properties and instead
     * use a proprietary out-of-band mechanism to transmit changes.
     *
     * As a concrete example, consider an object with a property
     * `ChatroomParticipants` which is an array of strings. Instead of
     * transmitting the same (long) array every time the property changes,
     * it is more efficient to only transmit the delta using e.g. signals
     * `ChatroomParticipantJoined(String name)` and
     * `ChatroomParticipantParted(String name)`.
     * @param propertyName Property name.
     * @param value Value for the property or %NULL to remove it from the cache.
     */
    setCachedProperty(propertyName: string, value: GLib.Variant | null): void
    /**
     * Sets the timeout to use if -1 (specifying default timeout) is
     * passed as `timeout_msec` in the g_dbus_proxy_call() and
     * g_dbus_proxy_call_sync() functions.
     *
     * See the #GDBusProxy:g-default-timeout property for more details.
     * @param timeoutMsec Timeout in milliseconds.
     */
    setDefaultTimeout(timeoutMsec: number): void
    /**
     * Ensure that interactions with `proxy` conform to the given
     * interface. See the #GDBusProxy:g-interface-info property for more
     * details.
     * @param info Minimum interface this proxy conforms to    or %NULL to unset.
     */
    setInterfaceInfo(info: DBusInterfaceInfo | null): void

    // Own virtual methods of Gio-2.0.Gio.DBusProxy

    /**
     * Signal class handler for the #GDBusProxy::g-properties-changed signal.
     * @virtual
     * @param changedProperties
     * @param invalidatedProperties
     */
    gPropertiesChanged(
      changedProperties: GLib.Variant,
      invalidatedProperties: string
    ): void
    /**
     * Signal class handler for the #GDBusProxy::g-signal signal.
     * @virtual
     * @param senderName
     * @param signalName
     * @param parameters
     */
    gSignal(
      senderName: string,
      signalName: string,
      parameters: GLib.Variant
    ): void

    // Own signals of Gio-2.0.Gio.DBusProxy

    connect(
      sigName: "g-properties-changed",
      callback: DBusProxy.GPropertiesChangedSignalCallback
    ): number
    on(
      sigName: "g-properties-changed",
      callback: DBusProxy.GPropertiesChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "g-properties-changed",
      callback: DBusProxy.GPropertiesChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "g-properties-changed",
      callback: DBusProxy.GPropertiesChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "g-properties-changed",
      invalidatedProperties: string[],
      ...args: any[]
    ): void
    connect(
      sigName: "g-signal",
      callback: DBusProxy.GSignalSignalCallback
    ): number
    on(
      sigName: "g-signal",
      callback: DBusProxy.GSignalSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "g-signal",
      callback: DBusProxy.GSignalSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "g-signal",
      callback: DBusProxy.GSignalSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "g-signal",
      signalName: string | null,
      parameters: GLib.Variant,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.DBusProxy

    connect(
      sigName: "notify::g-bus-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-bus-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-bus-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-bus-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-bus-type", ...args: any[]): void
    connect(
      sigName: "notify::g-connection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-connection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-connection", ...args: any[]): void
    connect(
      sigName: "notify::g-default-timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-default-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-default-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-default-timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-default-timeout", ...args: any[]): void
    connect(
      sigName: "notify::g-flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-flags", ...args: any[]): void
    connect(
      sigName: "notify::g-interface-info",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-interface-info",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-interface-info",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-interface-info",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-interface-info", ...args: any[]): void
    connect(
      sigName: "notify::g-interface-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-interface-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-interface-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-interface-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-interface-name", ...args: any[]): void
    connect(
      sigName: "notify::g-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-name", ...args: any[]): void
    connect(
      sigName: "notify::g-name-owner",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-name-owner",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-name-owner",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-name-owner",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-name-owner", ...args: any[]): void
    connect(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::g-object-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::g-object-path", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDBusProxy` is a base class used for proxies to access a D-Bus
   * interface on a remote object. A `GDBusProxy` can be constructed for
   * both well-known and unique names.
   *
   * By default, `GDBusProxy` will cache all properties (and listen to
   * changes) of the remote object, and proxy all signals that get
   * emitted. This behaviour can be changed by passing suitable
   * [flags`Gio`.DBusProxyFlags] when the proxy is created. If the proxy is for a
   * well-known name, the property cache is flushed when the name owner
   * vanishes and reloaded when a name owner appears.
   *
   * The unique name owner of the proxy’s name is tracked and can be read from
   * [property`Gio`.DBusProxy:g-name-owner]. Connect to the
   * [signal`GObject`.Object::notify] signal to get notified of changes.
   * Additionally, only signals and property changes emitted from the current name
   * owner are considered and calls are always sent to the current name owner.
   * This avoids a number of race conditions when the name is lost by one owner
   * and claimed by another. However, if no name owner currently exists,
   * then calls will be sent to the well-known name which may result in
   * the message bus launching an owner (unless
   * `G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START` is set).
   *
   * If the proxy is for a stateless D-Bus service, where the name owner may
   * be started and stopped between calls, the
   * [property`Gio`.DBusProxy:g-name-owner] tracking of `GDBusProxy` will cause the
   * proxy to drop signal and property changes from the service after it has
   * restarted for the first time. When interacting with a stateless D-Bus
   * service, do not use `GDBusProxy` — use direct D-Bus method calls and signal
   * connections.
   *
   * The generic [signal`Gio`.DBusProxy::g-properties-changed] and
   * [signal`Gio`.DBusProxy::g-signal] signals are not very convenient to work
   * with. Therefore, the recommended way of working with proxies is to subclass
   * `GDBusProxy`, and have more natural properties and signals in your derived
   * class. This [example](migrating-gdbus.html#using-gdbus-codegen) shows how
   * this can easily be done using the [`gdbus-codegen`](gdbus-codegen.html) tool.
   *
   * A `GDBusProxy` instance can be used from multiple threads but note
   * that all signals (e.g. [signal`Gio`.DBusProxy::g-signal],
   * [signal`Gio`.DBusProxy::g-properties-changed] and
   * [signal`GObject`.Object::notify]) are emitted in the thread-default main
   * context (see [method`GLib`.MainContext.push_thread_default]) of the thread
   * where the instance was constructed.
   *
   * An example using a proxy for a well-known name can be found in
   * [`gdbus-example-watch-proxy.c`](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-watch-proxy.c).
   * @class
   */
  class DBusProxy extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusProxy

    static name: string

    // Constructors of Gio-2.0.Gio.DBusProxy

    constructor(config?: DBusProxy.ConstructorProperties)
    /**
     * Finishes creating a #GDBusProxy.
     * @constructor
     * @param res A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new().
     * @returns A #GDBusProxy or %NULL if @error is set.    Free with g_object_unref().
     */
    static newFinish(res: AsyncResult): DBusProxy
    /**
     * Finishes creating a #GDBusProxy.
     * @constructor
     * @param res A #GAsyncResult obtained from the #GAsyncReadyCallback function passed to g_dbus_proxy_new_for_bus().
     * @returns A #GDBusProxy or %NULL if @error is set.    Free with g_object_unref().
     */
    static newForBusFinish(res: AsyncResult): DBusProxy
    /**
     * Like g_dbus_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
     *
     * #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
     * @constructor
     * @param busType A #GBusType.
     * @param flags Flags used when constructing the proxy.
     * @param info A #GDBusInterfaceInfo specifying the minimal interface        that `proxy` conforms to or %NULL.
     * @param name A bus name (well-known or unique).
     * @param objectPath An object path.
     * @param interfaceName A D-Bus interface name.
     * @param cancellable A #GCancellable or %NULL.
     * @returns A #GDBusProxy or %NULL if error is set.    Free with g_object_unref().
     */
    static newForBusSync(
      busType: BusType,
      flags: DBusProxyFlags,
      info: DBusInterfaceInfo | null,
      name: string,
      objectPath: string,
      interfaceName: string,
      cancellable: Cancellable | null
    ): DBusProxy
    /**
     * Creates a proxy for accessing `interface_name` on the remote object
     * at `object_path` owned by `name` at `connection` and synchronously
     * loads D-Bus properties unless the
     * %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used.
     *
     * If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
     * match rules for signals. Connect to the #GDBusProxy::g-signal signal
     * to handle signals from the remote object.
     *
     * If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and
     * %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is
     * guaranteed to return immediately without blocking.
     *
     * If `name` is a well-known name and the
     * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION
     * flags aren't set and no name owner currently exists, the message bus
     * will be requested to launch a name owner for the name.
     *
     * This is a synchronous failable constructor. See g_dbus_proxy_new()
     * and g_dbus_proxy_new_finish() for the asynchronous version.
     *
     * #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
     * @constructor
     * @param connection A #GDBusConnection.
     * @param flags Flags used when constructing the proxy.
     * @param info A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
     * @param name A bus name (well-known or unique) or %NULL if `connection` is not a message bus connection.
     * @param objectPath An object path.
     * @param interfaceName A D-Bus interface name.
     * @param cancellable A #GCancellable or %NULL.
     * @returns A #GDBusProxy or %NULL if error is set.    Free with g_object_unref().
     */
    static newSync(
      connection: DBusConnection,
      flags: DBusProxyFlags,
      info: DBusInterfaceInfo | null,
      name: string | null,
      objectPath: string,
      interfaceName: string,
      cancellable: Cancellable | null
    ): DBusProxy
    _init(config?: DBusProxy.ConstructorProperties): void
    /**
     * Creates a proxy for accessing `interface_name` on the remote object
     * at `object_path` owned by `name` at `connection` and asynchronously
     * loads D-Bus properties unless the
     * %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to
     * the #GDBusProxy::g-properties-changed signal to get notified about
     * property changes.
     *
     * If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
     * match rules for signals. Connect to the #GDBusProxy::g-signal signal
     * to handle signals from the remote object.
     *
     * If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and
     * %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is
     * guaranteed to complete immediately without blocking.
     *
     * If `name` is a well-known name and the
     * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION
     * flags aren't set and no name owner currently exists, the message bus
     * will be requested to launch a name owner for the name.
     *
     * This is a failable asynchronous constructor - when the proxy is
     * ready, `callback` will be invoked and you can use
     * g_dbus_proxy_new_finish() to get the result.
     *
     * See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
     *
     * #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
     * @param connection A #GDBusConnection.
     * @param flags Flags used when constructing the proxy.
     * @param info A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
     * @param name A bus name (well-known or unique) or %NULL if `connection` is not a message bus connection.
     * @param objectPath An object path.
     * @param interfaceName A D-Bus interface name.
     * @param cancellable A #GCancellable or %NULL.
     * @param callback Callback function to invoke when the proxy is ready.
     */
    static new(
      connection: DBusConnection,
      flags: DBusProxyFlags,
      info: DBusInterfaceInfo | null,
      name: string | null,
      objectPath: string,
      interfaceName: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Like g_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
     *
     * #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
     * @param busType A #GBusType.
     * @param flags Flags used when constructing the proxy.
     * @param info A #GDBusInterfaceInfo specifying the minimal interface that `proxy` conforms to or %NULL.
     * @param name A bus name (well-known or unique).
     * @param objectPath An object path.
     * @param interfaceName A D-Bus interface name.
     * @param cancellable A #GCancellable or %NULL.
     * @param callback Callback function to invoke when the proxy is ready.
     */
    static newForBus(
      busType: BusType,
      flags: DBusProxyFlags,
      info: DBusInterfaceInfo | null,
      name: string,
      objectPath: string,
      interfaceName: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
  }

  module DBusServer {
    // Signal callback interfaces

    /**
     * Signal callback interface for `new-connection`
     */
    interface NewConnectionSignalCallback {
      (connection: DBusConnection): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DBusServer

      /**
       * The D-Bus address to listen on.
       */
      address?: string | null
      /**
       * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
       */
      authentication_observer?: DBusAuthObserver | null
      /**
       * Flags from the #GDBusServerFlags enumeration.
       */
      flags?: DBusServerFlags | null
      /**
       * The GUID of the server.
       *
       * See #GDBusConnection:guid for more details.
       */
      guid?: string | null
    }
  }

  interface DBusServer extends Initable {
    // Own properties of Gio-2.0.Gio.DBusServer

    /**
     * Whether the server is currently active.
     */
    readonly active: boolean
    /**
     * The D-Bus address to listen on.
     */
    readonly address: string | null
    /**
     * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
     */
    readonly authenticationObserver: DBusAuthObserver
    /**
     * The D-Bus address that clients can use.
     */
    readonly clientAddress: string | null
    /**
     * Flags from the #GDBusServerFlags enumeration.
     */
    readonly flags: DBusServerFlags
    /**
     * The GUID of the server.
     *
     * See #GDBusConnection:guid for more details.
     */
    readonly guid: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DBusServer

    /**
     * Gets a
     * [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses)
     * string that can be used by clients to connect to `server`.
     *
     * This is valid and non-empty if initializing the #GDBusServer succeeded.
     * @returns A D-Bus address string. Do not free, the string is owned by @server.
     */
    getClientAddress(): string
    /**
     * Gets the flags for `server`.
     * @returns A set of flags from the #GDBusServerFlags enumeration.
     */
    getFlags(): DBusServerFlags
    /**
     * Gets the GUID for `server,` as provided to g_dbus_server_new_sync().
     * @returns A D-Bus GUID. Do not free this string, it is owned by @server.
     */
    getGuid(): string
    /**
     * Gets whether `server` is active.
     * @returns %TRUE if server is active, %FALSE otherwise.
     */
    isActive(): boolean
    /**
     * Starts `server`.
     */
    start(): void
    /**
     * Stops `server`.
     */
    stop(): void

    // Own signals of Gio-2.0.Gio.DBusServer

    connect(
      sigName: "new-connection",
      callback: DBusServer.NewConnectionSignalCallback
    ): number
    on(
      sigName: "new-connection",
      callback: DBusServer.NewConnectionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "new-connection",
      callback: DBusServer.NewConnectionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "new-connection",
      callback: DBusServer.NewConnectionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "new-connection", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.DBusServer

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::address", ...args: any[]): void
    connect(
      sigName: "notify::authentication-observer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::authentication-observer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::authentication-observer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::authentication-observer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::authentication-observer", ...args: any[]): void
    connect(
      sigName: "notify::client-address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::client-address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::client-address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::client-address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::client-address", ...args: any[]): void
    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(sigName: "notify::guid", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::guid",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::guid",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::guid",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::guid", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDBusServer` is a helper for listening to and accepting D-Bus
   * connections. This can be used to create a new D-Bus server, allowing two
   * peers to use the D-Bus protocol for their own specialized communication.
   * A server instance provided in this way will not perform message routing or
   * implement the
   * [`org.freedesktop.DBus` interface](https://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-messages).
   *
   * To just export an object on a well-known name on a message bus, such as the
   * session or system bus, you should instead use [func`Gio`.bus_own_name].
   *
   * An example of peer-to-peer communication with GDBus can be found
   * in [gdbus-example-peer.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-peer.c).
   *
   * Note that a minimal `GDBusServer` will accept connections from any
   * peer. In many use-cases it will be necessary to add a
   * [class`Gio`.DBusAuthObserver] that only accepts connections that have
   * successfully authenticated as the same user that is running the
   * `GDBusServer`. Since GLib 2.68 this can be achieved more simply by passing
   * the `G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER` flag to the
   * server.
   * @class
   */
  class DBusServer extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DBusServer

    static name: string

    // Constructors of Gio-2.0.Gio.DBusServer

    constructor(config?: DBusServer.ConstructorProperties)
    /**
     * Creates a new D-Bus server that listens on the first address in
     * `address` that works.
     *
     * Once constructed, you can use g_dbus_server_get_client_address() to
     * get a D-Bus address string that clients can use to connect.
     *
     * To have control over the available authentication mechanisms and
     * the users that are authorized to connect, it is strongly recommended
     * to provide a non-%NULL #GDBusAuthObserver.
     *
     * Connect to the #GDBusServer::new-connection signal to handle
     * incoming connections.
     *
     * The returned #GDBusServer isn't active - you have to start it with
     * g_dbus_server_start().
     *
     * #GDBusServer is used in this [example][gdbus-peer-to-peer].
     *
     * This is a synchronous failable constructor. There is currently no
     * asynchronous version.
     * @constructor
     * @param address A D-Bus address.
     * @param flags Flags from the #GDBusServerFlags enumeration.
     * @param guid A D-Bus GUID.
     * @param observer A #GDBusAuthObserver or %NULL.
     * @param cancellable A #GCancellable or %NULL.
     * @returns A #GDBusServer or %NULL if @error is set. Free with g_object_unref().
     */
    static newSync(
      address: string,
      flags: DBusServerFlags,
      guid: string,
      observer: DBusAuthObserver | null,
      cancellable: Cancellable | null
    ): DBusServer
    _init(config?: DBusServer.ConstructorProperties): void
  }

  module DataInputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends Seekable.ConstructorProperties,
        BufferedInputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DataInputStream

      /**
       * The :byte-order property determines the byte ordering that
       * is used when reading multi-byte entities (such as integers)
       * from the stream.
       */
      byte_order?: DataStreamByteOrder | null
      /**
       * The :newline-type property determines what is considered
       * as a line ending when reading complete lines from the stream.
       */
      newline_type?: DataStreamNewlineType | null
    }
  }

  interface DataInputStream extends Seekable {
    // Own properties of Gio-2.0.Gio.DataInputStream

    /**
     * The :byte-order property determines the byte ordering that
     * is used when reading multi-byte entities (such as integers)
     * from the stream.
     */
    byteOrder: DataStreamByteOrder
    /**
     * The :newline-type property determines what is considered
     * as a line ending when reading complete lines from the stream.
     */
    newlineType: DataStreamNewlineType
    __gtype__: number

    // Own fields of Gio-2.0.Gio.DataInputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.DataInputStream

    /**
     * Gets the byte order for the data input stream.
     * @returns the @stream's current #GDataStreamByteOrder.
     */
    getByteOrder(): DataStreamByteOrder
    /**
     * Gets the current newline type for the `stream`.
     * @returns #GDataStreamNewlineType for the given @stream.
     */
    getNewlineType(): DataStreamNewlineType
    /**
     * Reads an unsigned 8-bit/1-byte value from `stream`.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns an unsigned 8-bit/1-byte value read from the @stream or `0` if an error occurred.
     */
    readByte(cancellable: Cancellable | null): number
    /**
     * Reads a 16-bit/2-byte value from `stream`.
     *
     * In order to get the correct byte order for this read operation,
     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a signed 16-bit/2-byte value read from @stream or `0` if an error occurred.
     */
    readInt16(cancellable: Cancellable | null): number
    /**
     * Reads a signed 32-bit/4-byte value from `stream`.
     *
     * In order to get the correct byte order for this read operation,
     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a signed 32-bit/4-byte value read from the @stream or `0` if an error occurred.
     */
    readInt32(cancellable: Cancellable | null): number
    /**
     * Reads a 64-bit/8-byte value from `stream`.
     *
     * In order to get the correct byte order for this read operation,
     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a signed 64-bit/8-byte value read from @stream or `0` if an error occurred.
     */
    readInt64(cancellable: Cancellable | null): number
    /**
     * Reads a line from the data input stream.  Note that no encoding
     * checks or conversion is performed; the input is not guaranteed to
     * be UTF-8, and may in fact have embedded NUL characters.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a NUL terminated byte array with the line that was read in  (without the newlines).  Set @length to a #gsize to get the length  of the read line.  On an error, it will return %NULL and @error  will be set. If there's no content to read, it will still return  %NULL, but @error won't be set.
     */
    readLine(
      cancellable: Cancellable | null
    ): [/* returnType */ number[] | null, /* length */ number]
    /**
     * The asynchronous version of g_data_input_stream_read_line().  It is
     * an error to have two outstanding calls to this function.
     *
     * When the operation is finished, `callback` will be called. You
     * can then call g_data_input_stream_read_line_finish() to get
     * the result of the operation.
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback callback to call when the request is satisfied.
     */
    readLineAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous call started by
     * g_data_input_stream_read_line_async().  Note the warning about
     * string encoding in g_data_input_stream_read_line() applies here as
     * well.
     * @param result the #GAsyncResult that was provided to the callback.
     * @returns a NUL-terminated byte array with the line that was read in  (without the newlines).  Set @length to a #gsize to get the length  of the read line.  On an error, it will return %NULL and @error  will be set. If there's no content to read, it will still return  %NULL, but @error won't be set.
     */
    readLineFinish(
      result: AsyncResult
    ): [/* returnType */ number[] | null, /* length */ number]
    /**
     * Finish an asynchronous call started by
     * g_data_input_stream_read_line_async().
     * @param result the #GAsyncResult that was provided to the callback.
     * @returns a string with the line that  was read in (without the newlines).  Set @length to a #gsize to  get the length of the read line.  On an error, it will return  %NULL and @error will be set. For UTF-8 conversion errors, the set  error domain is %G_CONVERT_ERROR.  If there's no content to read,  it will still return %NULL, but @error won't be set.
     */
    readLineFinishUtf8(
      result: AsyncResult
    ): [/* returnType */ string | null, /* length */ number]
    /**
     * Reads a UTF-8 encoded line from the data input stream.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a NUL terminated UTF-8 string  with the line that was read in (without the newlines).  Set  @length to a #gsize to get the length of the read line.  On an  error, it will return %NULL and @error will be set.  For UTF-8  conversion errors, the set error domain is %G_CONVERT_ERROR.  If  there's no content to read, it will still return %NULL, but @error  won't be set.
     */
    readLineUtf8(
      cancellable: Cancellable | null
    ): [/* returnType */ string | null, /* length */ number]
    /**
     * Reads an unsigned 16-bit/2-byte value from `stream`.
     *
     * In order to get the correct byte order for this read operation,
     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns an unsigned 16-bit/2-byte value read from the @stream or `0` if an error occurred.
     */
    readUint16(cancellable: Cancellable | null): number
    /**
     * Reads an unsigned 32-bit/4-byte value from `stream`.
     *
     * In order to get the correct byte order for this read operation,
     * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns an unsigned 32-bit/4-byte value read from the @stream or `0` if an error occurred.
     */
    readUint32(cancellable: Cancellable | null): number
    /**
     * Reads an unsigned 64-bit/8-byte value from `stream`.
     *
     * In order to get the correct byte order for this read operation,
     * see g_data_input_stream_get_byte_order().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns an unsigned 64-bit/8-byte read from @stream or `0` if an error occurred.
     */
    readUint64(cancellable: Cancellable | null): number
    /**
     * Reads a string from the data input stream, up to the first
     * occurrence of any of the stop characters.
     *
     * Note that, in contrast to g_data_input_stream_read_until_async(),
     * this function consumes the stop character that it finds.
     *
     * Don't use this function in new code.  Its functionality is
     * inconsistent with g_data_input_stream_read_until_async().  Both
     * functions will be marked as deprecated in a future release.  Use
     * g_data_input_stream_read_upto() instead, but note that that function
     * does not consume the stop character.
     * @param stopChars characters to terminate the read.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a string with the data that was read     before encountering any of the stop characters. Set @length to     a #gsize to get the length of the string. This function will     return %NULL on an error.
     */
    readUntil(
      stopChars: string,
      cancellable: Cancellable | null
    ): [/* returnType */ string | null, /* length */ number]
    /**
     * The asynchronous version of g_data_input_stream_read_until().
     * It is an error to have two outstanding calls to this function.
     *
     * Note that, in contrast to g_data_input_stream_read_until(),
     * this function does not consume the stop character that it finds.  You
     * must read it for yourself.
     *
     * When the operation is finished, `callback` will be called. You
     * can then call g_data_input_stream_read_until_finish() to get
     * the result of the operation.
     *
     * Don't use this function in new code.  Its functionality is
     * inconsistent with g_data_input_stream_read_until().  Both functions
     * will be marked as deprecated in a future release.  Use
     * g_data_input_stream_read_upto_async() instead.
     * @param stopChars characters to terminate the read.
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback callback to call when the request is satisfied.
     */
    readUntilAsync(
      stopChars: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous call started by
     * g_data_input_stream_read_until_async().
     * @param result the #GAsyncResult that was provided to the callback.
     * @returns a string with the data that was read     before encountering any of the stop characters. Set @length to     a #gsize to get the length of the string. This function will     return %NULL on an error.
     */
    readUntilFinish(
      result: AsyncResult
    ): [/* returnType */ string | null, /* length */ number]
    /**
     * Reads a string from the data input stream, up to the first
     * occurrence of any of the stop characters.
     *
     * In contrast to g_data_input_stream_read_until(), this function
     * does not consume the stop character. You have to use
     * g_data_input_stream_read_byte() to get it before calling
     * g_data_input_stream_read_upto() again.
     *
     * Note that `stop_chars` may contain '\0' if `stop_chars_len` is
     * specified.
     *
     * The returned string will always be nul-terminated on success.
     * @param stopChars characters to terminate the read
     * @param stopCharsLen length of `stop_chars`. May be -1 if `stop_chars` is     nul-terminated
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns a string with the data that was read     before encountering any of the stop characters. Set @length to     a #gsize to get the length of the string. This function will     return %NULL on an error
     */
    readUpto(
      stopChars: string,
      stopCharsLen: number,
      cancellable: Cancellable | null
    ): [/* returnType */ string | null, /* length */ number]
    /**
     * The asynchronous version of g_data_input_stream_read_upto().
     * It is an error to have two outstanding calls to this function.
     *
     * In contrast to g_data_input_stream_read_until(), this function
     * does not consume the stop character. You have to use
     * g_data_input_stream_read_byte() to get it before calling
     * g_data_input_stream_read_upto() again.
     *
     * Note that `stop_chars` may contain '\0' if `stop_chars_len` is
     * specified.
     *
     * When the operation is finished, `callback` will be called. You
     * can then call g_data_input_stream_read_upto_finish() to get
     * the result of the operation.
     * @param stopChars characters to terminate the read
     * @param stopCharsLen length of `stop_chars`. May be -1 if `stop_chars` is     nul-terminated
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback callback to call when the request is satisfied
     */
    readUptoAsync(
      stopChars: string,
      stopCharsLen: number,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous call started by
     * g_data_input_stream_read_upto_async().
     *
     * Note that this function does not consume the stop character. You
     * have to use g_data_input_stream_read_byte() to get it before calling
     * g_data_input_stream_read_upto_async() again.
     *
     * The returned string will always be nul-terminated on success.
     * @param result the #GAsyncResult that was provided to the callback
     * @returns a string with the data that was read     before encountering any of the stop characters. Set @length to     a #gsize to get the length of the string. This function will     return %NULL on an error.
     */
    readUptoFinish(
      result: AsyncResult
    ): [/* returnType */ string | null, /* length */ number]
    /**
     * This function sets the byte order for the given `stream`. All subsequent
     * reads from the `stream` will be read in the given `order`.
     * @param order a #GDataStreamByteOrder to set.
     */
    setByteOrder(order: DataStreamByteOrder): void
    /**
     * Sets the newline type for the `stream`.
     *
     * Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read
     * chunk ends in "CR" we must read an additional byte to know if this is "CR" or
     * "CR LF", and this might block if there is no more data available.
     * @param type the type of new line return as #GDataStreamNewlineType.
     */
    setNewlineType(type: DataStreamNewlineType): void

    // Class property signals of Gio-2.0.Gio.DataInputStream

    connect(
      sigName: "notify::byte-order",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::byte-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::byte-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::byte-order",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::byte-order", ...args: any[]): void
    connect(
      sigName: "notify::newline-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::newline-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::newline-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::newline-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::newline-type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::buffer-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::buffer-size", ...args: any[]): void
    connect(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-base-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Data input stream implements [class`Gio`.InputStream] and includes functions
   * for reading structured data directly from a binary input stream.
   * @class
   */
  class DataInputStream extends BufferedInputStream {
    // Own properties of Gio-2.0.Gio.DataInputStream

    static name: string

    // Constructors of Gio-2.0.Gio.DataInputStream

    constructor(config?: DataInputStream.ConstructorProperties)
    /**
     * Creates a new data input stream for the `base_stream`.
     * @constructor
     * @param baseStream a #GInputStream.
     * @returns a new #GDataInputStream.
     */
    constructor(baseStream: InputStream)
    /**
     * Creates a new data input stream for the `base_stream`.
     * @constructor
     * @param baseStream a #GInputStream.
     * @returns a new #GDataInputStream.
     */
    static new(baseStream: InputStream): DataInputStream

    // Overloads of new

    /**
     * Creates a new #GInputStream from the given `base_stream,` with
     * a buffer set to the default size (4 kilobytes).
     * @constructor
     * @param baseStream a #GInputStream
     * @returns a #GInputStream for the given @base_stream.
     */
    static new(baseStream: InputStream): BufferedInputStream
    _init(config?: DataInputStream.ConstructorProperties): void
  }

  module DataOutputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends Seekable.ConstructorProperties,
        FilterOutputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DataOutputStream

      /**
       * Determines the byte ordering that is used when writing
       * multi-byte entities (such as integers) to the stream.
       */
      byte_order?: DataStreamByteOrder | null
    }
  }

  interface DataOutputStream extends Seekable {
    // Own properties of Gio-2.0.Gio.DataOutputStream

    /**
     * Determines the byte ordering that is used when writing
     * multi-byte entities (such as integers) to the stream.
     */
    byteOrder: DataStreamByteOrder
    __gtype__: number

    // Own fields of Gio-2.0.Gio.DataOutputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.DataOutputStream

    /**
     * Gets the byte order for the stream.
     * @returns the #GDataStreamByteOrder for the @stream.
     */
    getByteOrder(): DataStreamByteOrder
    /**
     * Puts a byte into the output stream.
     * @param data a #guchar.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if @data was successfully added to the @stream.
     */
    putByte(data: number, cancellable: Cancellable | null): boolean
    /**
     * Puts a signed 16-bit integer into the output stream.
     * @param data a #gint16.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if @data was successfully added to the @stream.
     */
    putInt16(data: number, cancellable: Cancellable | null): boolean
    /**
     * Puts a signed 32-bit integer into the output stream.
     * @param data a #gint32.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if @data was successfully added to the @stream.
     */
    putInt32(data: number, cancellable: Cancellable | null): boolean
    /**
     * Puts a signed 64-bit integer into the stream.
     * @param data a #gint64.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if @data was successfully added to the @stream.
     */
    putInt64(data: number, cancellable: Cancellable | null): boolean
    /**
     * Puts a string into the output stream.
     * @param str a string.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if @string was successfully added to the @stream.
     */
    putString(str: string, cancellable: Cancellable | null): boolean
    /**
     * Puts an unsigned 16-bit integer into the output stream.
     * @param data a #guint16.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if @data was successfully added to the @stream.
     */
    putUint16(data: number, cancellable: Cancellable | null): boolean
    /**
     * Puts an unsigned 32-bit integer into the stream.
     * @param data a #guint32.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if @data was successfully added to the @stream.
     */
    putUint32(data: number, cancellable: Cancellable | null): boolean
    /**
     * Puts an unsigned 64-bit integer into the stream.
     * @param data a #guint64.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if @data was successfully added to the @stream.
     */
    putUint64(data: number, cancellable: Cancellable | null): boolean
    /**
     * Sets the byte order of the data output stream to `order`.
     * @param order a %GDataStreamByteOrder.
     */
    setByteOrder(order: DataStreamByteOrder): void

    // Class property signals of Gio-2.0.Gio.DataOutputStream

    connect(
      sigName: "notify::byte-order",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::byte-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::byte-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::byte-order",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::byte-order", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-base-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Data output stream implements [class`Gio`.OutputStream] and includes functions
   * for writing data directly to an output stream.
   * @class
   */
  class DataOutputStream extends FilterOutputStream {
    // Own properties of Gio-2.0.Gio.DataOutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.DataOutputStream

    constructor(config?: DataOutputStream.ConstructorProperties)
    /**
     * Creates a new data output stream for `base_stream`.
     * @constructor
     * @param baseStream a #GOutputStream.
     * @returns #GDataOutputStream.
     */
    constructor(baseStream: OutputStream)
    /**
     * Creates a new data output stream for `base_stream`.
     * @constructor
     * @param baseStream a #GOutputStream.
     * @returns #GDataOutputStream.
     */
    static new(baseStream: OutputStream): DataOutputStream
    _init(config?: DataOutputStream.ConstructorProperties): void
  }

  module DebugControllerDBus {
    // Signal callback interfaces

    /**
     * Signal callback interface for `authorize`
     */
    interface AuthorizeSignalCallback {
      (invocation: DBusMethodInvocation): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends DebugController.ConstructorProperties,
        Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DebugControllerDBus

      /**
       * The D-Bus connection to expose the debugging interface on.
       *
       * Typically this will be the same connection (to the system or session bus)
       * which the rest of the application or service’s D-Bus objects are registered
       * on.
       */
      connection?: DBusConnection | null
    }
  }

  interface DebugControllerDBus extends DebugController, Initable {
    // Own properties of Gio-2.0.Gio.DebugControllerDBus

    /**
     * The D-Bus connection to expose the debugging interface on.
     *
     * Typically this will be the same connection (to the system or session bus)
     * which the rest of the application or service’s D-Bus objects are registered
     * on.
     */
    readonly connection: DBusConnection
    __gtype__: number

    // Own fields of Gio-2.0.Gio.DebugControllerDBus

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.DebugControllerDBus

    /**
     * Stop the debug controller, unregistering its object from the bus.
     *
     * Any pending method calls to the object will complete successfully, but new
     * ones will return an error. This method will block until all pending
     * #GDebugControllerDBus::authorize signals have been handled. This is expected
     * to not take long, as it will just be waiting for threads to join. If any
     * #GDebugControllerDBus::authorize signal handlers are still executing in other
     * threads, this will block until after they have returned.
     *
     * This method will be called automatically when the final reference to the
     * #GDebugControllerDBus is dropped. You may want to call it explicitly to know
     * when the controller has been fully removed from the bus, or to break
     * reference count cycles.
     *
     * Calling this method from within a #GDebugControllerDBus::authorize signal
     * handler will cause a deadlock and must not be done.
     */
    stop(): void

    // Own virtual methods of Gio-2.0.Gio.DebugControllerDBus

    /**
     * Default handler for the #GDebugControllerDBus::authorize signal.
     * @virtual
     * @param invocation
     */
    authorize(invocation: DBusMethodInvocation): boolean

    // Own signals of Gio-2.0.Gio.DebugControllerDBus

    connect(
      sigName: "authorize",
      callback: DebugControllerDBus.AuthorizeSignalCallback
    ): number
    on(
      sigName: "authorize",
      callback: DebugControllerDBus.AuthorizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "authorize",
      callback: DebugControllerDBus.AuthorizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "authorize",
      callback: DebugControllerDBus.AuthorizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "authorize", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.DebugControllerDBus

    connect(
      sigName: "notify::connection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::connection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::connection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::connection", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::debug-enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::debug-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::debug-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::debug-enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::debug-enabled", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDebugControllerDBus` is an implementation of [iface`Gio`.DebugController]
   * which exposes debug settings as a D-Bus object.
   *
   * It is a [iface`Gio`.Initable] object, and will register an object at
   * `/org/gtk/Debugging` on the bus given as
   * [property`Gio`.DebugControllerDBus:connection] once it’s initialized. The
   * object will be unregistered when the last reference to the
   * `GDebugControllerDBus` is dropped.
   *
   * This D-Bus object can be used by remote processes to enable or disable debug
   * output in this process. Remote processes calling
   * `org.gtk.Debugging.SetDebugEnabled()` will affect the value of
   * [property`Gio`.DebugController:debug-enabled] and, by default,
   * [func`GLib`.log_get_debug_enabled].
   *
   * By default, no processes are allowed to call `SetDebugEnabled()` unless a
   * [signal`Gio`.DebugControllerDBus::authorize] signal handler is installed. This
   * is because the process may be privileged, or might expose sensitive
   * information in its debug output. You may want to restrict the ability to
   * enable debug output to privileged users or processes.
   *
   * One option is to install a D-Bus security policy which restricts access to
   * `SetDebugEnabled()`, installing something like the following in
   * `$datadir/dbus-1/system.d/`:
   *
   * ```xml
   * <?xml version="1.0"?> <!--*-nxml-*-->
   * <!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
   *      "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
   * <busconfig>
   *   <policy user="root">
   *     <allow send_destination="com.example.MyService" send_interface="org.gtk.Debugging"/>
   *   </policy>
   *   <policy context="default">
   *     <deny send_destination="com.example.MyService" send_interface="org.gtk.Debugging"/>
   *   </policy>
   * </busconfig>
   * ```
   *
   * This will prevent the `SetDebugEnabled()` method from being called by all
   * except root. It will not prevent the `DebugEnabled` property from being read,
   * as it’s accessed through the `org.freedesktop.DBus.Properties` interface.
   *
   * Another option is to use polkit to allow or deny requests on a case-by-case
   * basis, allowing for the possibility of dynamic authorisation. To do this,
   * connect to the [signal`Gio`.DebugControllerDBus::authorize] signal and query
   * polkit in it:
   *
   * ```c
   *   g_autoptr(GError) child_error = NULL;
   *   g_autoptr(GDBusConnection) connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
   *   gulong debug_controller_authorize_id = 0;
   *
   *   // Set up the debug controller.
   *   debug_controller = G_DEBUG_CONTROLLER (g_debug_controller_dbus_new (priv->connection, NULL, &child_error));
   *   if (debug_controller == NULL)
   *     {
   *       g_error ("Could not register debug controller on bus: %s"),
   *                child_error->message);
   *     }
   *
   *   debug_controller_authorize_id = g_signal_connect (debug_controller,
   *                                                     "authorize",
   *                                                     G_CALLBACK (debug_controller_authorize_cb),
   *                                                     self);
   *
   *   static gboolean
   *   debug_controller_authorize_cb (GDebugControllerDBus  *debug_controller,
   *                                  GDBusMethodInvocation *invocation,
   *                                  gpointer               user_data)
   *   {
   *     g_autoptr(PolkitAuthority) authority = NULL;
   *     g_autoptr(PolkitSubject) subject = NULL;
   *     g_autoptr(PolkitAuthorizationResult) auth_result = NULL;
   *     g_autoptr(GError) local_error = NULL;
   *     GDBusMessage *message;
   *     GDBusMessageFlags message_flags;
   *     PolkitCheckAuthorizationFlags flags = POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE;
   *
   *     message = g_dbus_method_invocation_get_message (invocation);
   *     message_flags = g_dbus_message_get_flags (message);
   *
   *     authority = polkit_authority_get_sync (NULL, &local_error);
   *     if (authority == NULL)
   *       {
   *         g_warning ("Failed to get polkit authority: %s", local_error->message);
   *         return FALSE;
   *       }
   *
   *     if (message_flags & G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION)
   *       flags |= POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION;
   *
   *     subject = polkit_system_bus_name_new (g_dbus_method_invocation_get_sender (invocation));
   *
   *     auth_result = polkit_authority_check_authorization_sync (authority,
   *                                                              subject,
   *                                                              "com.example.MyService.set-debug-enabled",
   *                                                              NULL,
   *                                                              flags,
   *                                                              NULL,
   *                                                              &local_error);
   *     if (auth_result == NULL)
   *       {
   *         g_warning ("Failed to get check polkit authorization: %s", local_error->message);
   *         return FALSE;
   *       }
   *
   *     return polkit_authorization_result_get_is_authorized (auth_result);
   *   }
   * ```
   * @class
   */
  class DebugControllerDBus extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DebugControllerDBus

    static name: string

    // Constructors of Gio-2.0.Gio.DebugControllerDBus

    constructor(config?: DebugControllerDBus.ConstructorProperties)
    /**
     * Create a new #GDebugControllerDBus and synchronously initialize it.
     *
     * Initializing the object will export the debug object on `connection`. The
     * object will remain registered until the last reference to the
     * #GDebugControllerDBus is dropped.
     *
     * Initialization may fail if registering the object on `connection` fails.
     * @constructor
     * @param connection a #GDBusConnection to register the debug object on
     * @param cancellable a #GCancellable, or %NULL
     * @returns a new #GDebugControllerDBus, or %NULL   on failure
     */
    constructor(connection: DBusConnection, cancellable: Cancellable | null)
    /**
     * Create a new #GDebugControllerDBus and synchronously initialize it.
     *
     * Initializing the object will export the debug object on `connection`. The
     * object will remain registered until the last reference to the
     * #GDebugControllerDBus is dropped.
     *
     * Initialization may fail if registering the object on `connection` fails.
     * @constructor
     * @param connection a #GDBusConnection to register the debug object on
     * @param cancellable a #GCancellable, or %NULL
     * @returns a new #GDebugControllerDBus, or %NULL   on failure
     */
    static new(
      connection: DBusConnection,
      cancellable: Cancellable | null
    ): DebugControllerDBus
    _init(config?: DebugControllerDBus.ConstructorProperties): void
  }

  module DesktopAppInfo {
    // Constructor properties interface

    interface ConstructorProperties
      extends AppInfo.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.DesktopAppInfo

      /**
       * The origin filename of this #GDesktopAppInfo
       */
      filename?: string | null
    }
  }

  interface DesktopAppInfo extends AppInfo {
    // Own properties of Gio-2.0.Gio.DesktopAppInfo

    /**
     * The origin filename of this #GDesktopAppInfo
     */
    readonly filename: string | null
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.DesktopAppInfo

    /**
     * Gets the user-visible display name of the "additional application
     * action" specified by `action_name`.
     *
     * This corresponds to the "Name" key within the keyfile group for the
     * action.
     * @param actionName the name of the action as from   g_desktop_app_info_list_actions()
     * @returns the locale-specific action name
     */
    getActionName(actionName: string): string | null
    /**
     * Looks up a boolean value in the keyfile backing `info`.
     *
     * The `key` is looked up in the "Desktop Entry" group.
     * @param key the key to look up
     * @returns the boolean value, or %FALSE if the key     is not found
     */
    getBoolean(key: string): boolean
    /**
     * Gets the categories from the desktop file.
     * @returns The unparsed Categories key from the desktop file;     i.e. no attempt is made to split it by ';' or validate it.
     */
    getCategories(): string | null
    /**
     * When `info` was created from a known filename, return it.  In some
     * situations such as the #GDesktopAppInfo returned from
     * g_desktop_app_info_new_from_keyfile(), this function will return %NULL.
     * @returns The full path to the file for @info,     or %NULL if not known.
     */
    getFilename(): string | null
    /**
     * Gets the generic name from the desktop file.
     * @returns The value of the GenericName key
     */
    getGenericName(): string | null
    /**
     * A desktop file is hidden if the Hidden key in it is
     * set to True.
     * @returns %TRUE if hidden, %FALSE otherwise.
     */
    getIsHidden(): boolean
    /**
     * Gets the keywords from the desktop file.
     * @returns The value of the Keywords key
     */
    getKeywords(): string[]
    /**
     * Looks up a localized string value in the keyfile backing `info`
     * translated to the current locale.
     *
     * The `key` is looked up in the "Desktop Entry" group.
     * @param key the key to look up
     * @returns a newly allocated string, or %NULL if the key     is not found
     */
    getLocaleString(key: string): string | null
    /**
     * Gets the value of the NoDisplay key, which helps determine if the
     * application info should be shown in menus. See
     * %G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY and g_app_info_should_show().
     * @returns The value of the NoDisplay key
     */
    getNodisplay(): boolean
    /**
     * Checks if the application info should be shown in menus that list available
     * applications for a specific name of the desktop, based on the
     * `OnlyShowIn` and `NotShowIn` keys.
     *
     * `desktop_env` should typically be given as %NULL, in which case the
     * `XDG_CURRENT_DESKTOP` environment variable is consulted.  If you want
     * to override the default mechanism then you may specify `desktop_env,`
     * but this is not recommended.
     *
     * Note that g_app_info_should_show() for `info` will include this check (with
     * %NULL for `desktop_env)` as well as additional checks.
     * @param desktopEnv a string specifying a desktop name
     * @returns %TRUE if the @info should be shown in @desktop_env according to the `OnlyShowIn` and `NotShowIn` keys, %FALSE otherwise.
     */
    getShowIn(desktopEnv: string | null): boolean
    /**
     * Retrieves the StartupWMClass field from `info`. This represents the
     * WM_CLASS property of the main window of the application, if launched
     * through `info`.
     * @returns the startup WM class, or %NULL if none is set in the desktop file.
     */
    getStartupWmClass(): string | null
    /**
     * Looks up a string value in the keyfile backing `info`.
     *
     * The `key` is looked up in the "Desktop Entry" group.
     * @param key the key to look up
     * @returns a newly allocated string, or %NULL if the key     is not found
     */
    getString(key: string): string | null
    /**
     * Looks up a string list value in the keyfile backing `info`.
     *
     * The `key` is looked up in the "Desktop Entry" group.
     * @param key the key to look up
     * @returns a %NULL-terminated string array or %NULL if the specified  key cannot be found. The array should be freed with g_strfreev().
     */
    getStringList(key: string): string[]
    /**
     * Returns whether `key` exists in the "Desktop Entry" group
     * of the keyfile backing `info`.
     * @param key the key to look up
     * @returns %TRUE if the @key exists
     */
    hasKey(key: string): boolean
    /**
     * Activates the named application action.
     *
     * You may only call this function on action names that were
     * returned from g_desktop_app_info_list_actions().
     *
     * Note that if the main entry of the desktop file indicates that the
     * application supports startup notification, and `launch_context` is
     * non-%NULL, then startup notification will be used when activating the
     * action (and as such, invocation of the action on the receiving side
     * must signal the end of startup notification when it is completed).
     * This is the expected behaviour of applications declaring additional
     * actions, as per the desktop file specification.
     *
     * As with g_app_info_launch() there is no way to detect failures that
     * occur while using this function.
     * @param actionName the name of the action as from   g_desktop_app_info_list_actions()
     * @param launchContext a #GAppLaunchContext
     */
    launchAction(
      actionName: string,
      launchContext: AppLaunchContext | null
    ): void
    /**
     * This function performs the equivalent of g_app_info_launch_uris(),
     * but is intended primarily for operating system components that
     * launch applications.  Ordinary applications should use
     * g_app_info_launch_uris().
     *
     * If the application is launched via GSpawn, then `spawn_flags,` `user_setup`
     * and `user_setup_data` are used for the call to g_spawn_async().
     * Additionally, `pid_callback` (with `pid_callback_data)` will be called to
     * inform about the PID of the created process. See g_spawn_async_with_pipes()
     * for information on certain parameter conditions that can enable an
     * optimized posix_spawn() codepath to be used.
     *
     * If application launching occurs via some other mechanism (eg: D-Bus
     * activation) then `spawn_flags,` `user_setup,` `user_setup_data,`
     * `pid_callback` and `pid_callback_data` are ignored.
     * @param uris List of URIs
     * @param launchContext a #GAppLaunchContext
     * @param spawnFlags #GSpawnFlags, used for each process
     * @param userSetup a #GSpawnChildSetupFunc, used once     for each process.
     * @returns %TRUE on successful launch, %FALSE otherwise.
     */
    launchUrisAsManager(
      uris: string[],
      launchContext: AppLaunchContext | null,
      spawnFlags: GLib.SpawnFlags,
      userSetup: GLib.SpawnChildSetupFunc | null
    ): boolean
    /**
     * Equivalent to g_desktop_app_info_launch_uris_as_manager() but allows
     * you to pass in file descriptors for the stdin, stdout and stderr streams
     * of the launched process.
     *
     * If application launching occurs via some non-spawn mechanism (e.g. D-Bus
     * activation) then `stdin_fd,` `stdout_fd` and `stderr_fd` are ignored.
     * @param uris List of URIs
     * @param launchContext a #GAppLaunchContext
     * @param spawnFlags #GSpawnFlags, used for each process
     * @param userSetup a #GSpawnChildSetupFunc, used once     for each process.
     * @param pidCallback Callback for child processes
     * @param stdinFd file descriptor to use for child's stdin, or -1
     * @param stdoutFd file descriptor to use for child's stdout, or -1
     * @param stderrFd file descriptor to use for child's stderr, or -1
     * @returns %TRUE on successful launch, %FALSE otherwise.
     */
    launchUrisAsManagerWithFds(
      uris: string[],
      launchContext: AppLaunchContext | null,
      spawnFlags: GLib.SpawnFlags,
      userSetup: GLib.SpawnChildSetupFunc | null,
      pidCallback: DesktopAppLaunchCallback | null,
      stdinFd: number,
      stdoutFd: number,
      stderrFd: number
    ): boolean
    /**
     * Returns the list of "additional application actions" supported on the
     * desktop file, as per the desktop file specification.
     *
     * As per the specification, this is the list of actions that are
     * explicitly listed in the "Actions" key of the [Desktop Entry] group.
     * @returns a list of strings, always non-%NULL
     */
    listActions(): string[]

    // Class property signals of Gio-2.0.Gio.DesktopAppInfo

    connect(
      sigName: "notify::filename",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filename",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filename",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filename",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filename", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GDesktopAppInfo` is an implementation of [iface`Gio`.AppInfo] based on
   * desktop files.
   *
   * Note that `<gio/gdesktopappinfo.h>` belongs to the UNIX-specific
   * GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
   * file or the `GioUnix-2.0` GIR namespace when using it.
   * @class
   */
  class DesktopAppInfo extends GObject.Object {
    // Own properties of Gio-2.0.Gio.DesktopAppInfo

    static name: string

    // Constructors of Gio-2.0.Gio.DesktopAppInfo

    constructor(config?: DesktopAppInfo.ConstructorProperties)
    /**
     * Creates a new #GDesktopAppInfo based on a desktop file id.
     *
     * A desktop file id is the basename of the desktop file, including the
     * .desktop extension. GIO is looking for a desktop file with this name
     * in the `applications` subdirectories of the XDG
     * data directories (i.e. the directories specified in the `XDG_DATA_HOME`
     * and `XDG_DATA_DIRS` environment variables). GIO also supports the
     * prefix-to-subdirectory mapping that is described in the
     * [Menu Spec](http://standards.freedesktop.org/menu-spec/latest/)
     * (i.e. a desktop id of kde-foo.desktop will match
     * `/usr/share/applications/kde/foo.desktop`).
     * @constructor
     * @param desktopId the desktop file id
     * @returns a new #GDesktopAppInfo, or %NULL if no desktop     file with that id exists.
     */
    constructor(desktopId: string)
    /**
     * Creates a new #GDesktopAppInfo based on a desktop file id.
     *
     * A desktop file id is the basename of the desktop file, including the
     * .desktop extension. GIO is looking for a desktop file with this name
     * in the `applications` subdirectories of the XDG
     * data directories (i.e. the directories specified in the `XDG_DATA_HOME`
     * and `XDG_DATA_DIRS` environment variables). GIO also supports the
     * prefix-to-subdirectory mapping that is described in the
     * [Menu Spec](http://standards.freedesktop.org/menu-spec/latest/)
     * (i.e. a desktop id of kde-foo.desktop will match
     * `/usr/share/applications/kde/foo.desktop`).
     * @constructor
     * @param desktopId the desktop file id
     * @returns a new #GDesktopAppInfo, or %NULL if no desktop     file with that id exists.
     */
    static new(desktopId: string): DesktopAppInfo
    /**
     * Creates a new #GDesktopAppInfo.
     * @constructor
     * @param filename the path of a desktop file, in the GLib      filename encoding
     * @returns a new #GDesktopAppInfo or %NULL on error.
     */
    static newFromFilename(filename: string): DesktopAppInfo
    /**
     * Creates a new #GDesktopAppInfo.
     * @constructor
     * @param keyFile an opened #GKeyFile
     * @returns a new #GDesktopAppInfo or %NULL on error.
     */
    static newFromKeyfile(keyFile: GLib.KeyFile): DesktopAppInfo
    _init(config?: DesktopAppInfo.ConstructorProperties): void
    /**
     * Gets all applications that implement `interface`.
     *
     * An application implements an interface if that interface is listed in
     * the Implements= line of the desktop file of the application.
     * @param interface the name of the interface
     * @returns a list of #GDesktopAppInfo objects.
     */
    static getImplementations(interface: string): DesktopAppInfo[]
    /**
     * Searches desktop files for ones that match `search_string`.
     *
     * The return value is an array of strvs.  Each strv contains a list of
     * applications that matched `search_string` with an equal score.  The
     * outer list is sorted by score so that the first strv contains the
     * best-matching applications, and so on.
     * The algorithm for determining matches is undefined and may change at
     * any time.
     *
     * None of the search results are subjected to the normal validation
     * checks performed by g_desktop_app_info_new() (for example, checking that
     * the executable referenced by a result exists), and so it is possible for
     * g_desktop_app_info_new() to return %NULL when passed an app ID returned by
     * this function. It is expected that calling code will do this when
     * subsequently creating a #GDesktopAppInfo for each result.
     * @param searchString the search string to use
     * @returns a   list of strvs.  Free each item with g_strfreev() and free the outer   list with g_free().
     */
    static search(searchString: string): string[]
    /**
     * Sets the name of the desktop that the application is running in.
     * This is used by g_app_info_should_show() and
     * g_desktop_app_info_get_show_in() to evaluate the
     * `OnlyShowIn` and `NotShowIn`
     * desktop entry fields.
     *
     * Should be called only once; subsequent calls are ignored.
     * @param desktopEnv a string specifying what desktop this is
     */
    static setDesktopEnv(desktopEnv: string): void
  }

  module Emblem {
    // Constructor properties interface

    interface ConstructorProperties
      extends Icon.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.Emblem

      /**
       * The actual icon of the emblem.
       */
      icon?: GObject.Object | null
      /**
       * The origin the emblem is derived from.
       */
      origin?: EmblemOrigin | null
    }
  }

  interface Emblem extends Icon {
    // Own properties of Gio-2.0.Gio.Emblem

    /**
     * The actual icon of the emblem.
     */
    readonly icon: GObject.Object
    /**
     * The origin the emblem is derived from.
     */
    readonly origin: EmblemOrigin
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Emblem

    /**
     * Gives back the icon from `emblem`.
     * @returns a #GIcon. The returned object belongs to          the emblem and should not be modified or freed.
     */
    getIcon(): Icon
    /**
     * Gets the origin of the emblem.
     * @returns the origin of the emblem
     */
    getOrigin(): EmblemOrigin

    // Class property signals of Gio-2.0.Gio.Emblem

    connect(sigName: "notify::icon", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon", ...args: any[]): void
    connect(
      sigName: "notify::origin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::origin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::origin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::origin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::origin", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GEmblem` is an implementation of [iface`Gio`.Icon] that supports
   * having an emblem, which is an icon with additional properties.
   * It can than be added to a [class`Gio`.EmblemedIcon].
   *
   * Currently, only metainformation about the emblem's origin is
   * supported. More may be added in the future.
   * @class
   */
  class Emblem extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Emblem

    static name: string

    // Constructors of Gio-2.0.Gio.Emblem

    constructor(config?: Emblem.ConstructorProperties)
    /**
     * Creates a new emblem for `icon`.
     * @constructor
     * @param icon a GIcon containing the icon.
     * @returns a new #GEmblem.
     */
    constructor(icon: Icon)
    /**
     * Creates a new emblem for `icon`.
     * @constructor
     * @param icon a GIcon containing the icon.
     * @returns a new #GEmblem.
     */
    static new(icon: Icon): Emblem
    /**
     * Creates a new emblem for `icon`.
     * @constructor
     * @param icon a GIcon containing the icon.
     * @param origin a GEmblemOrigin enum defining the emblem's origin
     * @returns a new #GEmblem.
     */
    static newWithOrigin(icon: Icon, origin: EmblemOrigin): Emblem
    _init(config?: Emblem.ConstructorProperties): void
  }

  module EmblemedIcon {
    // Constructor properties interface

    interface ConstructorProperties
      extends Icon.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.EmblemedIcon

      /**
       * The [iface`Gio`.Icon] to attach emblems to.
       */
      gicon?: Icon | null
    }
  }

  interface EmblemedIcon extends Icon {
    // Own properties of Gio-2.0.Gio.EmblemedIcon

    /**
     * The [iface`Gio`.Icon] to attach emblems to.
     */
    readonly gicon: Icon
    __gtype__: number

    // Own fields of Gio-2.0.Gio.EmblemedIcon

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.EmblemedIcon

    /**
     * Adds `emblem` to the #GList of #GEmblems.
     * @param emblem a #GEmblem
     */
    addEmblem(emblem: Emblem): void
    /**
     * Removes all the emblems from `icon`.
     */
    clearEmblems(): void
    /**
     * Gets the list of emblems for the `icon`.
     * @returns a #GList of     #GEmblems that is owned by @emblemed
     */
    getEmblems(): Emblem[]
    /**
     * Gets the main icon for `emblemed`.
     * @returns a #GIcon that is owned by @emblemed
     */
    getIcon(): Icon

    // Class property signals of Gio-2.0.Gio.EmblemedIcon

    connect(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gicon", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GEmblemedIcon` is an implementation of [iface`Gio`.Icon] that supports
   * adding an emblem to an icon. Adding multiple emblems to an
   * icon is ensured via [method`Gio`.EmblemedIcon.add_emblem].
   *
   * Note that `GEmblemedIcon` allows no control over the position
   * of the emblems. See also [class`Gio`.Emblem] for more information.
   * @class
   */
  class EmblemedIcon extends GObject.Object {
    // Own properties of Gio-2.0.Gio.EmblemedIcon

    static name: string

    // Constructors of Gio-2.0.Gio.EmblemedIcon

    constructor(config?: EmblemedIcon.ConstructorProperties)
    /**
     * Creates a new emblemed icon for `icon` with the emblem `emblem`.
     * @constructor
     * @param icon a #GIcon
     * @param emblem a #GEmblem, or %NULL
     * @returns a new #GIcon
     */
    constructor(icon: Icon, emblem: Emblem | null)
    /**
     * Creates a new emblemed icon for `icon` with the emblem `emblem`.
     * @constructor
     * @param icon a #GIcon
     * @param emblem a #GEmblem, or %NULL
     * @returns a new #GIcon
     */
    static new(icon: Icon, emblem: Emblem | null): EmblemedIcon
    _init(config?: EmblemedIcon.ConstructorProperties): void
  }

  module FileEnumerator {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.FileEnumerator

      /**
       * The container that is being enumerated.
       */
      container?: File | null
    }
  }

  interface FileEnumerator {
    // Own properties of Gio-2.0.Gio.FileEnumerator

    /**
     * The container that is being enumerated.
     */
    readonly container: File
    __gtype__: number

    // Own fields of Gio-2.0.Gio.FileEnumerator

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.FileEnumerator

    /**
     * Releases all resources used by this enumerator, making the
     * enumerator return %G_IO_ERROR_CLOSED on all calls.
     *
     * This will be automatically called when the last reference
     * is dropped, but you might want to call this function to make
     * sure resources are released as early as possible.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns #TRUE on success or #FALSE on error.
     */
    close(cancellable: Cancellable | null): boolean
    // Has conflict: closeAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: closeFinish(result: AsyncResult): boolean
    /**
     * Return a new #GFile which refers to the file named by `info` in the source
     * directory of `enumerator`.  This function is primarily intended to be used
     * inside loops with g_file_enumerator_next_file().
     *
     * To use this, %G_FILE_ATTRIBUTE_STANDARD_NAME must have been listed in the
     * attributes list used when creating the #GFileEnumerator.
     *
     * This is a convenience method that's equivalent to:
     *
     * ```c
     *   gchar *name = g_file_info_get_name (info);
     *   GFile *child = g_file_get_child (g_file_enumerator_get_container (enumr),
     *                                    name);
     * ```
     *
     * @param info a #GFileInfo gotten from g_file_enumerator_next_file()   or the async equivalents.
     * @returns a #GFile for the #GFileInfo passed it.
     */
    getChild(info: FileInfo): File
    /**
     * Get the #GFile container which is being enumerated.
     * @returns the #GFile which is being enumerated.
     */
    getContainer(): File
    /**
     * Checks if the file enumerator has pending operations.
     * @returns %TRUE if the @enumerator has pending operations.
     */
    hasPending(): boolean
    /**
     * Checks if the file enumerator has been closed.
     * @returns %TRUE if the @enumerator is closed.
     */
    isClosed(): boolean
    /**
     * This is a version of g_file_enumerator_next_file() that's easier to
     * use correctly from C programs.  With g_file_enumerator_next_file(),
     * the gboolean return value signifies "end of iteration or error", which
     * requires allocation of a temporary #GError.
     *
     * In contrast, with this function, a %FALSE return from
     * g_file_enumerator_iterate() *always* means
     * "error".  End of iteration is signaled by `out_info` or `out_child` being %NULL.
     *
     * Another crucial difference is that the references for `out_info` and
     * `out_child` are owned by `direnum` (they are cached as hidden
     * properties).  You must not unref them in your own code.  This makes
     * memory management significantly easier for C code in combination
     * with loops.
     *
     * Finally, this function optionally allows retrieving a #GFile as
     * well.
     *
     * You must specify at least one of `out_info` or `out_child`.
     *
     * The code pattern for correctly using g_file_enumerator_iterate() from C
     * is:
     *
     *
     * ```
     * direnum = g_file_enumerate_children (file, ...);
     * while (TRUE)
     *   {
     *     GFileInfo *info;
     *     if (!g_file_enumerator_iterate (direnum, &info, NULL, cancellable, error))
     *       goto out;
     *     if (!info)
     *       break;
     *     ... do stuff with "info"; do not unref it! ...
     *   }
     *
     * out:
     *   g_object_unref (direnum); // Note: frees the last `info`
     * ```
     *
     * @param cancellable a #GCancellable
     */
    iterate(
      cancellable: Cancellable | null
    ): [/* returnType */ boolean, /* outInfo */ FileInfo, /* outChild */ File]
    // Has conflict: nextFile(cancellable: Cancellable | null): FileInfo | null
    // Has conflict: nextFilesAsync(numFiles: number, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: nextFilesFinish(result: AsyncResult): FileInfo[]
    /**
     * Sets the file enumerator as having pending operations.
     * @param pending a boolean value.
     */
    setPending(pending: boolean): void

    // Own virtual methods of Gio-2.0.Gio.FileEnumerator

    /**
     * Asynchronously closes the file enumerator.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in
     * g_file_enumerator_close_finish().
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    closeAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes closing a file enumerator, started from g_file_enumerator_close_async().
     *
     * If the file enumerator was already closed when g_file_enumerator_close_async()
     * was called, then this function will report %G_IO_ERROR_CLOSED in `error,` and
     * return %FALSE. If the file enumerator had pending operation when the close
     * operation was started, then this function will report %G_IO_ERROR_PENDING, and
     * return %FALSE.  If `cancellable` was not %NULL, then the operation may have been
     * cancelled by triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %FALSE will be
     * returned.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the close operation has finished successfully.
     */
    closeFinish(result: AsyncResult): boolean
    closeFn(cancellable: Cancellable | null): boolean
    /**
     * Returns information for the next file in the enumerated object.
     * Will block until the information is available. The #GFileInfo
     * returned from this function will contain attributes that match the
     * attribute string that was passed when the #GFileEnumerator was created.
     *
     * See the documentation of #GFileEnumerator for information about the
     * order of returned files.
     *
     * On error, returns %NULL and sets `error` to the error. If the
     * enumerator is at the end, %NULL will be returned and `error` will
     * be unset.
     * @virtual
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns A #GFileInfo or %NULL on error    or end of enumerator.  Free the returned object with    g_object_unref() when no longer needed.
     */
    nextFile(cancellable: Cancellable | null): FileInfo | null
    /**
     * Request information for a number of files from the enumerator asynchronously.
     * When all I/O for the operation is finished the `callback` will be called with
     * the requested information.
     *
     * See the documentation of #GFileEnumerator for information about the
     * order of returned files.
     *
     * Once the end of the enumerator is reached, or if an error occurs, the
     * `callback` will be called with an empty list. In this case, the previous call
     * to g_file_enumerator_next_files_async() will typically have returned fewer
     * than `num_files` items.
     *
     * If a request is cancelled the callback will be called with
     * %G_IO_ERROR_CANCELLED.
     *
     * This leads to the following pseudo-code usage:
     *
     * ```
     * g_autoptr(GFile) dir = get_directory ();
     * g_autoptr(GFileEnumerator) enumerator = NULL;
     * g_autolist(GFileInfo) files = NULL;
     * g_autoptr(GError) local_error = NULL;
     *
     * enumerator = yield g_file_enumerate_children_async (dir,
     *                                                     G_FILE_ATTRIBUTE_STANDARD_NAME ","
     *                                                     G_FILE_ATTRIBUTE_STANDARD_TYPE,
     *                                                     G_FILE_QUERY_INFO_NONE,
     *                                                     G_PRIORITY_DEFAULT,
     *                                                     cancellable,
     *                                                     …,
     *                                                     &local_error);
     * if (enumerator == NULL)
     *   g_error ("Error enumerating: %s", local_error->message);
     *
     * // Loop until no files are returned, either because the end of the enumerator
     * // has been reached, or an error was returned.
     * do
     *   {
     *     files = yield g_file_enumerator_next_files_async (enumerator,
     *                                                       5,  // number of files to request
     *                                                       G_PRIORITY_DEFAULT,
     *                                                       cancellable,
     *                                                       …,
     *                                                       &local_error);
     *
     *     // Process the returned files, but don’t assume that exactly 5 were returned.
     *     for (GList *l = files; l != NULL; l = l->next)
     *       {
     *         GFileInfo *info = l->data;
     *         handle_file_info (info);
     *       }
     *   }
     * while (files != NULL);
     *
     * if (local_error != NULL &&
     *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
     *   g_error ("Error while enumerating: %s", local_error->message);
     * ```
     *
     *
     * During an async request no other sync and async calls are allowed, and will
     * result in %G_IO_ERROR_PENDING errors.
     *
     * Any outstanding I/O request with higher priority (lower numerical value) will
     * be executed before an outstanding request with lower priority. Default
     * priority is %G_PRIORITY_DEFAULT.
     * @virtual
     * @param numFiles the number of file info objects to request
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    nextFilesAsync(
      numFiles: number,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes the asynchronous operation started with g_file_enumerator_next_files_async().
     * @virtual
     * @param result a #GAsyncResult.
     * @returns a #GList of #GFileInfos. You must free the list with     g_list_free() and unref the infos with g_object_unref() when you're     done with them.
     */
    nextFilesFinish(result: AsyncResult): FileInfo[]

    // Class property signals of Gio-2.0.Gio.FileEnumerator

    connect(
      sigName: "notify::container",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::container",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::container",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::container",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::container", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GFileEnumerator` allows you to operate on a set of [iface`Gio`.File] objects,
   * returning a [class`Gio`.FileInfo] structure for each file enumerated (e.g.
   * [method`Gio`.File.enumerate_children] will return a `GFileEnumerator` for each
   * of the children within a directory).
   *
   * To get the next file's information from a `GFileEnumerator`, use
   * [method`Gio`.FileEnumerator.next_file] or its asynchronous version,
   * [method`Gio`.FileEnumerator.next_files_async]. Note that the asynchronous
   * version will return a list of [class`Gio`.FileInfo] objects, whereas the
   * synchronous will only return the next file in the enumerator.
   *
   * The ordering of returned files is unspecified for non-Unix
   * platforms; for more information, see [method`GLib`.Dir.read_name].  On Unix,
   * when operating on local files, returned files will be sorted by
   * inode number.  Effectively you can assume that the ordering of
   * returned files will be stable between successive calls (and
   * applications) assuming the directory is unchanged.
   *
   * If your application needs a specific ordering, such as by name or
   * modification time, you will have to implement that in your
   * application code.
   *
   * To close a `GFileEnumerator`, use [method`Gio`.FileEnumerator.close], or
   * its asynchronous version, [method`Gio`.FileEnumerator.close_async]. Once
   * a `GFileEnumerator` is closed, no further actions may be performed
   * on it, and it should be freed with [method`GObject`.Object.unref].
   * @class
   */
  class FileEnumerator extends GObject.Object {
    // Own properties of Gio-2.0.Gio.FileEnumerator

    static name: string

    // Constructors of Gio-2.0.Gio.FileEnumerator

    constructor(config?: FileEnumerator.ConstructorProperties)
    _init(config?: FileEnumerator.ConstructorProperties): void
  }

  module FileIOStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends Seekable.ConstructorProperties,
        IOStream.ConstructorProperties {}
  }

  interface FileIOStream extends Seekable {
    // Own properties of Gio-2.0.Gio.FileIOStream

    __gtype__: number

    // Own fields of Gio-2.0.Gio.FileIOStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.FileIOStream

    // Has conflict: getEtag(): string | null
    // Has conflict: queryInfo(attributes: string, cancellable: Cancellable | null): FileInfo
    // Has conflict: queryInfoAsync(attributes: string, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: queryInfoFinish(result: AsyncResult): FileInfo

    // Own virtual methods of Gio-2.0.Gio.FileIOStream

    canSeek(): boolean

    // Overloads of canSeek

    /**
     * Tests if the stream supports the #GSeekableIface.
     * @virtual
     * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
     */
    canSeek(): boolean
    canTruncate(): boolean

    // Overloads of canTruncate

    /**
     * Tests if the length of the stream can be adjusted with
     * g_seekable_truncate().
     * @virtual
     * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
     */
    canTruncate(): boolean
    /**
     * Gets the entity tag for the file when it has been written.
     * This must be called after the stream has been written
     * and closed, as the etag can change while writing.
     * @virtual
     * @returns the entity tag for the stream.
     */
    getEtag(): string | null
    /**
     * Queries a file io stream for the given `attributes`.
     * This function blocks while querying the stream. For the asynchronous
     * version of this function, see g_file_io_stream_query_info_async().
     * While the stream is blocked, the stream will set the pending flag
     * internally, and any other operations on the stream will fail with
     * %G_IO_ERROR_PENDING.
     *
     * Can fail if the stream was already closed (with `error` being set to
     * %G_IO_ERROR_CLOSED), the stream has pending operations (with `error` being
     * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
     * the stream's interface (with `error` being set to %G_IO_ERROR_NOT_SUPPORTED). I
     * all cases of failure, %NULL will be returned.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
     * be returned.
     * @virtual
     * @param attributes a file attribute query string.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #GFileInfo for the @stream, or %NULL on error.
     */
    queryInfo(attributes: string, cancellable: Cancellable | null): FileInfo
    /**
     * Asynchronously queries the `stream` for a #GFileInfo. When completed,
     * `callback` will be called with a #GAsyncResult which can be used to
     * finish the operation with g_file_io_stream_query_info_finish().
     *
     * For the synchronous version of this function, see
     * g_file_io_stream_query_info().
     * @virtual
     * @param attributes a file attribute query string.
     * @param ioPriority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    queryInfoAsync(
      attributes: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finalizes the asynchronous query started
     * by g_file_io_stream_query_info_async().
     * @virtual
     * @param result a #GAsyncResult.
     * @returns A #GFileInfo for the finished query.
     */
    queryInfoFinish(result: AsyncResult): FileInfo
    seek(
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ): boolean

    // Overloads of seek

    /**
     * Seeks in the stream by the given `offset,` modified by `type`.
     *
     * Attempting to seek past the end of the stream will have different
     * results depending on if the stream is fixed-sized or resizable.  If
     * the stream is resizable then seeking past the end and then writing
     * will result in zeros filling the empty space.  Seeking past the end
     * of a resizable stream and reading will result in EOF.  Seeking past
     * the end of a fixed-sized stream will fail.
     *
     * Any operation that would result in a negative offset will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param offset a #goffset.
     * @param type a #GSeekType.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
     */
    seek(
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ): boolean
    tell(): number

    // Overloads of tell

    /**
     * Tells the current position within the stream.
     * @virtual
     * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
     */
    tell(): number
    truncateFn(size: number, cancellable: Cancellable | null): boolean

    // Class property signals of Gio-2.0.Gio.FileIOStream

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::output-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GFileIOStream` provides I/O streams that both read and write to the same
   * file handle.
   *
   * `GFileIOStream` implements [iface`Gio`.Seekable], which allows the I/O
   * stream to jump to arbitrary positions in the file and to truncate
   * the file, provided the filesystem of the file supports these
   * operations.
   *
   * To find the position of a file I/O stream, use [method`Gio`.Seekable.tell].
   *
   * To find out if a file I/O stream supports seeking, use
   * [method`Gio`.Seekable.can_seek]. To position a file I/O stream, use
   * [method`Gio`.Seekable.seek]. To find out if a file I/O stream supports
   * truncating, use [method`Gio`.Seekable.can_truncate]. To truncate a file I/O
   * stream, use [method`Gio`.Seekable.truncate].
   *
   * The default implementation of all the `GFileIOStream` operations
   * and the implementation of [iface`Gio`.Seekable] just call into the same
   * operations on the output stream.
   * @class
   */
  class FileIOStream extends IOStream {
    // Own properties of Gio-2.0.Gio.FileIOStream

    static name: string

    // Constructors of Gio-2.0.Gio.FileIOStream

    constructor(config?: FileIOStream.ConstructorProperties)
    _init(config?: FileIOStream.ConstructorProperties): void
  }

  module FileIcon {
    // Constructor properties interface

    interface ConstructorProperties
      extends Icon.ConstructorProperties,
        LoadableIcon.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.FileIcon

      /**
       * The file containing the icon.
       */
      file?: File | null
    }
  }

  interface FileIcon extends Icon, LoadableIcon {
    // Own properties of Gio-2.0.Gio.FileIcon

    /**
     * The file containing the icon.
     */
    readonly file: File
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.FileIcon

    /**
     * Gets the #GFile associated with the given `icon`.
     * @returns a #GFile.
     */
    getFile(): File

    // Class property signals of Gio-2.0.Gio.FileIcon

    connect(sigName: "notify::file", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GFileIcon` specifies an icon by pointing to an image file
   * to be used as icon.
   *
   * It implements [iface`Gio`.LoadableIcon].
   * @class
   */
  class FileIcon extends GObject.Object {
    // Own properties of Gio-2.0.Gio.FileIcon

    static name: string

    // Constructors of Gio-2.0.Gio.FileIcon

    constructor(config?: FileIcon.ConstructorProperties)
    /**
     * Creates a new icon for a file.
     * @constructor
     * @param file a #GFile.
     * @returns a #GIcon for the given   @file, or %NULL on error.
     */
    constructor(file: File)
    /**
     * Creates a new icon for a file.
     * @constructor
     * @param file a #GFile.
     * @returns a #GIcon for the given   @file, or %NULL on error.
     */
    static new(file: File): FileIcon
    _init(config?: FileIcon.ConstructorProperties): void
  }

  module FileInfo {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface FileInfo {
    // Own properties of Gio-2.0.Gio.FileInfo

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.FileInfo

    /**
     * Clears the status information from `info`.
     */
    clearStatus(): void
    /**
     * First clears all of the [GFileAttribute][gio-GFileAttribute] of `dest_info,`
     * and then copies all of the file attributes from `src_info` to `dest_info`.
     * @param destInfo destination to copy attributes to.
     */
    copyInto(destInfo: FileInfo): void
    /**
     * Duplicates a file info structure.
     * @returns a duplicate #GFileInfo of @other.
     */
    dup(): FileInfo
    /**
     * Gets the access time of the current `info` and returns it as a
     * #GDateTime.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_TIME_ACCESS. If %G_FILE_ATTRIBUTE_TIME_ACCESS_USEC is
     * provided, the resulting #GDateTime will additionally have microsecond
     * precision.
     *
     * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_ACCESS_NSEC must
     * be queried separately using g_file_info_get_attribute_uint32().
     * @returns access time, or %NULL if unknown
     */
    getAccessDateTime(): GLib.DateTime | null
    /**
     * Gets the value of an attribute, formatted as a string.
     * This escapes things as needed to make the string valid
     * UTF-8.
     * @param attribute a file attribute key.
     * @returns a UTF-8 string associated with the given @attribute, or    %NULL if the attribute wasn’t set.    When you're done with the string it must be freed with g_free().
     */
    getAttributeAsString(attribute: string): string | null
    /**
     * Gets the value of a boolean attribute. If the attribute does not
     * contain a boolean value, %FALSE will be returned.
     * @param attribute a file attribute key.
     * @returns the boolean value contained within the attribute.
     */
    getAttributeBoolean(attribute: string): boolean
    /**
     * Gets the value of a byte string attribute. If the attribute does
     * not contain a byte string, %NULL will be returned.
     * @param attribute a file attribute key.
     * @returns the contents of the @attribute value as a byte string, or %NULL otherwise.
     */
    getAttributeByteString(attribute: string): string | null
    /**
     * Gets the attribute type, value and status for an attribute key.
     * @param attribute a file attribute key
     * @returns %TRUE if @info has an attribute named @attribute,      %FALSE otherwise.
     */
    getAttributeData(
      attribute: string
    ): [
      /* returnType */ boolean,
      /* type */ FileAttributeType,
      /* valuePp */ any,
      /* status */ FileAttributeStatus,
    ]
    /**
     * Gets the value of a byte string attribute as a file path.
     *
     * If the attribute does not contain a byte string, `NULL` will be returned.
     *
     * This function is meant to be used by language bindings that have specific
     * handling for Unix paths.
     * @param attribute a file attribute key.
     * @returns the contents of the @attribute value as a file path, or %NULL otherwise.
     */
    getAttributeFilePath(attribute: string): string | null
    /**
     * Gets a signed 32-bit integer contained within the attribute. If the
     * attribute does not contain a signed 32-bit integer, or is invalid,
     * 0 will be returned.
     * @param attribute a file attribute key.
     * @returns a signed 32-bit integer from the attribute.
     */
    getAttributeInt32(attribute: string): number
    /**
     * Gets a signed 64-bit integer contained within the attribute. If the
     * attribute does not contain a signed 64-bit integer, or is invalid,
     * 0 will be returned.
     * @param attribute a file attribute key.
     * @returns a signed 64-bit integer from the attribute.
     */
    getAttributeInt64(attribute: string): number
    /**
     * Gets the value of a #GObject attribute. If the attribute does
     * not contain a #GObject, %NULL will be returned.
     * @param attribute a file attribute key.
     * @returns a #GObject associated with the given @attribute, or %NULL otherwise.
     */
    getAttributeObject(attribute: string): GObject.Object | null
    /**
     * Gets the attribute status for an attribute key.
     * @param attribute a file attribute key
     * @returns a #GFileAttributeStatus for the given @attribute, or    %G_FILE_ATTRIBUTE_STATUS_UNSET if the key is invalid.
     */
    getAttributeStatus(attribute: string): FileAttributeStatus
    /**
     * Gets the value of a string attribute. If the attribute does
     * not contain a string, %NULL will be returned.
     * @param attribute a file attribute key.
     * @returns the contents of the @attribute value as a UTF-8 string, or %NULL otherwise.
     */
    getAttributeString(attribute: string): string | null
    /**
     * Gets the value of a stringv attribute. If the attribute does
     * not contain a stringv, %NULL will be returned.
     * @param attribute a file attribute key.
     * @returns the contents of the @attribute value as a stringv, or %NULL otherwise. Do not free. These returned strings are UTF-8.
     */
    getAttributeStringv(attribute: string): string[] | null
    /**
     * Gets the attribute type for an attribute key.
     * @param attribute a file attribute key.
     * @returns a #GFileAttributeType for the given @attribute, or %G_FILE_ATTRIBUTE_TYPE_INVALID if the key is not set.
     */
    getAttributeType(attribute: string): FileAttributeType
    /**
     * Gets an unsigned 32-bit integer contained within the attribute. If the
     * attribute does not contain an unsigned 32-bit integer, or is invalid,
     * 0 will be returned.
     * @param attribute a file attribute key.
     * @returns an unsigned 32-bit integer from the attribute.
     */
    getAttributeUint32(attribute: string): number
    /**
     * Gets a unsigned 64-bit integer contained within the attribute. If the
     * attribute does not contain an unsigned 64-bit integer, or is invalid,
     * 0 will be returned.
     * @param attribute a file attribute key.
     * @returns a unsigned 64-bit integer from the attribute.
     */
    getAttributeUint64(attribute: string): number
    /**
     * Gets the file's content type.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE.
     * @returns a string containing the file's content type, or %NULL if unknown.
     */
    getContentType(): string | null
    /**
     * Gets the creation time of the current `info` and returns it as a
     * #GDateTime.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_TIME_CREATED. If %G_FILE_ATTRIBUTE_TIME_CREATED_USEC is
     * provided, the resulting #GDateTime will additionally have microsecond
     * precision.
     *
     * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_CREATED_NSEC must
     * be queried separately using g_file_info_get_attribute_uint32().
     * @returns creation time, or %NULL if unknown
     */
    getCreationDateTime(): GLib.DateTime | null
    /**
     * Returns the #GDateTime representing the deletion date of the file, as
     * available in %G_FILE_ATTRIBUTE_TRASH_DELETION_DATE. If the
     * %G_FILE_ATTRIBUTE_TRASH_DELETION_DATE attribute is unset, %NULL is returned.
     * @returns a #GDateTime, or %NULL.
     */
    getDeletionDate(): GLib.DateTime | null
    /**
     * Gets a display name for a file. This is guaranteed to always be set.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME.
     * @returns a string containing the display name.
     */
    getDisplayName(): string
    /**
     * Gets the edit name for a file.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME.
     * @returns a string containing the edit name.
     */
    getEditName(): string
    /**
     * Gets the [entity tag](iface.File.html#entity-tags) for a given
     * #GFileInfo. See %G_FILE_ATTRIBUTE_ETAG_VALUE.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_ETAG_VALUE.
     * @returns a string containing the value of the "etag:value" attribute.
     */
    getEtag(): string | null
    /**
     * Gets a file's type (whether it is a regular file, symlink, etc).
     * This is different from the file's content type, see g_file_info_get_content_type().
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_TYPE.
     * @returns a #GFileType for the given file.
     */
    getFileType(): FileType
    /**
     * Gets the icon for a file.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_ICON.
     * @returns #GIcon for the given @info.
     */
    getIcon(): Icon | null
    /**
     * Checks if a file is a backup file.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP.
     * @returns %TRUE if file is a backup file, %FALSE otherwise.
     */
    getIsBackup(): boolean
    /**
     * Checks if a file is hidden.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN.
     * @returns %TRUE if the file is a hidden file, %FALSE otherwise.
     */
    getIsHidden(): boolean
    /**
     * Checks if a file is a symlink.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK.
     * @returns %TRUE if the given @info is a symlink.
     */
    getIsSymlink(): boolean
    /**
     * Gets the modification time of the current `info` and returns it as a
     * #GDateTime.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_TIME_MODIFIED. If %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC is
     * provided, the resulting #GDateTime will additionally have microsecond
     * precision.
     *
     * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC must
     * be queried separately using g_file_info_get_attribute_uint32().
     * @returns modification time, or %NULL if unknown
     */
    getModificationDateTime(): GLib.DateTime | null
    /**
     * Gets the modification time of the current `info` and sets it
     * in `result`.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_TIME_MODIFIED. If %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC is
     * provided it will be used too.
     */
    getModificationTime(): /* result */ GLib.TimeVal
    /**
     * Gets the name for a file. This is guaranteed to always be set.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_NAME.
     * @returns a string containing the file name.
     */
    getName(): string
    /**
     * Gets the file's size (in bytes). The size is retrieved through the value of
     * the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute and is converted
     * from #guint64 to #goffset before returning the result.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_SIZE.
     * @returns a #goffset containing the file's size (in bytes).
     */
    getSize(): number
    /**
     * Gets the value of the sort_order attribute from the #GFileInfo.
     * See %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
     * @returns a #gint32 containing the value of the "standard::sort_order" attribute.
     */
    getSortOrder(): number
    /**
     * Gets the symbolic icon for a file.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON.
     * @returns #GIcon for the given @info.
     */
    getSymbolicIcon(): Icon | null
    /**
     * Gets the symlink target for a given #GFileInfo.
     *
     * It is an error to call this if the #GFileInfo does not contain
     * %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET.
     * @returns a string containing the symlink target.
     */
    getSymlinkTarget(): string | null
    /**
     * Checks if a file info structure has an attribute named `attribute`.
     * @param attribute a file attribute key.
     * @returns %TRUE if @info has an attribute named @attribute,     %FALSE otherwise.
     */
    hasAttribute(attribute: string): boolean
    /**
     * Checks if a file info structure has an attribute in the
     * specified `name_space`.
     * @param nameSpace a file attribute namespace.
     * @returns %TRUE if @info has an attribute in @name_space,     %FALSE otherwise.
     */
    hasNamespace(nameSpace: string): boolean
    /**
     * Lists the file info structure's attributes.
     * @param nameSpace a file attribute key's namespace, or %NULL to list   all attributes.
     * @returns a null-terminated array of strings of all of the possible attribute types for the given @name_space, or %NULL on error.
     */
    listAttributes(nameSpace: string | null): string[] | null
    /**
     * Removes all cases of `attribute` from `info` if it exists.
     * @param attribute a file attribute key.
     */
    removeAttribute(attribute: string): void
    /**
     * Sets the %G_FILE_ATTRIBUTE_TIME_ACCESS and
     * %G_FILE_ATTRIBUTE_TIME_ACCESS_USEC attributes in the file info to the
     * given date/time value.
     *
     * %G_FILE_ATTRIBUTE_TIME_ACCESS_NSEC will be cleared.
     * @param atime a #GDateTime.
     */
    setAccessDateTime(atime: GLib.DateTime): void
    /**
     * Sets the `attribute` to contain the given value, if possible. To unset the
     * attribute, use %G_FILE_ATTRIBUTE_TYPE_INVALID for `type`.
     * @param attribute a file attribute key.
     * @param type a #GFileAttributeType
     * @param valueP pointer to the value
     */
    setAttribute(attribute: string, type: FileAttributeType, valueP: any): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     * @param attribute a file attribute key.
     * @param attrValue a boolean value.
     */
    setAttributeBoolean(attribute: string, attrValue: boolean): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     * @param attribute a file attribute key.
     * @param attrValue a byte string.
     */
    setAttributeByteString(attribute: string, attrValue: string): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     *
     * This function is meant to be used by language bindings that have specific
     * handling for Unix paths.
     * @param attribute a file attribute key.
     * @param attrValue a file path.
     */
    setAttributeFilePath(attribute: string, attrValue: string): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     * @param attribute a file attribute key.
     * @param attrValue a signed 32-bit integer
     */
    setAttributeInt32(attribute: string, attrValue: number): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     * @param attribute attribute name to set.
     * @param attrValue int64 value to set attribute to.
     */
    setAttributeInt64(attribute: string, attrValue: number): void
    /**
     * Sets `mask` on `info` to match specific attribute types.
     * @param mask a #GFileAttributeMatcher.
     */
    setAttributeMask(mask: FileAttributeMatcher): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     * @param attribute a file attribute key.
     * @param attrValue a #GObject.
     */
    setAttributeObject(attribute: string, attrValue: GObject.Object): void
    /**
     * Sets the attribute status for an attribute key. This is only
     * needed by external code that implement g_file_set_attributes_from_info()
     * or similar functions.
     *
     * The attribute must exist in `info` for this to work. Otherwise %FALSE
     * is returned and `info` is unchanged.
     * @param attribute a file attribute key
     * @param status a #GFileAttributeStatus
     * @returns %TRUE if the status was changed, %FALSE if the key was not set.
     */
    setAttributeStatus(attribute: string, status: FileAttributeStatus): boolean
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     * @param attribute a file attribute key.
     * @param attrValue a UTF-8 string.
     */
    setAttributeString(attribute: string, attrValue: string): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     *
     * Sinze: 2.22
     * @param attribute a file attribute key
     * @param attrValue a %NULL   terminated array of UTF-8 strings.
     */
    setAttributeStringv(attribute: string, attrValue: string[]): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     * @param attribute a file attribute key.
     * @param attrValue an unsigned 32-bit integer.
     */
    setAttributeUint32(attribute: string, attrValue: number): void
    /**
     * Sets the `attribute` to contain the given `attr_value,`
     * if possible.
     * @param attribute a file attribute key.
     * @param attrValue an unsigned 64-bit integer.
     */
    setAttributeUint64(attribute: string, attrValue: number): void
    /**
     * Sets the content type attribute for a given #GFileInfo.
     * See %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE.
     * @param contentType a content type. See [GContentType][gio-GContentType]
     */
    setContentType(contentType: string): void
    /**
     * Sets the %G_FILE_ATTRIBUTE_TIME_CREATED and
     * %G_FILE_ATTRIBUTE_TIME_CREATED_USEC attributes in the file info to the
     * given date/time value.
     *
     * %G_FILE_ATTRIBUTE_TIME_CREATED_NSEC will be cleared.
     * @param creationTime a #GDateTime.
     */
    setCreationDateTime(creationTime: GLib.DateTime): void
    /**
     * Sets the display name for the current #GFileInfo.
     * See %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME.
     * @param displayName a string containing a display name.
     */
    setDisplayName(displayName: string): void
    /**
     * Sets the edit name for the current file.
     * See %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME.
     * @param editName a string containing an edit name.
     */
    setEditName(editName: string): void
    /**
     * Sets the file type in a #GFileInfo to `type`.
     * See %G_FILE_ATTRIBUTE_STANDARD_TYPE.
     * @param type a #GFileType.
     */
    setFileType(type: FileType): void
    /**
     * Sets the icon for a given #GFileInfo.
     * See %G_FILE_ATTRIBUTE_STANDARD_ICON.
     * @param icon a #GIcon.
     */
    setIcon(icon: Icon): void
    /**
     * Sets the "is_hidden" attribute in a #GFileInfo according to `is_hidden`.
     * See %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN.
     * @param isHidden a #gboolean.
     */
    setIsHidden(isHidden: boolean): void
    /**
     * Sets the "is_symlink" attribute in a #GFileInfo according to `is_symlink`.
     * See %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK.
     * @param isSymlink a #gboolean.
     */
    setIsSymlink(isSymlink: boolean): void
    /**
     * Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED and
     * %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC attributes in the file info to the
     * given date/time value.
     *
     * %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC will be cleared.
     * @param mtime a #GDateTime.
     */
    setModificationDateTime(mtime: GLib.DateTime): void
    /**
     * Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED and
     * %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC attributes in the file info to the
     * given time value.
     *
     * %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC will be cleared.
     * @param mtime a #GTimeVal.
     */
    setModificationTime(mtime: GLib.TimeVal): void
    /**
     * Sets the name attribute for the current #GFileInfo.
     * See %G_FILE_ATTRIBUTE_STANDARD_NAME.
     * @param name a string containing a name.
     */
    setName(name: string): void
    /**
     * Sets the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute in the file info
     * to the given size.
     * @param size a #goffset containing the file's size.
     */
    setSize(size: number): void
    /**
     * Sets the sort order attribute in the file info structure. See
     * %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
     * @param sortOrder a sort order integer.
     */
    setSortOrder(sortOrder: number): void
    /**
     * Sets the symbolic icon for a given #GFileInfo.
     * See %G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON.
     * @param icon a #GIcon.
     */
    setSymbolicIcon(icon: Icon): void
    /**
     * Sets the %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET attribute in the file info
     * to the given symlink target.
     * @param symlinkTarget a static string containing a path to a symlink target.
     */
    setSymlinkTarget(symlinkTarget: string): void
    /**
     * Unsets a mask set by g_file_info_set_attribute_mask(), if one
     * is set.
     */
    unsetAttributeMask(): void

    // Class property signals of Gio-2.0.Gio.FileInfo

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Stores information about a file system object referenced by a [iface`Gio`.File].
   *
   * Functionality for manipulating basic metadata for files. `GFileInfo`
   * implements methods for getting information that all files should
   * contain, and allows for manipulation of extended attributes.
   *
   * See [file-attributes.html](file attributes) for more information on how GIO
   * handles file attributes.
   *
   * To obtain a `GFileInfo` for a [iface`Gio`.File], use
   * [method`Gio`.File.query_info] (or its async variant). To obtain a `GFileInfo`
   * for a file input or output stream, use [method`Gio`.FileInputStream.query_info]
   * or [method`Gio`.FileOutputStream.query_info] (or their async variants).
   *
   * To change the actual attributes of a file, you should then set the
   * attribute in the `GFileInfo` and call [method`Gio`.File.set_attributes_from_info]
   * or [method`Gio`.File.set_attributes_async] on a `GFile`.
   *
   * However, not all attributes can be changed in the file. For instance,
   * the actual size of a file cannot be changed via [method`Gio`.FileInfo.set_size].
   * You may call [method`Gio`.File.query_settable_attributes] and
   * [method`Gio`.File.query_writable_namespaces] to discover the settable attributes
   * of a particular file at runtime.
   *
   * The direct accessors, such as [method`Gio`.FileInfo.get_name], are slightly more
   * optimized than the generic attribute accessors, such as
   * [method`Gio`.FileInfo.get_attribute_byte_string].This optimization will matter
   * only if calling the API in a tight loop.
   *
   * It is an error to call these accessors without specifying their required file
   * attributes when creating the `GFileInfo`. Use
   * [method`Gio`.FileInfo.has_attribute] or [method`Gio`.FileInfo.list_attributes]
   * to check what attributes are specified for a `GFileInfo`.
   *
   * [struct`Gio`.FileAttributeMatcher] allows for searching through a `GFileInfo`
   * for attributes.
   * @class
   */
  class FileInfo extends GObject.Object {
    // Own properties of Gio-2.0.Gio.FileInfo

    static name: string

    // Constructors of Gio-2.0.Gio.FileInfo

    constructor(config?: FileInfo.ConstructorProperties)
    /**
     * Creates a new file info structure.
     * @constructor
     * @returns a #GFileInfo.
     */
    constructor()
    /**
     * Creates a new file info structure.
     * @constructor
     * @returns a #GFileInfo.
     */
    static new(): FileInfo
    _init(config?: FileInfo.ConstructorProperties): void
  }

  module FileInputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends Seekable.ConstructorProperties,
        InputStream.ConstructorProperties {}
  }

  interface FileInputStream extends Seekable {
    // Own properties of Gio-2.0.Gio.FileInputStream

    __gtype__: number

    // Own fields of Gio-2.0.Gio.FileInputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.FileInputStream

    // Has conflict: queryInfo(attributes: string, cancellable: Cancellable | null): FileInfo
    // Has conflict: queryInfoAsync(attributes: string, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: queryInfoFinish(result: AsyncResult): FileInfo

    // Own virtual methods of Gio-2.0.Gio.FileInputStream

    canSeek(): boolean

    // Overloads of canSeek

    /**
     * Tests if the stream supports the #GSeekableIface.
     * @virtual
     * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
     */
    canSeek(): boolean
    /**
     * Queries a file input stream the given `attributes`. This function blocks
     * while querying the stream. For the asynchronous (non-blocking) version
     * of this function, see g_file_input_stream_query_info_async(). While the
     * stream is blocked, the stream will set the pending flag internally, and
     * any other operations on the stream will fail with %G_IO_ERROR_PENDING.
     * @virtual
     * @param attributes a file attribute query string.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #GFileInfo, or %NULL on error.
     */
    queryInfo(attributes: string, cancellable: Cancellable | null): FileInfo
    /**
     * Queries the stream information asynchronously.
     * When the operation is finished `callback` will be called.
     * You can then call g_file_input_stream_query_info_finish()
     * to get the result of the operation.
     *
     * For the synchronous version of this function,
     * see g_file_input_stream_query_info().
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be set
     * @virtual
     * @param attributes a file attribute query string.
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    queryInfoAsync(
      attributes: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous info query operation.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns #GFileInfo.
     */
    queryInfoFinish(result: AsyncResult): FileInfo
    seek(
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ): boolean

    // Overloads of seek

    /**
     * Seeks in the stream by the given `offset,` modified by `type`.
     *
     * Attempting to seek past the end of the stream will have different
     * results depending on if the stream is fixed-sized or resizable.  If
     * the stream is resizable then seeking past the end and then writing
     * will result in zeros filling the empty space.  Seeking past the end
     * of a resizable stream and reading will result in EOF.  Seeking past
     * the end of a fixed-sized stream will fail.
     *
     * Any operation that would result in a negative offset will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param offset a #goffset.
     * @param type a #GSeekType.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
     */
    seek(
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ): boolean
    tell(): number

    // Overloads of tell

    /**
     * Tells the current position within the stream.
     * @virtual
     * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
     */
    tell(): number

    // Class property signals of Gio-2.0.Gio.FileInputStream

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GFileInputStream` provides input streams that take their
   * content from a file.
   *
   * `GFileInputStream` implements [iface`Gio`.Seekable], which allows the input
   * stream to jump to arbitrary positions in the file, provided the
   * filesystem of the file allows it. To find the position of a file
   * input stream, use [method`Gio`.Seekable.tell]. To find out if a file input
   * stream supports seeking, use [vfunc`Gio`.Seekable.can_seek].
   * To position a file input stream, use [vfunc`Gio`.Seekable.seek].
   * @class
   */
  class FileInputStream extends InputStream {
    // Own properties of Gio-2.0.Gio.FileInputStream

    static name: string

    // Constructors of Gio-2.0.Gio.FileInputStream

    constructor(config?: FileInputStream.ConstructorProperties)
    _init(config?: FileInputStream.ConstructorProperties): void
  }

  module FileMonitor {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (file: File, otherFile: File | null, eventType: FileMonitorEvent): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.FileMonitor

      /**
       * The limit of the monitor to watch for changes, in milliseconds.
       */
      rate_limit?: number | null
    }
  }

  interface FileMonitor {
    // Own properties of Gio-2.0.Gio.FileMonitor

    /**
     * Whether the monitor has been cancelled.
     */
    readonly cancelled: boolean
    /**
     * The limit of the monitor to watch for changes, in milliseconds.
     */
    rateLimit: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.FileMonitor

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.FileMonitor

    // Has conflict: cancel(): boolean
    /**
     * Emits the #GFileMonitor::changed signal if a change
     * has taken place. Should be called from file monitor
     * implementations only.
     *
     * Implementations are responsible to call this method from the
     * [thread-default main context][g-main-context-push-thread-default] of the
     * thread that the monitor was created in.
     * @param child a #GFile.
     * @param otherFile a #GFile.
     * @param eventType a set of #GFileMonitorEvent flags.
     */
    emitEvent(child: File, otherFile: File, eventType: FileMonitorEvent): void
    /**
     * Returns whether the monitor is canceled.
     * @returns %TRUE if monitor is canceled. %FALSE otherwise.
     */
    isCancelled(): boolean
    /**
     * Sets the rate limit to which the `monitor` will report
     * consecutive change events to the same file.
     * @param limitMsecs a non-negative integer with the limit in milliseconds     to poll for changes
     */
    setRateLimit(limitMsecs: number): void

    // Own virtual methods of Gio-2.0.Gio.FileMonitor

    /**
     * Cancels a file monitor.
     * @virtual
     * @returns always %TRUE
     */
    cancel(): boolean
    changed(file: File, otherFile: File, eventType: FileMonitorEvent): void

    // Own signals of Gio-2.0.Gio.FileMonitor

    connect(
      sigName: "changed",
      callback: FileMonitor.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: FileMonitor.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: FileMonitor.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: FileMonitor.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "changed",
      otherFile: File | null,
      eventType: FileMonitorEvent,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.FileMonitor

    connect(
      sigName: "notify::cancelled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cancelled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cancelled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cancelled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cancelled", ...args: any[]): void
    connect(
      sigName: "notify::rate-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rate-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rate-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rate-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rate-limit", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Monitors a file or directory for changes.
   *
   * To obtain a `GFileMonitor` for a file or directory, use
   * [method`Gio`.File.monitor], [method`Gio`.File.monitor_file], or
   * [method`Gio`.File.monitor_directory].
   *
   * To get informed about changes to the file or directory you are
   * monitoring, connect to the [signal`Gio`.FileMonitor::changed] signal. The
   * signal will be emitted in the thread-default main context (see
   * [method`GLib`.MainContext.push_thread_default]) of the thread that the monitor
   * was created in (though if the global default main context is blocked, this
   * may cause notifications to be blocked even if the thread-default
   * context is still running).
   * @class
   */
  class FileMonitor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.FileMonitor

    static name: string

    // Constructors of Gio-2.0.Gio.FileMonitor

    constructor(config?: FileMonitor.ConstructorProperties)
    _init(config?: FileMonitor.ConstructorProperties): void
  }

  module FileOutputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends Seekable.ConstructorProperties,
        OutputStream.ConstructorProperties {}
  }

  interface FileOutputStream extends Seekable {
    // Own properties of Gio-2.0.Gio.FileOutputStream

    __gtype__: number

    // Own fields of Gio-2.0.Gio.FileOutputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.FileOutputStream

    // Has conflict: getEtag(): string | null
    // Has conflict: queryInfo(attributes: string, cancellable: Cancellable | null): FileInfo
    // Has conflict: queryInfoAsync(attributes: string, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: queryInfoFinish(result: AsyncResult): FileInfo

    // Own virtual methods of Gio-2.0.Gio.FileOutputStream

    canSeek(): boolean

    // Overloads of canSeek

    /**
     * Tests if the stream supports the #GSeekableIface.
     * @virtual
     * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
     */
    canSeek(): boolean
    canTruncate(): boolean

    // Overloads of canTruncate

    /**
     * Tests if the length of the stream can be adjusted with
     * g_seekable_truncate().
     * @virtual
     * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
     */
    canTruncate(): boolean
    /**
     * Gets the entity tag for the file when it has been written.
     * This must be called after the stream has been written
     * and closed, as the etag can change while writing.
     * @virtual
     * @returns the entity tag for the stream.
     */
    getEtag(): string | null
    /**
     * Queries a file output stream for the given `attributes`.
     * This function blocks while querying the stream. For the asynchronous
     * version of this function, see g_file_output_stream_query_info_async().
     * While the stream is blocked, the stream will set the pending flag
     * internally, and any other operations on the stream will fail with
     * %G_IO_ERROR_PENDING.
     *
     * Can fail if the stream was already closed (with `error` being set to
     * %G_IO_ERROR_CLOSED), the stream has pending operations (with `error` being
     * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
     * the stream's interface (with `error` being set to %G_IO_ERROR_NOT_SUPPORTED). In
     * all cases of failure, %NULL will be returned.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
     * be returned.
     * @virtual
     * @param attributes a file attribute query string.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #GFileInfo for the @stream, or %NULL on error.
     */
    queryInfo(attributes: string, cancellable: Cancellable | null): FileInfo
    /**
     * Asynchronously queries the `stream` for a #GFileInfo. When completed,
     * `callback` will be called with a #GAsyncResult which can be used to
     * finish the operation with g_file_output_stream_query_info_finish().
     *
     * For the synchronous version of this function, see
     * g_file_output_stream_query_info().
     * @virtual
     * @param attributes a file attribute query string.
     * @param ioPriority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback callback to call when the request is satisfied
     */
    queryInfoAsync(
      attributes: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finalizes the asynchronous query started
     * by g_file_output_stream_query_info_async().
     * @virtual
     * @param result a #GAsyncResult.
     * @returns A #GFileInfo for the finished query.
     */
    queryInfoFinish(result: AsyncResult): FileInfo
    seek(
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ): boolean

    // Overloads of seek

    /**
     * Seeks in the stream by the given `offset,` modified by `type`.
     *
     * Attempting to seek past the end of the stream will have different
     * results depending on if the stream is fixed-sized or resizable.  If
     * the stream is resizable then seeking past the end and then writing
     * will result in zeros filling the empty space.  Seeking past the end
     * of a resizable stream and reading will result in EOF.  Seeking past
     * the end of a fixed-sized stream will fail.
     *
     * Any operation that would result in a negative offset will fail.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param offset a #goffset.
     * @param type a #GSeekType.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
     */
    seek(
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ): boolean
    tell(): number

    // Overloads of tell

    /**
     * Tells the current position within the stream.
     * @virtual
     * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
     */
    tell(): number
    truncateFn(size: number, cancellable: Cancellable | null): boolean

    // Class property signals of Gio-2.0.Gio.FileOutputStream

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GFileOutputStream` provides output streams that write their
   * content to a file.
   *
   * `GFileOutputStream` implements [iface`Gio`.Seekable], which allows the output
   * stream to jump to arbitrary positions in the file and to truncate
   * the file, provided the filesystem of the file supports these
   * operations.
   *
   * To find the position of a file output stream, use [method`Gio`.Seekable.tell].
   * To find out if a file output stream supports seeking, use
   * [method`Gio`.Seekable.can_seek].To position a file output stream, use
   * [method`Gio`.Seekable.seek]. To find out if a file output stream supports
   * truncating, use [method`Gio`.Seekable.can_truncate]. To truncate a file output
   * stream, use [method`Gio`.Seekable.truncate].
   * @class
   */
  class FileOutputStream extends OutputStream {
    // Own properties of Gio-2.0.Gio.FileOutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.FileOutputStream

    constructor(config?: FileOutputStream.ConstructorProperties)
    _init(config?: FileOutputStream.ConstructorProperties): void
  }

  module FilenameCompleter {
    // Signal callback interfaces

    /**
     * Signal callback interface for `got-completion-data`
     */
    interface GotCompletionDataSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface FilenameCompleter {
    // Own properties of Gio-2.0.Gio.FilenameCompleter

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.FilenameCompleter

    /**
     * Obtains a completion for `initial_text` from `completer`.
     * @param initialText text to be completed.
     * @returns a completed string, or %NULL if no     completion exists. This string is not owned by GIO, so remember to g_free()     it when finished.
     */
    getCompletionSuffix(initialText: string): string | null
    /**
     * Gets an array of completion strings for a given initial text.
     * @param initialText text to be completed.
     * @returns array of strings with possible completions for @initial_text. This array must be freed by g_strfreev() when finished.
     */
    getCompletions(initialText: string): string[]
    /**
     * If `dirs_only` is %TRUE, `completer` will only
     * complete directory names, and not file names.
     * @param dirsOnly a #gboolean.
     */
    setDirsOnly(dirsOnly: boolean): void

    // Own virtual methods of Gio-2.0.Gio.FilenameCompleter

    gotCompletionData(): void

    // Own signals of Gio-2.0.Gio.FilenameCompleter

    connect(
      sigName: "got-completion-data",
      callback: FilenameCompleter.GotCompletionDataSignalCallback
    ): number
    on(
      sigName: "got-completion-data",
      callback: FilenameCompleter.GotCompletionDataSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "got-completion-data",
      callback: FilenameCompleter.GotCompletionDataSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "got-completion-data",
      callback: FilenameCompleter.GotCompletionDataSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "got-completion-data", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.FilenameCompleter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Completes partial file and directory names given a partial string by
   * looking in the file system for clues. Can return a list of possible
   * completion strings for widget implementations.
   * @class
   */
  class FilenameCompleter extends GObject.Object {
    // Own properties of Gio-2.0.Gio.FilenameCompleter

    static name: string

    // Constructors of Gio-2.0.Gio.FilenameCompleter

    constructor(config?: FilenameCompleter.ConstructorProperties)
    /**
     * Creates a new filename completer.
     * @constructor
     * @returns a #GFilenameCompleter.
     */
    constructor()
    /**
     * Creates a new filename completer.
     * @constructor
     * @returns a #GFilenameCompleter.
     */
    static new(): FilenameCompleter
    _init(config?: FilenameCompleter.ConstructorProperties): void
  }

  module FilterInputStream {
    // Constructor properties interface

    interface ConstructorProperties extends InputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.FilterInputStream

      /**
       * The underlying base stream on which the I/O ops will be done.
       */
      base_stream?: InputStream | null
      /**
       * Whether the base stream should be closed when the filter stream is closed.
       */
      close_base_stream?: boolean | null
    }
  }

  interface FilterInputStream {
    // Own properties of Gio-2.0.Gio.FilterInputStream

    /**
     * Whether the base stream should be closed when the filter stream is closed.
     */
    closeBaseStream: boolean
    __gtype__: number

    // Own fields of Gio-2.0.Gio.FilterInputStream

    parentInstance: any
    baseStream: InputStream

    // Owm methods of Gio-2.0.Gio.FilterInputStream

    /**
     * Gets the base stream for the filter stream.
     * @returns a #GInputStream.
     */
    getBaseStream(): InputStream
    /**
     * Returns whether the base stream will be closed when `stream` is
     * closed.
     * @returns %TRUE if the base stream will be closed.
     */
    getCloseBaseStream(): boolean
    /**
     * Sets whether the base stream will be closed when `stream` is closed.
     * @param closeBase %TRUE to close the base stream.
     */
    setCloseBaseStream(closeBase: boolean): void

    // Class property signals of Gio-2.0.Gio.FilterInputStream

    connect(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-base-stream", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Base class for input stream implementations that perform some
   * kind of filtering operation on a base stream. Typical examples
   * of filtering operations are character set conversion, compression
   * and byte order flipping.
   * @class
   */
  class FilterInputStream extends InputStream {
    // Own properties of Gio-2.0.Gio.FilterInputStream

    static name: string

    // Constructors of Gio-2.0.Gio.FilterInputStream

    constructor(config?: FilterInputStream.ConstructorProperties)
    _init(config?: FilterInputStream.ConstructorProperties): void
  }

  module FilterOutputStream {
    // Constructor properties interface

    interface ConstructorProperties extends OutputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.FilterOutputStream

      base_stream?: OutputStream | null
      /**
       * Whether the base stream should be closed when the filter stream is closed.
       */
      close_base_stream?: boolean | null
    }
  }

  interface FilterOutputStream {
    // Own properties of Gio-2.0.Gio.FilterOutputStream

    /**
     * Whether the base stream should be closed when the filter stream is closed.
     */
    readonly closeBaseStream: boolean
    __gtype__: number

    // Own fields of Gio-2.0.Gio.FilterOutputStream

    parentInstance: any
    baseStream: OutputStream

    // Owm methods of Gio-2.0.Gio.FilterOutputStream

    /**
     * Gets the base stream for the filter stream.
     * @returns a #GOutputStream.
     */
    getBaseStream(): OutputStream
    /**
     * Returns whether the base stream will be closed when `stream` is
     * closed.
     * @returns %TRUE if the base stream will be closed.
     */
    getCloseBaseStream(): boolean
    /**
     * Sets whether the base stream will be closed when `stream` is closed.
     * @param closeBase %TRUE to close the base stream.
     */
    setCloseBaseStream(closeBase: boolean): void

    // Class property signals of Gio-2.0.Gio.FilterOutputStream

    connect(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-base-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-base-stream", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Base class for output stream implementations that perform some
   * kind of filtering operation on a base stream. Typical examples
   * of filtering operations are character set conversion, compression
   * and byte order flipping.
   * @class
   */
  class FilterOutputStream extends OutputStream {
    // Own properties of Gio-2.0.Gio.FilterOutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.FilterOutputStream

    constructor(config?: FilterOutputStream.ConstructorProperties)
    _init(config?: FilterOutputStream.ConstructorProperties): void
  }

  module IOModule {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.TypePlugin.ConstructorProperties,
        GObject.TypeModule.ConstructorProperties {}
  }

  interface IOModule extends GObject.TypePlugin {
    // Own properties of Gio-2.0.Gio.IOModule

    __gtype__: number

    // Conflicting methods

    /**
     * Calls the `use_plugin` function from the #GTypePluginClass of
     * `plugin`.  There should be no need to use this function outside of
     * the GObject type system itself.
     */
    use(): void
    /**
     * Increases the use count of a #GTypeModule by one. If the
     * use count was zero before, the plugin will be loaded.
     * If loading the plugin fails, the use count is reset to
     * its prior value.
     * @returns %FALSE if the plugin needed to be loaded and  loading the plugin failed.
     */
    use(): boolean

    // Overloads of use

    /**
     * Calls the `use_plugin` function from the #GTypePluginClass of
     * `plugin`.  There should be no need to use this function outside of
     * the GObject type system itself.
     */
    use(): void

    // Class property signals of Gio-2.0.Gio.IOModule

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Provides an interface and default functions for loading and unloading
   * modules. This is used internally to make GIO extensible, but can also
   * be used by others to implement module loading.
   * @class
   */
  class IOModule extends GObject.TypeModule {
    // Own properties of Gio-2.0.Gio.IOModule

    static name: string

    // Constructors of Gio-2.0.Gio.IOModule

    constructor(config?: IOModule.ConstructorProperties)
    /**
     * Creates a new GIOModule that will load the specific
     * shared library when in use.
     * @constructor
     * @param filename filename of the shared library module.
     * @returns a #GIOModule from given @filename, or %NULL on error.
     */
    constructor(filename: string)
    /**
     * Creates a new GIOModule that will load the specific
     * shared library when in use.
     * @constructor
     * @param filename filename of the shared library module.
     * @returns a #GIOModule from given @filename, or %NULL on error.
     */
    static new(filename: string): IOModule
    _init(config?: IOModule.ConstructorProperties): void
    /**
     * Optional API for GIO modules to implement.
     *
     * Should return a list of all the extension points that may be
     * implemented in this module.
     *
     * This method will not be called in normal use, however it may be
     * called when probing existing modules and recording which extension
     * points that this model is used for. This means we won't have to
     * load and initialize this module unless its needed.
     *
     * If this function is not implemented by the module the module will
     * always be loaded, initialized and then unloaded on application
     * startup so that it can register its extension points during init.
     *
     * Note that a module need not actually implement all the extension
     * points that g_io_module_query() returns, since the exact list of
     * extension may depend on runtime issues. However all extension
     * points actually implemented must be returned by g_io_module_query()
     * (if defined).
     *
     * When installing a module that implements g_io_module_query() you must
     * run gio-querymodules in order to build the cache files required for
     * lazy loading.
     *
     * Since 2.56, this function should be named `g_io_<modulename>_query`, where
     * `modulename` is the plugin’s filename with the `lib` or `libgio` prefix and
     * everything after the first dot removed, and with `-` replaced with `_`
     * throughout. For example, `libgiognutls-helper.so` becomes `gnutls_helper`.
     * Using the new symbol names avoids name clashes when building modules
     * statically. The old symbol names continue to be supported, but cannot be used
     * for static builds.
     * @returns A %NULL-terminated array of strings,     listing the supported extension points of the module. The array     must be suitable for freeing with g_strfreev().
     */
    static query(): string[]
  }

  module IOStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface IOStream {
    // Own properties of Gio-2.0.Gio.IOStream

    /**
     * Whether the stream is closed.
     */
    readonly closed: boolean
    /**
     * The [class`Gio`.InputStream] to read from.
     */
    readonly inputStream: InputStream
    /**
     * The [class`Gio`.OutputStream] to write to.
     */
    readonly outputStream: OutputStream
    __gtype__: number

    // Own fields of Gio-2.0.Gio.IOStream

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.IOStream

    /**
     * Clears the pending flag on `stream`.
     */
    clearPending(): void
    /**
     * Closes the stream, releasing resources related to it. This will also
     * close the individual input and output streams, if they are not already
     * closed.
     *
     * Once the stream is closed, all other operations will return
     * %G_IO_ERROR_CLOSED. Closing a stream multiple times will not
     * return an error.
     *
     * Closing a stream will automatically flush any outstanding buffers
     * in the stream.
     *
     * Streams will be automatically closed when the last reference
     * is dropped, but you might want to call this function to make sure
     * resources are released as early as possible.
     *
     * Some streams might keep the backing store of the stream (e.g. a file
     * descriptor) open after the stream is closed. See the documentation for
     * the individual stream for details.
     *
     * On failure the first error that happened will be reported, but the
     * close operation will finish as much as possible. A stream that failed
     * to close will still return %G_IO_ERROR_CLOSED for all operations.
     * Still, it is important to check and report the error to the user,
     * otherwise there might be a loss of data as all data might not be written.
     *
     * If `cancellable` is not NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * Cancelling a close will still leave the stream closed, but some streams
     * can use a faster close that doesn't block to e.g. check errors.
     *
     * The default implementation of this method just calls close on the
     * individual input/output streams.
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns %TRUE on success, %FALSE on failure
     */
    close(cancellable: Cancellable | null): boolean
    // Has conflict: closeAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: closeFinish(result: AsyncResult): boolean
    // Has conflict: getInputStream(): InputStream
    // Has conflict: getOutputStream(): OutputStream
    /**
     * Checks if a stream has pending actions.
     * @returns %TRUE if @stream has pending actions.
     */
    hasPending(): boolean
    /**
     * Checks if a stream is closed.
     * @returns %TRUE if the stream is closed.
     */
    isClosed(): boolean
    /**
     * Sets `stream` to have actions pending. If the pending flag is
     * already set or `stream` is closed, it will return %FALSE and set
     * `error`.
     * @returns %TRUE if pending was previously unset and is now set.
     */
    setPending(): boolean
    /**
     * Asynchronously splice the output stream of `stream1` to the input stream of
     * `stream2`, and splice the output stream of `stream2` to the input stream of
     * `stream1`.
     *
     * When the operation is finished `callback` will be called.
     * You can then call g_io_stream_splice_finish() to get the
     * result of the operation.
     * @param stream2 a #GIOStream.
     * @param flags a set of #GIOStreamSpliceFlags.
     * @param ioPriority the io priority of the request.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    spliceAsync(
      stream2: IOStream,
      flags: IOStreamSpliceFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void

    // Own virtual methods of Gio-2.0.Gio.IOStream

    /**
     * Requests an asynchronous close of the stream, releasing resources
     * related to it. When the operation is finished `callback` will be
     * called. You can then call g_io_stream_close_finish() to get
     * the result of the operation.
     *
     * For behaviour details see g_io_stream_close().
     *
     * The asynchronous methods have a default fallback that uses threads
     * to implement asynchronicity, so they are optional for inheriting
     * classes. However, if you override one you must override all.
     * @virtual
     * @param ioPriority the io priority of the request
     * @param cancellable optional cancellable object
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    closeAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Closes a stream.
     * @virtual
     * @param result a #GAsyncResult
     * @returns %TRUE if stream was successfully closed, %FALSE otherwise.
     */
    closeFinish(result: AsyncResult): boolean
    closeFn(cancellable: Cancellable | null): boolean
    /**
     * Gets the input stream for this object. This is used
     * for reading.
     * @virtual
     * @returns a #GInputStream, owned by the #GIOStream. Do not free.
     */
    getInputStream(): InputStream
    /**
     * Gets the output stream for this object. This is used for
     * writing.
     * @virtual
     * @returns a #GOutputStream, owned by the #GIOStream. Do not free.
     */
    getOutputStream(): OutputStream

    // Class property signals of Gio-2.0.Gio.IOStream

    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::output-stream", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GIOStream` represents an object that has both read and write streams.
   * Generally the two streams act as separate input and output streams,
   * but they share some common resources and state. For instance, for
   * seekable streams, both streams may use the same position.
   *
   * Examples of `GIOStream` objects are [class`Gio`.SocketConnection], which represents
   * a two-way network connection; and [class`Gio`.FileIOStream], which represents a
   * file handle opened in read-write mode.
   *
   * To do the actual reading and writing you need to get the substreams
   * with [method`Gio`.IOStream.get_input_stream] and
   * [method`Gio`.IOStream.get_output_stream].
   *
   * The `GIOStream` object owns the input and the output streams, not the other
   * way around, so keeping the substreams alive will not keep the `GIOStream`
   * object alive. If the `GIOStream` object is freed it will be closed, thus
   * closing the substreams, so even if the substreams stay alive they will
   * always return `G_IO_ERROR_CLOSED` for all operations.
   *
   * To close a stream use [method`Gio`.IOStream.close] which will close the common
   * stream object and also the individual substreams. You can also close
   * the substreams themselves. In most cases this only marks the
   * substream as closed, so further I/O on it fails but common state in the
   * `GIOStream` may still be open. However, some streams may support
   * ‘half-closed’ states where one direction of the stream is actually shut down.
   *
   * Operations on `GIOStream`s cannot be started while another operation on the
   * `GIOStream` or its substreams is in progress. Specifically, an application can
   * read from the [class`Gio`.InputStream] and write to the
   * [class`Gio`.OutputStream] simultaneously (either in separate threads, or as
   * asynchronous operations in the same thread), but an application cannot start
   * any `GIOStream` operation while there is a `GIOStream`, `GInputStream` or
   * `GOutputStream` operation in progress, and an application can’t start any
   * `GInputStream` or `GOutputStream` operation while there is a `GIOStream`
   * operation in progress.
   *
   * This is a product of individual stream operations being associated with a
   * given [type`GLib`.MainContext] (the thread-default context at the time the
   * operation was started), rather than entire streams being associated with a
   * single `GMainContext`.
   *
   * GIO may run operations on `GIOStream`s from other (worker) threads, and this
   * may be exposed to application code in the behaviour of wrapper streams, such
   * as [class`Gio`.BufferedInputStream] or [class`Gio`.TlsConnection]. With such
   * wrapper APIs, application code may only run operations on the base (wrapped)
   * stream when the wrapper stream is idle. Note that the semantics of such
   * operations may not be well-defined due to the state the wrapper stream leaves
   * the base stream in (though they are guaranteed not to crash).
   * @class
   */
  class IOStream extends GObject.Object {
    // Own properties of Gio-2.0.Gio.IOStream

    static name: string

    // Constructors of Gio-2.0.Gio.IOStream

    constructor(config?: IOStream.ConstructorProperties)
    _init(config?: IOStream.ConstructorProperties): void
    /**
     * Finishes an asynchronous io stream splice operation.
     * @param result a #GAsyncResult.
     * @returns %TRUE on success, %FALSE otherwise.
     */
    static spliceFinish(result: AsyncResult): boolean
  }

  module InetAddress {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.InetAddress

      /**
       * The raw address data.
       */
      bytes?: any | null
      /**
       * The address family (IPv4 or IPv6).
       */
      family?: SocketFamily | null
    }
  }

  interface InetAddress {
    // Own properties of Gio-2.0.Gio.InetAddress

    /**
     * The raw address data.
     */
    readonly bytes: any
    /**
     * The address family (IPv4 or IPv6).
     */
    readonly family: SocketFamily
    /**
     * Whether this is the "any" address for its family.
     * See g_inet_address_get_is_any().
     */
    readonly isAny: boolean
    /**
     * Whether this is a link-local address.
     * See g_inet_address_get_is_link_local().
     */
    readonly isLinkLocal: boolean
    /**
     * Whether this is the loopback address for its family.
     * See g_inet_address_get_is_loopback().
     */
    readonly isLoopback: boolean
    /**
     * Whether this is a global multicast address.
     * See g_inet_address_get_is_mc_global().
     */
    readonly isMcGlobal: boolean
    /**
     * Whether this is a link-local multicast address.
     * See g_inet_address_get_is_mc_link_local().
     */
    readonly isMcLinkLocal: boolean
    /**
     * Whether this is a node-local multicast address.
     * See g_inet_address_get_is_mc_node_local().
     */
    readonly isMcNodeLocal: boolean
    /**
     * Whether this is an organization-local multicast address.
     * See g_inet_address_get_is_mc_org_local().
     */
    readonly isMcOrgLocal: boolean
    /**
     * Whether this is a site-local multicast address.
     * See g_inet_address_get_is_mc_site_local().
     */
    readonly isMcSiteLocal: boolean
    /**
     * Whether this is a multicast address.
     * See g_inet_address_get_is_multicast().
     */
    readonly isMulticast: boolean
    /**
     * Whether this is a site-local address.
     * See g_inet_address_get_is_loopback().
     */
    readonly isSiteLocal: boolean
    __gtype__: number

    // Own fields of Gio-2.0.Gio.InetAddress

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.InetAddress

    /**
     * Checks if two #GInetAddress instances are equal, e.g. the same address.
     * @param otherAddress Another #GInetAddress.
     * @returns %TRUE if @address and @other_address are equal, %FALSE otherwise.
     */
    equal(otherAddress: InetAddress): boolean
    /**
     * Gets `address'`s family
     * @returns @address's family
     */
    getFamily(): SocketFamily
    /**
     * Tests whether `address` is the "any" address for its family.
     * @returns %TRUE if @address is the "any" address for its family.
     */
    getIsAny(): boolean
    /**
     * Tests whether `address` is a link-local address (that is, if it
     * identifies a host on a local network that is not connected to the
     * Internet).
     * @returns %TRUE if @address is a link-local address.
     */
    getIsLinkLocal(): boolean
    /**
     * Tests whether `address` is the loopback address for its family.
     * @returns %TRUE if @address is the loopback address for its family.
     */
    getIsLoopback(): boolean
    /**
     * Tests whether `address` is a global multicast address.
     * @returns %TRUE if @address is a global multicast address.
     */
    getIsMcGlobal(): boolean
    /**
     * Tests whether `address` is a link-local multicast address.
     * @returns %TRUE if @address is a link-local multicast address.
     */
    getIsMcLinkLocal(): boolean
    /**
     * Tests whether `address` is a node-local multicast address.
     * @returns %TRUE if @address is a node-local multicast address.
     */
    getIsMcNodeLocal(): boolean
    /**
     * Tests whether `address` is an organization-local multicast address.
     * @returns %TRUE if @address is an organization-local multicast address.
     */
    getIsMcOrgLocal(): boolean
    /**
     * Tests whether `address` is a site-local multicast address.
     * @returns %TRUE if @address is a site-local multicast address.
     */
    getIsMcSiteLocal(): boolean
    /**
     * Tests whether `address` is a multicast address.
     * @returns %TRUE if @address is a multicast address.
     */
    getIsMulticast(): boolean
    /**
     * Tests whether `address` is a site-local address such as 10.0.0.1
     * (that is, the address identifies a host on a local network that can
     * not be reached directly from the Internet, but which may have
     * outgoing Internet connectivity via a NAT or firewall).
     * @returns %TRUE if @address is a site-local address.
     */
    getIsSiteLocal(): boolean
    /**
     * Gets the size of the native raw binary address for `address`. This
     * is the size of the data that you get from g_inet_address_to_bytes().
     * @returns the number of bytes used for the native version of @address.
     */
    getNativeSize(): number
    // Has conflict: toString(): string | null

    // Own virtual methods of Gio-2.0.Gio.InetAddress

    /**
     * Converts `address` to string form.
     * @virtual
     * @returns a representation of @address as a string, which should be freed after use.
     */
    toString(): string | null

    // Class property signals of Gio-2.0.Gio.InetAddress

    connect(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::bytes", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::is-any",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-any",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-any",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-any",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-any", ...args: any[]): void
    connect(
      sigName: "notify::is-link-local",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-link-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-link-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-link-local",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-link-local", ...args: any[]): void
    connect(
      sigName: "notify::is-loopback",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-loopback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-loopback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-loopback",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-loopback", ...args: any[]): void
    connect(
      sigName: "notify::is-mc-global",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-mc-global",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-mc-global",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-mc-global",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-mc-global", ...args: any[]): void
    connect(
      sigName: "notify::is-mc-link-local",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-mc-link-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-mc-link-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-mc-link-local",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-mc-link-local", ...args: any[]): void
    connect(
      sigName: "notify::is-mc-node-local",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-mc-node-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-mc-node-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-mc-node-local",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-mc-node-local", ...args: any[]): void
    connect(
      sigName: "notify::is-mc-org-local",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-mc-org-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-mc-org-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-mc-org-local",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-mc-org-local", ...args: any[]): void
    connect(
      sigName: "notify::is-mc-site-local",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-mc-site-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-mc-site-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-mc-site-local",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-mc-site-local", ...args: any[]): void
    connect(
      sigName: "notify::is-multicast",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-multicast",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-multicast",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-multicast",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-multicast", ...args: any[]): void
    connect(
      sigName: "notify::is-site-local",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-site-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-site-local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-site-local",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-site-local", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GInetAddress` represents an IPv4 or IPv6 internet address. Use
   * [method`Gio`.Resolver.lookup_by_name] or
   * [method`Gio`.Resolver.lookup_by_name_async] to look up the `GInetAddress` for
   * a hostname. Use [method`Gio`.Resolver.lookup_by_address] or
   * [method`Gio`.Resolver.lookup_by_address_async] to look up the hostname for a
   * `GInetAddress`.
   *
   * To actually connect to a remote host, you will need a
   * [class`Gio`.InetSocketAddress] (which includes a `GInetAddress` as well as a
   * port number).
   * @class
   */
  class InetAddress extends GObject.Object {
    // Own properties of Gio-2.0.Gio.InetAddress

    static name: string

    // Constructors of Gio-2.0.Gio.InetAddress

    constructor(config?: InetAddress.ConstructorProperties)
    /**
     * Creates a #GInetAddress for the "any" address (unassigned/"don't
     * care") for `family`.
     * @constructor
     * @param family the address family
     * @returns a new #GInetAddress corresponding to the "any" address for @family.     Free the returned object with g_object_unref().
     */
    static newAny(family: SocketFamily): InetAddress
    /**
     * Creates a new #GInetAddress from the given `family` and `bytes`.
     * `bytes` should be 4 bytes for %G_SOCKET_FAMILY_IPV4 and 16 bytes for
     * %G_SOCKET_FAMILY_IPV6.
     * @constructor
     * @param bytes raw address data
     * @param family the address family of `bytes`
     * @returns a new #GInetAddress corresponding to @family and @bytes.     Free the returned object with g_object_unref().
     */
    static newFromBytes(bytes: number[], family: SocketFamily): InetAddress
    /**
     * Parses `string` as an IP address and creates a new #GInetAddress.
     * @constructor
     * @param string a string representation of an IP address
     * @returns a new #GInetAddress corresponding to @string, or %NULL if @string could not be parsed.     Free the returned object with g_object_unref().
     */
    static newFromString(string: string): InetAddress
    /**
     * Creates a #GInetAddress for the loopback address for `family`.
     * @constructor
     * @param family the address family
     * @returns a new #GInetAddress corresponding to the loopback address for @family.     Free the returned object with g_object_unref().
     */
    static newLoopback(family: SocketFamily): InetAddress
    _init(config?: InetAddress.ConstructorProperties): void
  }

  module InetAddressMask {
    // Constructor properties interface

    interface ConstructorProperties
      extends Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.InetAddressMask

      /**
       * The base address.
       */
      address?: InetAddress | null
      /**
       * The prefix length, in bytes.
       */
      length?: number | null
    }
  }

  interface InetAddressMask extends Initable {
    // Own properties of Gio-2.0.Gio.InetAddressMask

    /**
     * The base address.
     */
    address: InetAddress
    /**
     * The address family (IPv4 or IPv6).
     */
    readonly family: SocketFamily
    /**
     * The prefix length, in bytes.
     */
    length: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.InetAddressMask

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.InetAddressMask

    /**
     * Tests if `mask` and `mask2` are the same mask.
     * @param mask2 another #GInetAddressMask
     * @returns whether @mask and @mask2 are the same mask
     */
    equal(mask2: InetAddressMask): boolean
    /**
     * Gets `mask'`s base address
     * @returns @mask's base address
     */
    getAddress(): InetAddress
    /**
     * Gets the #GSocketFamily of `mask'`s address
     * @returns the #GSocketFamily of @mask's address
     */
    getFamily(): SocketFamily
    /**
     * Gets `mask'`s length
     * @returns @mask's length
     */
    getLength(): number
    /**
     * Tests if `address` falls within the range described by `mask`.
     * @param address a #GInetAddress
     * @returns whether @address falls within the range described by @mask.
     */
    matches(address: InetAddress): boolean
    /**
     * Converts `mask` back to its corresponding string form.
     * @returns a string corresponding to @mask.
     */
    toString(): string | null

    // Class property signals of Gio-2.0.Gio.InetAddressMask

    connect(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::address", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::length", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GInetAddressMask` represents a range of IPv4 or IPv6 addresses
   * described by a base address and a length indicating how many bits
   * of the base address are relevant for matching purposes. These are
   * often given in string form. For example, `10.0.0.0/8`, or `fe80::/10`.
   * @class
   */
  class InetAddressMask extends GObject.Object {
    // Own properties of Gio-2.0.Gio.InetAddressMask

    static name: string

    // Constructors of Gio-2.0.Gio.InetAddressMask

    constructor(config?: InetAddressMask.ConstructorProperties)
    /**
     * Creates a new #GInetAddressMask representing all addresses whose
     * first `length` bits match `addr`.
     * @constructor
     * @param addr a #GInetAddress
     * @param length number of bits of `addr` to use
     * @returns a new #GInetAddressMask, or %NULL on error
     */
    constructor(addr: InetAddress, length: number)
    /**
     * Creates a new #GInetAddressMask representing all addresses whose
     * first `length` bits match `addr`.
     * @constructor
     * @param addr a #GInetAddress
     * @param length number of bits of `addr` to use
     * @returns a new #GInetAddressMask, or %NULL on error
     */
    static new(addr: InetAddress, length: number): InetAddressMask
    /**
     * Parses `mask_string` as an IP address and (optional) length, and
     * creates a new #GInetAddressMask. The length, if present, is
     * delimited by a "/". If it is not present, then the length is
     * assumed to be the full length of the address.
     * @constructor
     * @param maskString an IP address or address/length string
     * @returns a new #GInetAddressMask corresponding to @string, or %NULL on error.
     */
    static newFromString(maskString: string): InetAddressMask
    _init(config?: InetAddressMask.ConstructorProperties): void
  }

  module InetSocketAddress {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnectable.ConstructorProperties,
        SocketAddress.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.InetSocketAddress

      /**
       * The address.
       */
      address?: InetAddress | null
      /**
       * The `sin6_flowinfo` field, for IPv6 addresses.
       */
      flowinfo?: number | null
      /**
       * The port.
       */
      port?: number | null
      /**
       * The `sin6_scope_id` field, for IPv6 addresses.
       */
      scope_id?: number | null
    }
  }

  interface InetSocketAddress extends SocketConnectable {
    // Own properties of Gio-2.0.Gio.InetSocketAddress

    /**
     * The address.
     */
    readonly address: InetAddress
    /**
     * The `sin6_flowinfo` field, for IPv6 addresses.
     */
    readonly flowinfo: number
    /**
     * The port.
     */
    readonly port: number
    /**
     * The `sin6_scope_id` field, for IPv6 addresses.
     */
    readonly scopeId: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.InetSocketAddress

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.InetSocketAddress

    /**
     * Gets `address'`s #GInetAddress.
     * @returns the #GInetAddress for @address, which must be g_object_ref()'d if it will be stored
     */
    getAddress(): InetAddress
    /**
     * Gets the `sin6_flowinfo` field from `address,`
     * which must be an IPv6 address.
     * @returns the flowinfo field
     */
    getFlowinfo(): number
    /**
     * Gets `address'`s port.
     * @returns the port for @address
     */
    getPort(): number
    /**
     * Gets the `sin6_scope_id` field from `address,`
     * which must be an IPv6 address.
     * @returns the scope id field
     */
    getScopeId(): number

    // Class property signals of Gio-2.0.Gio.InetSocketAddress

    connect(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::address", ...args: any[]): void
    connect(
      sigName: "notify::flowinfo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flowinfo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flowinfo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flowinfo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flowinfo", ...args: any[]): void
    connect(sigName: "notify::port", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::port",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::port", ...args: any[]): void
    connect(
      sigName: "notify::scope-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scope-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scope-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scope-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scope-id", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An IPv4 or IPv6 socket address. That is, the combination of a
   * [class`Gio`.InetAddress] and a port number.
   *
   * In UNIX terms, `GInetSocketAddress` corresponds to a
   * [`struct sockaddr_in` or `struct sockaddr_in6`](man:sockaddr(3type)).
   * @class
   */
  class InetSocketAddress extends SocketAddress {
    // Own properties of Gio-2.0.Gio.InetSocketAddress

    static name: string

    // Constructors of Gio-2.0.Gio.InetSocketAddress

    constructor(config?: InetSocketAddress.ConstructorProperties)
    /**
     * Creates a new #GInetSocketAddress for `address` and `port`.
     * @constructor
     * @param address a #GInetAddress
     * @param port a port number
     * @returns a new #GInetSocketAddress
     */
    constructor(address: InetAddress, port: number)
    /**
     * Creates a new #GInetSocketAddress for `address` and `port`.
     * @constructor
     * @param address a #GInetAddress
     * @param port a port number
     * @returns a new #GInetSocketAddress
     */
    static new(address: InetAddress, port: number): InetSocketAddress
    /**
     * Creates a new #GInetSocketAddress for `address` and `port`.
     *
     * If `address` is an IPv6 address, it can also contain a scope ID
     * (separated from the address by a `%`).
     * @constructor
     * @param address the string form of an IP address
     * @param port a port number
     * @returns a new #GInetSocketAddress, or %NULL if @address cannot be parsed.
     */
    static newFromString(address: string, port: number): InetSocketAddress
    _init(config?: InetSocketAddress.ConstructorProperties): void
  }

  module InputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface InputStream {
    // Own properties of Gio-2.0.Gio.InputStream

    __gtype__: number

    // Own fields of Gio-2.0.Gio.InputStream

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.InputStream

    /**
     * Clears the pending flag on `stream`.
     */
    clearPending(): void
    /**
     * Closes the stream, releasing resources related to it.
     *
     * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
     * Closing a stream multiple times will not return an error.
     *
     * Streams will be automatically closed when the last reference
     * is dropped, but you might want to call this function to make sure
     * resources are released as early as possible.
     *
     * Some streams might keep the backing store of the stream (e.g. a file descriptor)
     * open after the stream is closed. See the documentation for the individual
     * stream for details.
     *
     * On failure the first error that happened will be reported, but the close
     * operation will finish as much as possible. A stream that failed to
     * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
     * is important to check and report the error to the user.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * Cancelling a close will still leave the stream closed, but some streams
     * can use a faster close that doesn't block to e.g. check errors.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE on success, %FALSE on failure
     */
    close(cancellable: Cancellable | null): boolean
    // Has conflict: closeAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: closeFinish(result: AsyncResult): boolean
    /**
     * Checks if an input stream has pending actions.
     * @returns %TRUE if @stream has pending actions.
     */
    hasPending(): boolean
    /**
     * Checks if an input stream is closed.
     * @returns %TRUE if the stream is closed.
     */
    isClosed(): boolean
    /**
     * Tries to read `count` bytes from the stream into the buffer starting at
     * `buffer`. Will block during this read.
     *
     * If count is zero returns zero and does nothing. A value of `count`
     * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, the number of bytes read into the buffer is returned.
     * It is not an error if this is not the same as the requested size, as it
     * can happen e.g. near the end of a file. Zero is returned on end of file
     * (or if `count` is zero),  but never otherwise.
     *
     * The returned `buffer` is not a nul-terminated string, it can contain nul bytes
     * at any position, and this function doesn't nul-terminate the `buffer`.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     *
     * On error -1 is returned and `error` is set accordingly.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns Number of bytes read, or -1 on error, or 0 on end of file.
     */
    read(
      cancellable: Cancellable | null
    ): [/* returnType */ number, /* buffer */ number[]]
    /**
     * Tries to read `count` bytes from the stream into the buffer starting at
     * `buffer`. Will block during this read.
     *
     * This function is similar to g_input_stream_read(), except it tries to
     * read as many bytes as requested, only stopping on an error or end of stream.
     *
     * On a successful read of `count` bytes, or if we reached the end of the
     * stream,  %TRUE is returned, and `bytes_read` is set to the number of bytes
     * read into `buffer`.
     *
     * If there is an error during the operation %FALSE is returned and `error`
     * is set to indicate the error status.
     *
     * As a special exception to the normal conventions for functions that
     * use #GError, if this function returns %FALSE (and sets `error)` then
     * `bytes_read` will be set to the number of bytes that were successfully
     * read before the error was encountered.  This functionality is only
     * available from C.  If you need it from another language then you must
     * write your own loop around g_input_stream_read().
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE on success, %FALSE if there was an error
     */
    readAll(
      cancellable: Cancellable | null
    ): [/* returnType */ boolean, /* buffer */ number[], /* bytesRead */ number]
    /**
     * Request an asynchronous read of `count` bytes from the stream into the
     * buffer starting at `buffer`.
     *
     * This is the asynchronous equivalent of g_input_stream_read_all().
     *
     * Call g_input_stream_read_all_finish() to collect the result.
     *
     * Any outstanding I/O request with higher priority (lower numerical
     * value) will be executed before an outstanding request with lower
     * priority. Default priority is %G_PRIORITY_DEFAULT.
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    readAllAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): /* buffer */ number[]
    /**
     * Finishes an asynchronous stream read operation started with
     * g_input_stream_read_all_async().
     *
     * As a special exception to the normal conventions for functions that
     * use #GError, if this function returns %FALSE (and sets `error)` then
     * `bytes_read` will be set to the number of bytes that were successfully
     * read before the error was encountered.  This functionality is only
     * available from C.  If you need it from another language then you must
     * write your own loop around g_input_stream_read_async().
     * @param result a #GAsyncResult
     * @returns %TRUE on success, %FALSE if there was an error
     */
    readAllFinish(
      result: AsyncResult
    ): [/* returnType */ boolean, /* bytesRead */ number]
    // Has conflict: readAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): /* buffer */ number[]
    /**
     * Like g_input_stream_read(), this tries to read `count` bytes from
     * the stream in a blocking fashion. However, rather than reading into
     * a user-supplied buffer, this will create a new #GBytes containing
     * the data that was read. This may be easier to use from language
     * bindings.
     *
     * If count is zero, returns a zero-length #GBytes and does nothing. A
     * value of `count` larger than %G_MAXSSIZE will cause a
     * %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, a new #GBytes is returned. It is not an error if the
     * size of this object is not the same as the requested size, as it
     * can happen e.g. near the end of a file. A zero-length #GBytes is
     * returned on end of file (or if `count` is zero), but never
     * otherwise.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     *
     * On error %NULL is returned and `error` is set accordingly.
     * @param count maximum number of bytes that will be read from the stream. Common values include 4096 and 8192.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a new #GBytes, or %NULL on error
     */
    readBytes(count: number, cancellable: Cancellable | null): any
    /**
     * Request an asynchronous read of `count` bytes from the stream into a
     * new #GBytes. When the operation is finished `callback` will be
     * called. You can then call g_input_stream_read_bytes_finish() to get the
     * result of the operation.
     *
     * During an async request no other sync and async calls are allowed
     * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
     *
     * A value of `count` larger than %G_MAXSSIZE will cause a
     * %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, the new #GBytes will be passed to the callback. It is
     * not an error if this is smaller than the requested size, as it can
     * happen e.g. near the end of a file, but generally we try to read as
     * many bytes as requested. Zero is returned on end of file (or if
     * `count` is zero), but never otherwise.
     *
     * Any outstanding I/O request with higher priority (lower numerical
     * value) will be executed before an outstanding request with lower
     * priority. Default priority is %G_PRIORITY_DEFAULT.
     * @param count the number of bytes that will be read from the stream
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    readBytesAsync(
      count: number,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous stream read-into-#GBytes operation.
     * @param result a #GAsyncResult.
     * @returns the newly-allocated #GBytes, or %NULL on error
     */
    readBytesFinish(result: AsyncResult): any
    // Has conflict: readFinish(result: AsyncResult): number
    /**
     * Sets `stream` to have actions pending. If the pending flag is
     * already set or `stream` is closed, it will return %FALSE and set
     * `error`.
     * @returns %TRUE if pending was previously unset and is now set.
     */
    setPending(): boolean
    // Has conflict: skip(count: number, cancellable: Cancellable | null): number
    // Has conflict: skipAsync(count: number, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: skipFinish(result: AsyncResult): number

    // Own virtual methods of Gio-2.0.Gio.InputStream

    /**
     * Requests an asynchronous closes of the stream, releasing resources related to it.
     * When the operation is finished `callback` will be called.
     * You can then call g_input_stream_close_finish() to get the result of the
     * operation.
     *
     * For behaviour details see g_input_stream_close().
     *
     * The asynchronous methods have a default fallback that uses threads to implement
     * asynchronicity, so they are optional for inheriting classes. However, if you
     * override one you must override all.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional cancellable object
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    closeAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if the stream was closed successfully.
     */
    closeFinish(result: AsyncResult): boolean
    closeFn(cancellable: Cancellable | null): boolean
    /**
     * Request an asynchronous read of `count` bytes from the stream into the buffer
     * starting at `buffer`. When the operation is finished `callback` will be called.
     * You can then call g_input_stream_read_finish() to get the result of the
     * operation.
     *
     * During an async request no other sync and async calls are allowed on `stream,` and will
     * result in %G_IO_ERROR_PENDING errors.
     *
     * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, the number of bytes read into the buffer will be passed to the
     * callback. It is not an error if this is not the same as the requested size, as it
     * can happen e.g. near the end of a file, but generally we try to read
     * as many bytes as requested. Zero is returned on end of file
     * (or if `count` is zero),  but never otherwise.
     *
     * Any outstanding i/o request with higher priority (lower numerical value) will
     * be executed before an outstanding request with lower priority. Default
     * priority is %G_PRIORITY_DEFAULT.
     *
     * The asynchronous methods have a default fallback that uses threads to implement
     * asynchronicity, so they are optional for inheriting classes. However, if you
     * override one you must override all.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    readAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): /* buffer */ number[] | null
    /**
     * Finishes an asynchronous stream read operation.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns number of bytes read in, or -1 on error, or 0 on end of file.
     */
    readFinish(result: AsyncResult): number
    readFn(
      buffer: any | null,
      count: number,
      cancellable: Cancellable | null
    ): number
    /**
     * Tries to skip `count` bytes from the stream. Will block during the operation.
     *
     * This is identical to g_input_stream_read(), from a behaviour standpoint,
     * but the bytes that are skipped are not returned to the user. Some
     * streams have an implementation that is more efficient than reading the data.
     *
     * This function is optional for inherited classes, as the default implementation
     * emulates it using read.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     * @virtual
     * @param count the number of bytes that will be skipped from the stream
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns Number of bytes skipped, or -1 on error
     */
    skip(count: number, cancellable: Cancellable | null): number
    /**
     * Request an asynchronous skip of `count` bytes from the stream.
     * When the operation is finished `callback` will be called.
     * You can then call g_input_stream_skip_finish() to get the result
     * of the operation.
     *
     * During an async request no other sync and async calls are allowed,
     * and will result in %G_IO_ERROR_PENDING errors.
     *
     * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, the number of bytes skipped will be passed to the callback.
     * It is not an error if this is not the same as the requested size, as it
     * can happen e.g. near the end of a file, but generally we try to skip
     * as many bytes as requested. Zero is returned on end of file
     * (or if `count` is zero), but never otherwise.
     *
     * Any outstanding i/o request with higher priority (lower numerical value)
     * will be executed before an outstanding request with lower priority.
     * Default priority is %G_PRIORITY_DEFAULT.
     *
     * The asynchronous methods have a default fallback that uses threads to
     * implement asynchronicity, so they are optional for inheriting classes.
     * However, if you override one, you must override all.
     * @virtual
     * @param count the number of bytes that will be skipped from the stream
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    skipAsync(
      count: number,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a stream skip operation.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns the size of the bytes skipped, or `-1` on error.
     */
    skipFinish(result: AsyncResult): number

    // Class property signals of Gio-2.0.Gio.InputStream

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GInputStream` is a base class for implementing streaming input.
   *
   * It has functions to read from a stream ([method`Gio`.InputStream.read]),
   * to close a stream ([method`Gio`.InputStream.close]) and to skip some content
   * ([method`Gio`.InputStream.skip]).
   *
   * To copy the content of an input stream to an output stream without
   * manually handling the reads and writes, use [method`Gio`.OutputStream.splice].
   *
   * See the documentation for [class`Gio`.IOStream] for details of thread safety
   * of streaming APIs.
   *
   * All of these functions have async variants too.
   * @interface
   */
  class InputStream extends GObject.Object {
    // Own properties of Gio-2.0.Gio.InputStream

    static name: string

    // Constructors of Gio-2.0.Gio.InputStream

    constructor(config?: InputStream.ConstructorProperties)
    _init(config?: InputStream.ConstructorProperties): void
  }

  module ListStore {
    // Constructor properties interface

    interface ConstructorProperties
      extends ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ListStore

      /**
       * The type of items contained in this list store. Items must be
       * subclasses of #GObject.
       */
      item_type?: GObject.GType | null
    }
  }

  interface ListStore<A extends GObject.Object = GObject.Object>
    extends ListModel {
    // Own properties of Gio-2.0.Gio.ListStore

    /**
     * The type of items contained in this list store. Items must be
     * subclasses of #GObject.
     */
    readonly itemType: GObject.GType
    /**
     * The number of items contained in this list store.
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ListStore

    /**
     * Appends `item` to `store`. `item` must be of type #GListStore:item-type.
     *
     * This function takes a ref on `item`.
     *
     * Use g_list_store_splice() to append multiple items at the same time
     * efficiently.
     * @param item the new item
     */
    append(item: GObject.Object): void
    /**
     * Looks up the given `item` in the list store by looping over the items until
     * the first occurrence of `item`. If `item` was not found, then `position` will
     * not be set, and this method will return %FALSE.
     *
     * If you need to compare the two items with a custom comparison function, use
     * g_list_store_find_with_equal_func() with a custom #GEqualFunc instead.
     * @param item an item
     * @returns Whether @store contains @item. If it was found, @position will be set to the position where @item occurred for the first time.
     */
    find(
      item: GObject.Object
    ): [/* returnType */ boolean, /* position */ number]
    /**
     * Looks up the given `item` in the list store by looping over the items and
     * comparing them with `equal_func` until the first occurrence of `item` which
     * matches. If `item` was not found, then `position` will not be set, and this
     * method will return %FALSE.
     *
     * `item` is always passed as second parameter to `equal_func`.
     *
     * Since GLib 2.76 it is possible to pass `NULL` for `item`.
     * @param item an item
     * @param equalFunc A custom equality check function
     * @returns Whether @store contains @item. If it was found, @position will be set to the position where @item occurred for the first time.
     */
    findWithEqualFunc(
      item: GObject.Object | null,
      equalFunc: GLib.EqualFunc
    ): [/* returnType */ boolean, /* position */ number]
    /**
     * Like g_list_store_find_with_equal_func() but with an additional `user_data`
     * that is passed to `equal_func`.
     *
     * `item` is always passed as second parameter to `equal_func`.
     *
     * Since GLib 2.76 it is possible to pass `NULL` for `item`.
     * @param item an item
     * @param equalFunc A custom equality check function
     * @returns Whether @store contains @item. If it was found, @position will be set to the position where @item occurred for the first time.
     */
    findWithEqualFuncFull(
      item: GObject.Object | null,
      equalFunc: GLib.EqualFuncFull
    ): [/* returnType */ boolean, /* position */ number]
    /**
     * Inserts `item` into `store` at `position`. `item` must be of type
     * #GListStore:item-type or derived from it. `position` must be smaller
     * than the length of the list, or equal to it to append.
     *
     * This function takes a ref on `item`.
     *
     * Use g_list_store_splice() to insert multiple items at the same time
     * efficiently.
     * @param position the position at which to insert the new item
     * @param item the new item
     */
    insert(position: number, item: GObject.Object): void
    /**
     * Inserts `item` into `store` at a position to be determined by the
     * `compare_func`.
     *
     * The list must already be sorted before calling this function or the
     * result is undefined.  Usually you would approach this by only ever
     * inserting items by way of this function.
     *
     * This function takes a ref on `item`.
     * @param item the new item
     * @param compareFunc pairwise comparison function for sorting
     * @returns the position at which @item was inserted
     */
    insertSorted(
      item: GObject.Object,
      compareFunc: GLib.CompareDataFunc
    ): number
    /**
     * Removes the item from `store` that is at `position`. `position` must be
     * smaller than the current length of the list.
     *
     * Use g_list_store_splice() to remove multiple items at the same time
     * efficiently.
     * @param position the position of the item that is to be removed
     */
    remove(position: number): void
    /**
     * Removes all items from `store`.
     */
    removeAll(): void
    /**
     * Sort the items in `store` according to `compare_func`.
     * @param compareFunc pairwise comparison function for sorting
     */
    sort(compareFunc: GLib.CompareDataFunc): void
    /**
     * Changes `store` by removing `n_removals` items and adding `n_additions`
     * items to it. `additions` must contain `n_additions` items of type
     * #GListStore:item-type.  %NULL is not permitted.
     *
     * This function is more efficient than g_list_store_insert() and
     * g_list_store_remove(), because it only emits
     * #GListModel::items-changed once for the change.
     *
     * This function takes a ref on each item in `additions`.
     *
     * The parameters `position` and `n_removals` must be correct (ie:
     * `position` + `n_removals` must be less than or equal to the length of
     * the list at the time this function is called).
     * @param position the position at which to make the change
     * @param nRemovals the number of items to remove
     * @param additions the items to add
     */
    splice(
      position: number,
      nRemovals: number,
      additions: GObject.Object[]
    ): void

    // Class property signals of Gio-2.0.Gio.ListStore

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GListStore` is a simple implementation of [iface`Gio`.ListModel] that stores
   * all items in memory.
   *
   * It provides insertions, deletions, and lookups in logarithmic time
   * with a fast path for the common case of iterating the list linearly.
   * @class
   */
  class ListStore<
    A extends GObject.Object = GObject.Object,
  > extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ListStore

    static name: string

    // Constructors of Gio-2.0.Gio.ListStore

    constructor(config?: ListStore.ConstructorProperties)
    /**
     * Creates a new #GListStore with items of type `item_type`. `item_type`
     * must be a subclass of #GObject.
     * @constructor
     * @param itemType the #GType of items in the list
     * @returns a new #GListStore
     */
    constructor(itemType: GObject.GType)
    /**
     * Creates a new #GListStore with items of type `item_type`. `item_type`
     * must be a subclass of #GObject.
     * @constructor
     * @param itemType the #GType of items in the list
     * @returns a new #GListStore
     */
    static new(itemType: GObject.GType): ListStore
    _init(config?: ListStore.ConstructorProperties): void
  }

  module MemoryInputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends PollableInputStream.ConstructorProperties,
        Seekable.ConstructorProperties,
        InputStream.ConstructorProperties {}
  }

  interface MemoryInputStream extends PollableInputStream, Seekable {
    // Own properties of Gio-2.0.Gio.MemoryInputStream

    __gtype__: number

    // Own fields of Gio-2.0.Gio.MemoryInputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.MemoryInputStream

    /**
     * Appends `bytes` to data that can be read from the input stream.
     * @param bytes input data
     */
    addBytes(bytes: any): void
    /**
     * Appends `data` to data that can be read from the input stream
     * @param data input data
     * @param destroy function that is called to free `data,` or %NULL
     */
    addData(data: number[], destroy: GLib.DestroyNotify | null): void

    // Class property signals of Gio-2.0.Gio.MemoryInputStream

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GMemoryInputStream` is a class for using arbitrary
   * memory chunks as input for GIO streaming input operations.
   *
   * As of GLib 2.34, `GMemoryInputStream` implements
   * [iface`Gio`.PollableInputStream].
   * @class
   */
  class MemoryInputStream extends InputStream {
    // Own properties of Gio-2.0.Gio.MemoryInputStream

    static name: string

    // Constructors of Gio-2.0.Gio.MemoryInputStream

    constructor(config?: MemoryInputStream.ConstructorProperties)
    /**
     * Creates a new empty #GMemoryInputStream.
     * @constructor
     * @returns a new #GInputStream
     */
    constructor()
    /**
     * Creates a new empty #GMemoryInputStream.
     * @constructor
     * @returns a new #GInputStream
     */
    static new(): MemoryInputStream
    /**
     * Creates a new #GMemoryInputStream with data from the given `bytes`.
     * @constructor
     * @param bytes a #GBytes
     * @returns new #GInputStream read from @bytes
     */
    static newFromBytes(bytes: any): MemoryInputStream
    /**
     * Creates a new #GMemoryInputStream with data in memory of a given size.
     * @constructor
     * @param data input data
     * @param destroy function that is called to free `data,` or %NULL
     * @returns new #GInputStream read from @data of @len bytes.
     */
    static newFromData(
      data: number[],
      destroy: GLib.DestroyNotify | null
    ): MemoryInputStream
    _init(config?: MemoryInputStream.ConstructorProperties): void
  }

  module MemoryOutputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends PollableOutputStream.ConstructorProperties,
        Seekable.ConstructorProperties,
        OutputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.MemoryOutputStream

      /**
       * Pointer to buffer where data will be written.
       */
      data?: any | null
      /**
       * Current size of the data buffer.
       */
      size?: number | null
    }
  }

  interface MemoryOutputStream extends PollableOutputStream, Seekable {
    // Own properties of Gio-2.0.Gio.MemoryOutputStream

    /**
     * Pointer to buffer where data will be written.
     */
    readonly data: any
    /**
     * Size of data written to the buffer.
     */
    readonly dataSize: number
    /**
     * Current size of the data buffer.
     */
    readonly size: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.MemoryOutputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.MemoryOutputStream

    /**
     * Gets any loaded data from the `ostream`.
     *
     * Note that the returned pointer may become invalid on the next
     * write or truncate operation on the stream.
     * @returns pointer to the stream's data, or %NULL if the data    has been stolen
     */
    getData(): any | null

    // Overloads of getData

    /**
     * Gets a named field from the objects table of associations (see g_object_set_data()).
     * @param key name of the key for that association
     * @returns the data if found,          or %NULL if no such data exists.
     */
    getData(key: string): any | null
    /**
     * Returns the number of bytes from the start up to including the last
     * byte written in the stream that has not been truncated away.
     * @returns the number of bytes written to the stream
     */
    getDataSize(): number
    /**
     * Gets the size of the currently allocated data area (available from
     * g_memory_output_stream_get_data()).
     *
     * You probably don't want to use this function on resizable streams.
     * See g_memory_output_stream_get_data_size() instead.  For resizable
     * streams the size returned by this function is an implementation
     * detail and may be change at any time in response to operations on the
     * stream.
     *
     * If the stream is fixed-sized (ie: no realloc was passed to
     * g_memory_output_stream_new()) then this is the maximum size of the
     * stream and further writes will return %G_IO_ERROR_NO_SPACE.
     *
     * In any case, if you want the number of bytes currently written to the
     * stream, use g_memory_output_stream_get_data_size().
     * @returns the number of bytes allocated for the data buffer
     */
    getSize(): number
    /**
     * Returns data from the `ostream` as a #GBytes. `ostream` must be
     * closed before calling this function.
     * @returns the stream's data
     */
    stealAsBytes(): any
    /**
     * Gets any loaded data from the `ostream`. Ownership of the data
     * is transferred to the caller; when no longer needed it must be
     * freed using the free function set in `ostream'`s
     * #GMemoryOutputStream:destroy-function property.
     *
     * `ostream` must be closed before calling this function.
     * @returns the stream's data, or %NULL if it has previously    been stolen
     */
    stealData(): any | null

    // Overloads of stealData

    /**
     * Remove a specified datum from the object's data associations,
     * without invoking the association's destroy handler.
     * @param key name of the key
     * @returns the data if found, or %NULL          if no such data exists.
     */
    stealData(key: string): any | null

    // Class property signals of Gio-2.0.Gio.MemoryOutputStream

    connect(sigName: "notify::data", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::data",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::data",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::data",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::data", ...args: any[]): void
    connect(
      sigName: "notify::data-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::data-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::data-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::data-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::data-size", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GMemoryOutputStream` is a class for using arbitrary
   * memory chunks as output for GIO streaming output operations.
   *
   * As of GLib 2.34, `GMemoryOutputStream` trivially implements
   * [iface`Gio`.PollableOutputStream]: it always polls as ready.
   * @class
   */
  class MemoryOutputStream extends OutputStream {
    // Own properties of Gio-2.0.Gio.MemoryOutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.MemoryOutputStream

    constructor(config?: MemoryOutputStream.ConstructorProperties)
    /**
     * Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
     * for memory allocation.
     * @constructor
     */
    static newResizable(): MemoryOutputStream
    _init(config?: MemoryOutputStream.ConstructorProperties): void
  }

  module Menu {
    // Constructor properties interface

    interface ConstructorProperties extends MenuModel.ConstructorProperties {}
  }

  interface Menu {
    // Own properties of Gio-2.0.Gio.Menu

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Menu

    /**
     * Convenience function for appending a normal menu item to the end of
     * `menu`.  Combine g_menu_item_new() and g_menu_insert_item() for a more
     * flexible alternative.
     * @param label the section label, or %NULL
     * @param detailedAction the detailed action string, or %NULL
     */
    append(label: string | null, detailedAction: string | null): void
    /**
     * Appends `item` to the end of `menu`.
     *
     * See g_menu_insert_item() for more information.
     * @param item a #GMenuItem to append
     */
    appendItem(item: MenuItem): void
    /**
     * Convenience function for appending a section menu item to the end of
     * `menu`.  Combine g_menu_item_new_section() and g_menu_insert_item() for a
     * more flexible alternative.
     * @param label the section label, or %NULL
     * @param section a #GMenuModel with the items of the section
     */
    appendSection(label: string | null, section: MenuModel): void
    /**
     * Convenience function for appending a submenu menu item to the end of
     * `menu`.  Combine g_menu_item_new_submenu() and g_menu_insert_item() for a
     * more flexible alternative.
     * @param label the section label, or %NULL
     * @param submenu a #GMenuModel with the items of the submenu
     */
    appendSubmenu(label: string | null, submenu: MenuModel): void
    /**
     * Marks `menu` as frozen.
     *
     * After the menu is frozen, it is an error to attempt to make any
     * changes to it.  In effect this means that the #GMenu API must no
     * longer be used.
     *
     * This function causes g_menu_model_is_mutable() to begin returning
     * %FALSE, which has some positive performance implications.
     */
    freeze(): void
    /**
     * Convenience function for inserting a normal menu item into `menu`.
     * Combine g_menu_item_new() and g_menu_insert_item() for a more flexible
     * alternative.
     * @param position the position at which to insert the item
     * @param label the section label, or %NULL
     * @param detailedAction the detailed action string, or %NULL
     */
    insert(
      position: number,
      label: string | null,
      detailedAction: string | null
    ): void
    /**
     * Inserts `item` into `menu`.
     *
     * The "insertion" is actually done by copying all of the attribute and
     * link values of `item` and using them to form a new item within `menu`.
     * As such, `item` itself is not really inserted, but rather, a menu item
     * that is exactly the same as the one presently described by `item`.
     *
     * This means that `item` is essentially useless after the insertion
     * occurs.  Any changes you make to it are ignored unless it is inserted
     * again (at which point its updated values will be copied).
     *
     * You should probably just free `item` once you're done.
     *
     * There are many convenience functions to take care of common cases.
     * See g_menu_insert(), g_menu_insert_section() and
     * g_menu_insert_submenu() as well as "prepend" and "append" variants of
     * each of these functions.
     * @param position the position at which to insert the item
     * @param item the #GMenuItem to insert
     */
    insertItem(position: number, item: MenuItem): void
    /**
     * Convenience function for inserting a section menu item into `menu`.
     * Combine g_menu_item_new_section() and g_menu_insert_item() for a more
     * flexible alternative.
     * @param position the position at which to insert the item
     * @param label the section label, or %NULL
     * @param section a #GMenuModel with the items of the section
     */
    insertSection(
      position: number,
      label: string | null,
      section: MenuModel
    ): void
    /**
     * Convenience function for inserting a submenu menu item into `menu`.
     * Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more
     * flexible alternative.
     * @param position the position at which to insert the item
     * @param label the section label, or %NULL
     * @param submenu a #GMenuModel with the items of the submenu
     */
    insertSubmenu(
      position: number,
      label: string | null,
      submenu: MenuModel
    ): void
    /**
     * Convenience function for prepending a normal menu item to the start
     * of `menu`.  Combine g_menu_item_new() and g_menu_insert_item() for a more
     * flexible alternative.
     * @param label the section label, or %NULL
     * @param detailedAction the detailed action string, or %NULL
     */
    prepend(label: string | null, detailedAction: string | null): void
    /**
     * Prepends `item` to the start of `menu`.
     *
     * See g_menu_insert_item() for more information.
     * @param item a #GMenuItem to prepend
     */
    prependItem(item: MenuItem): void
    /**
     * Convenience function for prepending a section menu item to the start
     * of `menu`.  Combine g_menu_item_new_section() and g_menu_insert_item() for
     * a more flexible alternative.
     * @param label the section label, or %NULL
     * @param section a #GMenuModel with the items of the section
     */
    prependSection(label: string | null, section: MenuModel): void
    /**
     * Convenience function for prepending a submenu menu item to the start
     * of `menu`.  Combine g_menu_item_new_submenu() and g_menu_insert_item() for
     * a more flexible alternative.
     * @param label the section label, or %NULL
     * @param submenu a #GMenuModel with the items of the submenu
     */
    prependSubmenu(label: string | null, submenu: MenuModel): void
    /**
     * Removes an item from the menu.
     *
     * `position` gives the index of the item to remove.
     *
     * It is an error if position is not in range the range from 0 to one
     * less than the number of items in the menu.
     *
     * It is not possible to remove items by identity since items are added
     * to the menu simply by copying their links and attributes (ie:
     * identity of the item itself is not preserved).
     * @param position the position of the item to remove
     */
    remove(position: number): void
    /**
     * Removes all items in the menu.
     */
    removeAll(): void

    // Class property signals of Gio-2.0.Gio.Menu

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GMenu` is a simple implementation of [class`Gio`.MenuModel].
   * You populate a `GMenu` by adding [class`Gio`.MenuItem] instances to it.
   *
   * There are some convenience functions to allow you to directly
   * add items (avoiding [class`Gio`.MenuItem]) for the common cases. To add
   * a regular item, use [method`Gio`.Menu.insert]. To add a section, use
   * [method`Gio`.Menu.insert_section]. To add a submenu, use
   * [method`Gio`.Menu.insert_submenu].
   * @class
   */
  class Menu extends MenuModel {
    // Own properties of Gio-2.0.Gio.Menu

    static name: string

    // Constructors of Gio-2.0.Gio.Menu

    constructor(config?: Menu.ConstructorProperties)
    /**
     * Creates a new #GMenu.
     *
     * The new menu has no items.
     * @constructor
     * @returns a new #GMenu
     */
    constructor()
    /**
     * Creates a new #GMenu.
     *
     * The new menu has no items.
     * @constructor
     * @returns a new #GMenu
     */
    static new(): Menu
    _init(config?: Menu.ConstructorProperties): void
  }

  module MenuAttributeIter {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface MenuAttributeIter {
    // Own properties of Gio-2.0.Gio.MenuAttributeIter

    __gtype__: number

    // Own fields of Gio-2.0.Gio.MenuAttributeIter

    parentInstance: GObject.Object
    priv: MenuAttributeIterPrivate

    // Owm methods of Gio-2.0.Gio.MenuAttributeIter

    /**
     * Gets the name of the attribute at the current iterator position, as
     * a string.
     *
     * The iterator is not advanced.
     * @returns the name of the attribute
     */
    getName(): string
    // Has conflict: getNext(): [ /* returnType */ boolean, /* outName */ string, /* value */ GLib.Variant ]
    /**
     * Gets the value of the attribute at the current iterator position.
     *
     * The iterator is not advanced.
     * @returns the value of the current attribute
     */
    getValue(): GLib.Variant
    /**
     * Attempts to advance the iterator to the next (possibly first)
     * attribute.
     *
     * %TRUE is returned on success, or %FALSE if there are no more
     * attributes.
     *
     * You must call this function when you first acquire the iterator
     * to advance it to the first attribute (and determine if the first
     * attribute exists at all).
     * @returns %TRUE on success, or %FALSE when there are no more attributes
     */
    next(): boolean

    // Own virtual methods of Gio-2.0.Gio.MenuAttributeIter

    /**
     * This function combines g_menu_attribute_iter_next() with
     * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value().
     *
     * First the iterator is advanced to the next (possibly first) attribute.
     * If that fails, then %FALSE is returned and there are no other
     * effects.
     *
     * If successful, `name` and `value` are set to the name and value of the
     * attribute that has just been advanced to.  At this point,
     * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value() will
     * return the same values again.
     *
     * The value returned in `name` remains valid for as long as the iterator
     * remains at the current position.  The value returned in `value` must
     * be unreffed using g_variant_unref() when it is no longer in use.
     * @virtual
     * @returns %TRUE on success, or %FALSE if there is no additional     attribute
     */
    getNext(): [
      /* returnType */ boolean,
      /* outName */ string,
      /* value */ GLib.Variant,
    ]

    // Class property signals of Gio-2.0.Gio.MenuAttributeIter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * #GMenuAttributeIter is an opaque structure type.  You must access it
   * using the functions below.
   * @class
   */
  class MenuAttributeIter extends GObject.Object {
    // Own properties of Gio-2.0.Gio.MenuAttributeIter

    static name: string

    // Constructors of Gio-2.0.Gio.MenuAttributeIter

    constructor(config?: MenuAttributeIter.ConstructorProperties)
    _init(config?: MenuAttributeIter.ConstructorProperties): void
  }

  module MenuItem {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface MenuItem {
    // Own properties of Gio-2.0.Gio.MenuItem

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.MenuItem

    /**
     * Queries the named `attribute` on `menu_item`.
     *
     * If `expected_type` is specified and the attribute does not have this
     * type, %NULL is returned.  %NULL is also returned if the attribute
     * simply does not exist.
     * @param attribute the attribute name to query
     * @param expectedType the expected type of the attribute
     * @returns the attribute value, or %NULL
     */
    getAttributeValue(
      attribute: string,
      expectedType: GLib.VariantType | null
    ): GLib.Variant | null
    /**
     * Queries the named `link` on `menu_item`.
     * @param link the link name to query
     * @returns the link, or %NULL
     */
    getLink(link: string): MenuModel | null
    /**
     * Sets or unsets the "action" and "target" attributes of `menu_item`.
     *
     * If `action` is %NULL then both the "action" and "target" attributes
     * are unset (and `target_value` is ignored).
     *
     * If `action` is non-%NULL then the "action" attribute is set.  The
     * "target" attribute is then set to the value of `target_value` if it is
     * non-%NULL or unset otherwise.
     *
     * Normal menu items (ie: not submenu, section or other custom item
     * types) are expected to have the "action" attribute set to identify
     * the action that they are associated with.  The state type of the
     * action help to determine the disposition of the menu item.  See
     * #GAction and #GActionGroup for an overview of actions.
     *
     * In general, clicking on the menu item will result in activation of
     * the named action with the "target" attribute given as the parameter
     * to the action invocation.  If the "target" attribute is not set then
     * the action is invoked with no parameter.
     *
     * If the action has no state then the menu item is usually drawn as a
     * plain menu item (ie: with no additional decoration).
     *
     * If the action has a boolean state then the menu item is usually drawn
     * as a toggle menu item (ie: with a checkmark or equivalent
     * indication).  The item should be marked as 'toggled' or 'checked'
     * when the boolean state is %TRUE.
     *
     * If the action has a string state then the menu item is usually drawn
     * as a radio menu item (ie: with a radio bullet or equivalent
     * indication).  The item should be marked as 'selected' when the string
     * state is equal to the value of the `target` property.
     *
     * See g_menu_item_set_action_and_target() or
     * g_menu_item_set_detailed_action() for two equivalent calls that are
     * probably more convenient for most uses.
     * @param action the name of the action for this item
     * @param targetValue a #GVariant to use as the action target
     */
    setActionAndTargetValue(
      action: string | null,
      targetValue: GLib.Variant | null
    ): void
    /**
     * Sets or unsets an attribute on `menu_item`.
     *
     * The attribute to set or unset is specified by `attribute`. This
     * can be one of the standard attribute names %G_MENU_ATTRIBUTE_LABEL,
     * %G_MENU_ATTRIBUTE_ACTION, %G_MENU_ATTRIBUTE_TARGET, or a custom
     * attribute name.
     * Attribute names are restricted to lowercase characters, numbers
     * and '-'. Furthermore, the names must begin with a lowercase character,
     * must not end with a '-', and must not contain consecutive dashes.
     *
     * must consist only of lowercase
     * ASCII characters, digits and '-'.
     *
     * If `value` is non-%NULL then it is used as the new value for the
     * attribute.  If `value` is %NULL then the attribute is unset. If
     * the `value` #GVariant is floating, it is consumed.
     *
     * See also g_menu_item_set_attribute() for a more convenient way to do
     * the same.
     * @param attribute the attribute to set
     * @param value a #GVariant to use as the value, or %NULL
     */
    setAttributeValue(attribute: string, value: GLib.Variant | null): void
    /**
     * Sets the "action" and possibly the "target" attribute of `menu_item`.
     *
     * The format of `detailed_action` is the same format parsed by
     * g_action_parse_detailed_name().
     *
     * See g_menu_item_set_action_and_target() or
     * g_menu_item_set_action_and_target_value() for more flexible (but
     * slightly less convenient) alternatives.
     *
     * See also g_menu_item_set_action_and_target_value() for a description of
     * the semantics of the action and target attributes.
     * @param detailedAction the "detailed" action string
     */
    setDetailedAction(detailedAction: string): void
    /**
     * Sets (or unsets) the icon on `menu_item`.
     *
     * This call is the same as calling g_icon_serialize() and using the
     * result as the value to g_menu_item_set_attribute_value() for
     * %G_MENU_ATTRIBUTE_ICON.
     *
     * This API is only intended for use with "noun" menu items; things like
     * bookmarks or applications in an "Open With" menu.  Don't use it on
     * menu items corresponding to verbs (eg: stock icons for 'Save' or
     * 'Quit').
     *
     * If `icon` is %NULL then the icon is unset.
     * @param icon a #GIcon, or %NULL
     */
    setIcon(icon: Icon): void
    /**
     * Sets or unsets the "label" attribute of `menu_item`.
     *
     * If `label` is non-%NULL it is used as the label for the menu item.  If
     * it is %NULL then the label attribute is unset.
     * @param label the label to set, or %NULL to unset
     */
    setLabel(label: string | null): void
    /**
     * Creates a link from `menu_item` to `model` if non-%NULL, or unsets it.
     *
     * Links are used to establish a relationship between a particular menu
     * item and another menu.  For example, %G_MENU_LINK_SUBMENU is used to
     * associate a submenu with a particular menu item, and %G_MENU_LINK_SECTION
     * is used to create a section. Other types of link can be used, but there
     * is no guarantee that clients will be able to make sense of them.
     * Link types are restricted to lowercase characters, numbers
     * and '-'. Furthermore, the names must begin with a lowercase character,
     * must not end with a '-', and must not contain consecutive dashes.
     * @param link type of link to establish or unset
     * @param model the #GMenuModel to link to (or %NULL to unset)
     */
    setLink(link: string, model: MenuModel | null): void
    /**
     * Sets or unsets the "section" link of `menu_item` to `section`.
     *
     * The effect of having one menu appear as a section of another is
     * exactly as it sounds: the items from `section` become a direct part of
     * the menu that `menu_item` is added to.  See g_menu_item_new_section()
     * for more information about what it means for a menu item to be a
     * section.
     * @param section a #GMenuModel, or %NULL
     */
    setSection(section: MenuModel | null): void
    /**
     * Sets or unsets the "submenu" link of `menu_item` to `submenu`.
     *
     * If `submenu` is non-%NULL, it is linked to.  If it is %NULL then the
     * link is unset.
     *
     * The effect of having one menu appear as a submenu of another is
     * exactly as it sounds.
     * @param submenu a #GMenuModel, or %NULL
     */
    setSubmenu(submenu: MenuModel | null): void

    // Class property signals of Gio-2.0.Gio.MenuItem

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * #GMenuItem is an opaque structure type.  You must access it using the
   * functions below.
   * @class
   */
  class MenuItem extends GObject.Object {
    // Own properties of Gio-2.0.Gio.MenuItem

    static name: string

    // Constructors of Gio-2.0.Gio.MenuItem

    constructor(config?: MenuItem.ConstructorProperties)
    /**
     * Creates a new #GMenuItem.
     *
     * If `label` is non-%NULL it is used to set the "label" attribute of the
     * new item.
     *
     * If `detailed_action` is non-%NULL it is used to set the "action" and
     * possibly the "target" attribute of the new item.  See
     * g_menu_item_set_detailed_action() for more information.
     * @constructor
     * @param label the section label, or %NULL
     * @param detailedAction the detailed action string, or %NULL
     * @returns a new #GMenuItem
     */
    constructor(label: string | null, detailedAction: string | null)
    /**
     * Creates a new #GMenuItem.
     *
     * If `label` is non-%NULL it is used to set the "label" attribute of the
     * new item.
     *
     * If `detailed_action` is non-%NULL it is used to set the "action" and
     * possibly the "target" attribute of the new item.  See
     * g_menu_item_set_detailed_action() for more information.
     * @constructor
     * @param label the section label, or %NULL
     * @param detailedAction the detailed action string, or %NULL
     * @returns a new #GMenuItem
     */
    static new(label: string | null, detailedAction: string | null): MenuItem
    /**
     * Creates a #GMenuItem as an exact copy of an existing menu item in a
     * #GMenuModel.
     *
     * `item_index` must be valid (ie: be sure to call
     * g_menu_model_get_n_items() first).
     * @constructor
     * @param model a #GMenuModel
     * @param itemIndex the index of an item in `model`
     * @returns a new #GMenuItem.
     */
    static newFromModel(model: MenuModel, itemIndex: number): MenuItem
    /**
     * Creates a new #GMenuItem representing a section.
     *
     * This is a convenience API around g_menu_item_new() and
     * g_menu_item_set_section().
     *
     * The effect of having one menu appear as a section of another is
     * exactly as it sounds: the items from `section` become a direct part of
     * the menu that `menu_item` is added to.
     *
     * Visual separation is typically displayed between two non-empty
     * sections.  If `label` is non-%NULL then it will be encorporated into
     * this visual indication.  This allows for labeled subsections of a
     * menu.
     *
     * As a simple example, consider a typical "Edit" menu from a simple
     * program.  It probably contains an "Undo" and "Redo" item, followed by
     * a separator, followed by "Cut", "Copy" and "Paste".
     *
     * This would be accomplished by creating three #GMenu instances.  The
     * first would be populated with the "Undo" and "Redo" items, and the
     * second with the "Cut", "Copy" and "Paste" items.  The first and
     * second menus would then be added as submenus of the third.  In XML
     * format, this would look something like the following:
     *
     * ```
     * <menu id='edit-menu'>
     *   <section>
     *     <item label='Undo'/>
     *     <item label='Redo'/>
     *   </section>
     *   <section>
     *     <item label='Cut'/>
     *     <item label='Copy'/>
     *     <item label='Paste'/>
     *   </section>
     * </menu>
     * ```
     *
     *
     * The following example is exactly equivalent.  It is more illustrative
     * of the exact relationship between the menus and items (keeping in
     * mind that the 'link' element defines a new menu that is linked to the
     * containing one).  The style of the second example is more verbose and
     * difficult to read (and therefore not recommended except for the
     * purpose of understanding what is really going on).
     *
     * ```
     * <menu id='edit-menu'>
     *   <item>
     *     <link name='section'>
     *       <item label='Undo'/>
     *       <item label='Redo'/>
     *     </link>
     *   </item>
     *   <item>
     *     <link name='section'>
     *       <item label='Cut'/>
     *       <item label='Copy'/>
     *       <item label='Paste'/>
     *     </link>
     *   </item>
     * </menu>
     * ```
     *
     * @constructor
     * @param label the section label, or %NULL
     * @param section a #GMenuModel with the items of the section
     * @returns a new #GMenuItem
     */
    static newSection(label: string | null, section: MenuModel): MenuItem
    /**
     * Creates a new #GMenuItem representing a submenu.
     *
     * This is a convenience API around g_menu_item_new() and
     * g_menu_item_set_submenu().
     * @constructor
     * @param label the section label, or %NULL
     * @param submenu a #GMenuModel with the items of the submenu
     * @returns a new #GMenuItem
     */
    static newSubmenu(label: string | null, submenu: MenuModel): MenuItem
    _init(config?: MenuItem.ConstructorProperties): void
  }

  module MenuLinkIter {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface MenuLinkIter {
    // Own properties of Gio-2.0.Gio.MenuLinkIter

    __gtype__: number

    // Own fields of Gio-2.0.Gio.MenuLinkIter

    parentInstance: GObject.Object
    priv: MenuLinkIterPrivate

    // Owm methods of Gio-2.0.Gio.MenuLinkIter

    /**
     * Gets the name of the link at the current iterator position.
     *
     * The iterator is not advanced.
     * @returns the type of the link
     */
    getName(): string
    // Has conflict: getNext(): [ /* returnType */ boolean, /* outLink */ string, /* value */ MenuModel ]
    /**
     * Gets the linked #GMenuModel at the current iterator position.
     *
     * The iterator is not advanced.
     * @returns the #GMenuModel that is linked to
     */
    getValue(): MenuModel
    /**
     * Attempts to advance the iterator to the next (possibly first)
     * link.
     *
     * %TRUE is returned on success, or %FALSE if there are no more links.
     *
     * You must call this function when you first acquire the iterator to
     * advance it to the first link (and determine if the first link exists
     * at all).
     * @returns %TRUE on success, or %FALSE when there are no more links
     */
    next(): boolean

    // Own virtual methods of Gio-2.0.Gio.MenuLinkIter

    /**
     * This function combines g_menu_link_iter_next() with
     * g_menu_link_iter_get_name() and g_menu_link_iter_get_value().
     *
     * First the iterator is advanced to the next (possibly first) link.
     * If that fails, then %FALSE is returned and there are no other effects.
     *
     * If successful, `out_link` and `value` are set to the name and #GMenuModel
     * of the link that has just been advanced to.  At this point,
     * g_menu_link_iter_get_name() and g_menu_link_iter_get_value() will return the
     * same values again.
     *
     * The value returned in `out_link` remains valid for as long as the iterator
     * remains at the current position.  The value returned in `value` must
     * be unreffed using g_object_unref() when it is no longer in use.
     * @virtual
     * @returns %TRUE on success, or %FALSE if there is no additional link
     */
    getNext(): [
      /* returnType */ boolean,
      /* outLink */ string,
      /* value */ MenuModel,
    ]

    // Class property signals of Gio-2.0.Gio.MenuLinkIter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * #GMenuLinkIter is an opaque structure type.  You must access it using
   * the functions below.
   * @class
   */
  class MenuLinkIter extends GObject.Object {
    // Own properties of Gio-2.0.Gio.MenuLinkIter

    static name: string

    // Constructors of Gio-2.0.Gio.MenuLinkIter

    constructor(config?: MenuLinkIter.ConstructorProperties)
    _init(config?: MenuLinkIter.ConstructorProperties): void
  }

  module MenuModel {
    // Signal callback interfaces

    /**
     * Signal callback interface for `items-changed`
     */
    interface ItemsChangedSignalCallback {
      (position: number, removed: number, added: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface MenuModel {
    // Own properties of Gio-2.0.Gio.MenuModel

    __gtype__: number

    // Own fields of Gio-2.0.Gio.MenuModel

    parentInstance: GObject.Object
    priv: MenuModelPrivate

    // Owm methods of Gio-2.0.Gio.MenuModel

    // Has conflict: getItemAttributeValue(itemIndex: number, attribute: string, expectedType: GLib.VariantType | null): GLib.Variant | null
    // Has conflict: getItemLink(itemIndex: number, link: string): MenuModel | null
    // Has conflict: getNItems(): number
    // Has conflict: isMutable(): boolean
    /**
     * Requests emission of the #GMenuModel::items-changed signal on `model`.
     *
     * This function should never be called except by #GMenuModel
     * subclasses.  Any other calls to this function will very likely lead
     * to a violation of the interface of the model.
     *
     * The implementation should update its internal representation of the
     * menu before emitting the signal.  The implementation should further
     * expect to receive queries about the new state of the menu (and
     * particularly added menu items) while signal handlers are running.
     *
     * The implementation must dispatch this call directly from a mainloop
     * entry and not in response to calls -- particularly those from the
     * #GMenuModel API.  Said another way: the menu must not change while
     * user code is running without returning to the mainloop.
     * @param position the position of the change
     * @param removed the number of items removed
     * @param added the number of items added
     */
    itemsChanged(position: number, removed: number, added: number): void
    // Has conflict: iterateItemAttributes(itemIndex: number): MenuAttributeIter
    // Has conflict: iterateItemLinks(itemIndex: number): MenuLinkIter

    // Own virtual methods of Gio-2.0.Gio.MenuModel

    /**
     * Queries the item at position `item_index` in `model` for the attribute
     * specified by `attribute`.
     *
     * If `expected_type` is non-%NULL then it specifies the expected type of
     * the attribute.  If it is %NULL then any type will be accepted.
     *
     * If the attribute exists and matches `expected_type` (or if the
     * expected type is unspecified) then the value is returned.
     *
     * If the attribute does not exist, or does not match the expected type
     * then %NULL is returned.
     * @virtual
     * @param itemIndex the index of the item
     * @param attribute the attribute to query
     * @param expectedType the expected type of the attribute, or     %NULL
     * @returns the value of the attribute
     */
    getItemAttributeValue(
      itemIndex: number,
      attribute: string,
      expectedType: GLib.VariantType | null
    ): GLib.Variant | null
    /**
     * Gets all the attributes associated with the item in the menu model.
     * @virtual
     * @param itemIndex The #GMenuItem to query
     */
    getItemAttributes(itemIndex: number): /* attributes */ GLib.HashTable
    /**
     * Queries the item at position `item_index` in `model` for the link
     * specified by `link`.
     *
     * If the link exists, the linked #GMenuModel is returned.  If the link
     * does not exist, %NULL is returned.
     * @virtual
     * @param itemIndex the index of the item
     * @param link the link to query
     * @returns the linked #GMenuModel, or %NULL
     */
    getItemLink(itemIndex: number, link: string): MenuModel | null
    /**
     * Gets all the links associated with the item in the menu model.
     * @virtual
     * @param itemIndex The #GMenuItem to query
     */
    getItemLinks(itemIndex: number): /* links */ GLib.HashTable
    /**
     * Query the number of items in `model`.
     * @virtual
     * @returns the number of items
     */
    getNItems(): number
    /**
     * Queries if `model` is mutable.
     *
     * An immutable #GMenuModel will never emit the #GMenuModel::items-changed
     * signal. Consumers of the model may make optimisations accordingly.
     * @virtual
     * @returns %TRUE if the model is mutable (ie: "items-changed" may be     emitted).
     */
    isMutable(): boolean
    /**
     * Creates a #GMenuAttributeIter to iterate over the attributes of
     * the item at position `item_index` in `model`.
     *
     * You must free the iterator with g_object_unref() when you are done.
     * @virtual
     * @param itemIndex the index of the item
     * @returns a new #GMenuAttributeIter
     */
    iterateItemAttributes(itemIndex: number): MenuAttributeIter
    /**
     * Creates a #GMenuLinkIter to iterate over the links of the item at
     * position `item_index` in `model`.
     *
     * You must free the iterator with g_object_unref() when you are done.
     * @virtual
     * @param itemIndex the index of the item
     * @returns a new #GMenuLinkIter
     */
    iterateItemLinks(itemIndex: number): MenuLinkIter

    // Own signals of Gio-2.0.Gio.MenuModel

    connect(
      sigName: "items-changed",
      callback: MenuModel.ItemsChangedSignalCallback
    ): number
    on(
      sigName: "items-changed",
      callback: MenuModel.ItemsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "items-changed",
      callback: MenuModel.ItemsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "items-changed",
      callback: MenuModel.ItemsChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "items-changed",
      removed: number,
      added: number,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.MenuModel

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GMenuModel` represents the contents of a menu — an ordered list of
   * menu items. The items are associated with actions, which can be
   * activated through them. Items can be grouped in sections, and may
   * have submenus associated with them. Both items and sections usually
   * have some representation data, such as labels or icons. The type of
   * the associated action (ie whether it is stateful, and what kind of
   * state it has) can influence the representation of the item.
   *
   * The conceptual model of menus in `GMenuModel` is hierarchical:
   * sections and submenus are again represented by `GMenuModel`s.
   * Menus themselves do not define their own roles. Rather, the role
   * of a particular `GMenuModel` is defined by the item that references
   * it (or, in the case of the ‘root’ menu, is defined by the context
   * in which it is used).
   *
   * As an example, consider the visible portions of this menu:
   *
   * ## An example menu
   *
   * ![](menu-example.png)
   *
   * There are 8 ‘menus’ visible in the screenshot: one menubar, two
   * submenus and 5 sections:
   *
   * - the toplevel menubar (containing 4 items)
   * - the View submenu (containing 3 sections)
   * - the first section of the View submenu (containing 2 items)
   * - the second section of the View submenu (containing 1 item)
   * - the final section of the View submenu (containing 1 item)
   * - the Highlight Mode submenu (containing 2 sections)
   * - the Sources section (containing 2 items)
   * - the Markup section (containing 2 items)
   *
   * The [example](#a-menu-example) illustrates the conceptual connection between
   * these 8 menus. Each large block in the figure represents a menu and the
   * smaller blocks within the large block represent items in that menu. Some
   * items contain references to other menus.
   *
   * ## A menu example
   *
   * ![](menu-model.png)
   *
   * Notice that the separators visible in the [example](#an-example-menu)
   * appear nowhere in the [menu model](#a-menu-example). This is because
   * separators are not explicitly represented in the menu model. Instead,
   * a separator is inserted between any two non-empty sections of a menu.
   * Section items can have labels just like any other item. In that case,
   * a display system may show a section header instead of a separator.
   *
   * The motivation for this abstract model of application controls is
   * that modern user interfaces tend to make these controls available
   * outside the application. Examples include global menus, jumplists,
   * dash boards, etc. To support such uses, it is necessary to ‘export’
   * information about actions and their representation in menus, which
   * is exactly what the action group exporter and the menu model exporter do for
   * [iface`Gio`.ActionGroup] and [class`Gio`.MenuModel]. The client-side
   * counterparts to make use of the exported information are
   * [class`Gio`.DBusActionGroup] and [class`Gio`.DBusMenuModel].
   *
   * The API of `GMenuModel` is very generic, with iterators for the
   * attributes and links of an item, see
   * [method`Gio`.MenuModel.iterate_item_attributes] and
   * [method`Gio`.MenuModel.iterate_item_links]. The ‘standard’ attributes and
   * link types have predefined names: `G_MENU_ATTRIBUTE_LABEL`,
   * `G_MENU_ATTRIBUTE_ACTION`, `G_MENU_ATTRIBUTE_TARGET`, `G_MENU_LINK_SECTION`
   * and `G_MENU_LINK_SUBMENU`.
   *
   * Items in a `GMenuModel` represent active controls if they refer to
   * an action that can get activated when the user interacts with the
   * menu item. The reference to the action is encoded by the string ID
   * in the `G_MENU_ATTRIBUTE_ACTION` attribute. An action ID uniquely
   * identifies an action in an action group. Which action group(s) provide
   * actions depends on the context in which the menu model is used.
   * E.g. when the model is exported as the application menu of a
   * [`GtkApplication`](https://docs.gtk.org/gtk4/class.Application.html),
   * actions can be application-wide or window-specific (and thus come from
   * two different action groups). By convention, the application-wide actions
   * have names that start with `app.`, while the names of window-specific
   * actions start with `win.`.
   *
   * While a wide variety of stateful actions is possible, the following
   * is the minimum that is expected to be supported by all users of exported
   * menu information:
   * - an action with no parameter type and no state
   * - an action with no parameter type and boolean state
   * - an action with string parameter type and string state
   *
   * ## Stateless
   *
   * A stateless action typically corresponds to an ordinary menu item.
   *
   * Selecting such a menu item will activate the action (with no parameter).
   *
   * ## Boolean State
   *
   * An action with a boolean state will most typically be used with a ‘toggle’
   * or ‘switch’ menu item. The state can be set directly, but activating the
   * action (with no parameter) results in the state being toggled.
   *
   * Selecting a toggle menu item will activate the action. The menu item should
   * be rendered as ‘checked’ when the state is true.
   *
   * ## String Parameter and State
   *
   * Actions with string parameters and state will most typically be used to
   * represent an enumerated choice over the items available for a group of
   * radio menu items. Activating the action with a string parameter is
   * equivalent to setting that parameter as the state.
   *
   * Radio menu items, in addition to being associated with the action, will
   * have a target value. Selecting that menu item will result in activation
   * of the action with the target value as the parameter. The menu item should
   * be rendered as ‘selected’ when the state of the action is equal to the
   * target value of the menu item.
   * @class
   */
  class MenuModel extends GObject.Object {
    // Own properties of Gio-2.0.Gio.MenuModel

    static name: string

    // Constructors of Gio-2.0.Gio.MenuModel

    constructor(config?: MenuModel.ConstructorProperties)
    _init(config?: MenuModel.ConstructorProperties): void
  }

  module MountOperation {
    // Signal callback interfaces

    /**
     * Signal callback interface for `aborted`
     */
    interface AbortedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `ask-password`
     */
    interface AskPasswordSignalCallback {
      (
        message: string | null,
        defaultUser: string | null,
        defaultDomain: string | null,
        flags: AskPasswordFlags
      ): void
    }

    /**
     * Signal callback interface for `ask-question`
     */
    interface AskQuestionSignalCallback {
      (message: string | null, choices: string[]): void
    }

    /**
     * Signal callback interface for `reply`
     */
    interface ReplySignalCallback {
      (result: MountOperationResult): void
    }

    /**
     * Signal callback interface for `show-processes`
     */
    interface ShowProcessesSignalCallback {
      (message: string | null, processes: GLib.Pid[], choices: string[]): void
    }

    /**
     * Signal callback interface for `show-unmount-progress`
     */
    interface ShowUnmountProgressSignalCallback {
      (message: string | null, timeLeft: number, bytesLeft: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.MountOperation

      /**
       * Whether to use an anonymous user when authenticating.
       */
      anonymous?: boolean | null
      /**
       * The index of the user's choice when a question is asked during the
       * mount operation. See the #GMountOperation::ask-question signal.
       */
      choice?: number | null
      /**
       * The domain to use for the mount operation.
       */
      domain?: string | null
      /**
       * Whether the device to be unlocked is a TCRYPT hidden volume.
       * See [the VeraCrypt documentation](https://www.veracrypt.fr/en/Hidden%20Volume.html).
       */
      is_tcrypt_hidden_volume?: boolean | null
      /**
       * Whether the device to be unlocked is a TCRYPT system volume.
       * In this context, a system volume is a volume with a bootloader
       * and operating system installed. This is only supported for Windows
       * operating systems. For further documentation, see
       * [the VeraCrypt documentation](https://www.veracrypt.fr/en/System%20Encryption.html).
       */
      is_tcrypt_system_volume?: boolean | null
      /**
       * The password that is used for authentication when carrying out
       * the mount operation.
       */
      password?: string | null
      /**
       * Determines if and how the password information should be saved.
       */
      password_save?: PasswordSave | null
      /**
       * The VeraCrypt PIM value, when unlocking a VeraCrypt volume. See
       * [the VeraCrypt documentation](https://www.veracrypt.fr/en/Personal%20Iterations%20Multiplier%20(PIM).html).
       */
      pim?: number | null
      /**
       * The user name that is used for authentication when carrying out
       * the mount operation.
       */
      username?: string | null
    }
  }

  interface MountOperation {
    // Own properties of Gio-2.0.Gio.MountOperation

    /**
     * Whether to use an anonymous user when authenticating.
     */
    anonymous: boolean
    /**
     * The index of the user's choice when a question is asked during the
     * mount operation. See the #GMountOperation::ask-question signal.
     */
    choice: number
    /**
     * The domain to use for the mount operation.
     */
    domain: string | null
    /**
     * Whether the device to be unlocked is a TCRYPT hidden volume.
     * See [the VeraCrypt documentation](https://www.veracrypt.fr/en/Hidden%20Volume.html).
     */
    isTcryptHiddenVolume: boolean
    /**
     * Whether the device to be unlocked is a TCRYPT system volume.
     * In this context, a system volume is a volume with a bootloader
     * and operating system installed. This is only supported for Windows
     * operating systems. For further documentation, see
     * [the VeraCrypt documentation](https://www.veracrypt.fr/en/System%20Encryption.html).
     */
    isTcryptSystemVolume: boolean
    /**
     * The password that is used for authentication when carrying out
     * the mount operation.
     */
    password: string | null
    /**
     * Determines if and how the password information should be saved.
     */
    passwordSave: PasswordSave
    /**
     * The VeraCrypt PIM value, when unlocking a VeraCrypt volume. See
     * [the VeraCrypt documentation](https://www.veracrypt.fr/en/Personal%20Iterations%20Multiplier%20(PIM).html).
     */
    pim: number
    /**
     * The user name that is used for authentication when carrying out
     * the mount operation.
     */
    username: string | null
    __gtype__: number

    // Own fields of Gio-2.0.Gio.MountOperation

    parentInstance: GObject.Object
    priv: MountOperationPrivate

    // Owm methods of Gio-2.0.Gio.MountOperation

    /**
     * Check to see whether the mount operation is being used
     * for an anonymous user.
     * @returns %TRUE if mount operation is anonymous.
     */
    getAnonymous(): boolean
    /**
     * Gets a choice from the mount operation.
     * @returns an integer containing an index of the user's choice from the choice's list, or `0`.
     */
    getChoice(): number
    /**
     * Gets the domain of the mount operation.
     * @returns a string set to the domain.
     */
    getDomain(): string | null
    /**
     * Check to see whether the mount operation is being used
     * for a TCRYPT hidden volume.
     * @returns %TRUE if mount operation is for hidden volume.
     */
    getIsTcryptHiddenVolume(): boolean
    /**
     * Check to see whether the mount operation is being used
     * for a TCRYPT system volume.
     * @returns %TRUE if mount operation is for system volume.
     */
    getIsTcryptSystemVolume(): boolean
    /**
     * Gets a password from the mount operation.
     * @returns a string containing the password within @op.
     */
    getPassword(): string | null
    /**
     * Gets the state of saving passwords for the mount operation.
     * @returns a #GPasswordSave flag.
     */
    getPasswordSave(): PasswordSave
    /**
     * Gets a PIM from the mount operation.
     * @returns The VeraCrypt PIM within @op.
     */
    getPim(): number
    /**
     * Get the user name from the mount operation.
     * @returns a string containing the user name.
     */
    getUsername(): string | null
    // Has conflict: reply(result: MountOperationResult): void
    /**
     * Sets the mount operation to use an anonymous user if `anonymous` is %TRUE.
     * @param anonymous boolean value.
     */
    setAnonymous(anonymous: boolean): void
    /**
     * Sets a default choice for the mount operation.
     * @param choice an integer.
     */
    setChoice(choice: number): void
    /**
     * Sets the mount operation's domain.
     * @param domain the domain to set.
     */
    setDomain(domain: string | null): void
    /**
     * Sets the mount operation to use a hidden volume if `hidden_volume` is %TRUE.
     * @param hiddenVolume boolean value.
     */
    setIsTcryptHiddenVolume(hiddenVolume: boolean): void
    /**
     * Sets the mount operation to use a system volume if `system_volume` is %TRUE.
     * @param systemVolume boolean value.
     */
    setIsTcryptSystemVolume(systemVolume: boolean): void
    /**
     * Sets the mount operation's password to `password`.
     * @param password password to set.
     */
    setPassword(password: string | null): void
    /**
     * Sets the state of saving passwords for the mount operation.
     * @param save a set of #GPasswordSave flags.
     */
    setPasswordSave(save: PasswordSave): void
    /**
     * Sets the mount operation's PIM to `pim`.
     * @param pim an unsigned integer.
     */
    setPim(pim: number): void
    /**
     * Sets the user name within `op` to `username`.
     * @param username input username.
     */
    setUsername(username: string | null): void

    // Own virtual methods of Gio-2.0.Gio.MountOperation

    aborted(): void
    askPassword(
      message: string,
      defaultUser: string,
      defaultDomain: string,
      flags: AskPasswordFlags
    ): void
    /**
     * Virtual implementation of #GMountOperation::ask-question.
     * @virtual
     * @param message string containing a message to display to the user
     * @param choices an array of    strings for each possible choice
     */
    askQuestion(message: string, choices: string[]): void
    /**
     * Emits the #GMountOperation::reply signal.
     * @virtual
     * @param result a #GMountOperationResult
     */
    reply(result: MountOperationResult): void
    /**
     * Virtual implementation of #GMountOperation::show-processes.
     * @virtual
     * @param message string containing a message to display to the user
     * @param processes an array of #GPid for processes blocking    the operation
     * @param choices an array of    strings for each possible choice
     */
    showProcesses(
      message: string,
      processes: GLib.Pid[],
      choices: string[]
    ): void
    showUnmountProgress(
      message: string,
      timeLeft: number,
      bytesLeft: number
    ): void

    // Own signals of Gio-2.0.Gio.MountOperation

    connect(
      sigName: "aborted",
      callback: MountOperation.AbortedSignalCallback
    ): number
    on(
      sigName: "aborted",
      callback: MountOperation.AbortedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "aborted",
      callback: MountOperation.AbortedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "aborted",
      callback: MountOperation.AbortedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "aborted", ...args: any[]): void
    connect(
      sigName: "ask-password",
      callback: MountOperation.AskPasswordSignalCallback
    ): number
    on(
      sigName: "ask-password",
      callback: MountOperation.AskPasswordSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "ask-password",
      callback: MountOperation.AskPasswordSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "ask-password",
      callback: MountOperation.AskPasswordSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "ask-password",
      defaultUser: string | null,
      defaultDomain: string | null,
      flags: AskPasswordFlags,
      ...args: any[]
    ): void
    connect(
      sigName: "ask-question",
      callback: MountOperation.AskQuestionSignalCallback
    ): number
    on(
      sigName: "ask-question",
      callback: MountOperation.AskQuestionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "ask-question",
      callback: MountOperation.AskQuestionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "ask-question",
      callback: MountOperation.AskQuestionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "ask-question", choices: string[], ...args: any[]): void
    connect(
      sigName: "reply",
      callback: MountOperation.ReplySignalCallback
    ): number
    on(
      sigName: "reply",
      callback: MountOperation.ReplySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "reply",
      callback: MountOperation.ReplySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "reply",
      callback: MountOperation.ReplySignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "reply", ...args: any[]): void
    connect(
      sigName: "show-processes",
      callback: MountOperation.ShowProcessesSignalCallback
    ): number
    on(
      sigName: "show-processes",
      callback: MountOperation.ShowProcessesSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "show-processes",
      callback: MountOperation.ShowProcessesSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "show-processes",
      callback: MountOperation.ShowProcessesSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "show-processes",
      processes: GLib.Pid[],
      choices: string[],
      ...args: any[]
    ): void
    connect(
      sigName: "show-unmount-progress",
      callback: MountOperation.ShowUnmountProgressSignalCallback
    ): number
    on(
      sigName: "show-unmount-progress",
      callback: MountOperation.ShowUnmountProgressSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "show-unmount-progress",
      callback: MountOperation.ShowUnmountProgressSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "show-unmount-progress",
      callback: MountOperation.ShowUnmountProgressSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "show-unmount-progress",
      timeLeft: number,
      bytesLeft: number,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.MountOperation

    connect(
      sigName: "notify::anonymous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::anonymous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::anonymous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::anonymous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::anonymous", ...args: any[]): void
    connect(
      sigName: "notify::choice",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::choice",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::choice",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::choice",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::choice", ...args: any[]): void
    connect(
      sigName: "notify::domain",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::domain",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::domain",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::domain",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::domain", ...args: any[]): void
    connect(
      sigName: "notify::is-tcrypt-hidden-volume",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-tcrypt-hidden-volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-tcrypt-hidden-volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-tcrypt-hidden-volume",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-tcrypt-hidden-volume", ...args: any[]): void
    connect(
      sigName: "notify::is-tcrypt-system-volume",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-tcrypt-system-volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-tcrypt-system-volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-tcrypt-system-volume",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-tcrypt-system-volume", ...args: any[]): void
    connect(
      sigName: "notify::password",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::password",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::password",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::password",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::password", ...args: any[]): void
    connect(
      sigName: "notify::password-save",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::password-save",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::password-save",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::password-save",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::password-save", ...args: any[]): void
    connect(sigName: "notify::pim", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::pim",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pim",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pim",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pim", ...args: any[]): void
    connect(
      sigName: "notify::username",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::username",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::username",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::username",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::username", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GMountOperation` provides a mechanism for interacting with the user.
   * It can be used for authenticating mountable operations, such as loop
   * mounting files, hard drive partitions or server locations. It can
   * also be used to ask the user questions or show a list of applications
   * preventing unmount or eject operations from completing.
   *
   * Note that `GMountOperation` is used for more than just [iface`Gio`.Mount]
   * objects – for example it is also used in [method`Gio`.Drive.start] and
   * [method`Gio`.Drive.stop].
   *
   * Users should instantiate a subclass of this that implements all the
   * various callbacks to show the required dialogs, such as
   * [`GtkMountOperation`](https://docs.gtk.org/gtk4/class.MountOperation.html).
   * If no user interaction is desired (for example when automounting
   * filesystems at login time), usually `NULL` can be passed, see each method
   * taking a `GMountOperation` for details.
   *
   * Throughout the API, the term ‘TCRYPT’ is used to mean ‘compatible with TrueCrypt and VeraCrypt’.
   * [TrueCrypt](https://en.wikipedia.org/wiki/TrueCrypt) is a discontinued system for
   * encrypting file containers, partitions or whole disks, typically used with Windows.
   * [VeraCrypt](https://www.veracrypt.fr/) is a maintained fork of TrueCrypt with various
   * improvements and auditing fixes.
   * @class
   */
  class MountOperation extends GObject.Object {
    // Own properties of Gio-2.0.Gio.MountOperation

    static name: string

    // Constructors of Gio-2.0.Gio.MountOperation

    constructor(config?: MountOperation.ConstructorProperties)
    /**
     * Creates a new mount operation.
     * @constructor
     * @returns a #GMountOperation.
     */
    constructor()
    /**
     * Creates a new mount operation.
     * @constructor
     * @returns a #GMountOperation.
     */
    static new(): MountOperation
    _init(config?: MountOperation.ConstructorProperties): void
  }

  module NativeSocketAddress {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnectable.ConstructorProperties,
        SocketAddress.ConstructorProperties {}
  }

  interface NativeSocketAddress extends SocketConnectable {
    // Own properties of Gio-2.0.Gio.NativeSocketAddress

    __gtype__: number

    // Own fields of Gio-2.0.Gio.NativeSocketAddress

    parentInstance: any

    // Class property signals of Gio-2.0.Gio.NativeSocketAddress

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A socket address of some unknown native type.
   *
   * This corresponds to a general `struct sockaddr` of a type not otherwise
   * handled by GLib.
   * @class
   */
  class NativeSocketAddress extends SocketAddress {
    // Own properties of Gio-2.0.Gio.NativeSocketAddress

    static name: string

    // Constructors of Gio-2.0.Gio.NativeSocketAddress

    constructor(config?: NativeSocketAddress.ConstructorProperties)
    /**
     * Creates a new #GNativeSocketAddress for `native` and `len`.
     * @constructor
     * @param native a native address object
     * @param len the length of `native,` in bytes
     * @returns a new #GNativeSocketAddress
     */
    constructor(native: any | null, len: number)
    /**
     * Creates a new #GNativeSocketAddress for `native` and `len`.
     * @constructor
     * @param native a native address object
     * @param len the length of `native,` in bytes
     * @returns a new #GNativeSocketAddress
     */
    static new(native: any | null, len: number): NativeSocketAddress
    _init(config?: NativeSocketAddress.ConstructorProperties): void
  }

  module NativeVolumeMonitor {
    // Constructor properties interface

    interface ConstructorProperties
      extends VolumeMonitor.ConstructorProperties {}
  }

  interface NativeVolumeMonitor {
    // Own properties of Gio-2.0.Gio.NativeVolumeMonitor

    __gtype__: number

    // Own fields of Gio-2.0.Gio.NativeVolumeMonitor

    parentInstance: any

    // Class property signals of Gio-2.0.Gio.NativeVolumeMonitor

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  class NativeVolumeMonitor extends VolumeMonitor {
    // Own properties of Gio-2.0.Gio.NativeVolumeMonitor

    static name: string

    // Constructors of Gio-2.0.Gio.NativeVolumeMonitor

    constructor(config?: NativeVolumeMonitor.ConstructorProperties)
    _init(config?: NativeVolumeMonitor.ConstructorProperties): void
  }

  module NetworkAddress {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnectable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.NetworkAddress

      /**
       * Hostname to resolve.
       */
      hostname?: string | null
      /**
       * Network port.
       */
      port?: number | null
      /**
       * URI scheme.
       */
      scheme?: string | null
    }
  }

  interface NetworkAddress extends SocketConnectable {
    // Own properties of Gio-2.0.Gio.NetworkAddress

    /**
     * Hostname to resolve.
     */
    readonly hostname: string | null
    /**
     * Network port.
     */
    readonly port: number
    /**
     * URI scheme.
     */
    readonly scheme: string | null
    __gtype__: number

    // Own fields of Gio-2.0.Gio.NetworkAddress

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.NetworkAddress

    /**
     * Gets `addr'`s hostname. This might be either UTF-8 or ASCII-encoded,
     * depending on what `addr` was created with.
     * @returns @addr's hostname
     */
    getHostname(): string
    /**
     * Gets `addr'`s port number
     * @returns @addr's port (which may be 0)
     */
    getPort(): number
    /**
     * Gets `addr'`s scheme
     * @returns @addr's scheme (%NULL if not built from URI)
     */
    getScheme(): string | null

    // Class property signals of Gio-2.0.Gio.NetworkAddress

    connect(
      sigName: "notify::hostname",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hostname",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hostname",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hostname",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hostname", ...args: any[]): void
    connect(sigName: "notify::port", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::port",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::port", ...args: any[]): void
    connect(
      sigName: "notify::scheme",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scheme",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scheme",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scheme",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scheme", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GNetworkAddress` provides an easy way to resolve a hostname and
   * then attempt to connect to that host, handling the possibility of
   * multiple IP addresses and multiple address families.
   *
   * The enumeration results of resolved addresses *may* be cached as long
   * as this object is kept alive which may have unexpected results if
   * alive for too long.
   *
   * See [iface`Gio`.SocketConnectable] for an example of using the connectable
   * interface.
   * @class
   */
  class NetworkAddress extends GObject.Object {
    // Own properties of Gio-2.0.Gio.NetworkAddress

    static name: string

    // Constructors of Gio-2.0.Gio.NetworkAddress

    constructor(config?: NetworkAddress.ConstructorProperties)
    /**
     * Creates a new #GSocketConnectable for connecting to the given
     * `hostname` and `port`.
     *
     * Note that depending on the configuration of the machine, a
     * `hostname` of `localhost` may refer to the IPv4 loopback address
     * only, or to both IPv4 and IPv6; use
     * g_network_address_new_loopback() to create a #GNetworkAddress that
     * is guaranteed to resolve to both addresses.
     * @constructor
     * @param hostname the hostname
     * @param port the port
     * @returns the new #GNetworkAddress
     */
    constructor(hostname: string, port: number)
    /**
     * Creates a new #GSocketConnectable for connecting to the given
     * `hostname` and `port`.
     *
     * Note that depending on the configuration of the machine, a
     * `hostname` of `localhost` may refer to the IPv4 loopback address
     * only, or to both IPv4 and IPv6; use
     * g_network_address_new_loopback() to create a #GNetworkAddress that
     * is guaranteed to resolve to both addresses.
     * @constructor
     * @param hostname the hostname
     * @param port the port
     * @returns the new #GNetworkAddress
     */
    static new(hostname: string, port: number): NetworkAddress
    /**
     * Creates a new #GSocketConnectable for connecting to the local host
     * over a loopback connection to the given `port`. This is intended for
     * use in connecting to local services which may be running on IPv4 or
     * IPv6.
     *
     * The connectable will return IPv4 and IPv6 loopback addresses,
     * regardless of how the host resolves `localhost`. By contrast,
     * g_network_address_new() will often only return an IPv4 address when
     * resolving `localhost`, and an IPv6 address for `localhost6`.
     *
     * g_network_address_get_hostname() will always return `localhost` for
     * a #GNetworkAddress created with this constructor.
     * @constructor
     * @param port the port
     * @returns the new #GNetworkAddress
     */
    static newLoopback(port: number): NetworkAddress
    _init(config?: NetworkAddress.ConstructorProperties): void
    /**
     * Creates a new #GSocketConnectable for connecting to the given
     * `hostname` and `port`. May fail and return %NULL in case
     * parsing `host_and_port` fails.
     *
     * `host_and_port` may be in any of a number of recognised formats; an IPv6
     * address, an IPv4 address, or a domain name (in which case a DNS
     * lookup is performed). Quoting with [] is supported for all address
     * types. A port override may be specified in the usual way with a
     * colon.
     *
     * If no port is specified in `host_and_port` then `default_port` will be
     * used as the port number to connect to.
     *
     * In general, `host_and_port` is expected to be provided by the user
     * (allowing them to give the hostname, and a port override if necessary)
     * and `default_port` is expected to be provided by the application.
     *
     * (The port component of `host_and_port` can also be specified as a
     * service name rather than as a numeric port, but this functionality
     * is deprecated, because it depends on the contents of /etc/services,
     * which is generally quite sparse on platforms other than Linux.)
     * @param hostAndPort the hostname and optionally a port
     * @param defaultPort the default port if not in `host_and_port`
     * @returns the new   #GNetworkAddress, or %NULL on error
     */
    static parse(hostAndPort: string, defaultPort: number): NetworkAddress
    /**
     * Creates a new #GSocketConnectable for connecting to the given
     * `uri`. May fail and return %NULL in case parsing `uri` fails.
     *
     * Using this rather than g_network_address_new() or
     * g_network_address_parse() allows #GSocketClient to determine
     * when to use application-specific proxy protocols.
     * @param uri the hostname and optionally a port
     * @param defaultPort The default port if none is found in the URI
     * @returns the new   #GNetworkAddress, or %NULL on error
     */
    static parseUri(uri: string, defaultPort: number): NetworkAddress
  }

  module NetworkService {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnectable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.NetworkService

      /**
       * Network domain, for example `example.com`.
       */
      domain?: string | null
      /**
       * Network protocol, for example `tcp`.
       */
      protocol?: string | null
      /**
       * Network scheme (default is to use service).
       */
      scheme?: string | null
      /**
       * Service name, for example `ldap`.
       */
      service?: string | null
    }
  }

  interface NetworkService extends SocketConnectable {
    // Own properties of Gio-2.0.Gio.NetworkService

    /**
     * Network domain, for example `example.com`.
     */
    readonly domain: string | null
    /**
     * Network protocol, for example `tcp`.
     */
    readonly protocol: string | null
    /**
     * Network scheme (default is to use service).
     */
    scheme: string | null
    /**
     * Service name, for example `ldap`.
     */
    readonly service: string | null
    __gtype__: number

    // Own fields of Gio-2.0.Gio.NetworkService

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.NetworkService

    /**
     * Gets the domain that `srv` serves. This might be either UTF-8 or
     * ASCII-encoded, depending on what `srv` was created with.
     * @returns @srv's domain name
     */
    getDomain(): string
    /**
     * Gets `srv'`s protocol name (eg, "tcp").
     * @returns @srv's protocol name
     */
    getProtocol(): string
    /**
     * Gets the URI scheme used to resolve proxies. By default, the service name
     * is used as scheme.
     * @returns @srv's scheme name
     */
    getScheme(): string
    /**
     * Gets `srv'`s service name (eg, "ldap").
     * @returns @srv's service name
     */
    getService(): string
    /**
     * Set's the URI scheme used to resolve proxies. By default, the service name
     * is used as scheme.
     * @param scheme a URI scheme
     */
    setScheme(scheme: string): void

    // Class property signals of Gio-2.0.Gio.NetworkService

    connect(
      sigName: "notify::domain",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::domain",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::domain",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::domain",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::domain", ...args: any[]): void
    connect(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol", ...args: any[]): void
    connect(
      sigName: "notify::scheme",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scheme",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scheme",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scheme",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scheme", ...args: any[]): void
    connect(
      sigName: "notify::service",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::service",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::service",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::service",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::service", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Like [class`Gio`.NetworkAddress] does with hostnames, `GNetworkService`
   * provides an easy way to resolve a SRV record, and then attempt to
   * connect to one of the hosts that implements that service, handling
   * service priority/weighting, multiple IP addresses, and multiple
   * address families.
   *
   * See [struct`Gio`.SrvTarget] for more information about SRV records, and see
   * [iface`Gio`.SocketConnectable] for an example of using the connectable
   * interface.
   * @class
   */
  class NetworkService extends GObject.Object {
    // Own properties of Gio-2.0.Gio.NetworkService

    static name: string

    // Constructors of Gio-2.0.Gio.NetworkService

    constructor(config?: NetworkService.ConstructorProperties)
    /**
     * Creates a new #GNetworkService representing the given `service,`
     * `protocol,` and `domain`. This will initially be unresolved; use the
     * #GSocketConnectable interface to resolve it.
     * @constructor
     * @param service the service type to look up (eg, "ldap")
     * @param protocol the networking protocol to use for `service` (eg, "tcp")
     * @param domain the DNS domain to look up the service in
     * @returns a new #GNetworkService
     */
    constructor(service: string, protocol: string, domain: string)
    /**
     * Creates a new #GNetworkService representing the given `service,`
     * `protocol,` and `domain`. This will initially be unresolved; use the
     * #GSocketConnectable interface to resolve it.
     * @constructor
     * @param service the service type to look up (eg, "ldap")
     * @param protocol the networking protocol to use for `service` (eg, "tcp")
     * @param domain the DNS domain to look up the service in
     * @returns a new #GNetworkService
     */
    static new(
      service: string,
      protocol: string,
      domain: string
    ): NetworkService
    _init(config?: NetworkService.ConstructorProperties): void
  }

  module Notification {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Notification {
    // Own properties of Gio-2.0.Gio.Notification

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Notification

    /**
     * Adds a button to `notification` that activates the action in
     * `detailed_action` when clicked. That action must be an
     * application-wide action (starting with "app."). If `detailed_action`
     * contains a target, the action will be activated with that target as
     * its parameter.
     *
     * See g_action_parse_detailed_name() for a description of the format
     * for `detailed_action`.
     * @param label label of the button
     * @param detailedAction a detailed action name
     */
    addButton(label: string, detailedAction: string): void
    /**
     * Adds a button to `notification` that activates `action` when clicked.
     * `action` must be an application-wide action (it must start with "app.").
     *
     * If `target` is non-%NULL, `action` will be activated with `target` as
     * its parameter.
     * @param label label of the button
     * @param action an action name
     * @param target a #GVariant to use as `action'`s parameter, or %NULL
     */
    addButtonWithTarget(
      label: string,
      action: string,
      target: GLib.Variant | null
    ): void
    /**
     * Sets the body of `notification` to `body`.
     * @param body the new body for `notification,` or %NULL
     */
    setBody(body: string | null): void
    /**
     * Sets the type of `notification` to `category`. Categories have a main
     * type like `email`, `im` or `device` and can have a detail separated
     * by a `.`, e.g. `im.received` or `email.arrived`. Setting the category
     * helps the notification server to select proper feedback to the user.
     *
     * Standard categories are [listed in the specification](https://specifications.freedesktop.org/notification-spec/latest/ar01s06.html).
     * @param category the category for `notification,` or %NULL for no category
     */
    setCategory(category: string | null): void
    /**
     * Sets the default action of `notification` to `detailed_action`. This
     * action is activated when the notification is clicked on.
     *
     * The action in `detailed_action` must be an application-wide action (it
     * must start with "app."). If `detailed_action` contains a target, the
     * given action will be activated with that target as its parameter.
     * See g_action_parse_detailed_name() for a description of the format
     * for `detailed_action`.
     *
     * When no default action is set, the application that the notification
     * was sent on is activated.
     * @param detailedAction a detailed action name
     */
    setDefaultAction(detailedAction: string): void
    /**
     * Sets the default action of `notification` to `action`. This action is
     * activated when the notification is clicked on. It must be an
     * application-wide action (start with "app.").
     *
     * If `target` is non-%NULL, `action` will be activated with `target` as
     * its parameter. If `target` is floating, it will be consumed.
     *
     * When no default action is set, the application that the notification
     * was sent on is activated.
     * @param action an action name
     * @param target a #GVariant to use as `action'`s parameter, or %NULL
     */
    setDefaultActionAndTarget(action: string, target: GLib.Variant | null): void
    /**
     * Sets the icon of `notification` to `icon`.
     * @param icon the icon to be shown in `notification,` as a #GIcon
     */
    setIcon(icon: Icon): void
    /**
     * Sets the priority of `notification` to `priority`. See
     * #GNotificationPriority for possible values.
     * @param priority a #GNotificationPriority
     */
    setPriority(priority: NotificationPriority): void
    /**
     * Sets the title of `notification` to `title`.
     * @param title the new title for `notification`
     */
    setTitle(title: string): void
    /**
     * Deprecated in favor of g_notification_set_priority().
     * @param urgent %TRUE if `notification` is urgent
     */
    setUrgent(urgent: boolean): void

    // Class property signals of Gio-2.0.Gio.Notification

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GNotification` is a mechanism for creating a notification to be shown
   * to the user — typically as a pop-up notification presented by the
   * desktop environment shell.
   *
   * The key difference between `GNotification` and other similar APIs is
   * that, if supported by the desktop environment, notifications sent
   * with `GNotification` will persist after the application has exited,
   * and even across system reboots.
   *
   * Since the user may click on a notification while the application is
   * not running, applications using `GNotification` should be able to be
   * started as a D-Bus service, using [class`Gio`.Application].
   *
   * In order for `GNotification` to work, the application must have installed
   * a `.desktop` file. For example:
   * ```
   * [Desktop Entry]
   * Name=Test Application
   * Comment=Description of what Test Application does
   * Exec=gnome-test-application
   * Icon=org.gnome.TestApplication
   * Terminal=false
   * Type=Application
   * Categories=GNOME;GTK;TestApplication Category;
   * StartupNotify=true
   * DBusActivatable=true
   * X-GNOME-UsesNotifications=true
   * ```
   *
   * The `X-GNOME-UsesNotifications` key indicates to GNOME Control Center
   * that this application uses notifications, so it can be listed in the
   * Control Center’s ‘Notifications’ panel.
   *
   * The `.desktop` file must be named as `org.gnome.TestApplication.desktop`,
   * where `org.gnome.TestApplication` is the ID passed to
   * [ctor`Gio`.Application.new].
   *
   * User interaction with a notification (either the default action, or
   * buttons) must be associated with actions on the application (ie:
   * `app.` actions).  It is not possible to route user interaction
   * through the notification itself, because the object will not exist if
   * the application is autostarted as a result of a notification being
   * clicked.
   *
   * A notification can be sent with [method`Gio`.Application.send_notification].
   * @class
   */
  class Notification extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Notification

    static name: string

    // Constructors of Gio-2.0.Gio.Notification

    constructor(config?: Notification.ConstructorProperties)
    /**
     * Creates a new #GNotification with `title` as its title.
     *
     * After populating `notification` with more details, it can be sent to
     * the desktop shell with g_application_send_notification(). Changing
     * any properties after this call will not have any effect until
     * resending `notification`.
     * @constructor
     * @param title the title of the notification
     * @returns a new #GNotification instance
     */
    constructor(title: string)
    /**
     * Creates a new #GNotification with `title` as its title.
     *
     * After populating `notification` with more details, it can be sent to
     * the desktop shell with g_application_send_notification(). Changing
     * any properties after this call will not have any effect until
     * resending `notification`.
     * @constructor
     * @param title the title of the notification
     * @returns a new #GNotification instance
     */
    static new(title: string): Notification
    _init(config?: Notification.ConstructorProperties): void
  }

  module OutputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface OutputStream {
    // Own properties of Gio-2.0.Gio.OutputStream

    __gtype__: number

    // Own fields of Gio-2.0.Gio.OutputStream

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.OutputStream

    /**
     * Clears the pending flag on `stream`.
     */
    clearPending(): void
    /**
     * Closes the stream, releasing resources related to it.
     *
     * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
     * Closing a stream multiple times will not return an error.
     *
     * Closing a stream will automatically flush any outstanding buffers in the
     * stream.
     *
     * Streams will be automatically closed when the last reference
     * is dropped, but you might want to call this function to make sure
     * resources are released as early as possible.
     *
     * Some streams might keep the backing store of the stream (e.g. a file descriptor)
     * open after the stream is closed. See the documentation for the individual
     * stream for details.
     *
     * On failure the first error that happened will be reported, but the close
     * operation will finish as much as possible. A stream that failed to
     * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
     * is important to check and report the error to the user, otherwise
     * there might be a loss of data as all data might not be written.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * Cancelling a close will still leave the stream closed, but there some streams
     * can use a faster close that doesn't block to e.g. check errors. On
     * cancellation (as with any error) there is no guarantee that all written
     * data will reach the target.
     * @param cancellable optional cancellable object
     * @returns %TRUE on success, %FALSE on failure
     */
    close(cancellable: Cancellable | null): boolean
    // Has conflict: closeAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: closeFinish(result: AsyncResult): boolean
    // Has conflict: flush(cancellable: Cancellable | null): boolean
    // Has conflict: flushAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: flushFinish(result: AsyncResult): boolean
    /**
     * Checks if an output stream has pending actions.
     * @returns %TRUE if @stream has pending actions.
     */
    hasPending(): boolean
    /**
     * Checks if an output stream has already been closed.
     * @returns %TRUE if @stream is closed. %FALSE otherwise.
     */
    isClosed(): boolean
    /**
     * Checks if an output stream is being closed. This can be
     * used inside e.g. a flush implementation to see if the
     * flush (or other i/o operation) is called from within
     * the closing operation.
     * @returns %TRUE if @stream is being closed. %FALSE otherwise.
     */
    isClosing(): boolean
    /**
     * Sets `stream` to have actions pending. If the pending flag is
     * already set or `stream` is closed, it will return %FALSE and set
     * `error`.
     * @returns %TRUE if pending was previously unset and is now set.
     */
    setPending(): boolean
    // Has conflict: splice(source: InputStream, flags: OutputStreamSpliceFlags, cancellable: Cancellable | null): number
    // Has conflict: spliceAsync(source: InputStream, flags: OutputStreamSpliceFlags, ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: spliceFinish(result: AsyncResult): number
    /**
     * Tries to write `count` bytes from `buffer` into the stream. Will block
     * during the operation.
     *
     * If count is 0, returns 0 and does nothing. A value of `count`
     * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, the number of bytes written to the stream is returned.
     * It is not an error if this is not the same as the requested size, as it
     * can happen e.g. on a partial I/O error, or if there is not enough
     * storage in the stream. All writes block until at least one byte
     * is written or an error occurs; 0 is never returned (unless
     * `count` is 0).
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     *
     * On error -1 is returned and `error` is set accordingly.
     * @param buffer the buffer containing the data to write.
     * @param cancellable optional cancellable object
     * @returns Number of bytes written, or -1 on error
     */
    write(buffer: number[], cancellable: Cancellable | null): number
    /**
     * Tries to write `count` bytes from `buffer` into the stream. Will block
     * during the operation.
     *
     * This function is similar to g_output_stream_write(), except it tries to
     * write as many bytes as requested, only stopping on an error.
     *
     * On a successful write of `count` bytes, %TRUE is returned, and `bytes_written`
     * is set to `count`.
     *
     * If there is an error during the operation %FALSE is returned and `error`
     * is set to indicate the error status.
     *
     * As a special exception to the normal conventions for functions that
     * use #GError, if this function returns %FALSE (and sets `error)` then
     * `bytes_written` will be set to the number of bytes that were
     * successfully written before the error was encountered.  This
     * functionality is only available from C.  If you need it from another
     * language then you must write your own loop around
     * g_output_stream_write().
     * @param buffer the buffer containing the data to write.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE on success, %FALSE if there was an error
     */
    writeAll(
      buffer: number[],
      cancellable: Cancellable | null
    ): [/* returnType */ boolean, /* bytesWritten */ number]
    /**
     * Request an asynchronous write of `count` bytes from `buffer` into
     * the stream. When the operation is finished `callback` will be called.
     * You can then call g_output_stream_write_all_finish() to get the result of the
     * operation.
     *
     * This is the asynchronous version of g_output_stream_write_all().
     *
     * Call g_output_stream_write_all_finish() to collect the result.
     *
     * Any outstanding I/O request with higher priority (lower numerical
     * value) will be executed before an outstanding request with lower
     * priority. Default priority is %G_PRIORITY_DEFAULT.
     *
     * Note that no copy of `buffer` will be made, so it must stay valid
     * until `callback` is called.
     * @param buffer the buffer containing the data to write
     * @param ioPriority the io priority of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
     */
    writeAllAsync(
      buffer: number[],
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous stream write operation started with
     * g_output_stream_write_all_async().
     *
     * As a special exception to the normal conventions for functions that
     * use #GError, if this function returns %FALSE (and sets `error)` then
     * `bytes_written` will be set to the number of bytes that were
     * successfully written before the error was encountered.  This
     * functionality is only available from C.  If you need it from another
     * language then you must write your own loop around
     * g_output_stream_write_async().
     * @param result a #GAsyncResult
     * @returns %TRUE on success, %FALSE if there was an error
     */
    writeAllFinish(
      result: AsyncResult
    ): [/* returnType */ boolean, /* bytesWritten */ number]
    // Has conflict: writeAsync(buffer: number[], ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    /**
     * A wrapper function for g_output_stream_write() which takes a
     * #GBytes as input.  This can be more convenient for use by language
     * bindings or in other cases where the refcounted nature of #GBytes
     * is helpful over a bare pointer interface.
     *
     * However, note that this function may still perform partial writes,
     * just like g_output_stream_write().  If that occurs, to continue
     * writing, you will need to create a new #GBytes containing just the
     * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
     * #GBytes instance multiple times potentially can result in duplicated
     * data in the output stream.
     * @param bytes the #GBytes to write
     * @param cancellable optional cancellable object
     * @returns Number of bytes written, or -1 on error
     */
    writeBytes(bytes: any, cancellable: Cancellable | null): number
    /**
     * This function is similar to g_output_stream_write_async(), but
     * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
     * this allows the stream to avoid taking a copy of the data.
     *
     * However, note that this function may still perform partial writes,
     * just like g_output_stream_write_async(). If that occurs, to continue
     * writing, you will need to create a new #GBytes containing just the
     * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
     * #GBytes instance multiple times potentially can result in duplicated
     * data in the output stream.
     *
     * For the synchronous, blocking version of this function, see
     * g_output_stream_write_bytes().
     * @param bytes The bytes to write
     * @param ioPriority the io priority of the request.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    writeBytesAsync(
      bytes: any,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a stream write-from-#GBytes operation.
     * @param result a #GAsyncResult.
     * @returns a #gssize containing the number of bytes written to the stream.
     */
    writeBytesFinish(result: AsyncResult): number
    // Has conflict: writeFinish(result: AsyncResult): number
    /**
     * Tries to write the bytes contained in the `n_vectors` `vectors` into the
     * stream. Will block during the operation.
     *
     * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
     * does nothing.
     *
     * On success, the number of bytes written to the stream is returned.
     * It is not an error if this is not the same as the requested size, as it
     * can happen e.g. on a partial I/O error, or if there is not enough
     * storage in the stream. All writes block until at least one byte
     * is written or an error occurs; 0 is never returned (unless
     * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     *
     * Some implementations of g_output_stream_writev() may have limitations on the
     * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
     * are exceeded. For example, when writing to a local file on UNIX platforms,
     * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
     * @param vectors the buffer containing the #GOutputVectors to write.
     * @param cancellable optional cancellable object
     * @returns %TRUE on success, %FALSE if there was an error
     */
    writev(
      vectors: OutputVector[],
      cancellable: Cancellable | null
    ): [/* returnType */ boolean, /* bytesWritten */ number]
    /**
     * Tries to write the bytes contained in the `n_vectors` `vectors` into the
     * stream. Will block during the operation.
     *
     * This function is similar to g_output_stream_writev(), except it tries to
     * write as many bytes as requested, only stopping on an error.
     *
     * On a successful write of all `n_vectors` vectors, %TRUE is returned, and
     * `bytes_written` is set to the sum of all the sizes of `vectors`.
     *
     * If there is an error during the operation %FALSE is returned and `error`
     * is set to indicate the error status.
     *
     * As a special exception to the normal conventions for functions that
     * use #GError, if this function returns %FALSE (and sets `error)` then
     * `bytes_written` will be set to the number of bytes that were
     * successfully written before the error was encountered.  This
     * functionality is only available from C. If you need it from another
     * language then you must write your own loop around
     * g_output_stream_write().
     *
     * The content of the individual elements of `vectors` might be changed by this
     * function.
     * @param vectors the buffer containing the #GOutputVectors to write.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns %TRUE on success, %FALSE if there was an error
     */
    writevAll(
      vectors: OutputVector[],
      cancellable: Cancellable | null
    ): [/* returnType */ boolean, /* bytesWritten */ number]
    /**
     * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
     * the stream. When the operation is finished `callback` will be called.
     * You can then call g_output_stream_writev_all_finish() to get the result of the
     * operation.
     *
     * This is the asynchronous version of g_output_stream_writev_all().
     *
     * Call g_output_stream_writev_all_finish() to collect the result.
     *
     * Any outstanding I/O request with higher priority (lower numerical
     * value) will be executed before an outstanding request with lower
     * priority. Default priority is %G_PRIORITY_DEFAULT.
     *
     * Note that no copy of `vectors` will be made, so it must stay valid
     * until `callback` is called. The content of the individual elements
     * of `vectors` might be changed by this function.
     * @param vectors the buffer containing the #GOutputVectors to write.
     * @param ioPriority the I/O priority of the request
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
     */
    writevAllAsync(
      vectors: OutputVector[],
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous stream write operation started with
     * g_output_stream_writev_all_async().
     *
     * As a special exception to the normal conventions for functions that
     * use #GError, if this function returns %FALSE (and sets `error)` then
     * `bytes_written` will be set to the number of bytes that were
     * successfully written before the error was encountered.  This
     * functionality is only available from C.  If you need it from another
     * language then you must write your own loop around
     * g_output_stream_writev_async().
     * @param result a #GAsyncResult
     * @returns %TRUE on success, %FALSE if there was an error
     */
    writevAllFinish(
      result: AsyncResult
    ): [/* returnType */ boolean, /* bytesWritten */ number]
    // Has conflict: writevAsync(vectors: OutputVector[], ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: writevFinish(result: AsyncResult): [ /* returnType */ boolean, /* bytesWritten */ number ]

    // Own virtual methods of Gio-2.0.Gio.OutputStream

    /**
     * Requests an asynchronous close of the stream, releasing resources
     * related to it. When the operation is finished `callback` will be
     * called. You can then call g_output_stream_close_finish() to get
     * the result of the operation.
     *
     * For behaviour details see g_output_stream_close().
     *
     * The asynchronous methods have a default fallback that uses threads
     * to implement asynchronicity, so they are optional for inheriting
     * classes. However, if you override one you must override all.
     * @virtual
     * @param ioPriority the io priority of the request.
     * @param cancellable optional cancellable object
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    closeAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Closes an output stream.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE if stream was successfully closed, %FALSE otherwise.
     */
    closeFinish(result: AsyncResult): boolean
    closeFn(cancellable: Cancellable | null): boolean
    /**
     * Forces a write of all user-space buffered data for the given
     * `stream`. Will block during the operation. Closing the stream will
     * implicitly cause a flush.
     *
     * This function is optional for inherited classes.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @virtual
     * @param cancellable optional cancellable object
     * @returns %TRUE on success, %FALSE on error
     */
    flush(cancellable: Cancellable | null): boolean
    /**
     * Forces an asynchronous write of all user-space buffered data for
     * the given `stream`.
     * For behaviour details see g_output_stream_flush().
     *
     * When the operation is finished `callback` will be
     * called. You can then call g_output_stream_flush_finish() to get the
     * result of the operation.
     * @virtual
     * @param ioPriority the io priority of the request.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    flushAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes flushing an output stream.
     * @virtual
     * @param result a GAsyncResult.
     * @returns %TRUE if flush operation succeeded, %FALSE otherwise.
     */
    flushFinish(result: AsyncResult): boolean
    /**
     * Splices an input stream into an output stream.
     * @virtual
     * @param source a #GInputStream.
     * @param flags a set of #GOutputStreamSpliceFlags.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #gssize containing the size of the data spliced, or     -1 if an error occurred. Note that if the number of bytes     spliced is greater than %G_MAXSSIZE, then that will be     returned, and there is no way to determine the actual number     of bytes spliced.
     */
    splice(
      source: InputStream,
      flags: OutputStreamSpliceFlags,
      cancellable: Cancellable | null
    ): number
    /**
     * Splices a stream asynchronously.
     * When the operation is finished `callback` will be called.
     * You can then call g_output_stream_splice_finish() to get the
     * result of the operation.
     *
     * For the synchronous, blocking version of this function, see
     * g_output_stream_splice().
     * @virtual
     * @param source a #GInputStream.
     * @param flags a set of #GOutputStreamSpliceFlags.
     * @param ioPriority the io priority of the request.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    spliceAsync(
      source: InputStream,
      flags: OutputStreamSpliceFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous stream splice operation.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns a #gssize of the number of bytes spliced. Note that if the     number of bytes spliced is greater than %G_MAXSSIZE, then that     will be returned, and there is no way to determine the actual     number of bytes spliced.
     */
    spliceFinish(result: AsyncResult): number
    /**
     * Request an asynchronous write of `count` bytes from `buffer` into
     * the stream. When the operation is finished `callback` will be called.
     * You can then call g_output_stream_write_finish() to get the result of the
     * operation.
     *
     * During an async request no other sync and async calls are allowed,
     * and will result in %G_IO_ERROR_PENDING errors.
     *
     * A value of `count` larger than %G_MAXSSIZE will cause a
     * %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, the number of bytes written will be passed to the
     * `callback`. It is not an error if this is not the same as the
     * requested size, as it can happen e.g. on a partial I/O error,
     * but generally we try to write as many bytes as requested.
     *
     * You are guaranteed that this method will never fail with
     * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
     * method will just wait until this changes.
     *
     * Any outstanding I/O request with higher priority (lower numerical
     * value) will be executed before an outstanding request with lower
     * priority. Default priority is %G_PRIORITY_DEFAULT.
     *
     * The asynchronous methods have a default fallback that uses threads
     * to implement asynchronicity, so they are optional for inheriting
     * classes. However, if you override one you must override all.
     *
     * For the synchronous, blocking version of this function, see
     * g_output_stream_write().
     *
     * Note that no copy of `buffer` will be made, so it must stay valid
     * until `callback` is called. See g_output_stream_write_bytes_async()
     * for a #GBytes version that will automatically hold a reference to
     * the contents (without copying) for the duration of the call.
     * @virtual
     * @param buffer the buffer containing the data to write.
     * @param ioPriority the io priority of the request.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
     */
    writeAsync(
      buffer: number[] | null,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a stream write operation.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns a #gssize containing the number of bytes written to the stream.
     */
    writeFinish(result: AsyncResult): number
    /**
     * Tries to write `count` bytes from `buffer` into the stream. Will block
     * during the operation.
     *
     * If count is 0, returns 0 and does nothing. A value of `count`
     * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
     *
     * On success, the number of bytes written to the stream is returned.
     * It is not an error if this is not the same as the requested size, as it
     * can happen e.g. on a partial I/O error, or if there is not enough
     * storage in the stream. All writes block until at least one byte
     * is written or an error occurs; 0 is never returned (unless
     * `count` is 0).
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     *
     * On error -1 is returned and `error` is set accordingly.
     * @virtual
     * @param buffer the buffer containing the data to write.
     * @param cancellable optional cancellable object
     * @returns Number of bytes written, or -1 on error
     */
    writeFn(buffer: number[] | null, cancellable: Cancellable | null): number
    /**
     * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
     * the stream. When the operation is finished `callback` will be called.
     * You can then call g_output_stream_writev_finish() to get the result of the
     * operation.
     *
     * During an async request no other sync and async calls are allowed,
     * and will result in %G_IO_ERROR_PENDING errors.
     *
     * On success, the number of bytes written will be passed to the
     * `callback`. It is not an error if this is not the same as the
     * requested size, as it can happen e.g. on a partial I/O error,
     * but generally we try to write as many bytes as requested.
     *
     * You are guaranteed that this method will never fail with
     * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
     * method will just wait until this changes.
     *
     * Any outstanding I/O request with higher priority (lower numerical
     * value) will be executed before an outstanding request with lower
     * priority. Default priority is %G_PRIORITY_DEFAULT.
     *
     * The asynchronous methods have a default fallback that uses threads
     * to implement asynchronicity, so they are optional for inheriting
     * classes. However, if you override one you must override all.
     *
     * For the synchronous, blocking version of this function, see
     * g_output_stream_writev().
     *
     * Note that no copy of `vectors` will be made, so it must stay valid
     * until `callback` is called.
     * @virtual
     * @param vectors the buffer containing the #GOutputVectors to write.
     * @param ioPriority the I/O priority of the request.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
     */
    writevAsync(
      vectors: OutputVector[],
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes a stream writev operation.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE on success, %FALSE if there was an error
     */
    writevFinish(
      result: AsyncResult
    ): [/* returnType */ boolean, /* bytesWritten */ number]
    /**
     * Tries to write the bytes contained in the `n_vectors` `vectors` into the
     * stream. Will block during the operation.
     *
     * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
     * does nothing.
     *
     * On success, the number of bytes written to the stream is returned.
     * It is not an error if this is not the same as the requested size, as it
     * can happen e.g. on a partial I/O error, or if there is not enough
     * storage in the stream. All writes block until at least one byte
     * is written or an error occurs; 0 is never returned (unless
     * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
     * operation was partially finished when the operation was cancelled the
     * partial result will be returned, without an error.
     *
     * Some implementations of g_output_stream_writev() may have limitations on the
     * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
     * are exceeded. For example, when writing to a local file on UNIX platforms,
     * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
     * @virtual
     * @param vectors the buffer containing the #GOutputVectors to write.
     * @param cancellable optional cancellable object
     * @returns %TRUE on success, %FALSE if there was an error
     */
    writevFn(
      vectors: OutputVector[],
      cancellable: Cancellable | null
    ): [/* returnType */ boolean, /* bytesWritten */ number]

    // Class property signals of Gio-2.0.Gio.OutputStream

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GOutputStream` is a base class for implementing streaming output.
   *
   * It has functions to write to a stream ([method`Gio`.OutputStream.write]),
   * to close a stream ([method`Gio`.OutputStream.close]) and to flush pending
   * writes ([method`Gio`.OutputStream.flush]).
   *
   * To copy the content of an input stream to an output stream without
   * manually handling the reads and writes, use [method`Gio`.OutputStream.splice].
   *
   * See the documentation for [class`Gio`.IOStream] for details of thread safety
   * of streaming APIs.
   *
   * All of these functions have async variants too.
   *
   * All classes derived from `GOutputStream` *should* implement synchronous
   * writing, splicing, flushing and closing streams, but *may* implement
   * asynchronous versions.
   * @interface
   */
  class OutputStream extends GObject.Object {
    // Own properties of Gio-2.0.Gio.OutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.OutputStream

    constructor(config?: OutputStream.ConstructorProperties)
    _init(config?: OutputStream.ConstructorProperties): void
  }

  module Permission {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Permission {
    // Own properties of Gio-2.0.Gio.Permission

    /**
     * %TRUE if the caller currently has permission to perform the action that
     * `permission` represents the permission to perform.
     */
    readonly allowed: boolean
    /**
     * %TRUE if it is generally possible to acquire the permission by calling
     * g_permission_acquire().
     */
    readonly canAcquire: boolean
    /**
     * %TRUE if it is generally possible to release the permission by calling
     * g_permission_release().
     */
    readonly canRelease: boolean
    __gtype__: number

    // Own fields of Gio-2.0.Gio.Permission

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.Permission

    // Has conflict: acquire(cancellable: Cancellable | null): boolean
    // Has conflict: acquireAsync(cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: acquireFinish(result: AsyncResult): boolean
    /**
     * Gets the value of the 'allowed' property.  This property is %TRUE if
     * the caller currently has permission to perform the action that
     * `permission` represents the permission to perform.
     * @returns the value of the 'allowed' property
     */
    getAllowed(): boolean
    /**
     * Gets the value of the 'can-acquire' property.  This property is %TRUE
     * if it is generally possible to acquire the permission by calling
     * g_permission_acquire().
     * @returns the value of the 'can-acquire' property
     */
    getCanAcquire(): boolean
    /**
     * Gets the value of the 'can-release' property.  This property is %TRUE
     * if it is generally possible to release the permission by calling
     * g_permission_release().
     * @returns the value of the 'can-release' property
     */
    getCanRelease(): boolean
    /**
     * This function is called by the #GPermission implementation to update
     * the properties of the permission.  You should never call this
     * function except from a #GPermission implementation.
     *
     * GObject notify signals are generated, as appropriate.
     * @param allowed the new value for the 'allowed' property
     * @param canAcquire the new value for the 'can-acquire' property
     * @param canRelease the new value for the 'can-release' property
     */
    implUpdate(allowed: boolean, canAcquire: boolean, canRelease: boolean): void
    // Has conflict: release(cancellable: Cancellable | null): boolean
    // Has conflict: releaseAsync(cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: releaseFinish(result: AsyncResult): boolean

    // Own virtual methods of Gio-2.0.Gio.Permission

    /**
     * Attempts to acquire the permission represented by `permission`.
     *
     * The precise method by which this happens depends on the permission
     * and the underlying authentication mechanism.  A simple example is
     * that a dialog may appear asking the user to enter their password.
     *
     * You should check with g_permission_get_can_acquire() before calling
     * this function.
     *
     * If the permission is acquired then %TRUE is returned.  Otherwise,
     * %FALSE is returned and `error` is set appropriately.
     *
     * This call is blocking, likely for a very long time (in the case that
     * user interaction is required).  See g_permission_acquire_async() for
     * the non-blocking version.
     * @virtual
     * @param cancellable a #GCancellable, or %NULL
     * @returns %TRUE if the permission was successfully acquired
     */
    acquire(cancellable: Cancellable | null): boolean
    /**
     * Attempts to acquire the permission represented by `permission`.
     *
     * This is the first half of the asynchronous version of
     * g_permission_acquire().
     * @virtual
     * @param cancellable a #GCancellable, or %NULL
     * @param callback the #GAsyncReadyCallback to call when done
     */
    acquireAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Collects the result of attempting to acquire the permission
     * represented by `permission`.
     *
     * This is the second half of the asynchronous version of
     * g_permission_acquire().
     * @virtual
     * @param result the #GAsyncResult given to the #GAsyncReadyCallback
     * @returns %TRUE if the permission was successfully acquired
     */
    acquireFinish(result: AsyncResult): boolean
    /**
     * Attempts to release the permission represented by `permission`.
     *
     * The precise method by which this happens depends on the permission
     * and the underlying authentication mechanism.  In most cases the
     * permission will be dropped immediately without further action.
     *
     * You should check with g_permission_get_can_release() before calling
     * this function.
     *
     * If the permission is released then %TRUE is returned.  Otherwise,
     * %FALSE is returned and `error` is set appropriately.
     *
     * This call is blocking, likely for a very long time (in the case that
     * user interaction is required).  See g_permission_release_async() for
     * the non-blocking version.
     * @virtual
     * @param cancellable a #GCancellable, or %NULL
     * @returns %TRUE if the permission was successfully released
     */
    release(cancellable: Cancellable | null): boolean
    /**
     * Attempts to release the permission represented by `permission`.
     *
     * This is the first half of the asynchronous version of
     * g_permission_release().
     * @virtual
     * @param cancellable a #GCancellable, or %NULL
     * @param callback the #GAsyncReadyCallback to call when done
     */
    releaseAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Collects the result of attempting to release the permission
     * represented by `permission`.
     *
     * This is the second half of the asynchronous version of
     * g_permission_release().
     * @virtual
     * @param result the #GAsyncResult given to the #GAsyncReadyCallback
     * @returns %TRUE if the permission was successfully released
     */
    releaseFinish(result: AsyncResult): boolean

    // Class property signals of Gio-2.0.Gio.Permission

    connect(
      sigName: "notify::allowed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::allowed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::allowed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::allowed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::allowed", ...args: any[]): void
    connect(
      sigName: "notify::can-acquire",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-acquire",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-acquire",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-acquire",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-acquire", ...args: any[]): void
    connect(
      sigName: "notify::can-release",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-release",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-release",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-release",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-release", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GPermission` represents the status of the caller’s permission to
   * perform a certain action.
   *
   * You can query if the action is currently allowed and if it is
   * possible to acquire the permission so that the action will be allowed
   * in the future.
   *
   * There is also an API to actually acquire the permission and one to
   * release it.
   *
   * As an example, a `GPermission` might represent the ability for the
   * user to write to a [class`Gio`.Settings] object.  This `GPermission` object
   * could then be used to decide if it is appropriate to show a “Click here to
   * unlock” button in a dialog and to provide the mechanism to invoke
   * when that button is clicked.
   * @class
   */
  class Permission extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Permission

    static name: string

    // Constructors of Gio-2.0.Gio.Permission

    constructor(config?: Permission.ConstructorProperties)
    _init(config?: Permission.ConstructorProperties): void
  }

  module PropertyAction {
    // Constructor properties interface

    interface ConstructorProperties
      extends Action.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.PropertyAction

      /**
       * If %TRUE, the state of the action will be the negation of the
       * property value, provided the property is boolean.
       */
      invert_boolean?: boolean | null
      /**
       * The name of the action.  This is mostly meaningful for identifying
       * the action once it has been added to a #GActionMap.
       */
      name?: string | null
      /**
       * The object to wrap a property on.
       *
       * The object must be a non-%NULL #GObject with properties.
       */
      object?: GObject.Object | null
      /**
       * The name of the property to wrap on the object.
       *
       * The property must exist on the passed-in object and it must be
       * readable and writable (and not construct-only).
       */
      property_name?: string | null
    }
  }

  interface PropertyAction extends Action {
    // Own properties of Gio-2.0.Gio.PropertyAction

    /**
     * If `action` is currently enabled.
     *
     * If the action is disabled then calls to g_action_activate() and
     * g_action_change_state() have no effect.
     */
    readonly enabled: boolean
    /**
     * If %TRUE, the state of the action will be the negation of the
     * property value, provided the property is boolean.
     */
    readonly invertBoolean: boolean
    /**
     * The name of the action.  This is mostly meaningful for identifying
     * the action once it has been added to a #GActionMap.
     */
    readonly name: string | null
    /**
     * The object to wrap a property on.
     *
     * The object must be a non-%NULL #GObject with properties.
     */
    readonly object: GObject.Object
    /**
     * The type of the parameter that must be given when activating the
     * action.
     */
    readonly parameterType: GLib.VariantType
    /**
     * The name of the property to wrap on the object.
     *
     * The property must exist on the passed-in object and it must be
     * readable and writable (and not construct-only).
     */
    readonly propertyName: string | null
    /**
     * The state of the action, or %NULL if the action is stateless.
     */
    readonly state: GLib.Variant
    /**
     * The #GVariantType of the state that the action has, or %NULL if the
     * action is stateless.
     */
    readonly stateType: GLib.VariantType
    __gtype__: number

    // Class property signals of Gio-2.0.Gio.PropertyAction

    connect(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enabled", ...args: any[]): void
    connect(
      sigName: "notify::invert-boolean",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::invert-boolean",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::invert-boolean",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::invert-boolean",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::invert-boolean", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::object",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::object",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::object",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::object",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::object", ...args: any[]): void
    connect(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parameter-type", ...args: any[]): void
    connect(
      sigName: "notify::property-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::property-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::property-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::property-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::property-name", ...args: any[]): void
    connect(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state", ...args: any[]): void
    connect(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state-type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GPropertyAction` is a way to get a [iface`Gio`.Action] with a state value
   * reflecting and controlling the value of a [class`GObject`.Object] property.
   *
   * The state of the action will correspond to the value of the property.
   * Changing it will change the property (assuming the requested value
   * matches the requirements as specified in the [type`GObject`.ParamSpec]).
   *
   * Only the most common types are presently supported.  Booleans are
   * mapped to booleans, strings to strings, signed/unsigned integers to
   * int32/uint32 and floats and doubles to doubles.
   *
   * If the property is an enum then the state will be string-typed and
   * conversion will automatically be performed between the enum value and
   * ‘nick’ string as per the [type`GObject`.EnumValue] table.
   *
   * Flags types are not currently supported.
   *
   * Properties of object types, boxed types and pointer types are not
   * supported and probably never will be.
   *
   * Properties of [type`GLib`.Variant] types are not currently supported.
   *
   * If the property is boolean-valued then the action will have a `NULL`
   * parameter type, and activating the action (with no parameter) will
   * toggle the value of the property.
   *
   * In all other cases, the parameter type will correspond to the type of
   * the property.
   *
   * The general idea here is to reduce the number of locations where a
   * particular piece of state is kept (and therefore has to be synchronised
   * between). `GPropertyAction` does not have a separate state that is kept
   * in sync with the property value — its state is the property value.
   *
   * For example, it might be useful to create a [iface`Gio`.Action] corresponding
   * to the `visible-child-name` property of a [`GtkStack`](https://docs.gtk.org/gtk4/class.Stack.html)
   * so that the current page can be switched from a menu.  The active radio
   * indication in the menu is then directly determined from the active page of
   * the `GtkStack`.
   *
   * An anti-example would be binding the `active-id` property on a
   * [`GtkComboBox`](https://docs.gtk.org/gtk4/class.ComboBox.html). This is
   * because the state of the combo box itself is probably uninteresting and is
   * actually being used to control something else.
   *
   * Another anti-example would be to bind to the `visible-child-name`
   * property of a [`GtkStack`](https://docs.gtk.org/gtk4/class.Stack.html) if
   * this value is actually stored in [class`Gio`.Settings].  In that case, the
   * real source of the value is* [class`Gio`.Settings].  If you want
   * a [iface`Gio`.Action] to control a setting stored in [class`Gio`.Settings],
   * see [method`Gio`.Settings.create_action] instead, and possibly combine its
   * use with [method`Gio`.Settings.bind].
   * @class
   */
  class PropertyAction extends GObject.Object {
    // Own properties of Gio-2.0.Gio.PropertyAction

    static name: string

    // Constructors of Gio-2.0.Gio.PropertyAction

    constructor(config?: PropertyAction.ConstructorProperties)
    /**
     * Creates a #GAction corresponding to the value of property
     * `property_name` on `object`.
     *
     * The property must be existent and readable and writable (and not
     * construct-only).
     *
     * This function takes a reference on `object` and doesn't release it
     * until the action is destroyed.
     * @constructor
     * @param name the name of the action to create
     * @param object the object that has the property   to wrap
     * @param propertyName the name of the property
     * @returns a new #GPropertyAction
     */
    constructor(name: string, object: GObject.Object, propertyName: string)
    /**
     * Creates a #GAction corresponding to the value of property
     * `property_name` on `object`.
     *
     * The property must be existent and readable and writable (and not
     * construct-only).
     *
     * This function takes a reference on `object` and doesn't release it
     * until the action is destroyed.
     * @constructor
     * @param name the name of the action to create
     * @param object the object that has the property   to wrap
     * @param propertyName the name of the property
     * @returns a new #GPropertyAction
     */
    static new(
      name: string,
      object: GObject.Object,
      propertyName: string
    ): PropertyAction
    _init(config?: PropertyAction.ConstructorProperties): void
  }

  module ProxyAddress {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnectable.ConstructorProperties,
        InetSocketAddress.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ProxyAddress

      /**
       * The proxy destination hostname.
       */
      destination_hostname?: string | null
      /**
       * The proxy destination port.
       */
      destination_port?: number | null
      /**
       * The protocol being spoke to the destination host, or %NULL if
       * the #GProxyAddress doesn't know.
       */
      destination_protocol?: string | null
      /**
       * The proxy password.
       */
      password?: string | null
      /**
       * The proxy protocol.
       */
      protocol?: string | null
      /**
       * The URI string that the proxy was constructed from (or %NULL
       * if the creator didn't specify this).
       */
      uri?: string | null
      /**
       * The proxy username.
       */
      username?: string | null
    }
  }

  interface ProxyAddress extends SocketConnectable {
    // Own properties of Gio-2.0.Gio.ProxyAddress

    /**
     * The proxy destination hostname.
     */
    readonly destinationHostname: string | null
    /**
     * The proxy destination port.
     */
    readonly destinationPort: number
    /**
     * The protocol being spoke to the destination host, or %NULL if
     * the #GProxyAddress doesn't know.
     */
    readonly destinationProtocol: string | null
    /**
     * The proxy password.
     */
    readonly password: string | null
    /**
     * The proxy protocol.
     */
    readonly protocol: string | null
    /**
     * The URI string that the proxy was constructed from (or %NULL
     * if the creator didn't specify this).
     */
    readonly uri: string | null
    /**
     * The proxy username.
     */
    readonly username: string | null
    __gtype__: number

    // Own fields of Gio-2.0.Gio.ProxyAddress

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.ProxyAddress

    /**
     * Gets `proxy'`s destination hostname; that is, the name of the host
     * that will be connected to via the proxy, not the name of the proxy
     * itself.
     * @returns the @proxy's destination hostname
     */
    getDestinationHostname(): string
    /**
     * Gets `proxy'`s destination port; that is, the port on the
     * destination host that will be connected to via the proxy, not the
     * port number of the proxy itself.
     * @returns the @proxy's destination port
     */
    getDestinationPort(): number
    /**
     * Gets the protocol that is being spoken to the destination
     * server; eg, "http" or "ftp".
     * @returns the @proxy's destination protocol
     */
    getDestinationProtocol(): string
    /**
     * Gets `proxy'`s password.
     * @returns the @proxy's password
     */
    getPassword(): string | null
    /**
     * Gets `proxy'`s protocol. eg, "socks" or "http"
     * @returns the @proxy's protocol
     */
    getProtocol(): string
    /**
     * Gets the proxy URI that `proxy` was constructed from.
     * @returns the @proxy's URI, or %NULL if unknown
     */
    getUri(): string | null
    /**
     * Gets `proxy'`s username.
     * @returns the @proxy's username
     */
    getUsername(): string | null

    // Class property signals of Gio-2.0.Gio.ProxyAddress

    connect(
      sigName: "notify::destination-hostname",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destination-hostname",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destination-hostname",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destination-hostname",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destination-hostname", ...args: any[]): void
    connect(
      sigName: "notify::destination-port",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destination-port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destination-port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destination-port",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destination-port", ...args: any[]): void
    connect(
      sigName: "notify::destination-protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destination-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destination-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destination-protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destination-protocol", ...args: any[]): void
    connect(
      sigName: "notify::password",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::password",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::password",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::password",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::password", ...args: any[]): void
    connect(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol", ...args: any[]): void
    connect(sigName: "notify::uri", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::uri",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::uri", ...args: any[]): void
    connect(
      sigName: "notify::username",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::username",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::username",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::username",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::username", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::address", ...args: any[]): void
    connect(
      sigName: "notify::flowinfo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flowinfo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flowinfo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flowinfo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flowinfo", ...args: any[]): void
    connect(sigName: "notify::port", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::port",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::port", ...args: any[]): void
    connect(
      sigName: "notify::scope-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scope-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scope-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scope-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scope-id", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A [class`Gio`.InetSocketAddress] representing a connection via a proxy server.
   * @class
   */
  class ProxyAddress extends InetSocketAddress {
    // Own properties of Gio-2.0.Gio.ProxyAddress

    static name: string

    // Constructors of Gio-2.0.Gio.ProxyAddress

    constructor(config?: ProxyAddress.ConstructorProperties)
    /**
     * Creates a new #GProxyAddress for `inetaddr` with `protocol` that should
     * tunnel through `dest_hostname` and `dest_port`.
     *
     * (Note that this method doesn't set the #GProxyAddress:uri or
     * #GProxyAddress:destination-protocol fields; use g_object_new()
     * directly if you want to set those.)
     * @constructor
     * @param inetaddr The proxy server #GInetAddress.
     * @param port The proxy server port.
     * @param protocol The proxy protocol to support, in lower case (e.g. socks, http).
     * @param destHostname The destination hostname the proxy should tunnel to.
     * @param destPort The destination port to tunnel to.
     * @param username The username to authenticate to the proxy server     (or %NULL).
     * @param password The password to authenticate to the proxy server     (or %NULL).
     * @returns a new #GProxyAddress
     */
    constructor(
      inetaddr: InetAddress,
      port: number,
      protocol: string,
      destHostname: string,
      destPort: number,
      username: string | null,
      password: string | null
    )
    /**
     * Creates a new #GProxyAddress for `inetaddr` with `protocol` that should
     * tunnel through `dest_hostname` and `dest_port`.
     *
     * (Note that this method doesn't set the #GProxyAddress:uri or
     * #GProxyAddress:destination-protocol fields; use g_object_new()
     * directly if you want to set those.)
     * @constructor
     * @param inetaddr The proxy server #GInetAddress.
     * @param port The proxy server port.
     * @param protocol The proxy protocol to support, in lower case (e.g. socks, http).
     * @param destHostname The destination hostname the proxy should tunnel to.
     * @param destPort The destination port to tunnel to.
     * @param username The username to authenticate to the proxy server     (or %NULL).
     * @param password The password to authenticate to the proxy server     (or %NULL).
     * @returns a new #GProxyAddress
     */
    static new(
      inetaddr: InetAddress,
      port: number,
      protocol: string,
      destHostname: string,
      destPort: number,
      username: string | null,
      password: string | null
    ): ProxyAddress

    // Overloads of new

    /**
     * Creates a new #GInetSocketAddress for `address` and `port`.
     * @constructor
     * @param address a #GInetAddress
     * @param port a port number
     * @returns a new #GInetSocketAddress
     */
    static new(address: InetAddress, port: number): InetSocketAddress
    _init(config?: ProxyAddress.ConstructorProperties): void
  }

  module ProxyAddressEnumerator {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketAddressEnumerator.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ProxyAddressEnumerator

      /**
       * The connectable being enumerated.
       */
      connectable?: SocketConnectable | null
      /**
       * The default port to use if #GProxyAddressEnumerator:uri does not
       * specify one.
       */
      default_port?: number | null
      /**
       * The proxy resolver to use.
       */
      proxy_resolver?: ProxyResolver | null
      /**
       * The destination URI. Use `none://` for a generic socket.
       */
      uri?: string | null
    }
  }

  interface ProxyAddressEnumerator {
    // Own properties of Gio-2.0.Gio.ProxyAddressEnumerator

    /**
     * The connectable being enumerated.
     */
    readonly connectable: SocketConnectable
    /**
     * The default port to use if #GProxyAddressEnumerator:uri does not
     * specify one.
     */
    readonly defaultPort: number
    /**
     * The proxy resolver to use.
     */
    proxyResolver: ProxyResolver
    /**
     * The destination URI. Use `none://` for a generic socket.
     */
    readonly uri: string | null
    __gtype__: number

    // Class property signals of Gio-2.0.Gio.ProxyAddressEnumerator

    connect(
      sigName: "notify::connectable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::connectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::connectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::connectable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::connectable", ...args: any[]): void
    connect(
      sigName: "notify::default-port",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-port",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-port",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-port", ...args: any[]): void
    connect(
      sigName: "notify::proxy-resolver",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::proxy-resolver",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::proxy-resolver",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::proxy-resolver",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::proxy-resolver", ...args: any[]): void
    connect(sigName: "notify::uri", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::uri",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::uri", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GProxyAddressEnumerator` is a wrapper around
   * [class`Gio`.SocketAddressEnumerator] which takes the [class`Gio`.SocketAddress]
   * instances returned by the [class`Gio`.SocketAddressEnumerator]
   * and wraps them in [class`Gio`.ProxyAddress] instances, using the given
   * [property`Gio`.ProxyAddressEnumerator:proxy-resolver].
   *
   * This enumerator will be returned (for example, by
   * [method`Gio`.SocketConnectable.enumerate]) as appropriate when a proxy is
   * configured; there should be no need to manually wrap a
   * [class`Gio`.SocketAddressEnumerator] instance with one.
   * @class
   */
  class ProxyAddressEnumerator extends SocketAddressEnumerator {
    // Own properties of Gio-2.0.Gio.ProxyAddressEnumerator

    static name: string

    // Constructors of Gio-2.0.Gio.ProxyAddressEnumerator

    constructor(config?: ProxyAddressEnumerator.ConstructorProperties)
    _init(config?: ProxyAddressEnumerator.ConstructorProperties): void
  }

  module Resolver {
    // Signal callback interfaces

    /**
     * Signal callback interface for `reload`
     */
    interface ReloadSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.Resolver

      /**
       * The timeout applied to all resolver lookups, in milliseconds.
       *
       * This may be changed through the lifetime of the #GResolver. The new value
       * will apply to any lookups started after the change, but not to any
       * already-ongoing lookups.
       *
       * If this is `0`, no timeout is applied to lookups.
       *
       * No timeout was applied to lookups before this property was added in
       * GLib 2.78.
       */
      timeout?: number | null
    }
  }

  interface Resolver {
    // Own properties of Gio-2.0.Gio.Resolver

    /**
     * The timeout applied to all resolver lookups, in milliseconds.
     *
     * This may be changed through the lifetime of the #GResolver. The new value
     * will apply to any lookups started after the change, but not to any
     * already-ongoing lookups.
     *
     * If this is `0`, no timeout is applied to lookups.
     *
     * No timeout was applied to lookups before this property was added in
     * GLib 2.78.
     */
    timeout: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.Resolver

    parentInstance: GObject.Object
    priv: ResolverPrivate

    // Owm methods of Gio-2.0.Gio.Resolver

    /**
     * Get the timeout applied to all resolver lookups. See #GResolver:timeout.
     * @returns the resolver timeout, in milliseconds, or `0` for no timeout
     */
    getTimeout(): number
    // Has conflict: lookupByAddress(address: InetAddress, cancellable: Cancellable | null): string | null
    // Has conflict: lookupByAddressAsync(address: InetAddress, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupByAddressFinish(result: AsyncResult): string | null
    // Has conflict: lookupByName(hostname: string, cancellable: Cancellable | null): InetAddress[]
    // Has conflict: lookupByNameAsync(hostname: string, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupByNameFinish(result: AsyncResult): InetAddress[]
    // Has conflict: lookupByNameWithFlags(hostname: string, flags: ResolverNameLookupFlags, cancellable: Cancellable | null): InetAddress[]
    // Has conflict: lookupByNameWithFlagsAsync(hostname: string, flags: ResolverNameLookupFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupByNameWithFlagsFinish(result: AsyncResult): InetAddress[]
    // Has conflict: lookupRecords(rrname: string, recordType: ResolverRecordType, cancellable: Cancellable | null): GLib.Variant[]
    // Has conflict: lookupRecordsAsync(rrname: string, recordType: ResolverRecordType, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupRecordsFinish(result: AsyncResult): GLib.Variant[]
    /**
     * Synchronously performs a DNS SRV lookup for the given `service` and
     * `protocol` in the given `domain` and returns an array of #GSrvTarget.
     * `domain` may be an ASCII-only or UTF-8 hostname. Note also that the
     * `service` and `protocol` arguments do not include the leading underscore
     * that appears in the actual DNS entry.
     *
     * On success, g_resolver_lookup_service() will return a non-empty #GList of
     * #GSrvTarget, sorted in order of preference. (That is, you should
     * attempt to connect to the first target first, then the second if
     * the first fails, etc.)
     *
     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
     * a value from #GResolverError and %NULL will be returned.
     *
     * If `cancellable` is non-%NULL, it can be used to cancel the
     * operation, in which case `error` (if non-%NULL) will be set to
     * %G_IO_ERROR_CANCELLED.
     *
     * If you are planning to connect to the service, it is usually easier
     * to create a #GNetworkService and use its #GSocketConnectable
     * interface.
     * @param service the service type to look up (eg, "ldap")
     * @param protocol the networking protocol to use for `service` (eg, "tcp")
     * @param domain the DNS domain to look up the service in
     * @param cancellable a #GCancellable, or %NULL
     * @returns a non-empty #GList of #GSrvTarget, or %NULL on error. You must free each of the targets and the list when you are done with it. (You can use g_resolver_free_targets() to do this.)
     */
    lookupService(
      service: string,
      protocol: string,
      domain: string,
      cancellable: Cancellable | null
    ): SrvTarget[]
    // Has conflict: lookupServiceAsync(service: string, protocol: string, domain: string, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupServiceFinish(result: AsyncResult): SrvTarget[]
    /**
     * Sets `resolver` to be the application's default resolver (reffing
     * `resolver,` and unreffing the previous default resolver, if any).
     * Future calls to g_resolver_get_default() will return this resolver.
     *
     * This can be used if an application wants to perform any sort of DNS
     * caching or "pinning"; it can implement its own #GResolver that
     * calls the original default resolver for DNS operations, and
     * implements its own cache policies on top of that, and then set
     * itself as the default resolver for all later code to use.
     */
    setDefault(): void
    /**
     * Set the timeout applied to all resolver lookups. See #GResolver:timeout.
     * @param timeoutMs timeout in milliseconds, or `0` for no timeouts
     */
    setTimeout(timeoutMs: number): void

    // Own virtual methods of Gio-2.0.Gio.Resolver

    /**
     * Synchronously reverse-resolves `address` to determine its
     * associated hostname.
     *
     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
     * a value from #GResolverError.
     *
     * If `cancellable` is non-%NULL, it can be used to cancel the
     * operation, in which case `error` (if non-%NULL) will be set to
     * %G_IO_ERROR_CANCELLED.
     * @virtual
     * @param address the address to reverse-resolve
     * @param cancellable a #GCancellable, or %NULL
     * @returns a hostname (either ASCII-only, or in ASCII-encoded     form), or %NULL on error.
     */
    lookupByAddress(
      address: InetAddress,
      cancellable: Cancellable | null
    ): string | null
    /**
     * Begins asynchronously reverse-resolving `address` to determine its
     * associated hostname, and eventually calls `callback,` which must
     * call g_resolver_lookup_by_address_finish() to get the final result.
     * @virtual
     * @param address the address to reverse-resolve
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call after resolution completes
     */
    lookupByAddressAsync(
      address: InetAddress,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Retrieves the result of a previous call to
     * g_resolver_lookup_by_address_async().
     *
     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
     * a value from #GResolverError. If the operation was cancelled,
     * `error` will be set to %G_IO_ERROR_CANCELLED.
     * @virtual
     * @param result the result passed to your #GAsyncReadyCallback
     * @returns a hostname (either ASCII-only, or in ASCII-encoded form), or %NULL on error.
     */
    lookupByAddressFinish(result: AsyncResult): string | null
    /**
     * Synchronously resolves `hostname` to determine its associated IP
     * address(es). `hostname` may be an ASCII-only or UTF-8 hostname, or
     * the textual form of an IP address (in which case this just becomes
     * a wrapper around g_inet_address_new_from_string()).
     *
     * On success, g_resolver_lookup_by_name() will return a non-empty #GList of
     * #GInetAddress, sorted in order of preference and guaranteed to not
     * contain duplicates. That is, if using the result to connect to
     * `hostname,` you should attempt to connect to the first address
     * first, then the second if the first fails, etc. If you are using
     * the result to listen on a socket, it is appropriate to add each
     * result using e.g. g_socket_listener_add_address().
     *
     * If the DNS resolution fails, `error` (if non-%NULL) will be set to a
     * value from #GResolverError and %NULL will be returned.
     *
     * If `cancellable` is non-%NULL, it can be used to cancel the
     * operation, in which case `error` (if non-%NULL) will be set to
     * %G_IO_ERROR_CANCELLED.
     *
     * If you are planning to connect to a socket on the resolved IP
     * address, it may be easier to create a #GNetworkAddress and use its
     * #GSocketConnectable interface.
     * @virtual
     * @param hostname the hostname to look up
     * @param cancellable a #GCancellable, or %NULL
     * @returns a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.)
     */
    lookupByName(
      hostname: string,
      cancellable: Cancellable | null
    ): InetAddress[]
    /**
     * Begins asynchronously resolving `hostname` to determine its
     * associated IP address(es), and eventually calls `callback,` which
     * must call g_resolver_lookup_by_name_finish() to get the result.
     * See g_resolver_lookup_by_name() for more details.
     * @virtual
     * @param hostname the hostname to look up the address of
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call after resolution completes
     */
    lookupByNameAsync(
      hostname: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Retrieves the result of a call to
     * g_resolver_lookup_by_name_async().
     *
     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
     * a value from #GResolverError. If the operation was cancelled,
     * `error` will be set to %G_IO_ERROR_CANCELLED.
     * @virtual
     * @param result the result passed to your #GAsyncReadyCallback
     * @returns a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details.
     */
    lookupByNameFinish(result: AsyncResult): InetAddress[]
    /**
     * This differs from g_resolver_lookup_by_name() in that you can modify
     * the lookup behavior with `flags`. For example this can be used to limit
     * results with %G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY.
     * @virtual
     * @param hostname the hostname to look up
     * @param flags extra #GResolverNameLookupFlags for the lookup
     * @param cancellable a #GCancellable, or %NULL
     * @returns a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.)
     */
    lookupByNameWithFlags(
      hostname: string,
      flags: ResolverNameLookupFlags,
      cancellable: Cancellable | null
    ): InetAddress[]
    /**
     * Begins asynchronously resolving `hostname` to determine its
     * associated IP address(es), and eventually calls `callback,` which
     * must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
     * See g_resolver_lookup_by_name() for more details.
     * @virtual
     * @param hostname the hostname to look up the address of
     * @param flags extra #GResolverNameLookupFlags for the lookup
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call after resolution completes
     */
    lookupByNameWithFlagsAsync(
      hostname: string,
      flags: ResolverNameLookupFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Retrieves the result of a call to
     * g_resolver_lookup_by_name_with_flags_async().
     *
     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
     * a value from #GResolverError. If the operation was cancelled,
     * `error` will be set to %G_IO_ERROR_CANCELLED.
     * @virtual
     * @param result the result passed to your #GAsyncReadyCallback
     * @returns a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details.
     */
    lookupByNameWithFlagsFinish(result: AsyncResult): InetAddress[]
    /**
     * Synchronously performs a DNS record lookup for the given `rrname` and returns
     * a list of records as #GVariant tuples. See #GResolverRecordType for
     * information on what the records contain for each `record_type`.
     *
     * If the DNS resolution fails, `error` (if non-%NULL) will be set to
     * a value from #GResolverError and %NULL will be returned.
     *
     * If `cancellable` is non-%NULL, it can be used to cancel the
     * operation, in which case `error` (if non-%NULL) will be set to
     * %G_IO_ERROR_CANCELLED.
     * @virtual
     * @param rrname the DNS name to look up the record for
     * @param recordType the type of DNS record to look up
     * @param cancellable a #GCancellable, or %NULL
     * @returns a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.)
     */
    lookupRecords(
      rrname: string,
      recordType: ResolverRecordType,
      cancellable: Cancellable | null
    ): GLib.Variant[]
    /**
     * Begins asynchronously performing a DNS lookup for the given
     * `rrname,` and eventually calls `callback,` which must call
     * g_resolver_lookup_records_finish() to get the final result. See
     * g_resolver_lookup_records() for more details.
     * @virtual
     * @param rrname the DNS name to look up the record for
     * @param recordType the type of DNS record to look up
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call after resolution completes
     */
    lookupRecordsAsync(
      rrname: string,
      recordType: ResolverRecordType,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Retrieves the result of a previous call to
     * g_resolver_lookup_records_async(). Returns a non-empty list of records as
     * #GVariant tuples. See #GResolverRecordType for information on what the
     * records contain.
     *
     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
     * a value from #GResolverError. If the operation was cancelled,
     * `error` will be set to %G_IO_ERROR_CANCELLED.
     * @virtual
     * @param result the result passed to your #GAsyncReadyCallback
     * @returns a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.)
     */
    lookupRecordsFinish(result: AsyncResult): GLib.Variant[]
    lookupServiceAsync(
      rrname: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Retrieves the result of a previous call to
     * g_resolver_lookup_service_async().
     *
     * If the DNS resolution failed, `error` (if non-%NULL) will be set to
     * a value from #GResolverError. If the operation was cancelled,
     * `error` will be set to %G_IO_ERROR_CANCELLED.
     * @virtual
     * @param result the result passed to your #GAsyncReadyCallback
     * @returns a non-empty #GList of #GSrvTarget, or %NULL on error. See g_resolver_lookup_service() for more details.
     */
    lookupServiceFinish(result: AsyncResult): SrvTarget[]
    reload(): void

    // Own signals of Gio-2.0.Gio.Resolver

    connect(sigName: "reload", callback: Resolver.ReloadSignalCallback): number
    on(
      sigName: "reload",
      callback: Resolver.ReloadSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "reload",
      callback: Resolver.ReloadSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "reload",
      callback: Resolver.ReloadSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "reload", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.Resolver

    connect(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::timeout", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The object that handles DNS resolution. Use [func`Gio`.Resolver.get_default]
   * to get the default resolver.
   *
   * `GResolver` provides cancellable synchronous and asynchronous DNS
   * resolution, for hostnames ([method`Gio`.Resolver.lookup_by_address],
   * [method`Gio`.Resolver.lookup_by_name] and their async variants) and SRV
   * (service) records ([method`Gio`.Resolver.lookup_service]).
   *
   * [class`Gio`.NetworkAddress] and [class`Gio`.NetworkService] provide wrappers
   * around `GResolver` functionality that also implement
   * [iface`Gio`.SocketConnectable], making it easy to connect to a remote
   * host/service.
   *
   * The default resolver (see [func`Gio`.Resolver.get_default]) has a timeout of
   * 30s set on it since GLib 2.78. Earlier versions of GLib did not support
   * resolver timeouts.
   *
   * This is an abstract type; subclasses of it implement different resolvers for
   * different platforms and situations.
   * @class
   */
  class Resolver extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Resolver

    static name: string

    // Constructors of Gio-2.0.Gio.Resolver

    constructor(config?: Resolver.ConstructorProperties)
    _init(config?: Resolver.ConstructorProperties): void
    /**
     * Gets the default #GResolver. You should unref it when you are done
     * with it. #GResolver may use its reference count as a hint about how
     * many threads it should allocate for concurrent DNS resolutions.
     * @returns the default #GResolver.
     */
    static getDefault(): Resolver
  }

  module Settings {
    // Signal callback interfaces

    /**
     * Signal callback interface for `change-event`
     */
    interface ChangeEventSignalCallback {
      (keys: GLib.Quark[] | null): boolean
    }

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (key: string | null): void
    }

    /**
     * Signal callback interface for `writable-change-event`
     */
    interface WritableChangeEventSignalCallback {
      (key: number): boolean
    }

    /**
     * Signal callback interface for `writable-changed`
     */
    interface WritableChangedSignalCallback {
      (key: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.Settings

      /**
       * The name of the context that the settings are stored in.
       */
      backend?: SettingsBackend | null
      /**
       * The path within the backend where the settings are stored.
       */
      path?: string | null
      /**
       * The name of the schema that describes the types of keys
       * for this #GSettings object.
       *
       * The type of this property is *not* #GSettingsSchema.
       * #GSettingsSchema has only existed since version 2.32 and
       * unfortunately this name was used in previous versions to refer to
       * the schema ID rather than the schema itself.  Take care to use the
       * 'settings-schema' property if you wish to pass in a
       * #GSettingsSchema.
       */
      schema?: string | null
      /**
       * The name of the schema that describes the types of keys
       * for this #GSettings object.
       */
      schema_id?: string | null
      /**
       * The #GSettingsSchema describing the types of keys for this
       * #GSettings object.
       *
       * Ideally, this property would be called 'schema'.  #GSettingsSchema
       * has only existed since version 2.32, however, and before then the
       * 'schema' property was used to refer to the ID of the schema rather
       * than the schema itself.  Take care.
       */
      settings_schema?: SettingsSchema | null
    }
  }

  interface Settings {
    // Own properties of Gio-2.0.Gio.Settings

    /**
     * The name of the context that the settings are stored in.
     */
    readonly backend: SettingsBackend
    /**
     * Whether the #GSettings object is in 'delay-apply' mode. See
     * g_settings_delay() for details.
     */
    readonly delayApply: boolean
    /**
     * If this property is %TRUE, the #GSettings object has outstanding
     * changes that will be applied when g_settings_apply() is called.
     */
    readonly hasUnapplied: boolean
    /**
     * The path within the backend where the settings are stored.
     */
    readonly path: string | null
    /**
     * The name of the schema that describes the types of keys
     * for this #GSettings object.
     *
     * The type of this property is *not* #GSettingsSchema.
     * #GSettingsSchema has only existed since version 2.32 and
     * unfortunately this name was used in previous versions to refer to
     * the schema ID rather than the schema itself.  Take care to use the
     * 'settings-schema' property if you wish to pass in a
     * #GSettingsSchema.
     */
    readonly schema: string | null
    /**
     * The name of the schema that describes the types of keys
     * for this #GSettings object.
     */
    readonly schemaId: string | null
    /**
     * The #GSettingsSchema describing the types of keys for this
     * #GSettings object.
     *
     * Ideally, this property would be called 'schema'.  #GSettingsSchema
     * has only existed since version 2.32, however, and before then the
     * 'schema' property was used to refer to the ID of the schema rather
     * than the schema itself.  Take care.
     */
    readonly settingsSchema: SettingsSchema
    __gtype__: number

    // Own fields of Gio-2.0.Gio.Settings

    parentInstance: GObject.Object
    priv: SettingsPrivate

    // Owm methods of Gio-2.0.Gio.Settings

    /**
     * Applies any changes that have been made to the settings.  This
     * function does nothing unless `settings` is in 'delay-apply' mode;
     * see g_settings_delay().  In the normal case settings are always
     * applied immediately.
     */
    apply(): void
    /**
     * Create a binding between the `key` in the `settings` object
     * and the property `property` of `object`.
     *
     * The binding uses the default GIO mapping functions to map
     * between the settings and property values. These functions
     * handle booleans, numeric types and string types in a
     * straightforward way. Use g_settings_bind_with_mapping() if
     * you need a custom mapping, or map between types that are not
     * supported by the default mapping functions.
     *
     * Unless the `flags` include %G_SETTINGS_BIND_NO_SENSITIVITY, this
     * function also establishes a binding between the writability of
     * `key` and the "sensitive" property of `object` (if `object` has
     * a boolean property by that name). See g_settings_bind_writable()
     * for more details about writable bindings.
     *
     * Note that the lifecycle of the binding is tied to `object,`
     * and that you can have only one binding per object property.
     * If you bind the same property twice on the same object, the second
     * binding overrides the first one.
     * @param key the key to bind
     * @param object a #GObject
     * @param property the name of the property to bind
     * @param flags flags for the binding
     */
    bind(
      key: string,
      object: GObject.Object,
      property: string,
      flags: SettingsBindFlags
    ): void
    /**
     * Create a binding between the writability of `key` in the
     * `settings` object and the property `property` of `object`.
     * The property must be boolean; "sensitive" or "visible"
     * properties of widgets are the most likely candidates.
     *
     * Writable bindings are always uni-directional; changes of the
     * writability of the setting will be propagated to the object
     * property, not the other way.
     *
     * When the `inverted` argument is %TRUE, the binding inverts the
     * value as it passes from the setting to the object, i.e. `property`
     * will be set to %TRUE if the key is not writable.
     *
     * Note that the lifecycle of the binding is tied to `object,`
     * and that you can have only one binding per object property.
     * If you bind the same property twice on the same object, the second
     * binding overrides the first one.
     * @param key the key to bind
     * @param object a #GObject
     * @param property the name of a boolean property to bind
     * @param inverted whether to 'invert' the value
     */
    bindWritable(
      key: string,
      object: GObject.Object,
      property: string,
      inverted: boolean
    ): void
    /**
     * Creates a #GAction corresponding to a given #GSettings key.
     *
     * The action has the same name as the key.
     *
     * The value of the key becomes the state of the action and the action
     * is enabled when the key is writable.  Changing the state of the
     * action results in the key being written to.  Changes to the value or
     * writability of the key cause appropriate change notifications to be
     * emitted for the action.
     *
     * For boolean-valued keys, action activations take no parameter and
     * result in the toggling of the value.  For all other types,
     * activations take the new value for the key (which must have the
     * correct type).
     * @param key the name of a key in `settings`
     * @returns a new #GAction
     */
    createAction(key: string): Action
    /**
     * Changes the #GSettings object into 'delay-apply' mode. In this
     * mode, changes to `settings` are not immediately propagated to the
     * backend, but kept locally until g_settings_apply() is called.
     */
    delay(): void
    /**
     * Gets the value that is stored at `key` in `settings`.
     *
     * A convenience variant of g_settings_get() for booleans.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a boolean type in the schema for `settings`.
     * @param key the key to get the value for
     * @returns a boolean
     */
    getBoolean(key: string): boolean
    /**
     * Creates a child settings object which has a base path of
     * `base-path/`name``, where `base-path` is the base path of
     * `settings`.
     *
     * The schema for the child settings object must have been declared
     * in the schema of `settings` using a `<child>` element.
     *
     * The created child settings object will inherit the #GSettings:delay-apply
     * mode from `settings`.
     * @param name the name of the child schema
     * @returns a 'child' settings object
     */
    getChild(name: string): Settings
    /**
     * Gets the "default value" of a key.
     *
     * This is the value that would be read if g_settings_reset() were to be
     * called on the key.
     *
     * Note that this may be a different value than returned by
     * g_settings_schema_key_get_default_value() if the system administrator
     * has provided a default value.
     *
     * Comparing the return values of g_settings_get_default_value() and
     * g_settings_get_value() is not sufficient for determining if a value
     * has been set because the user may have explicitly set the value to
     * something that happens to be equal to the default.  The difference
     * here is that if the default changes in the future, the user's key
     * will still be set.
     *
     * This function may be useful for adding an indication to a UI of what
     * the default value was before the user set it.
     *
     * It is a programmer error to give a `key` that isn't contained in the
     * schema for `settings`.
     * @param key the key to get the default value for
     * @returns the default value
     */
    getDefaultValue(key: string): GLib.Variant | null
    /**
     * Gets the value that is stored at `key` in `settings`.
     *
     * A convenience variant of g_settings_get() for doubles.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a 'double' type in the schema for `settings`.
     * @param key the key to get the value for
     * @returns a double
     */
    getDouble(key: string): number
    /**
     * Gets the value that is stored in `settings` for `key` and converts it
     * to the enum value that it represents.
     *
     * In order to use this function the type of the value must be a string
     * and it must be marked in the schema file as an enumerated type.
     *
     * It is a programmer error to give a `key` that isn't contained in the
     * schema for `settings` or is not marked as an enumerated type.
     *
     * If the value stored in the configuration database is not a valid
     * value for the enumerated type then this function will return the
     * default value.
     * @param key the key to get the value for
     * @returns the enum value
     */
    getEnum(key: string): number
    /**
     * Gets the value that is stored in `settings` for `key` and converts it
     * to the flags value that it represents.
     *
     * In order to use this function the type of the value must be an array
     * of strings and it must be marked in the schema file as a flags type.
     *
     * It is a programmer error to give a `key` that isn't contained in the
     * schema for `settings` or is not marked as a flags type.
     *
     * If the value stored in the configuration database is not a valid
     * value for the flags type then this function will return the default
     * value.
     * @param key the key to get the value for
     * @returns the flags value
     */
    getFlags(key: string): number
    /**
     * Returns whether the #GSettings object has any unapplied
     * changes.  This can only be the case if it is in 'delayed-apply' mode.
     * @returns %TRUE if @settings has unapplied changes
     */
    getHasUnapplied(): boolean
    /**
     * Gets the value that is stored at `key` in `settings`.
     *
     * A convenience variant of g_settings_get() for 32-bit integers.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a int32 type in the schema for `settings`.
     * @param key the key to get the value for
     * @returns an integer
     */
    getInt(key: string): number
    /**
     * Gets the value that is stored at `key` in `settings`.
     *
     * A convenience variant of g_settings_get() for 64-bit integers.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a int64 type in the schema for `settings`.
     * @param key the key to get the value for
     * @returns a 64-bit integer
     */
    getInt64(key: string): number
    /**
     * Gets the value that is stored at `key` in `settings,` subject to
     * application-level validation/mapping.
     *
     * You should use this function when the application needs to perform
     * some processing on the value of the key (for example, parsing).  The
     * `mapping` function performs that processing.  If the function
     * indicates that the processing was unsuccessful (due to a parse error,
     * for example) then the mapping is tried again with another value.
     *
     * This allows a robust 'fall back to defaults' behaviour to be
     * implemented somewhat automatically.
     *
     * The first value that is tried is the user's setting for the key.  If
     * the mapping function fails to map this value, other values may be
     * tried in an unspecified order (system or site defaults, translated
     * schema default values, untranslated schema default values, etc).
     *
     * If the mapping function fails for all possible values, one additional
     * attempt is made: the mapping function is called with a %NULL value.
     * If the mapping function still indicates failure at this point then
     * the application will be aborted.
     *
     * The result parameter for the `mapping` function is pointed to a
     * #gpointer which is initially set to %NULL.  The same pointer is given
     * to each invocation of `mapping`.  The final value of that #gpointer is
     * what is returned by this function.  %NULL is valid; it is returned
     * just as any other value would be.
     * @param key the key to get the value for
     * @param mapping the function to map the value in the           settings database to the value used by the application
     * @returns the result, which may be %NULL
     */
    getMapped(key: string, mapping: SettingsGetMapping): any | null
    /**
     * Queries the range of a key.
     * @param key the key to query the range of
     */
    getRange(key: string): GLib.Variant
    /**
     * Gets the value that is stored at `key` in `settings`.
     *
     * A convenience variant of g_settings_get() for strings.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a string type in the schema for `settings`.
     * @param key the key to get the value for
     * @returns a newly-allocated string
     */
    getString(key: string): string | null
    /**
     * A convenience variant of g_settings_get() for string arrays.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having an array of strings type in the schema for `settings`.
     * @param key the key to get the value for
     * @returns a newly-allocated, %NULL-terminated array of strings, the value that is stored at @key in @settings.
     */
    getStrv(key: string): string[]
    /**
     * Gets the value that is stored at `key` in `settings`.
     *
     * A convenience variant of g_settings_get() for 32-bit unsigned
     * integers.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a uint32 type in the schema for `settings`.
     * @param key the key to get the value for
     * @returns an unsigned integer
     */
    getUint(key: string): number
    /**
     * Gets the value that is stored at `key` in `settings`.
     *
     * A convenience variant of g_settings_get() for 64-bit unsigned
     * integers.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a uint64 type in the schema for `settings`.
     * @param key the key to get the value for
     * @returns a 64-bit unsigned integer
     */
    getUint64(key: string): number
    /**
     * Checks the "user value" of a key, if there is one.
     *
     * The user value of a key is the last value that was set by the user.
     *
     * After calling g_settings_reset() this function should always return
     * %NULL (assuming something is not wrong with the system
     * configuration).
     *
     * It is possible that g_settings_get_value() will return a different
     * value than this function.  This can happen in the case that the user
     * set a value for a key that was subsequently locked down by the system
     * administrator -- this function will return the user's old value.
     *
     * This function may be useful for adding a "reset" option to a UI or
     * for providing indication that a particular value has been changed.
     *
     * It is a programmer error to give a `key` that isn't contained in the
     * schema for `settings`.
     * @param key the key to get the user value for
     * @returns the user's value, if set
     */
    getUserValue(key: string): GLib.Variant | null
    /**
     * Gets the value that is stored in `settings` for `key`.
     *
     * It is a programmer error to give a `key` that isn't contained in the
     * schema for `settings`.
     * @param key the key to get the value for
     * @returns a new #GVariant
     */
    getValue(key: string): GLib.Variant
    /**
     * Finds out if a key can be written or not
     * @param name the name of a key
     * @returns %TRUE if the key @name is writable
     */
    isWritable(name: string): boolean
    /**
     * Gets the list of children on `settings`.
     *
     * The list is exactly the list of strings for which it is not an error
     * to call g_settings_get_child().
     *
     * There is little reason to call this function from "normal" code, since
     * you should already know what children are in your schema. This function
     * may still be useful there for introspection reasons, however.
     *
     * You should free the return value with g_strfreev() when you are done
     * with it.
     * @returns a list of the children    on @settings, in no defined order
     */
    listChildren(): string[]
    /**
     * Introspects the list of keys on `settings`.
     *
     * You should probably not be calling this function from "normal" code
     * (since you should already know what keys are in your schema).  This
     * function is intended for introspection reasons.
     *
     * You should free the return value with g_strfreev() when you are done
     * with it.
     * @returns a list    of the keys on @settings, in no defined order
     */
    listKeys(): string[]
    /**
     * Checks if the given `value` is of the correct type and within the
     * permitted range for `key`.
     * @param key the key to check
     * @param value the value to check
     * @returns %TRUE if @value is valid for @key
     */
    rangeCheck(key: string, value: GLib.Variant): boolean
    /**
     * Resets `key` to its default value.
     *
     * This call resets the key, as much as possible, to its default value.
     * That might be the value specified in the schema or the one set by the
     * administrator.
     * @param key the name of a key
     */
    reset(key: string): void
    /**
     * Reverts all non-applied changes to the settings.  This function
     * does nothing unless `settings` is in 'delay-apply' mode; see
     * g_settings_delay().  In the normal case settings are always applied
     * immediately.
     *
     * Change notifications will be emitted for affected keys.
     */
    revert(): void
    /**
     * Sets `key` in `settings` to `value`.
     *
     * A convenience variant of g_settings_set() for booleans.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a boolean type in the schema for `settings`.
     * @param key the name of the key to set
     * @param value the value to set it to
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setBoolean(key: string, value: boolean): boolean
    /**
     * Sets `key` in `settings` to `value`.
     *
     * A convenience variant of g_settings_set() for doubles.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a 'double' type in the schema for `settings`.
     * @param key the name of the key to set
     * @param value the value to set it to
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setDouble(key: string, value: number): boolean
    /**
     * Looks up the enumerated type nick for `value` and writes it to `key,`
     * within `settings`.
     *
     * It is a programmer error to give a `key` that isn't contained in the
     * schema for `settings` or is not marked as an enumerated type, or for
     * `value` not to be a valid value for the named type.
     *
     * After performing the write, accessing `key` directly with
     * g_settings_get_string() will return the 'nick' associated with
     * `value`.
     * @param key a key, within `settings`
     * @param value an enumerated value
     * @returns %TRUE, if the set succeeds
     */
    setEnum(key: string, value: number): boolean
    /**
     * Looks up the flags type nicks for the bits specified by `value,` puts
     * them in an array of strings and writes the array to `key,` within
     * `settings`.
     *
     * It is a programmer error to give a `key` that isn't contained in the
     * schema for `settings` or is not marked as a flags type, or for `value`
     * to contain any bits that are not value for the named type.
     *
     * After performing the write, accessing `key` directly with
     * g_settings_get_strv() will return an array of 'nicks'; one for each
     * bit in `value`.
     * @param key a key, within `settings`
     * @param value a flags value
     * @returns %TRUE, if the set succeeds
     */
    setFlags(key: string, value: number): boolean
    /**
     * Sets `key` in `settings` to `value`.
     *
     * A convenience variant of g_settings_set() for 32-bit integers.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a int32 type in the schema for `settings`.
     * @param key the name of the key to set
     * @param value the value to set it to
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setInt(key: string, value: number): boolean
    /**
     * Sets `key` in `settings` to `value`.
     *
     * A convenience variant of g_settings_set() for 64-bit integers.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a int64 type in the schema for `settings`.
     * @param key the name of the key to set
     * @param value the value to set it to
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setInt64(key: string, value: number): boolean
    /**
     * Sets `key` in `settings` to `value`.
     *
     * A convenience variant of g_settings_set() for strings.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a string type in the schema for `settings`.
     * @param key the name of the key to set
     * @param value the value to set it to
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setString(key: string, value: string): boolean
    /**
     * Sets `key` in `settings` to `value`.
     *
     * A convenience variant of g_settings_set() for string arrays.  If
     * `value` is %NULL, then `key` is set to be the empty array.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having an array of strings type in the schema for `settings`.
     * @param key the name of the key to set
     * @param value the value to set it to, or %NULL
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setStrv(key: string, value: string[] | null): boolean
    /**
     * Sets `key` in `settings` to `value`.
     *
     * A convenience variant of g_settings_set() for 32-bit unsigned
     * integers.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a uint32 type in the schema for `settings`.
     * @param key the name of the key to set
     * @param value the value to set it to
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setUint(key: string, value: number): boolean
    /**
     * Sets `key` in `settings` to `value`.
     *
     * A convenience variant of g_settings_set() for 64-bit unsigned
     * integers.
     *
     * It is a programmer error to give a `key` that isn't specified as
     * having a uint64 type in the schema for `settings`.
     * @param key the name of the key to set
     * @param value the value to set it to
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setUint64(key: string, value: number): boolean
    /**
     * Sets `key` in `settings` to `value`.
     *
     * It is a programmer error to give a `key` that isn't contained in the
     * schema for `settings` or for `value` to have the incorrect type, per
     * the schema.
     *
     * If `value` is floating then this function consumes the reference.
     * @param key the name of the key to set
     * @param value a #GVariant of the correct type
     * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
     */
    setValue(key: string, value: GLib.Variant): boolean

    // Own virtual methods of Gio-2.0.Gio.Settings

    changeEvent(keys: GLib.Quark, nKeys: number): boolean
    changed(key: string): void
    writableChangeEvent(key: GLib.Quark): boolean
    writableChanged(key: string): void

    // Own signals of Gio-2.0.Gio.Settings

    connect(
      sigName: "change-event",
      callback: Settings.ChangeEventSignalCallback
    ): number
    on(
      sigName: "change-event",
      callback: Settings.ChangeEventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "change-event",
      callback: Settings.ChangeEventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "change-event",
      callback: Settings.ChangeEventSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "change-event", ...args: any[]): void
    connect(
      sigName: "changed",
      callback: Settings.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: Settings.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Settings.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Settings.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "writable-change-event",
      callback: Settings.WritableChangeEventSignalCallback
    ): number
    on(
      sigName: "writable-change-event",
      callback: Settings.WritableChangeEventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "writable-change-event",
      callback: Settings.WritableChangeEventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "writable-change-event",
      callback: Settings.WritableChangeEventSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "writable-change-event", ...args: any[]): void
    connect(
      sigName: "writable-changed",
      callback: Settings.WritableChangedSignalCallback
    ): number
    on(
      sigName: "writable-changed",
      callback: Settings.WritableChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "writable-changed",
      callback: Settings.WritableChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "writable-changed",
      callback: Settings.WritableChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "writable-changed", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.Settings

    connect(
      sigName: "notify::backend",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::backend",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::backend",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::backend",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::backend", ...args: any[]): void
    connect(
      sigName: "notify::delay-apply",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::delay-apply",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::delay-apply",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::delay-apply",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::delay-apply", ...args: any[]): void
    connect(
      sigName: "notify::has-unapplied",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-unapplied",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-unapplied",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-unapplied",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-unapplied", ...args: any[]): void
    connect(sigName: "notify::path", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::path", ...args: any[]): void
    connect(
      sigName: "notify::schema",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::schema",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::schema",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::schema",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::schema", ...args: any[]): void
    connect(
      sigName: "notify::schema-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::schema-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::schema-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::schema-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::schema-id", ...args: any[]): void
    connect(
      sigName: "notify::settings-schema",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::settings-schema",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::settings-schema",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::settings-schema",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::settings-schema", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GSettings` class provides a convenient API for storing and retrieving
   * application settings.
   *
   * Reads and writes can be considered to be non-blocking.  Reading
   * settings with `GSettings` is typically extremely fast: on
   * approximately the same order of magnitude (but slower than) a
   * [struct`GLib`.HashTable] lookup.  Writing settings is also extremely fast in
   * terms of time to return to your application, but can be extremely expensive
   * for other threads and other processes.  Many settings backends
   * (including dconf) have lazy initialisation which means in the common
   * case of the user using their computer without modifying any settings
   * a lot of work can be avoided.  For dconf, the D-Bus service doesn’t
   * even need to be started in this case.  For this reason, you should
   * only ever modify `GSettings` keys in response to explicit user action.
   * Particular care should be paid to ensure that modifications are not
   * made during startup — for example, when setting the initial value
   * of preferences widgets.  The built-in [method`Gio`.Settings.bind]
   * functionality is careful not to write settings in response to notify signals
   * as a result of modifications that it makes to widgets.
   *
   * When creating a `GSettings` instance, you have to specify a schema
   * that describes the keys in your settings and their types and default
   * values, as well as some other information.
   *
   * Normally, a schema has a fixed path that determines where the settings
   * are stored in the conceptual global tree of settings. However, schemas
   * can also be ‘[relocatable](#relocatable-schemas)’, i.e. not equipped with
   * a fixed path. This is
   * useful e.g. when the schema describes an ‘account’, and you want to be
   * able to store a arbitrary number of accounts.
   *
   * Paths must start with and end with a forward slash character (`/`)
   * and must not contain two sequential slash characters.  Paths should
   * be chosen based on a domain name associated with the program or
   * library to which the settings belong.  Examples of paths are
   * `/org/gtk/settings/file-chooser/` and `/ca/desrt/dconf-editor/`.
   * Paths should not start with `/apps/`, `/desktop/` or `/system/` as
   * they often did in GConf.
   *
   * Unlike other configuration systems (like GConf), GSettings does not
   * restrict keys to basic types like strings and numbers. GSettings stores
   * values as [struct`GLib`.Variant], and allows any [type`GLib`.VariantType] for
   * keys. Key names are restricted to lowercase characters, numbers and `-`.
   * Furthermore, the names must begin with a lowercase character, must not end
   * with a `-`, and must not contain consecutive dashes.
   *
   * Similar to GConf, the default values in GSettings schemas can be
   * localized, but the localized values are stored in gettext catalogs
   * and looked up with the domain that is specified in the
   * `gettext-domain` attribute of the `<schemalist>` or `<schema>`
   * elements and the category that is specified in the `l10n` attribute of
   * the `<default>` element. The string which is translated includes all text in
   * the `<default>` element, including any surrounding quotation marks.
   *
   * The `l10n` attribute must be set to `messages` or `time`, and sets the
   * [locale category for
   * translation](https://www.gnu.org/software/gettext/manual/html_node/Aspects.html#index-locale-categories-1).
   * The `messages` category should be used by default; use `time` for
   * translatable date or time formats. A translation comment can be added as an
   * XML comment immediately above the `<default>` element — it is recommended to
   * add these comments to aid translators understand the meaning and
   * implications of the default value. An optional translation `context`
   * attribute can be set on the `<default>` element to disambiguate multiple
   * defaults which use the same string.
   *
   * For example:
   * ```xml
   *  <!-- Translators: A list of words which are not allowed to be typed, in
   *       GVariant serialization syntax.
   *       See: https://developer.gnome.org/glib/stable/gvariant-text.html -->
   *  <default l10n='messages' context='Banned words'>['bad', 'words']</default>
   * ```
   *
   * Translations of default values must remain syntactically valid serialized
   * [struct`GLib`.Variant]s (e.g. retaining any surrounding quotation marks) or
   * runtime errors will occur.
   *
   * GSettings uses schemas in a compact binary form that is created
   * by the [`glib-compile-schemas`](glib-compile-schemas.html)
   * utility. The input is a schema description in an XML format.
   *
   * A DTD for the gschema XML format can be found here:
   * [gschema.dtd](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/gschema.dtd)
   *
   * The [`glib-compile-schemas`](glib-compile-schemas.html) tool expects schema
   * files to have the extension `.gschema.xml`.
   *
   * At runtime, schemas are identified by their ID (as specified in the
   * `id` attribute of the `<schema>` element). The convention for schema
   * IDs is to use a dotted name, similar in style to a D-Bus bus name,
   * e.g. `org.gnome.SessionManager`. In particular, if the settings are
   * for a specific service that owns a D-Bus bus name, the D-Bus bus name
   * and schema ID should match. For schemas which deal with settings not
   * associated with one named application, the ID should not use
   * StudlyCaps, e.g. `org.gnome.font-rendering`.
   *
   * In addition to [struct`GLib`.Variant] types, keys can have types that have
   * enumerated types. These can be described by a `<choice>`,
   * `<enum>` or `<flags>` element, as seen in the
   * second example below. The underlying type of such a key
   * is string, but you can use [method`Gio`.Settings.get_enum],
   * [method`Gio`.Settings.set_enum], [method`Gio`.Settings.get_flags],
   * [method`Gio`.Settings.set_flags] access the numeric values corresponding to
   * the string value of enum and flags keys.
   *
   * An example for default value:
   * ```xml
   * <schemalist>
   *   <schema id="org.gtk.Test" path="/org/gtk/Test/" gettext-domain="test">
   *
   *     <key name="greeting" type="s">
   *       <default l10n="messages">"Hello, earthlings"</default>
   *       <summary>A greeting</summary>
   *       <description>
   *         Greeting of the invading martians
   *       </description>
   *     </key>
   *
   *     <key name="box" type="(ii)">
   *       <default>(20,30)</default>
   *     </key>
   *
   *     <key name="empty-string" type="s">
   *       <default>""</default>
   *       <summary>Empty strings have to be provided in GVariant form</summary>
   *     </key>
   *
   *   </schema>
   * </schemalist>
   * ```
   *
   * An example for ranges, choices and enumerated types:
   * ```xml
   * <schemalist>
   *
   *   <enum id="org.gtk.Test.myenum">
   *     <value nick="first" value="1"/>
   *     <value nick="second" value="2"/>
   *   </enum>
   *
   *   <flags id="org.gtk.Test.myflags">
   *     <value nick="flag1" value="1"/>
   *     <value nick="flag2" value="2"/>
   *     <value nick="flag3" value="4"/>
   *   </flags>
   *
   *   <schema id="org.gtk.Test">
   *
   *     <key name="key-with-range" type="i">
   *       <range min="1" max="100"/>
   *       <default>10</default>
   *     </key>
   *
   *     <key name="key-with-choices" type="s">
   *       <choices>
   *         <choice value='Elisabeth'/>
   *         <choice value='Annabeth'/>
   *         <choice value='Joe'/>
   *       </choices>
   *       <aliases>
   *         <alias value='Anna' target='Annabeth'/>
   *         <alias value='Beth' target='Elisabeth'/>
   *       </aliases>
   *       <default>'Joe'</default>
   *     </key>
   *
   *     <key name='enumerated-key' enum='org.gtk.Test.myenum'>
   *       <default>'first'</default>
   *     </key>
   *
   *     <key name='flags-key' flags='org.gtk.Test.myflags'>
   *       <default>["flag1","flag2"]</default>
   *     </key>
   *   </schema>
   * </schemalist>
   * ```
   *
   * ## Vendor overrides
   *
   * Default values are defined in the schemas that get installed by
   * an application. Sometimes, it is necessary for a vendor or distributor
   * to adjust these defaults. Since patching the XML source for the schema
   * is inconvenient and error-prone,
   * [`glib-compile-schemas`](glib-compile-schemas.html) reads so-called ‘vendor
   * override’ files. These are keyfiles in the same directory as the XML
   * schema sources which can override default values. The schema ID serves
   * as the group name in the key file, and the values are expected in
   * serialized [struct`GLib`.Variant] form, as in the following example:
   * ```
   * [org.gtk.Example]
   * key1='string'
   * key2=1.5
   * ```
   *
   * `glib-compile-schemas` expects schema files to have the extension
   * `.gschema.override`.
   *
   * ## Binding
   *
   * A very convenient feature of GSettings lets you bind [class`GObject`.Object]
   * properties directly to settings, using [method`Gio`.Settings.bind]. Once a
   * [class`GObject`.Object] property has been bound to a setting, changes on
   * either side are automatically propagated to the other side. GSettings handles
   * details like mapping between [class`GObject`.Object] and [struct`GLib`.Variant]
   * types, and preventing infinite cycles.
   *
   * This makes it very easy to hook up a preferences dialog to the
   * underlying settings. To make this even more convenient, GSettings
   * looks for a boolean property with the name `sensitivity` and
   * automatically binds it to the writability of the bound setting.
   * If this ‘magic’ gets in the way, it can be suppressed with the
   * `G_SETTINGS_BIND_NO_SENSITIVITY` flag.
   *
   * ## Relocatable schemas
   *
   * A relocatable schema is one with no `path` attribute specified on its
   * `<schema>` element. By using [ctor`Gio`.Settings.new_with_path], a `GSettings`
   * object can be instantiated for a relocatable schema, assigning a path to the
   * instance. Paths passed to [ctor`Gio`.Settings.new_with_path] will typically be
   * constructed dynamically from a constant prefix plus some form of instance
   * identifier; but they must still be valid GSettings paths. Paths could also
   * be constant and used with a globally installed schema originating from a
   * dependency library.
   *
   * For example, a relocatable schema could be used to store geometry information
   * for different windows in an application. If the schema ID was
   * `org.foo.MyApp.Window`, it could be instantiated for paths
   * `/org/foo/MyApp/main/`, `/org/foo/MyApp/document-1/`,
   * `/org/foo/MyApp/document-2/`, etc. If any of the paths are well-known
   * they can be specified as `<child>` elements in the parent schema, e.g.:
   * ```xml
   * <schema id="org.foo.MyApp" path="/org/foo/MyApp/">
   *   <child name="main" schema="org.foo.MyApp.Window"/>
   * </schema>
   * ```
   *
   * ## Build system integration
   *
   * GSettings comes with autotools integration to simplify compiling and
   * installing schemas. To add GSettings support to an application, add the
   * following to your `configure.ac`:
   * ```
   * GLIB_GSETTINGS
   * ```
   *
   * In the appropriate `Makefile.am`, use the following snippet to compile and
   * install the named schema:
   * ```
   * gsettings_SCHEMAS = org.foo.MyApp.gschema.xml
   * EXTRA_DIST = $(gsettings_SCHEMAS)
   *
   * `GSETTINGS_RULES@`
   * ```
   *
   * No changes are needed to the build system to mark a schema XML file for
   * translation. Assuming it sets the `gettext-domain` attribute, a schema may
   * be marked for translation by adding it to `POTFILES.in`, assuming gettext
   * 0.19 is in use (the preferred method for translation):
   * ```
   * data/org.foo.MyApp.gschema.xml
   * ```
   *
   * Alternatively, if intltool 0.50.1 is in use:
   * ```
   * [type: gettext/gsettings]data/org.foo.MyApp.gschema.xml
   * ```
   *
   * GSettings will use gettext to look up translations for the `<summary>` and
   * `<description>` elements, and also any `<default>` elements which have a
   * `l10n` attribute set. Translations must not be included in the `.gschema.xml`
   * file by the build system, for example by using intltool XML rules with a
   * `.gschema.xml.in` template.
   *
   * If an enumerated type defined in a C header file is to be used in a GSettings
   * schema, it can either be defined manually using an `<enum>` element in the
   * schema XML, or it can be extracted automatically from the C header. This
   * approach is preferred, as it ensures the two representations are always
   * synchronised. To do so, add the following to the relevant `Makefile.am`:
   * ```
   * gsettings_ENUM_NAMESPACE = org.foo.MyApp
   * gsettings_ENUM_FILES = my-app-enums.h my-app-misc.h
   * ```
   *
   * `gsettings_ENUM_NAMESPACE` specifies the schema namespace for the enum files,
   * which are specified in `gsettings_ENUM_FILES`. This will generate a
   * `org.foo.MyApp.enums.xml` file containing the extracted enums, which will be
   * automatically included in the schema compilation, install and uninstall
   * rules. It should not be committed to version control or included in
   * `EXTRA_DIST`.
   * @class
   */
  class Settings extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Settings

    static name: string

    // Constructors of Gio-2.0.Gio.Settings

    constructor(config?: Settings.ConstructorProperties)
    /**
     * Creates a new #GSettings object with the schema specified by
     * `schema_id`.
     *
     * It is an error for the schema to not exist: schemas are an
     * essential part of a program, as they provide type information.
     * If schemas need to be dynamically loaded (for example, from an
     * optional runtime dependency), g_settings_schema_source_lookup()
     * can be used to test for their existence before loading them.
     *
     * Signals on the newly created #GSettings object will be dispatched
     * via the thread-default #GMainContext in effect at the time of the
     * call to g_settings_new().  The new #GSettings will hold a reference
     * on the context.  See g_main_context_push_thread_default().
     * @constructor
     * @param schemaId the id of the schema
     * @returns a new #GSettings object
     */
    constructor(schemaId: string)
    /**
     * Creates a new #GSettings object with the schema specified by
     * `schema_id`.
     *
     * It is an error for the schema to not exist: schemas are an
     * essential part of a program, as they provide type information.
     * If schemas need to be dynamically loaded (for example, from an
     * optional runtime dependency), g_settings_schema_source_lookup()
     * can be used to test for their existence before loading them.
     *
     * Signals on the newly created #GSettings object will be dispatched
     * via the thread-default #GMainContext in effect at the time of the
     * call to g_settings_new().  The new #GSettings will hold a reference
     * on the context.  See g_main_context_push_thread_default().
     * @constructor
     * @param schemaId the id of the schema
     * @returns a new #GSettings object
     */
    static new(schemaId: string): Settings
    /**
     * Creates a new #GSettings object with a given schema, backend and
     * path.
     *
     * It should be extremely rare that you ever want to use this function.
     * It is made available for advanced use-cases (such as plugin systems
     * that want to provide access to schemas loaded from custom locations,
     * etc).
     *
     * At the most basic level, a #GSettings object is a pure composition of
     * 4 things: a #GSettingsSchema, a #GSettingsBackend, a path within that
     * backend, and a #GMainContext to which signals are dispatched.
     *
     * This constructor therefore gives you full control over constructing
     * #GSettings instances.  The first 3 parameters are given directly as
     * `schema,` `backend` and `path,` and the main context is taken from the
     * thread-default (as per g_settings_new()).
     *
     * If `backend` is %NULL then the default backend is used.
     *
     * If `path` is %NULL then the path from the schema is used.  It is an
     * error if `path` is %NULL and the schema has no path of its own or if
     * `path` is non-%NULL and not equal to the path that the schema does
     * have.
     * @constructor
     * @param schema a #GSettingsSchema
     * @param backend a #GSettingsBackend
     * @param path the path to use
     * @returns a new #GSettings object
     */
    static newFull(
      schema: SettingsSchema,
      backend: SettingsBackend | null,
      path: string | null
    ): Settings
    /**
     * Creates a new #GSettings object with the schema specified by
     * `schema_id` and a given #GSettingsBackend.
     *
     * Creating a #GSettings object with a different backend allows accessing
     * settings from a database other than the usual one. For example, it may make
     * sense to pass a backend corresponding to the "defaults" settings database on
     * the system to get a settings object that modifies the system default
     * settings instead of the settings for this user.
     * @constructor
     * @param schemaId the id of the schema
     * @param backend the #GSettingsBackend to use
     * @returns a new #GSettings object
     */
    static newWithBackend(schemaId: string, backend: SettingsBackend): Settings
    /**
     * Creates a new #GSettings object with the schema specified by
     * `schema_id` and a given #GSettingsBackend and path.
     *
     * This is a mix of g_settings_new_with_backend() and
     * g_settings_new_with_path().
     * @constructor
     * @param schemaId the id of the schema
     * @param backend the #GSettingsBackend to use
     * @param path the path to use
     * @returns a new #GSettings object
     */
    static newWithBackendAndPath(
      schemaId: string,
      backend: SettingsBackend,
      path: string
    ): Settings
    /**
     * Creates a new #GSettings object with the relocatable schema specified
     * by `schema_id` and a given path.
     *
     * You only need to do this if you want to directly create a settings
     * object with a schema that doesn't have a specified path of its own.
     * That's quite rare.
     *
     * It is a programmer error to call this function for a schema that
     * has an explicitly specified path.
     *
     * It is a programmer error if `path` is not a valid path.  A valid path
     * begins and ends with '/' and does not contain two consecutive '/'
     * characters.
     * @constructor
     * @param schemaId the id of the schema
     * @param path the path to use
     * @returns a new #GSettings object
     */
    static newWithPath(schemaId: string, path: string): Settings
    _init(config?: Settings.ConstructorProperties): void
    /**
     * Deprecated.
     * @returns a list of   relocatable #GSettings schemas that are available, in no defined order.   The list must not be modified or freed.
     */
    static listRelocatableSchemas(): string[]
    /**
     * Deprecated.
     * @returns a list of   #GSettings schemas that are available, in no defined order.  The list   must not be modified or freed.
     */
    static listSchemas(): string[]
    /**
     * Ensures that all pending operations are complete for the default backend.
     *
     * Writes made to a #GSettings are handled asynchronously.  For this
     * reason, it is very unlikely that the changes have it to disk by the
     * time g_settings_set() returns.
     *
     * This call will block until all of the writes have made it to the
     * backend.  Since the mainloop is not running, no change notifications
     * will be dispatched during this call (but some may be queued by the
     * time the call is done).
     */
    static sync(): void
    /**
     * Removes an existing binding for `property` on `object`.
     *
     * Note that bindings are automatically removed when the
     * object is finalized, so it is rarely necessary to call this
     * function.
     * @param object the object
     * @param property the property whose binding is removed
     */
    static unbind(object: GObject.Object, property: string): void
  }

  module SettingsBackend {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface SettingsBackend {
    // Own properties of Gio-2.0.Gio.SettingsBackend

    __gtype__: number

    // Own fields of Gio-2.0.Gio.SettingsBackend

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.SettingsBackend

    /**
     * Signals that a single key has possibly changed.  Backend
     * implementations should call this if a key has possibly changed its
     * value.
     *
     * `key` must be a valid key (ie starting with a slash, not containing
     * '//', and not ending with a slash).
     *
     * The implementation must call this function during any call to
     * g_settings_backend_write(), before the call returns (except in the
     * case that no keys are actually changed and it cares to detect this
     * fact).  It may not rely on the existence of a mainloop for
     * dispatching the signal later.
     *
     * The implementation may call this function at any other time it likes
     * in response to other events (such as changes occurring outside of the
     * program).  These calls may originate from a mainloop or may originate
     * in response to any other action (including from calls to
     * g_settings_backend_write()).
     *
     * In the case that this call is in response to a call to
     * g_settings_backend_write() then `origin_tag` must be set to the same
     * value that was passed to that call.
     * @param key the name of the key
     * @param originTag the origin tag
     */
    changed(key: string, originTag: any | null): void
    /**
     * This call is a convenience wrapper.  It gets the list of changes from
     * `tree,` computes the longest common prefix and calls
     * g_settings_backend_changed().
     * @param tree a #GTree containing the changes
     * @param originTag the origin tag
     */
    changedTree(tree: GLib.Tree, originTag: any | null): void
    /**
     * Signals that a list of keys have possibly changed.  Backend
     * implementations should call this if keys have possibly changed their
     * values.
     *
     * `path` must be a valid path (ie starting and ending with a slash and
     * not containing '//').  Each string in `items` must form a valid key
     * name when `path` is prefixed to it (ie: each item must not start or
     * end with '/' and must not contain '//').
     *
     * The meaning of this signal is that any of the key names resulting
     * from the contatenation of `path` with each item in `items` may have
     * changed.
     *
     * The same rules for when notifications must occur apply as per
     * g_settings_backend_changed().  These two calls can be used
     * interchangeably if exactly one item has changed (although in that
     * case g_settings_backend_changed() is definitely preferred).
     *
     * For efficiency reasons, the implementation should strive for `path` to
     * be as long as possible (ie: the longest common prefix of all of the
     * keys that were changed) but this is not strictly required.
     * @param path the path containing the changes
     * @param items the %NULL-terminated list of changed keys
     * @param originTag the origin tag
     */
    keysChanged(path: string, items: string[], originTag: any | null): void
    /**
     * Signals that all keys below a given path may have possibly changed.
     * Backend implementations should call this if an entire path of keys
     * have possibly changed their values.
     *
     * `path` must be a valid path (ie starting and ending with a slash and
     * not containing '//').
     *
     * The meaning of this signal is that any of the key which has a name
     * starting with `path` may have changed.
     *
     * The same rules for when notifications must occur apply as per
     * g_settings_backend_changed().  This call might be an appropriate
     * reasponse to a 'reset' call but implementations are also free to
     * explicitly list the keys that were affected by that call if they can
     * easily do so.
     *
     * For efficiency reasons, the implementation should strive for `path` to
     * be as long as possible (ie: the longest common prefix of all of the
     * keys that were changed) but this is not strictly required.  As an
     * example, if this function is called with the path of "/" then every
     * single key in the application will be notified of a possible change.
     * @param path the path containing the changes
     * @param originTag the origin tag
     */
    pathChanged(path: string, originTag: any | null): void
    /**
     * Signals that the writability of all keys below a given path may have
     * changed.
     *
     * Since GSettings performs no locking operations for itself, this call
     * will always be made in response to external events.
     * @param path the name of the path
     */
    pathWritableChanged(path: string): void
    /**
     * Signals that the writability of a single key has possibly changed.
     *
     * Since GSettings performs no locking operations for itself, this call
     * will always be made in response to external events.
     * @param key the name of the key
     */
    writableChanged(key: string): void

    // Own virtual methods of Gio-2.0.Gio.SettingsBackend

    /**
     * virtual method to get if a key is writable
     * @virtual
     * @param key
     */
    getWritable(key: string): boolean
    /**
     * virtual method to read a key's value
     * @virtual
     * @param key
     * @param expectedType
     * @param defaultValue
     */
    read(
      key: string,
      expectedType: GLib.VariantType,
      defaultValue: boolean
    ): GLib.Variant
    /**
     * virtual method to read user's key value
     * @virtual
     * @param key
     * @param expectedType
     */
    readUserValue(key: string, expectedType: GLib.VariantType): GLib.Variant
    /**
     * virtual method to reset state
     * @virtual
     * @param key
     * @param originTag
     */
    reset(key: string, originTag: any | null): void
    /**
     * virtual method to subscribe to key changes
     * @virtual
     * @param name
     */
    subscribe(name: string): void
    /**
     * virtual method to sync state
     * @virtual
     */
    sync(): void
    /**
     * virtual method to unsubscribe to key changes
     * @virtual
     * @param name
     */
    unsubscribe(name: string): void
    /**
     * virtual method to change key's value
     * @virtual
     * @param key
     * @param value
     * @param originTag
     */
    write(key: string, value: GLib.Variant, originTag: any | null): boolean
    /**
     * virtual method to change a tree of keys
     * @virtual
     * @param tree
     * @param originTag
     */
    writeTree(tree: GLib.Tree, originTag: any | null): boolean

    // Class property signals of Gio-2.0.Gio.SettingsBackend

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GSettingsBackend` interface defines a generic interface for
   * non-strictly-typed data that is stored in a hierarchy. To implement
   * an alternative storage backend for [class`Gio`.Settings], you need to
   * implement the `GSettingsBackend` interface and then make it implement the
   * extension point `G_SETTINGS_BACKEND_EXTENSION_POINT_NAME`.
   *
   * The interface defines methods for reading and writing values, a
   * method for determining if writing of certain values will fail
   * (lockdown) and a change notification mechanism.
   *
   * The semantics of the interface are very precisely defined and
   * implementations must carefully adhere to the expectations of
   * callers that are documented on each of the interface methods.
   *
   * Some of the `GSettingsBackend` functions accept or return a
   * [struct`GLib`.Tree]. These trees always have strings as keys and
   * [struct`GLib`.Variant] as values.
   *
   * The `GSettingsBackend` API is exported to allow third-party
   * implementations, but does not carry the same stability guarantees
   * as the public GIO API. For this reason, you have to define the
   * C preprocessor symbol `G_SETTINGS_ENABLE_BACKEND` before including
   * `gio/gsettingsbackend.h`.
   * @class
   */
  class SettingsBackend extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SettingsBackend

    static name: string

    // Constructors of Gio-2.0.Gio.SettingsBackend

    constructor(config?: SettingsBackend.ConstructorProperties)
    _init(config?: SettingsBackend.ConstructorProperties): void
    /**
     * Calculate the longest common prefix of all keys in a tree and write
     * out an array of the key names relative to that prefix and,
     * optionally, the value to store at each of those keys.
     *
     * You must free the value returned in `path,` `keys` and `values` using
     * g_free().  You should not attempt to free or unref the contents of
     * `keys` or `values`.
     * @param tree a #GTree containing the changes
     */
    static flattenTree(
      tree: GLib.Tree
    ): [
      /* path */ string | null,
      /* keys */ string[],
      /* values */ GLib.Variant[],
    ]
    /**
     * Returns the default #GSettingsBackend. It is possible to override
     * the default by setting the `GSETTINGS_BACKEND` environment variable
     * to the name of a settings backend.
     *
     * The user gets a reference to the backend.
     * @returns the default #GSettingsBackend,     which will be a dummy (memory) settings backend if no other settings     backend is available.
     */
    static getDefault(): SettingsBackend
  }

  module SimpleAction {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (parameter: GLib.Variant | null): void
    }

    /**
     * Signal callback interface for `change-state`
     */
    interface ChangeStateSignalCallback {
      (value: GLib.Variant | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Action.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.SimpleAction

      /**
       * If `action` is currently enabled.
       *
       * If the action is disabled then calls to g_action_activate() and
       * g_action_change_state() have no effect.
       */
      enabled?: boolean | null
      /**
       * The name of the action. This is mostly meaningful for identifying
       * the action once it has been added to a #GSimpleActionGroup.
       */
      name?: string | null
      /**
       * The type of the parameter that must be given when activating the
       * action.
       */
      parameter_type?: GLib.VariantType | null
      /**
       * The state of the action, or %NULL if the action is stateless.
       */
      state?: GLib.Variant | null
    }
  }

  interface SimpleAction extends Action {
    // Own properties of Gio-2.0.Gio.SimpleAction

    /**
     * If `action` is currently enabled.
     *
     * If the action is disabled then calls to g_action_activate() and
     * g_action_change_state() have no effect.
     */
    enabled: any
    /**
     * The name of the action. This is mostly meaningful for identifying
     * the action once it has been added to a #GSimpleActionGroup.
     */
    readonly name: string | null
    /**
     * The type of the parameter that must be given when activating the
     * action.
     */
    readonly parameterType: GLib.VariantType
    /**
     * The state of the action, or %NULL if the action is stateless.
     */
    state: any
    /**
     * The #GVariantType of the state that the action has, or %NULL if the
     * action is stateless.
     */
    readonly stateType: GLib.VariantType
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.SimpleAction

    /**
     * Sets the action as enabled or not.
     *
     * An action must be enabled in order to be activated or in order to
     * have its state changed from outside callers.
     *
     * This should only be called by the implementor of the action.  Users
     * of the action should not attempt to modify its enabled flag.
     * @param enabled whether the action is enabled
     */
    setEnabled(enabled: boolean): void
    /**
     * Sets the state of the action.
     *
     * This directly updates the 'state' property to the given value.
     *
     * This should only be called by the implementor of the action.  Users
     * of the action should not attempt to directly modify the 'state'
     * property.  Instead, they should call g_action_change_state() to
     * request the change.
     *
     * If the `value` GVariant is floating, it is consumed.
     * @param value the new #GVariant for the state
     */
    setState(value: GLib.Variant): void
    /**
     * Sets the state hint for the action.
     *
     * See g_action_get_state_hint() for more information about
     * action state hints.
     * @param stateHint a #GVariant representing the state hint
     */
    setStateHint(stateHint: GLib.Variant | null): void

    // Own signals of Gio-2.0.Gio.SimpleAction

    connect(
      sigName: "activate",
      callback: SimpleAction.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: SimpleAction.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: SimpleAction.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: SimpleAction.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "change-state",
      callback: SimpleAction.ChangeStateSignalCallback
    ): number
    on(
      sigName: "change-state",
      callback: SimpleAction.ChangeStateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "change-state",
      callback: SimpleAction.ChangeStateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "change-state",
      callback: SimpleAction.ChangeStateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "change-state", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.SimpleAction

    connect(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enabled", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parameter-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parameter-type", ...args: any[]): void
    connect(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state", ...args: any[]): void
    connect(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state-type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GSimpleAction` is the obvious simple implementation of the
   * [iface`Gio`.Action] interface. This is the easiest way to create an action for
   * purposes of adding it to a [class`Gio`.SimpleActionGroup].
   * @class
   */
  class SimpleAction extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SimpleAction

    static name: string

    // Constructors of Gio-2.0.Gio.SimpleAction

    constructor(config?: SimpleAction.ConstructorProperties)
    /**
     * Creates a new action.
     *
     * The created action is stateless. See g_simple_action_new_stateful() to create
     * an action that has state.
     * @constructor
     * @param name the name of the action
     * @param parameterType the type of parameter that will be passed to   handlers for the #GSimpleAction::activate signal, or %NULL for no parameter
     * @returns a new #GSimpleAction
     */
    constructor(name: string, parameterType: GLib.VariantType | null)
    /**
     * Creates a new action.
     *
     * The created action is stateless. See g_simple_action_new_stateful() to create
     * an action that has state.
     * @constructor
     * @param name the name of the action
     * @param parameterType the type of parameter that will be passed to   handlers for the #GSimpleAction::activate signal, or %NULL for no parameter
     * @returns a new #GSimpleAction
     */
    static new(
      name: string,
      parameterType: GLib.VariantType | null
    ): SimpleAction
    /**
     * Creates a new stateful action.
     *
     * All future state values must have the same #GVariantType as the initial
     * `state`.
     *
     * If the `state` #GVariant is floating, it is consumed.
     * @constructor
     * @param name the name of the action
     * @param parameterType the type of the parameter that will be passed to   handlers for the #GSimpleAction::activate signal, or %NULL for no parameter
     * @param state the initial state of the action
     * @returns a new #GSimpleAction
     */
    static newStateful(
      name: string,
      parameterType: GLib.VariantType | null,
      state: GLib.Variant
    ): SimpleAction
    _init(config?: SimpleAction.ConstructorProperties): void
  }

  module SimpleActionGroup {
    // Constructor properties interface

    interface ConstructorProperties
      extends ActionGroup.ConstructorProperties,
        ActionMap.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface SimpleActionGroup extends ActionGroup, ActionMap {
    // Own properties of Gio-2.0.Gio.SimpleActionGroup

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.SimpleActionGroup

    /**
     * A convenience function for creating multiple #GSimpleAction instances
     * and adding them to the action group.
     * @param entries a pointer to the first item in           an array of #GActionEntry structs
     * @param userData the user data for signal connections
     */
    addEntries(entries: ActionEntry[], userData: any | null): void
    /**
     * Adds an action to the action group.
     *
     * If the action group already contains an action with the same name as
     * `action` then the old action is dropped from the group.
     *
     * The action group takes its own reference on `action`.
     * @param action a #GAction
     */
    insert(action: Action): void
    /**
     * Looks up the action with the name `action_name` in the group.
     *
     * If no such action exists, returns %NULL.
     * @param actionName the name of an action
     * @returns a #GAction, or %NULL
     */
    lookup(actionName: string): Action
    /**
     * Removes the named action from the action group.
     *
     * If no action of this name is in the group then nothing happens.
     * @param actionName the name of the action
     */
    remove(actionName: string): void

    // Class property signals of Gio-2.0.Gio.SimpleActionGroup

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSimpleActionGroup` is a hash table filled with [iface`Gio`.Action] objects,
   * implementing the [iface`Gio`.ActionGroup] and [iface`Gio`.ActionMap]
   * interfaces.
   * @class
   */
  class SimpleActionGroup extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SimpleActionGroup

    static name: string

    // Constructors of Gio-2.0.Gio.SimpleActionGroup

    constructor(config?: SimpleActionGroup.ConstructorProperties)
    /**
     * Creates a new, empty, #GSimpleActionGroup.
     * @constructor
     * @returns a new #GSimpleActionGroup
     */
    constructor()
    /**
     * Creates a new, empty, #GSimpleActionGroup.
     * @constructor
     * @returns a new #GSimpleActionGroup
     */
    static new(): SimpleActionGroup
    _init(config?: SimpleActionGroup.ConstructorProperties): void
  }

  module SimpleAsyncResult {
    // Constructor properties interface

    interface ConstructorProperties
      extends AsyncResult.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface SimpleAsyncResult extends AsyncResult {
    // Own properties of Gio-2.0.Gio.SimpleAsyncResult

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.SimpleAsyncResult

    /**
     * Completes an asynchronous I/O job immediately. Must be called in
     * the thread where the asynchronous result was to be delivered, as it
     * invokes the callback directly. If you are in a different thread use
     * g_simple_async_result_complete_in_idle().
     *
     * Calling this function takes a reference to `simple` for as long as
     * is needed to complete the call.
     */
    complete(): void
    /**
     * Completes an asynchronous function in an idle handler in the
     * [thread-default main context][g-main-context-push-thread-default]
     * of the thread that `simple` was initially created in
     * (and re-pushes that context around the invocation of the callback).
     *
     * Calling this function takes a reference to `simple` for as long as
     * is needed to complete the call.
     */
    completeInIdle(): void
    /**
     * Gets the operation result boolean from within the asynchronous result.
     * @returns %TRUE if the operation's result was %TRUE, %FALSE     if the operation's result was %FALSE.
     */
    getOpResGboolean(): boolean
    /**
     * Gets a gssize from the asynchronous result.
     * @returns a gssize returned from the asynchronous function.
     */
    getOpResGssize(): number
    /**
     * Propagates an error from within the simple asynchronous result to
     * a given destination.
     *
     * If the #GCancellable given to a prior call to
     * g_simple_async_result_set_check_cancellable() is cancelled then this
     * function will return %TRUE with `dest` set appropriately.
     * @returns %TRUE if the error was propagated to @dest. %FALSE otherwise.
     */
    propagateError(): boolean
    /**
     * Sets a #GCancellable to check before dispatching results.
     *
     * This function has one very specific purpose: the provided cancellable
     * is checked at the time of g_simple_async_result_propagate_error() If
     * it is cancelled, these functions will return an "Operation was
     * cancelled" error (%G_IO_ERROR_CANCELLED).
     *
     * Implementors of cancellable asynchronous functions should use this in
     * order to provide a guarantee to their callers that cancelling an
     * async operation will reliably result in an error being returned for
     * that operation (even if a positive result for the operation has
     * already been sent as an idle to the main context to be dispatched).
     *
     * The checking described above is done regardless of any call to the
     * unrelated g_simple_async_result_set_handle_cancellation() function.
     * @param checkCancellable a #GCancellable to check, or %NULL to unset
     */
    setCheckCancellable(checkCancellable: Cancellable | null): void
    /**
     * Sets the result from a #GError.
     * @param error #GError.
     */
    setFromError(error: GLib.Error): void
    /**
     * Sets whether to handle cancellation within the asynchronous operation.
     *
     * This function has nothing to do with
     * g_simple_async_result_set_check_cancellable().  It only refers to the
     * #GCancellable passed to g_simple_async_result_run_in_thread().
     * @param handleCancellation a #gboolean.
     */
    setHandleCancellation(handleCancellation: boolean): void
    /**
     * Sets the operation result to a boolean within the asynchronous result.
     * @param opRes a #gboolean.
     */
    setOpResGboolean(opRes: boolean): void
    /**
     * Sets the operation result within the asynchronous result to
     * the given `op_res`.
     * @param opRes a #gssize.
     */
    setOpResGssize(opRes: number): void

    // Class property signals of Gio-2.0.Gio.SimpleAsyncResult

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * As of GLib 2.46, `GSimpleAsyncResult` is deprecated in favor of
   * [class`Gio`.Task], which provides a simpler API.
   *
   * `GSimpleAsyncResult` implements [iface`Gio`.AsyncResult].
   *
   * `GSimpleAsyncResult` handles [type`Gio`.AsyncReadyCallback]s, error
   * reporting, operation cancellation and the final state of an operation,
   * completely transparent to the application. Results can be returned
   * as a pointer e.g. for functions that return data that is collected
   * asynchronously, a boolean value for checking the success or failure
   * of an operation, or a `gssize` for operations which return the number
   * of bytes modified by the operation; all of the simple return cases
   * are covered.
   *
   * Most of the time, an application will not need to know of the details
   * of this API; it is handled transparently, and any necessary operations
   * are handled by [iface`Gio`.AsyncResult]’s interface. However, if implementing
   * a new GIO module, for writing language bindings, or for complex
   * applications that need better control of how asynchronous operations
   * are completed, it is important to understand this functionality.
   *
   * `GSimpleAsyncResult`s are tagged with the calling function to ensure
   * that asynchronous functions and their finishing functions are used
   * together correctly.
   *
   * To create a new `GSimpleAsyncResult`, call [ctor`Gio`.SimpleAsyncResult.new].
   * If the result needs to be created for a `GError`, use
   * [ctor`Gio`.SimpleAsyncResult.new_from_error] or
   * [ctor`Gio`.SimpleAsyncResult.new_take_error]. If a `GError` is not available
   * (e.g. the asynchronous operation doesn’t take a `GError` argument),
   * but the result still needs to be created for an error condition, use
   * [ctor`Gio`.SimpleAsyncResult.new_error] (or
   * [method`Gio`.SimpleAsyncResult.set_error_va] if your application or binding
   * requires passing a variable argument list directly), and the error can then
   * be propagated through the use of
   * [method`Gio`.SimpleAsyncResult.propagate_error].
   *
   * An asynchronous operation can be made to ignore a cancellation event by
   * calling [method`Gio`.SimpleAsyncResult.set_handle_cancellation] with a
   * `GSimpleAsyncResult` for the operation and `FALSE`. This is useful for
   * operations that are dangerous to cancel, such as close (which would
   * cause a leak if cancelled before being run).
   *
   * `GSimpleAsyncResult` can integrate into GLib’s event loop,
   * [type`GLib`.MainLoop], or it can use [type`GLib`.Thread]s.
   * [method`Gio`.SimpleAsyncResult.complete] will finish an I/O task directly
   * from the point where it is called.
   * [method`Gio`.SimpleAsyncResult.complete_in_idle] will finish it from an idle
   * handler in the  thread-default main context (see
   * [method`GLib`.MainContext.push_thread_default]) where the `GSimpleAsyncResult`
   * was created. [method`Gio`.SimpleAsyncResult.run_in_thread] will run the job in
   * a separate thread and then use
   * [method`Gio`.SimpleAsyncResult.complete_in_idle] to deliver the result.
   *
   * To set the results of an asynchronous function,
   * [method`Gio`.SimpleAsyncResult.set_op_res_gpointer],
   * [method`Gio`.SimpleAsyncResult.set_op_res_gboolean], and
   * [method`Gio`.SimpleAsyncResult.set_op_res_gssize]
   * are provided, setting the operation's result to a `gpointer`, `gboolean`, or
   * `gssize`, respectively.
   *
   * Likewise, to get the result of an asynchronous function,
   * [method`Gio`.SimpleAsyncResult.get_op_res_gpointer],
   * [method`Gio`.SimpleAsyncResult.get_op_res_gboolean], and
   * [method`Gio`.SimpleAsyncResult.get_op_res_gssize] are
   * provided, getting the operation’s result as a `gpointer`, `gboolean`, and
   * `gssize`, respectively.
   *
   * For the details of the requirements implementations must respect, see
   * [iface`Gio`.AsyncResult].  A typical implementation of an asynchronous
   * operation using `GSimpleAsyncResult` looks something like this:
   *
   * ```c
   * static void
   * baked_cb (Cake    *cake,
   *           gpointer user_data)
   * {
   *   // In this example, this callback is not given a reference to the cake,
   *   // so the GSimpleAsyncResult has to take a reference to it.
   *   GSimpleAsyncResult *result = user_data;
   *
   *   if (cake == NULL)
   *     g_simple_async_result_set_error (result,
   *                                      BAKER_ERRORS,
   *                                      BAKER_ERROR_NO_FLOUR,
   *                                      "Go to the supermarket");
   *   else
   *     g_simple_async_result_set_op_res_gpointer (result,
   *                                                g_object_ref (cake),
   *                                                g_object_unref);
   *
   *
   *   // In this example, we assume that baked_cb is called as a callback from
   *   // the mainloop, so it's safe to complete the operation synchronously here.
   *   // If, however, _baker_prepare_cake () might call its callback without
   *   // first returning to the mainloop — inadvisable, but some APIs do so —
   *   // we would need to use g_simple_async_result_complete_in_idle().
   *   g_simple_async_result_complete (result);
   *   g_object_unref (result);
   * }
   *
   * void
   * baker_bake_cake_async (Baker              *self,
   *                        guint               radius,
   *                        GAsyncReadyCallback callback,
   *                        gpointer            user_data)
   * {
   *   GSimpleAsyncResult *simple;
   *   Cake               *cake;
   *
   *   if (radius < 3)
   *     {
   *       g_simple_async_report_error_in_idle (G_OBJECT (self),
   *                                            callback,
   *                                            user_data,
   *                                            BAKER_ERRORS,
   *                                            BAKER_ERROR_TOO_SMALL,
   *                                            "%ucm radius cakes are silly",
   *                                            radius);
   *       return;
   *     }
   *
   *   simple = g_simple_async_result_new (G_OBJECT (self),
   *                                       callback,
   *                                       user_data,
   *                                       baker_bake_cake_async);
   *   cake = _baker_get_cached_cake (self, radius);
   *
   *   if (cake != NULL)
   *     {
   *       g_simple_async_result_set_op_res_gpointer (simple,
   *                                                  g_object_ref (cake),
   *                                                  g_object_unref);
   *       g_simple_async_result_complete_in_idle (simple);
   *       g_object_unref (simple);
   *       // Drop the reference returned by _baker_get_cached_cake();
   *       // the GSimpleAsyncResult has taken its own reference.
   *       g_object_unref (cake);
   *       return;
   *     }
   *
   *   _baker_prepare_cake (self, radius, baked_cb, simple);
   * }
   *
   * Cake *
   * baker_bake_cake_finish (Baker        *self,
   *                         GAsyncResult *result,
   *                         GError      **error)
   * {
   *   GSimpleAsyncResult *simple;
   *   Cake               *cake;
   *
   *   g_return_val_if_fail (g_simple_async_result_is_valid (result,
   *                                                         G_OBJECT (self),
   *                                                         baker_bake_cake_async),
   *                         NULL);
   *
   *   simple = (GSimpleAsyncResult *) result;
   *
   *   if (g_simple_async_result_propagate_error (simple, error))
   *     return NULL;
   *
   *   cake = CAKE (g_simple_async_result_get_op_res_gpointer (simple));
   *   return g_object_ref (cake);
   * }
   * ```
   * @class
   */
  class SimpleAsyncResult extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SimpleAsyncResult

    static name: string

    // Constructors of Gio-2.0.Gio.SimpleAsyncResult

    constructor(config?: SimpleAsyncResult.ConstructorProperties)
    /**
     * Creates a #GSimpleAsyncResult.
     *
     * The common convention is to create the #GSimpleAsyncResult in the
     * function that starts the asynchronous operation and use that same
     * function as the `source_tag`.
     *
     * If your operation supports cancellation with #GCancellable (which it
     * probably should) then you should provide the user's cancellable to
     * g_simple_async_result_set_check_cancellable() immediately after
     * this function returns.
     * @constructor
     * @param sourceObject a #GObject, or %NULL.
     * @param callback a #GAsyncReadyCallback.
     * @param sourceTag the asynchronous function.
     * @returns a #GSimpleAsyncResult.
     */
    constructor(
      sourceObject: GObject.Object | null,
      callback: AsyncReadyCallback | null,
      sourceTag: any | null
    )
    /**
     * Creates a #GSimpleAsyncResult.
     *
     * The common convention is to create the #GSimpleAsyncResult in the
     * function that starts the asynchronous operation and use that same
     * function as the `source_tag`.
     *
     * If your operation supports cancellation with #GCancellable (which it
     * probably should) then you should provide the user's cancellable to
     * g_simple_async_result_set_check_cancellable() immediately after
     * this function returns.
     * @constructor
     * @param sourceObject a #GObject, or %NULL.
     * @param callback a #GAsyncReadyCallback.
     * @param sourceTag the asynchronous function.
     * @returns a #GSimpleAsyncResult.
     */
    static new(
      sourceObject: GObject.Object | null,
      callback: AsyncReadyCallback | null,
      sourceTag: any | null
    ): SimpleAsyncResult
    /**
     * Creates a #GSimpleAsyncResult from an error condition.
     * @constructor
     * @param sourceObject a #GObject, or %NULL.
     * @param callback a #GAsyncReadyCallback.
     * @param error a #GError
     * @returns a #GSimpleAsyncResult.
     */
    static newFromError(
      sourceObject: GObject.Object | null,
      callback: AsyncReadyCallback | null,
      error: GLib.Error
    ): SimpleAsyncResult
    _init(config?: SimpleAsyncResult.ConstructorProperties): void
    /**
     * Ensures that the data passed to the _finish function of an async
     * operation is consistent.  Three checks are performed.
     *
     * First, `result` is checked to ensure that it is really a
     * #GSimpleAsyncResult.  Second, `source` is checked to ensure that it
     * matches the source object of `result`.  Third, `source_tag` is
     * checked to ensure that it is equal to the `source_tag` argument given
     * to g_simple_async_result_new() (which, by convention, is a pointer
     * to the _async function corresponding to the _finish function from
     * which this function is called).  (Alternatively, if either
     * `source_tag` or `result'`s source tag is %NULL, then the source tag
     * check is skipped.)
     * @param result the #GAsyncResult passed to the _finish function.
     * @param source the #GObject passed to the _finish function.
     * @param sourceTag the asynchronous function.
     * @returns #TRUE if all checks passed or #FALSE if any failed.
     */
    static isValid(
      result: AsyncResult,
      source: GObject.Object | null,
      sourceTag: any | null
    ): boolean
  }

  module SimpleIOStream {
    // Constructor properties interface

    interface ConstructorProperties extends IOStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.SimpleIOStream

      /**
       * The [class`Gio`.InputStream] to read from.
       */
      input_stream?: InputStream | null
      /**
       * The [class`Gio`.OutputStream] to write to.
       */
      output_stream?: OutputStream | null
    }
  }

  interface SimpleIOStream {
    // Own properties of Gio-2.0.Gio.SimpleIOStream

    /**
     * The [class`Gio`.InputStream] to read from.
     */
    readonly inputStream: InputStream
    /**
     * The [class`Gio`.OutputStream] to write to.
     */
    readonly outputStream: OutputStream
    __gtype__: number

    // Class property signals of Gio-2.0.Gio.SimpleIOStream

    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::output-stream", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSimpleIOStream` creates a [class`Gio`.IOStream] from an arbitrary
   * [class`Gio`.InputStream] and [class`Gio`.OutputStream]. This allows any pair of
   * input and output streams to be used with [class`Gio`.IOStream] methods.
   *
   * This is useful when you obtained a [class`Gio`.InputStream] and a
   * [class`Gio`.OutputStream] by other means, for instance creating them with
   * platform specific methods as
   * [`g_unix_input_stream_new()`](../gio-unix/ctor.UnixInputStream.new.html)
   * (from `gio-unix-2.0.pc` / `GioUnix-2.0`), and you want to
   * take advantage of the methods provided by [class`Gio`.IOStream].
   * @class
   */
  class SimpleIOStream extends IOStream {
    // Own properties of Gio-2.0.Gio.SimpleIOStream

    static name: string

    // Constructors of Gio-2.0.Gio.SimpleIOStream

    constructor(config?: SimpleIOStream.ConstructorProperties)
    /**
     * Creates a new #GSimpleIOStream wrapping `input_stream` and `output_stream`.
     * See also #GIOStream.
     * @constructor
     * @param inputStream a #GInputStream.
     * @param outputStream a #GOutputStream.
     * @returns a new #GSimpleIOStream instance.
     */
    constructor(inputStream: InputStream, outputStream: OutputStream)
    /**
     * Creates a new #GSimpleIOStream wrapping `input_stream` and `output_stream`.
     * See also #GIOStream.
     * @constructor
     * @param inputStream a #GInputStream.
     * @param outputStream a #GOutputStream.
     * @returns a new #GSimpleIOStream instance.
     */
    static new(
      inputStream: InputStream,
      outputStream: OutputStream
    ): SimpleIOStream
    _init(config?: SimpleIOStream.ConstructorProperties): void
  }

  module SimplePermission {
    // Constructor properties interface

    interface ConstructorProperties extends Permission.ConstructorProperties {}
  }

  interface SimplePermission {
    // Own properties of Gio-2.0.Gio.SimplePermission

    __gtype__: number

    // Class property signals of Gio-2.0.Gio.SimplePermission

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::allowed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::allowed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::allowed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::allowed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::allowed", ...args: any[]): void
    connect(
      sigName: "notify::can-acquire",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-acquire",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-acquire",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-acquire",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-acquire", ...args: any[]): void
    connect(
      sigName: "notify::can-release",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-release",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-release",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-release",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-release", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSimplePermission` is a trivial implementation of [class`Gio`.Permission]
   * that represents a permission that is either always or never allowed.  The
   * value is given at construction and doesn’t change.
   *
   * Calling [method`Gio`.Permission.acquire] or [method`Gio`.Permission.release]
   * on a `GSimplePermission` will result in errors.
   * @class
   */
  class SimplePermission extends Permission {
    // Own properties of Gio-2.0.Gio.SimplePermission

    static name: string

    // Constructors of Gio-2.0.Gio.SimplePermission

    constructor(config?: SimplePermission.ConstructorProperties)
    /**
     * Creates a new #GPermission instance that represents an action that is
     * either always or never allowed.
     * @constructor
     * @param allowed %TRUE if the action is allowed
     * @returns the #GSimplePermission, as a #GPermission
     */
    constructor(allowed: boolean)
    /**
     * Creates a new #GPermission instance that represents an action that is
     * either always or never allowed.
     * @constructor
     * @param allowed %TRUE if the action is allowed
     * @returns the #GSimplePermission, as a #GPermission
     */
    static new(allowed: boolean): SimplePermission
    _init(config?: SimplePermission.ConstructorProperties): void
  }

  module SimpleProxyResolver {
    // Constructor properties interface

    interface ConstructorProperties
      extends ProxyResolver.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.SimpleProxyResolver

      /**
       * The default proxy URI that will be used for any URI that doesn't
       * match #GSimpleProxyResolver:ignore-hosts, and doesn't match any
       * of the schemes set with g_simple_proxy_resolver_set_uri_proxy().
       *
       * Note that as a special case, if this URI starts with
       * "socks://", #GSimpleProxyResolver will treat it as referring
       * to all three of the socks5, socks4a, and socks4 proxy types.
       */
      default_proxy?: string | null
      /**
       * A list of hostnames and IP addresses that the resolver should
       * allow direct connections to.
       *
       * Entries can be in one of 4 formats:
       *
       * - A hostname, such as "example.com", ".example.com", or
       *   "*.example.com", any of which match "example.com" or
       *   any subdomain of it.
       *
       * - An IPv4 or IPv6 address, such as "192.168.1.1",
       *   which matches only that address.
       *
       * - A hostname or IP address followed by a port, such as
       *   "example.com:80", which matches whatever the hostname or IP
       *   address would match, but only for URLs with the (explicitly)
       *   indicated port. In the case of an IPv6 address, the address
       *   part must appear in brackets: "[::1]:443"
       *
       * - An IP address range, given by a base address and prefix length,
       *   such as "fe80::/10", which matches any address in that range.
       *
       * Note that when dealing with Unicode hostnames, the matching is
       * done against the ASCII form of the name.
       *
       * Also note that hostname exclusions apply only to connections made
       * to hosts identified by name, and IP address exclusions apply only
       * to connections made to hosts identified by address. That is, if
       * example.com has an address of 192.168.1.1, and the :ignore-hosts list
       * contains only "192.168.1.1", then a connection to "example.com"
       * (eg, via a #GNetworkAddress) will use the proxy, and a connection to
       * "192.168.1.1" (eg, via a #GInetSocketAddress) will not.
       *
       * These rules match the "ignore-hosts"/"noproxy" rules most
       * commonly used by other applications.
       */
      ignore_hosts?: string[] | null
    }
  }

  interface SimpleProxyResolver extends ProxyResolver {
    // Own properties of Gio-2.0.Gio.SimpleProxyResolver

    /**
     * The default proxy URI that will be used for any URI that doesn't
     * match #GSimpleProxyResolver:ignore-hosts, and doesn't match any
     * of the schemes set with g_simple_proxy_resolver_set_uri_proxy().
     *
     * Note that as a special case, if this URI starts with
     * "socks://", #GSimpleProxyResolver will treat it as referring
     * to all three of the socks5, socks4a, and socks4 proxy types.
     */
    defaultProxy: string | null
    /**
     * A list of hostnames and IP addresses that the resolver should
     * allow direct connections to.
     *
     * Entries can be in one of 4 formats:
     *
     * - A hostname, such as "example.com", ".example.com", or
     *   "*.example.com", any of which match "example.com" or
     *   any subdomain of it.
     *
     * - An IPv4 or IPv6 address, such as "192.168.1.1",
     *   which matches only that address.
     *
     * - A hostname or IP address followed by a port, such as
     *   "example.com:80", which matches whatever the hostname or IP
     *   address would match, but only for URLs with the (explicitly)
     *   indicated port. In the case of an IPv6 address, the address
     *   part must appear in brackets: "[::1]:443"
     *
     * - An IP address range, given by a base address and prefix length,
     *   such as "fe80::/10", which matches any address in that range.
     *
     * Note that when dealing with Unicode hostnames, the matching is
     * done against the ASCII form of the name.
     *
     * Also note that hostname exclusions apply only to connections made
     * to hosts identified by name, and IP address exclusions apply only
     * to connections made to hosts identified by address. That is, if
     * example.com has an address of 192.168.1.1, and the :ignore-hosts list
     * contains only "192.168.1.1", then a connection to "example.com"
     * (eg, via a #GNetworkAddress) will use the proxy, and a connection to
     * "192.168.1.1" (eg, via a #GInetSocketAddress) will not.
     *
     * These rules match the "ignore-hosts"/"noproxy" rules most
     * commonly used by other applications.
     */
    ignoreHosts: string[]
    __gtype__: number

    // Own fields of Gio-2.0.Gio.SimpleProxyResolver

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.SimpleProxyResolver

    /**
     * Sets the default proxy on `resolver,` to be used for any URIs that
     * don't match #GSimpleProxyResolver:ignore-hosts or a proxy set
     * via g_simple_proxy_resolver_set_uri_proxy().
     *
     * If `default_proxy` starts with "socks://",
     * #GSimpleProxyResolver will treat it as referring to all three of
     * the socks5, socks4a, and socks4 proxy types.
     * @param defaultProxy the default proxy to use
     */
    setDefaultProxy(defaultProxy: string | null): void
    /**
     * Sets the list of ignored hosts.
     *
     * See #GSimpleProxyResolver:ignore-hosts for more details on how the
     * `ignore_hosts` argument is interpreted.
     * @param ignoreHosts %NULL-terminated list of hosts/IP addresses     to not use a proxy for
     */
    setIgnoreHosts(ignoreHosts: string[]): void
    /**
     * Adds a URI-scheme-specific proxy to `resolver;` URIs whose scheme
     * matches `uri_scheme` (and which don't match
     * #GSimpleProxyResolver:ignore-hosts) will be proxied via `proxy`.
     *
     * As with #GSimpleProxyResolver:default-proxy, if `proxy` starts with
     * "socks://", #GSimpleProxyResolver will treat it
     * as referring to all three of the socks5, socks4a, and socks4 proxy
     * types.
     * @param uriScheme the URI scheme to add a proxy for
     * @param proxy the proxy to use for `uri_scheme`
     */
    setUriProxy(uriScheme: string, proxy: string): void

    // Class property signals of Gio-2.0.Gio.SimpleProxyResolver

    connect(
      sigName: "notify::default-proxy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-proxy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-proxy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-proxy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-proxy", ...args: any[]): void
    connect(
      sigName: "notify::ignore-hosts",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ignore-hosts",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ignore-hosts",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ignore-hosts",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ignore-hosts", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSimpleProxyResolver` is a simple [iface`Gio`.ProxyResolver] implementation
   * that handles a single default proxy, multiple URI-scheme-specific
   * proxies, and a list of hosts that proxies should not be used for.
   *
   * `GSimpleProxyResolver` is never the default proxy resolver, but it
   * can be used as the base class for another proxy resolver
   * implementation, or it can be created and used manually, such as
   * with [method`Gio`.SocketClient.set_proxy_resolver].
   * @class
   */
  class SimpleProxyResolver extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SimpleProxyResolver

    static name: string

    // Constructors of Gio-2.0.Gio.SimpleProxyResolver

    constructor(config?: SimpleProxyResolver.ConstructorProperties)
    _init(config?: SimpleProxyResolver.ConstructorProperties): void
    /**
     * Creates a new #GSimpleProxyResolver. See
     * #GSimpleProxyResolver:default-proxy and
     * #GSimpleProxyResolver:ignore-hosts for more details on how the
     * arguments are interpreted.
     * @param defaultProxy the default proxy to use, eg     "socks://192.168.1.1"
     * @param ignoreHosts an optional list of hosts/IP addresses     to not use a proxy for.
     * @returns a new #GSimpleProxyResolver
     */
    static new(
      defaultProxy: string | null,
      ignoreHosts: string[] | null
    ): ProxyResolver
  }

  module Socket {
    // Constructor properties interface

    interface ConstructorProperties
      extends DatagramBased.ConstructorProperties,
        Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.Socket

      /**
       * Whether I/O on this socket is blocking.
       */
      blocking?: boolean | null
      /**
       * Whether the socket should allow sending to broadcast addresses.
       */
      broadcast?: boolean | null
      /**
       * The socket’s address family.
       */
      family?: SocketFamily | null
      /**
       * The socket’s file descriptor.
       */
      fd?: number | null
      /**
       * Whether to keep the connection alive by sending periodic pings.
       */
      keepalive?: boolean | null
      /**
       * The number of outstanding connections in the listen queue.
       */
      listen_backlog?: number | null
      /**
       * Whether outgoing multicast packets loop back to the local host.
       */
      multicast_loopback?: boolean | null
      /**
       * Time-to-live out outgoing multicast packets
       */
      multicast_ttl?: number | null
      /**
       * The ID of the protocol to use, or `-1` for unknown.
       */
      protocol?: SocketProtocol | null
      /**
       * The timeout in seconds on socket I/O
       */
      timeout?: number | null
      /**
       * Time-to-live for outgoing unicast packets
       */
      ttl?: number | null
      /**
       * The socket’s type.
       */
      type?: SocketType | null
    }
  }

  interface Socket extends DatagramBased, Initable {
    // Own properties of Gio-2.0.Gio.Socket

    /**
     * Whether I/O on this socket is blocking.
     */
    blocking: boolean
    /**
     * Whether the socket should allow sending to broadcast addresses.
     */
    broadcast: boolean
    /**
     * The socket’s address family.
     */
    readonly family: SocketFamily
    /**
     * The socket’s file descriptor.
     */
    readonly fd: number
    /**
     * Whether to keep the connection alive by sending periodic pings.
     */
    keepalive: boolean
    /**
     * The number of outstanding connections in the listen queue.
     */
    listenBacklog: number
    /**
     * The local address the socket is bound to.
     */
    readonly localAddress: SocketAddress
    /**
     * Whether outgoing multicast packets loop back to the local host.
     */
    multicastLoopback: boolean
    /**
     * Time-to-live out outgoing multicast packets
     */
    multicastTtl: number
    /**
     * The ID of the protocol to use, or `-1` for unknown.
     */
    readonly protocol: SocketProtocol
    /**
     * The remote address the socket is connected to.
     */
    readonly remoteAddress: SocketAddress
    /**
     * The timeout in seconds on socket I/O
     */
    timeout: number
    /**
     * Time-to-live for outgoing unicast packets
     */
    ttl: number
    /**
     * The socket’s type.
     */
    readonly type: SocketType
    __gtype__: number

    // Own fields of Gio-2.0.Gio.Socket

    parentInstance: GObject.Object
    priv: SocketPrivate

    // Owm methods of Gio-2.0.Gio.Socket

    /**
     * Accept incoming connections on a connection-based socket. This removes
     * the first outstanding connection request from the listening socket and
     * creates a #GSocket object for it.
     *
     * The `socket` must be bound to a local address with g_socket_bind() and
     * must be listening for incoming connections (g_socket_listen()).
     *
     * If there are no outstanding connections then the operation will block
     * or return %G_IO_ERROR_WOULD_BLOCK if non-blocking I/O is enabled.
     * To be notified of an incoming connection, wait for the %G_IO_IN condition.
     * @param cancellable a %GCancellable or %NULL
     * @returns a new #GSocket, or %NULL on error.     Free the returned object with g_object_unref().
     */
    accept(cancellable: Cancellable | null): Socket
    /**
     * When a socket is created it is attached to an address family, but it
     * doesn't have an address in this family. g_socket_bind() assigns the
     * address (sometimes called name) of the socket.
     *
     * It is generally required to bind to a local address before you can
     * receive connections. (See g_socket_listen() and g_socket_accept() ).
     * In certain situations, you may also want to bind a socket that will be
     * used to initiate connections, though this is not normally required.
     *
     * If `socket` is a TCP socket, then `allow_reuse` controls the setting
     * of the `SO_REUSEADDR` socket option; normally it should be %TRUE for
     * server sockets (sockets that you will eventually call
     * g_socket_accept() on), and %FALSE for client sockets. (Failing to
     * set this flag on a server socket may cause g_socket_bind() to return
     * %G_IO_ERROR_ADDRESS_IN_USE if the server program is stopped and then
     * immediately restarted.)
     *
     * If `socket` is a UDP socket, then `allow_reuse` determines whether or
     * not other UDP sockets can be bound to the same address at the same
     * time. In particular, you can have several UDP sockets bound to the
     * same address, and they will all receive all of the multicast and
     * broadcast packets sent to that address. (The behavior of unicast
     * UDP packets to an address with multiple listeners is not defined.)
     * @param address a #GSocketAddress specifying the local address.
     * @param allowReuse whether to allow reusing this address
     * @returns %TRUE on success, %FALSE on error.
     */
    bind(address: SocketAddress, allowReuse: boolean): boolean
    /**
     * Checks and resets the pending connect error for the socket.
     * This is used to check for errors when g_socket_connect() is
     * used in non-blocking mode.
     * @returns %TRUE if no error, %FALSE otherwise, setting @error to the error
     */
    checkConnectResult(): boolean
    /**
     * Closes the socket, shutting down any active connection.
     *
     * Closing a socket does not wait for all outstanding I/O operations
     * to finish, so the caller should not rely on them to be guaranteed
     * to complete even if the close returns with no error.
     *
     * Once the socket is closed, all other operations will return
     * %G_IO_ERROR_CLOSED. Closing a socket multiple times will not
     * return an error.
     *
     * Sockets will be automatically closed when the last reference
     * is dropped, but you might want to call this function to make sure
     * resources are released as early as possible.
     *
     * Beware that due to the way that TCP works, it is possible for
     * recently-sent data to be lost if either you close a socket while the
     * %G_IO_IN condition is set, or else if the remote connection tries to
     * send something to you after you close the socket but before it has
     * finished reading all of the data you sent. There is no easy generic
     * way to avoid this problem; the easiest fix is to design the network
     * protocol such that the client will never send data "out of turn".
     * Another solution is for the server to half-close the connection by
     * calling g_socket_shutdown() with only the `shutdown_write` flag set,
     * and then wait for the client to notice this and close its side of the
     * connection, after which the server can safely call g_socket_close().
     * (This is what #GTcpConnection does if you call
     * g_tcp_connection_set_graceful_disconnect(). But of course, this
     * only works if the client will close its connection after the server
     * does.)
     * @returns %TRUE on success, %FALSE on error
     */
    close(): boolean
    /**
     * Checks on the readiness of `socket` to perform operations.
     * The operations specified in `condition` are checked for and masked
     * against the currently-satisfied conditions on `socket`. The result
     * is returned.
     *
     * Note that on Windows, it is possible for an operation to return
     * %G_IO_ERROR_WOULD_BLOCK even immediately after
     * g_socket_condition_check() has claimed that the socket is ready for
     * writing. Rather than calling g_socket_condition_check() and then
     * writing to the socket if it succeeds, it is generally better to
     * simply try writing to the socket right away, and try again later if
     * the initial attempt returns %G_IO_ERROR_WOULD_BLOCK.
     *
     * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in condition;
     * these conditions will always be set in the output if they are true.
     *
     * This call never blocks.
     * @param condition a #GIOCondition mask to check
     * @returns the @GIOCondition mask of the current state
     */
    conditionCheck(condition: GLib.IOCondition): GLib.IOCondition

    // Overloads of conditionCheck

    /**
     * Checks on the readiness of `datagram_based` to perform operations. The
     * operations specified in `condition` are checked for and masked against the
     * currently-satisfied conditions on `datagram_based`. The result is returned.
     *
     * %G_IO_IN will be set in the return value if data is available to read with
     * g_datagram_based_receive_messages(), or if the connection is closed remotely
     * (EOS); and if the datagram_based has not been closed locally using some
     * implementation-specific method (such as g_socket_close() or
     * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket).
     *
     * If the connection is shut down or closed (by calling g_socket_close() or
     * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
     * example), all calls to this function will return %G_IO_ERROR_CLOSED.
     *
     * %G_IO_OUT will be set if it is expected that at least one byte can be sent
     * using g_datagram_based_send_messages() without blocking. It will not be set
     * if the datagram_based has been closed locally.
     *
     * %G_IO_HUP will be set if the connection has been closed locally.
     *
     * %G_IO_ERR will be set if there was an asynchronous error in transmitting data
     * previously enqueued using g_datagram_based_send_messages().
     *
     * Note that on Windows, it is possible for an operation to return
     * %G_IO_ERROR_WOULD_BLOCK even immediately after
     * g_datagram_based_condition_check() has claimed that the #GDatagramBased is
     * ready for writing. Rather than calling g_datagram_based_condition_check() and
     * then writing to the #GDatagramBased if it succeeds, it is generally better to
     * simply try writing right away, and try again later if the initial attempt
     * returns %G_IO_ERROR_WOULD_BLOCK.
     *
     * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
     * conditions will always be set in the output if they are true. Apart from
     * these flags, the output is guaranteed to be masked by `condition`.
     *
     * This call never blocks.
     * @virtual
     * @param condition a #GIOCondition mask to check
     * @returns the #GIOCondition mask of the current state
     */
    conditionCheck(condition: GLib.IOCondition): GLib.IOCondition
    /**
     * Waits for up to `timeout_us` microseconds for `condition` to become true
     * on `socket`. If the condition is met, %TRUE is returned.
     *
     * If `cancellable` is cancelled before the condition is met, or if
     * `timeout_us` (or the socket's #GSocket:timeout) is reached before the
     * condition is met, then %FALSE is returned and `error,` if non-%NULL,
     * is set to the appropriate value (%G_IO_ERROR_CANCELLED or
     * %G_IO_ERROR_TIMED_OUT).
     *
     * If you don't want a timeout, use g_socket_condition_wait().
     * (Alternatively, you can pass -1 for `timeout_us`.)
     *
     * Note that although `timeout_us` is in microseconds for consistency with
     * other GLib APIs, this function actually only has millisecond
     * resolution, and the behavior is undefined if `timeout_us` is not an
     * exact number of milliseconds.
     * @param condition a #GIOCondition mask to wait for
     * @param timeoutUs the maximum time (in microseconds) to wait, or -1
     * @param cancellable a #GCancellable, or %NULL
     * @returns %TRUE if the condition was met, %FALSE otherwise
     */
    conditionTimedWait(
      condition: GLib.IOCondition,
      timeoutUs: number,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Waits for `condition` to become true on `socket`. When the condition
     * is met, %TRUE is returned.
     *
     * If `cancellable` is cancelled before the condition is met, or if the
     * socket has a timeout set and it is reached before the condition is
     * met, then %FALSE is returned and `error,` if non-%NULL, is set to
     * the appropriate value (%G_IO_ERROR_CANCELLED or
     * %G_IO_ERROR_TIMED_OUT).
     *
     * See also g_socket_condition_timed_wait().
     * @param condition a #GIOCondition mask to wait for
     * @param cancellable a #GCancellable, or %NULL
     * @returns %TRUE if the condition was met, %FALSE otherwise
     */
    conditionWait(
      condition: GLib.IOCondition,
      cancellable: Cancellable | null
    ): boolean

    // Overloads of conditionWait

    /**
     * Waits for up to `timeout` microseconds for condition to become true on
     * `datagram_based`. If the condition is met, %TRUE is returned.
     *
     * If `cancellable` is cancelled before the condition is met, or if `timeout` is
     * reached before the condition is met, then %FALSE is returned and `error` is
     * set appropriately (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT).
     * @virtual
     * @param condition a #GIOCondition mask to wait for
     * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
     * @param cancellable a #GCancellable
     * @returns %TRUE if the condition was met, %FALSE otherwise
     */
    conditionWait(
      condition: GLib.IOCondition,
      timeout: number,
      cancellable: Cancellable | null
    ): boolean
    /**
     * Connect the socket to the specified remote address.
     *
     * For connection oriented socket this generally means we attempt to make
     * a connection to the `address`. For a connection-less socket it sets
     * the default address for g_socket_send() and discards all incoming datagrams
     * from other sources.
     *
     * Generally connection oriented sockets can only connect once, but
     * connection-less sockets can connect multiple times to change the
     * default address.
     *
     * If the connect call needs to do network I/O it will block, unless
     * non-blocking I/O is enabled. Then %G_IO_ERROR_PENDING is returned
     * and the user can be notified of the connection finishing by waiting
     * for the G_IO_OUT condition. The result of the connection must then be
     * checked with g_socket_check_connect_result().
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if connected, %FALSE on error.
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    /**
     * Creates a #GSocketConnection subclass of the right type for
     * `socket`.
     * @returns a #GSocketConnection
     */
    connectionFactoryCreateConnection(): SocketConnection
    /**
     * Get the amount of data pending in the OS input buffer, without blocking.
     *
     * If `socket` is a UDP or SCTP socket, this will return the size of
     * just the next packet, even if additional packets are buffered after
     * that one.
     *
     * Note that on Windows, this function is rather inefficient in the
     * UDP case, and so if you know any plausible upper bound on the size
     * of the incoming packet, it is better to just do a
     * g_socket_receive() with a buffer of that size, rather than calling
     * g_socket_get_available_bytes() first and then doing a receive of
     * exactly the right size.
     * @returns the number of bytes that can be read from the socket without blocking or truncating, or -1 on error.
     */
    getAvailableBytes(): number
    /**
     * Gets the blocking mode of the socket. For details on blocking I/O,
     * see g_socket_set_blocking().
     * @returns %TRUE if blocking I/O is used, %FALSE otherwise.
     */
    getBlocking(): boolean
    /**
     * Gets the broadcast setting on `socket;` if %TRUE,
     * it is possible to send packets to broadcast
     * addresses.
     * @returns the broadcast setting on @socket
     */
    getBroadcast(): boolean
    /**
     * Returns the credentials of the foreign process connected to this
     * socket, if any (e.g. it is only supported for %G_SOCKET_FAMILY_UNIX
     * sockets).
     *
     * If this operation isn't supported on the OS, the method fails with
     * the %G_IO_ERROR_NOT_SUPPORTED error. On Linux this is implemented
     * by reading the %SO_PEERCRED option on the underlying socket.
     *
     * This method can be expected to be available on the following platforms:
     *
     * - Linux since GLib 2.26
     * - OpenBSD since GLib 2.30
     * - Solaris, Illumos and OpenSolaris since GLib 2.40
     * - NetBSD since GLib 2.42
     * - macOS, tvOS, iOS since GLib 2.66
     *
     * Other ways to obtain credentials from a foreign peer includes the
     * #GUnixCredentialsMessage type and
     * g_unix_connection_send_credentials() /
     * g_unix_connection_receive_credentials() functions.
     * @returns %NULL if @error is set, otherwise a #GCredentials object that must be freed with g_object_unref().
     */
    getCredentials(): Credentials
    /**
     * Gets the socket family of the socket.
     * @returns a #GSocketFamily
     */
    getFamily(): SocketFamily
    /**
     * Returns the underlying OS socket object. On unix this
     * is a socket file descriptor, and on Windows this is
     * a Winsock2 SOCKET handle. This may be useful for
     * doing platform specific or otherwise unusual operations
     * on the socket.
     * @returns the file descriptor of the socket.
     */
    getFd(): number
    /**
     * Gets the keepalive mode of the socket. For details on this,
     * see g_socket_set_keepalive().
     * @returns %TRUE if keepalive is active, %FALSE otherwise.
     */
    getKeepalive(): boolean
    /**
     * Gets the listen backlog setting of the socket. For details on this,
     * see g_socket_set_listen_backlog().
     * @returns the maximum number of pending connections.
     */
    getListenBacklog(): number
    /**
     * Try to get the local address of a bound socket. This is only
     * useful if the socket has been bound to a local address,
     * either explicitly or implicitly when connecting.
     * @returns a #GSocketAddress or %NULL on error.     Free the returned object with g_object_unref().
     */
    getLocalAddress(): SocketAddress
    /**
     * Gets the multicast loopback setting on `socket;` if %TRUE (the
     * default), outgoing multicast packets will be looped back to
     * multicast listeners on the same host.
     * @returns the multicast loopback setting on @socket
     */
    getMulticastLoopback(): boolean
    /**
     * Gets the multicast time-to-live setting on `socket;` see
     * g_socket_set_multicast_ttl() for more details.
     * @returns the multicast time-to-live setting on @socket
     */
    getMulticastTtl(): number
    /**
     * Gets the value of an integer-valued option on `socket,` as with
     * getsockopt(). (If you need to fetch a  non-integer-valued option,
     * you will need to call getsockopt() directly.)
     *
     * The [<gio/gnetworking.h>][gio-gnetworking.h]
     * header pulls in system headers that will define most of the
     * standard/portable socket options. For unusual socket protocols or
     * platform-dependent options, you may need to include additional
     * headers.
     *
     * Note that even for socket options that are a single byte in size,
     * `value` is still a pointer to a #gint variable, not a #guchar;
     * g_socket_get_option() will handle the conversion internally.
     * @param level the "API level" of the option (eg, `SOL_SOCKET`)
     * @param optname the "name" of the option (eg, `SO_BROADCAST`)
     * @returns success or failure. On failure, @error will be set, and   the system error value (`errno` or WSAGetLastError()) will still   be set to the result of the getsockopt() call.
     */
    getOption(
      level: number,
      optname: number
    ): [/* returnType */ boolean, /* value */ number]
    /**
     * Gets the socket protocol id the socket was created with.
     * In case the protocol is unknown, -1 is returned.
     * @returns a protocol id, or -1 if unknown
     */
    getProtocol(): SocketProtocol
    /**
     * Try to get the remote address of a connected socket. This is only
     * useful for connection oriented sockets that have been connected.
     * @returns a #GSocketAddress or %NULL on error.     Free the returned object with g_object_unref().
     */
    getRemoteAddress(): SocketAddress
    /**
     * Gets the socket type of the socket.
     * @returns a #GSocketType
     */
    getSocketType(): SocketType
    /**
     * Gets the timeout setting of the socket. For details on this, see
     * g_socket_set_timeout().
     * @returns the timeout in seconds
     */
    getTimeout(): number
    /**
     * Gets the unicast time-to-live setting on `socket;` see
     * g_socket_set_ttl() for more details.
     * @returns the time-to-live setting on @socket
     */
    getTtl(): number
    /**
     * Checks whether a socket is closed.
     * @returns %TRUE if socket is closed, %FALSE otherwise
     */
    isClosed(): boolean
    /**
     * Check whether the socket is connected. This is only useful for
     * connection-oriented sockets.
     *
     * If using g_socket_shutdown(), this function will return %TRUE until the
     * socket has been shut down for reading and writing. If you do a non-blocking
     * connect, this function will not return %TRUE until after you call
     * g_socket_check_connect_result().
     * @returns %TRUE if socket is connected, %FALSE otherwise.
     */
    isConnected(): boolean
    /**
     * Registers `socket` to receive multicast messages sent to `group`.
     * `socket` must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have
     * been bound to an appropriate interface and port with
     * g_socket_bind().
     *
     * If `iface` is %NULL, the system will automatically pick an interface
     * to bind to based on `group`.
     *
     * If `source_specific` is %TRUE, source-specific multicast as defined
     * in RFC 4604 is used. Note that on older platforms this may fail
     * with a %G_IO_ERROR_NOT_SUPPORTED error.
     *
     * To bind to a given source-specific multicast address, use
     * g_socket_join_multicast_group_ssm() instead.
     * @param group a #GInetAddress specifying the group address to join.
     * @param sourceSpecific %TRUE if source-specific multicast should be used
     * @param iface Name of the interface to use, or %NULL
     * @returns %TRUE on success, %FALSE on error.
     */
    joinMulticastGroup(
      group: InetAddress,
      sourceSpecific: boolean,
      iface: string | null
    ): boolean
    /**
     * Registers `socket` to receive multicast messages sent to `group`.
     * `socket` must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have
     * been bound to an appropriate interface and port with
     * g_socket_bind().
     *
     * If `iface` is %NULL, the system will automatically pick an interface
     * to bind to based on `group`.
     *
     * If `source_specific` is not %NULL, use source-specific multicast as
     * defined in RFC 4604. Note that on older platforms this may fail
     * with a %G_IO_ERROR_NOT_SUPPORTED error.
     *
     * Note that this function can be called multiple times for the same
     * `group` with different `source_specific` in order to receive multicast
     * packets from more than one source.
     * @param group a #GInetAddress specifying the group address to join.
     * @param sourceSpecific a #GInetAddress specifying the source-specific multicast address or %NULL to ignore.
     * @param iface Name of the interface to use, or %NULL
     * @returns %TRUE on success, %FALSE on error.
     */
    joinMulticastGroupSsm(
      group: InetAddress,
      sourceSpecific: InetAddress | null,
      iface: string | null
    ): boolean
    /**
     * Removes `socket` from the multicast group defined by `group,` `iface,`
     * and `source_specific` (which must all have the same values they had
     * when you joined the group).
     *
     * `socket` remains bound to its address and port, and can still receive
     * unicast messages after calling this.
     *
     * To unbind to a given source-specific multicast address, use
     * g_socket_leave_multicast_group_ssm() instead.
     * @param group a #GInetAddress specifying the group address to leave.
     * @param sourceSpecific %TRUE if source-specific multicast was used
     * @param iface Interface used
     * @returns %TRUE on success, %FALSE on error.
     */
    leaveMulticastGroup(
      group: InetAddress,
      sourceSpecific: boolean,
      iface: string | null
    ): boolean
    /**
     * Removes `socket` from the multicast group defined by `group,` `iface,`
     * and `source_specific` (which must all have the same values they had
     * when you joined the group).
     *
     * `socket` remains bound to its address and port, and can still receive
     * unicast messages after calling this.
     * @param group a #GInetAddress specifying the group address to leave.
     * @param sourceSpecific a #GInetAddress specifying the source-specific multicast address or %NULL to ignore.
     * @param iface Name of the interface to use, or %NULL
     * @returns %TRUE on success, %FALSE on error.
     */
    leaveMulticastGroupSsm(
      group: InetAddress,
      sourceSpecific: InetAddress | null,
      iface: string | null
    ): boolean
    /**
     * Marks the socket as a server socket, i.e. a socket that is used
     * to accept incoming requests using g_socket_accept().
     *
     * Before calling this the socket must be bound to a local address using
     * g_socket_bind().
     *
     * To set the maximum amount of outstanding clients, use
     * g_socket_set_listen_backlog().
     * @returns %TRUE on success, %FALSE on error.
     */
    listen(): boolean
    /**
     * Receive data (up to `size` bytes) from a socket. This is mainly used by
     * connection-oriented sockets; it is identical to g_socket_receive_from()
     * with `address` set to %NULL.
     *
     * For %G_SOCKET_TYPE_DATAGRAM and %G_SOCKET_TYPE_SEQPACKET sockets,
     * g_socket_receive() will always read either 0 or 1 complete messages from
     * the socket. If the received message is too large to fit in `buffer,` then
     * the data beyond `size` bytes will be discarded, without any explicit
     * indication that this has occurred.
     *
     * For %G_SOCKET_TYPE_STREAM sockets, g_socket_receive() can return any
     * number of bytes, up to `size`. If more than `size` bytes have been
     * received, the additional data will be returned in future calls to
     * g_socket_receive().
     *
     * If the socket is in blocking mode the call will block until there
     * is some data to receive, the connection is closed, or there is an
     * error. If there is no data available and the socket is in
     * non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
     * returned. To be notified when data is available, wait for the
     * %G_IO_IN condition.
     *
     * On error -1 is returned and `error` is set accordingly.
     * @param cancellable a %GCancellable or %NULL
     * @returns Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error
     */
    receive(
      cancellable: Cancellable | null
    ): [/* returnType */ number, /* buffer */ number[]]
    /**
     * Receives data (up to `size` bytes) from a socket.
     *
     * This function is a variant of [method`Gio`.Socket.receive] which returns a
     * [struct`GLib`.Bytes] rather than a plain buffer.
     *
     * Pass `-1` to `timeout_us` to block indefinitely until data is received (or
     * the connection is closed, or there is an error). Pass `0` to use the default
     * timeout from [property`Gio`.Socket:timeout], or pass a positive number to wait
     * for that many microseconds for data before returning `G_IO_ERROR_TIMED_OUT`.
     * @param size the number of bytes you want to read from the socket
     * @param timeoutUs the timeout to wait for, in microseconds, or `-1` to block   indefinitely
     * @param cancellable a %GCancellable, or `NULL`
     * @returns a bytes buffer containing the   received bytes, or `NULL` on error
     */
    receiveBytes(
      size: number,
      timeoutUs: number,
      cancellable: Cancellable | null
    ): any
    /**
     * Receive data (up to `size` bytes) from a socket.
     *
     * This function is a variant of [method`Gio`.Socket.receive_from] which returns
     * a [struct`GLib`.Bytes] rather than a plain buffer.
     *
     * If `address` is non-%NULL then `address` will be set equal to the
     * source address of the received packet.
     *
     * The `address` is owned by the caller.
     *
     * Pass `-1` to `timeout_us` to block indefinitely until data is received (or
     * the connection is closed, or there is an error). Pass `0` to use the default
     * timeout from [property`Gio`.Socket:timeout], or pass a positive number to wait
     * for that many microseconds for data before returning `G_IO_ERROR_TIMED_OUT`.
     * @param size the number of bytes you want to read from the socket
     * @param timeoutUs the timeout to wait for, in microseconds, or `-1` to block   indefinitely
     * @param cancellable a #GCancellable, or `NULL`
     * @returns a bytes buffer containing the   received bytes, or `NULL` on error
     */
    receiveBytesFrom(
      size: number,
      timeoutUs: number,
      cancellable: Cancellable | null
    ): [/* returnType */ any, /* address */ SocketAddress]
    /**
     * Receive data (up to `size` bytes) from a socket.
     *
     * If `address` is non-%NULL then `address` will be set equal to the
     * source address of the received packet.
     * `address` is owned by the caller.
     *
     * See g_socket_receive() for additional information.
     * @param cancellable a %GCancellable or %NULL
     * @returns Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error
     */
    receiveFrom(
      cancellable: Cancellable | null
    ): [
      /* returnType */ number,
      /* address */ SocketAddress,
      /* buffer */ number[],
    ]
    /**
     * Receive data from a socket.  For receiving multiple messages, see
     * g_socket_receive_messages(); for easier use, see
     * g_socket_receive() and g_socket_receive_from().
     *
     * If `address` is non-%NULL then `address` will be set equal to the
     * source address of the received packet.
     * `address` is owned by the caller.
     *
     * `vector` must point to an array of #GInputVector structs and
     * `num_vectors` must be the length of this array.  These structs
     * describe the buffers that received data will be scattered into.
     * If `num_vectors` is -1, then `vectors` is assumed to be terminated
     * by a #GInputVector with a %NULL buffer pointer.
     *
     * As a special case, if `num_vectors` is 0 (in which case, `vectors`
     * may of course be %NULL), then a single byte is received and
     * discarded. This is to facilitate the common practice of sending a
     * single '\0' byte for the purposes of transferring ancillary data.
     *
     * `messages,` if non-%NULL, will be set to point to a newly-allocated
     * array of #GSocketControlMessage instances or %NULL if no such
     * messages was received. These correspond to the control messages
     * received from the kernel, one #GSocketControlMessage per message
     * from the kernel. This array is %NULL-terminated and must be freed
     * by the caller using g_free() after calling g_object_unref() on each
     * element. If `messages` is %NULL, any control messages received will
     * be discarded.
     *
     * `num_messages,` if non-%NULL, will be set to the number of control
     * messages received.
     *
     * If both `messages` and `num_messages` are non-%NULL, then
     * `num_messages` gives the number of #GSocketControlMessage instances
     * in `messages` (ie: not including the %NULL terminator).
     *
     * `flags` is an in/out parameter. The commonly available arguments
     * for this are available in the #GSocketMsgFlags enum, but the
     * values there are the same as the system values, and the flags
     * are passed in as-is, so you can pass in system-specific flags too
     * (and g_socket_receive_message() may pass system-specific flags out).
     * Flags passed in to the parameter affect the receive operation; flags returned
     * out of it are relevant to the specific returned message.
     *
     * As with g_socket_receive(), data may be discarded if `socket` is
     * %G_SOCKET_TYPE_DATAGRAM or %G_SOCKET_TYPE_SEQPACKET and you do not
     * provide enough buffer space to read a complete message. You can pass
     * %G_SOCKET_MSG_PEEK in `flags` to peek at the current message without
     * removing it from the receive queue, but there is no portable way to find
     * out the length of the message other than by reading it into a
     * sufficiently-large buffer.
     *
     * If the socket is in blocking mode the call will block until there
     * is some data to receive, the connection is closed, or there is an
     * error. If there is no data available and the socket is in
     * non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
     * returned. To be notified when data is available, wait for the
     * %G_IO_IN condition.
     *
     * On error -1 is returned and `error` is set accordingly.
     * @param vectors an array of #GInputVector structs
     * @param flags a pointer to an int containing #GSocketMsgFlags flags,    which may additionally contain    [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
     * @param cancellable a %GCancellable or %NULL
     * @returns Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error
     */
    receiveMessage(
      vectors: InputVector[],
      flags: number,
      cancellable: Cancellable | null
    ): [
      /* returnType */ number,
      /* address */ SocketAddress,
      /* messages */ SocketControlMessage[] | null,
      /* flags */ number,
    ]
    /**
     * Receive multiple data messages from `socket` in one go.  This is the most
     * complicated and fully-featured version of this call. For easier use, see
     * g_socket_receive(), g_socket_receive_from(), and g_socket_receive_message().
     *
     * `messages` must point to an array of #GInputMessage structs and
     * `num_messages` must be the length of this array. Each #GInputMessage
     * contains a pointer to an array of #GInputVector structs describing the
     * buffers that the data received in each message will be written to. Using
     * multiple #GInputVectors is more memory-efficient than manually copying data
     * out of a single buffer to multiple sources, and more system-call-efficient
     * than making multiple calls to g_socket_receive(), such as in scenarios where
     * a lot of data packets need to be received (e.g. high-bandwidth video
     * streaming over RTP/UDP).
     *
     * `flags` modify how all messages are received. The commonly available
     * arguments for this are available in the #GSocketMsgFlags enum, but the
     * values there are the same as the system values, and the flags
     * are passed in as-is, so you can pass in system-specific flags too. These
     * flags affect the overall receive operation. Flags affecting individual
     * messages are returned in #GInputMessage.flags.
     *
     * The other members of #GInputMessage are treated as described in its
     * documentation.
     *
     * If #GSocket:blocking is %TRUE the call will block until `num_messages` have
     * been received, or the end of the stream is reached.
     *
     * If #GSocket:blocking is %FALSE the call will return up to `num_messages`
     * without blocking, or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the
     * operating system to be received.
     *
     * In blocking mode, if #GSocket:timeout is positive and is reached before any
     * messages are received, %G_IO_ERROR_TIMED_OUT is returned, otherwise up to
     * `num_messages` are returned. (Note: This is effectively the
     * behaviour of `MSG_WAITFORONE` with recvmmsg().)
     *
     * To be notified when messages are available, wait for the
     * %G_IO_IN condition. Note though that you may still receive
     * %G_IO_ERROR_WOULD_BLOCK from g_socket_receive_messages() even if you were
     * previously notified of a %G_IO_IN condition.
     *
     * If the remote peer closes the connection, any messages queued in the
     * operating system will be returned, and subsequent calls to
     * g_socket_receive_messages() will return 0 (with no error set).
     *
     * On error -1 is returned and `error` is set accordingly. An error will only
     * be returned if zero messages could be received; otherwise the number of
     * messages successfully received before the error will be returned.
     * @param messages an array of #GInputMessage structs
     * @param flags an int containing #GSocketMsgFlags flags for the overall operation,    which may additionally contain    [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
     * @param cancellable a %GCancellable or %NULL
     * @returns number of messages received, or -1 on error. Note that the number     of messages received may be smaller than @num_messages if in non-blocking     mode, if the peer closed the connection, or if @num_messages     was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try     to receive the remaining messages.
     */
    receiveMessages(
      messages: InputMessage[],
      flags: number,
      cancellable: Cancellable | null
    ): number

    // Overloads of receiveMessages

    /**
     * Receive one or more data messages from `datagram_based` in one go.
     *
     * `messages` must point to an array of #GInputMessage structs and
     * `num_messages` must be the length of this array. Each #GInputMessage
     * contains a pointer to an array of #GInputVector structs describing the
     * buffers that the data received in each message will be written to.
     *
     * `flags` modify how all messages are received. The commonly available
     * arguments for this are available in the #GSocketMsgFlags enum, but the
     * values there are the same as the system values, and the flags
     * are passed in as-is, so you can pass in system-specific flags too. These
     * flags affect the overall receive operation. Flags affecting individual
     * messages are returned in #GInputMessage.flags.
     *
     * The other members of #GInputMessage are treated as described in its
     * documentation.
     *
     * If `timeout` is negative the call will block until `num_messages` have been
     * received, the connection is closed remotely (EOS), `cancellable` is cancelled,
     * or an error occurs.
     *
     * If `timeout` is 0 the call will return up to `num_messages` without blocking,
     * or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the operating system
     * to be received.
     *
     * If `timeout` is positive the call will block on the same conditions as if
     * `timeout` were negative. If the timeout is reached
     * before any messages are received, %G_IO_ERROR_TIMED_OUT is returned,
     * otherwise it will return the number of messages received before timing out.
     * (Note: This is effectively the behaviour of `MSG_WAITFORONE` with
     * recvmmsg().)
     *
     * To be notified when messages are available, wait for the %G_IO_IN condition.
     * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
     * g_datagram_based_receive_messages() even if you were previously notified of a
     * %G_IO_IN condition.
     *
     * If the remote peer closes the connection, any messages queued in the
     * underlying receive buffer will be returned, and subsequent calls to
     * g_datagram_based_receive_messages() will return 0 (with no error set).
     *
     * If the connection is shut down or closed (by calling g_socket_close() or
     * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
     * example), all calls to this function will return %G_IO_ERROR_CLOSED.
     *
     * On error -1 is returned and `error` is set accordingly. An error will only
     * be returned if zero messages could be received; otherwise the number of
     * messages successfully received before the error will be returned. If
     * `cancellable` is cancelled, %G_IO_ERROR_CANCELLED is returned as with any
     * other error.
     * @virtual
     * @param messages an array of #GInputMessage structs
     * @param flags an int containing #GSocketMsgFlags flags for the overall operation
     * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
     * @param cancellable a %GCancellable
     * @returns number of messages received, or -1 on error. Note that the number     of messages received may be smaller than @num_messages if @timeout is     zero or positive, if the peer closed the connection, or if @num_messages     was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try     to receive the remaining messages.
     */
    receiveMessages(
      messages: InputMessage[],
      flags: number,
      timeout: number,
      cancellable: Cancellable | null
    ): number
    /**
     * This behaves exactly the same as g_socket_receive(), except that
     * the choice of blocking or non-blocking behavior is determined by
     * the `blocking` argument rather than by `socket'`s properties.
     * @param blocking whether to do blocking or non-blocking I/O
     * @param cancellable a %GCancellable or %NULL
     * @returns Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error
     */
    receiveWithBlocking(
      blocking: boolean,
      cancellable: Cancellable | null
    ): [/* returnType */ number, /* buffer */ number[]]
    /**
     * Tries to send `size` bytes from `buffer` on the socket. This is
     * mainly used by connection-oriented sockets; it is identical to
     * g_socket_send_to() with `address` set to %NULL.
     *
     * If the socket is in blocking mode the call will block until there is
     * space for the data in the socket queue. If there is no space available
     * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
     * will be returned. To be notified when space is available, wait for the
     * %G_IO_OUT condition. Note though that you may still receive
     * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
     * notified of a %G_IO_OUT condition. (On Windows in particular, this is
     * very common due to the way the underlying APIs work.)
     *
     * On error -1 is returned and `error` is set accordingly.
     * @param buffer the buffer     containing the data to send.
     * @param cancellable a %GCancellable or %NULL
     * @returns Number of bytes written (which may be less than @size), or -1 on error
     */
    send(buffer: number[], cancellable: Cancellable | null): number
    /**
     * Send data to `address` on `socket`.  For sending multiple messages see
     * g_socket_send_messages(); for easier use, see
     * g_socket_send() and g_socket_send_to().
     *
     * If `address` is %NULL then the message is sent to the default receiver
     * (set by g_socket_connect()).
     *
     * `vectors` must point to an array of #GOutputVector structs and
     * `num_vectors` must be the length of this array. (If `num_vectors` is -1,
     * then `vectors` is assumed to be terminated by a #GOutputVector with a
     * %NULL buffer pointer.) The #GOutputVector structs describe the buffers
     * that the sent data will be gathered from. Using multiple
     * #GOutputVectors is more memory-efficient than manually copying
     * data from multiple sources into a single buffer, and more
     * network-efficient than making multiple calls to g_socket_send().
     *
     * `messages,` if non-%NULL, is taken to point to an array of `num_messages`
     * #GSocketControlMessage instances. These correspond to the control
     * messages to be sent on the socket.
     * If `num_messages` is -1 then `messages` is treated as a %NULL-terminated
     * array.
     *
     * `flags` modify how the message is sent. The commonly available arguments
     * for this are available in the #GSocketMsgFlags enum, but the
     * values there are the same as the system values, and the flags
     * are passed in as-is, so you can pass in system-specific flags too.
     *
     * If the socket is in blocking mode the call will block until there is
     * space for the data in the socket queue. If there is no space available
     * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
     * will be returned. To be notified when space is available, wait for the
     * %G_IO_OUT condition. Note though that you may still receive
     * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
     * notified of a %G_IO_OUT condition. (On Windows in particular, this is
     * very common due to the way the underlying APIs work.)
     *
     * The sum of the sizes of each #GOutputVector in vectors must not be
     * greater than %G_MAXSSIZE. If the message can be larger than this,
     * then it is mandatory to use the g_socket_send_message_with_timeout()
     * function.
     *
     * On error -1 is returned and `error` is set accordingly.
     * @param address a #GSocketAddress, or %NULL
     * @param vectors an array of #GOutputVector structs
     * @param messages a pointer to an   array of #GSocketControlMessages, or %NULL.
     * @param flags an int containing #GSocketMsgFlags flags, which may additionally    contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
     * @param cancellable a %GCancellable or %NULL
     * @returns Number of bytes written (which may be less than @size), or -1 on error
     */
    sendMessage(
      address: SocketAddress | null,
      vectors: OutputVector[],
      messages: SocketControlMessage[] | null,
      flags: number,
      cancellable: Cancellable | null
    ): number
    /**
     * This behaves exactly the same as g_socket_send_message(), except that
     * the choice of timeout behavior is determined by the `timeout_us` argument
     * rather than by `socket'`s properties.
     *
     * On error %G_POLLABLE_RETURN_FAILED is returned and `error` is set accordingly, or
     * if the socket is currently not writable %G_POLLABLE_RETURN_WOULD_BLOCK is
     * returned. `bytes_written` will contain 0 in both cases.
     * @param address a #GSocketAddress, or %NULL
     * @param vectors an array of #GOutputVector structs
     * @param messages a pointer to an   array of #GSocketControlMessages, or %NULL.
     * @param flags an int containing #GSocketMsgFlags flags, which may additionally    contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
     * @param timeoutUs the maximum time (in microseconds) to wait, or -1
     * @param cancellable a %GCancellable or %NULL
     * @returns %G_POLLABLE_RETURN_OK if all data was successfully written, %G_POLLABLE_RETURN_WOULD_BLOCK if the socket is currently not writable, or %G_POLLABLE_RETURN_FAILED if an error happened and @error is set.
     */
    sendMessageWithTimeout(
      address: SocketAddress | null,
      vectors: OutputVector[],
      messages: SocketControlMessage[] | null,
      flags: number,
      timeoutUs: number,
      cancellable: Cancellable | null
    ): [/* returnType */ PollableReturn, /* bytesWritten */ number]
    /**
     * Send multiple data messages from `socket` in one go.  This is the most
     * complicated and fully-featured version of this call. For easier use, see
     * g_socket_send(), g_socket_send_to(), and g_socket_send_message().
     *
     * `messages` must point to an array of #GOutputMessage structs and
     * `num_messages` must be the length of this array. Each #GOutputMessage
     * contains an address to send the data to, and a pointer to an array of
     * #GOutputVector structs to describe the buffers that the data to be sent
     * for each message will be gathered from. Using multiple #GOutputVectors is
     * more memory-efficient than manually copying data from multiple sources
     * into a single buffer, and more network-efficient than making multiple
     * calls to g_socket_send(). Sending multiple messages in one go avoids the
     * overhead of making a lot of syscalls in scenarios where a lot of data
     * packets need to be sent (e.g. high-bandwidth video streaming over RTP/UDP),
     * or where the same data needs to be sent to multiple recipients.
     *
     * `flags` modify how the message is sent. The commonly available arguments
     * for this are available in the #GSocketMsgFlags enum, but the
     * values there are the same as the system values, and the flags
     * are passed in as-is, so you can pass in system-specific flags too.
     *
     * If the socket is in blocking mode the call will block until there is
     * space for all the data in the socket queue. If there is no space available
     * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
     * will be returned if no data was written at all, otherwise the number of
     * messages sent will be returned. To be notified when space is available,
     * wait for the %G_IO_OUT condition. Note though that you may still receive
     * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
     * notified of a %G_IO_OUT condition. (On Windows in particular, this is
     * very common due to the way the underlying APIs work.)
     *
     * On error -1 is returned and `error` is set accordingly. An error will only
     * be returned if zero messages could be sent; otherwise the number of messages
     * successfully sent before the error will be returned.
     * @param messages an array of #GOutputMessage structs
     * @param flags an int containing #GSocketMsgFlags flags, which may additionally    contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
     * @param cancellable a %GCancellable or %NULL
     * @returns number of messages sent, or -1 on error. Note that the number of     messages sent may be smaller than @num_messages if the socket is     non-blocking or if @num_messages was larger than UIO_MAXIOV (1024),     in which case the caller may re-try to send the remaining messages.
     */
    sendMessages(
      messages: OutputMessage[],
      flags: number,
      cancellable: Cancellable | null
    ): number

    // Overloads of sendMessages

    /**
     * Send one or more data messages from `datagram_based` in one go.
     *
     * `messages` must point to an array of #GOutputMessage structs and
     * `num_messages` must be the length of this array. Each #GOutputMessage
     * contains an address to send the data to, and a pointer to an array of
     * #GOutputVector structs to describe the buffers that the data to be sent
     * for each message will be gathered from.
     *
     * `flags` modify how the message is sent. The commonly available arguments
     * for this are available in the #GSocketMsgFlags enum, but the
     * values there are the same as the system values, and the flags
     * are passed in as-is, so you can pass in system-specific flags too.
     *
     * The other members of #GOutputMessage are treated as described in its
     * documentation.
     *
     * If `timeout` is negative the call will block until `num_messages` have been
     * sent, `cancellable` is cancelled, or an error occurs.
     *
     * If `timeout` is 0 the call will send up to `num_messages` without blocking,
     * or will return %G_IO_ERROR_WOULD_BLOCK if there is no space to send messages.
     *
     * If `timeout` is positive the call will block on the same conditions as if
     * `timeout` were negative. If the timeout is reached before any messages are
     * sent, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number
     * of messages sent before timing out.
     *
     * To be notified when messages can be sent, wait for the %G_IO_OUT condition.
     * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
     * g_datagram_based_send_messages() even if you were previously notified of a
     * %G_IO_OUT condition. (On Windows in particular, this is very common due to
     * the way the underlying APIs work.)
     *
     * If the connection is shut down or closed (by calling g_socket_close() or
     * g_socket_shutdown() with `shutdown_write` set, if it’s a #GSocket, for
     * example), all calls to this function will return %G_IO_ERROR_CLOSED.
     *
     * On error -1 is returned and `error` is set accordingly. An error will only
     * be returned if zero messages could be sent; otherwise the number of messages
     * successfully sent before the error will be returned. If `cancellable` is
     * cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error.
     * @virtual
     * @param messages an array of #GOutputMessage structs
     * @param flags an int containing #GSocketMsgFlags flags
     * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
     * @param cancellable a %GCancellable
     * @returns number of messages sent, or -1 on error. Note that the number of     messages sent may be smaller than @num_messages if @timeout is zero     or positive, or if @num_messages was larger than `UIO_MAXIOV` (1024), in     which case the caller may re-try to send the remaining messages.
     */
    sendMessages(
      messages: OutputMessage[],
      flags: number,
      timeout: number,
      cancellable: Cancellable | null
    ): number
    /**
     * Tries to send `size` bytes from `buffer` to `address`. If `address` is
     * %NULL then the message is sent to the default receiver (set by
     * g_socket_connect()).
     *
     * See g_socket_send() for additional information.
     * @param address a #GSocketAddress, or %NULL
     * @param buffer the buffer     containing the data to send.
     * @param cancellable a %GCancellable or %NULL
     * @returns Number of bytes written (which may be less than @size), or -1 on error
     */
    sendTo(
      address: SocketAddress | null,
      buffer: number[],
      cancellable: Cancellable | null
    ): number
    /**
     * This behaves exactly the same as g_socket_send(), except that
     * the choice of blocking or non-blocking behavior is determined by
     * the `blocking` argument rather than by `socket'`s properties.
     * @param buffer the buffer     containing the data to send.
     * @param blocking whether to do blocking or non-blocking I/O
     * @param cancellable a %GCancellable or %NULL
     * @returns Number of bytes written (which may be less than @size), or -1 on error
     */
    sendWithBlocking(
      buffer: number[],
      blocking: boolean,
      cancellable: Cancellable | null
    ): number
    /**
     * Sets the blocking mode of the socket. In blocking mode
     * all operations (which don’t take an explicit blocking parameter) block until
     * they succeed or there is an error. In
     * non-blocking mode all functions return results immediately or
     * with a %G_IO_ERROR_WOULD_BLOCK error.
     *
     * All sockets are created in blocking mode. However, note that the
     * platform level socket is always non-blocking, and blocking mode
     * is a GSocket level feature.
     * @param blocking Whether to use blocking I/O or not.
     */
    setBlocking(blocking: boolean): void
    /**
     * Sets whether `socket` should allow sending to broadcast addresses.
     * This is %FALSE by default.
     * @param broadcast whether `socket` should allow sending to broadcast     addresses
     */
    setBroadcast(broadcast: boolean): void
    /**
     * Sets or unsets the %SO_KEEPALIVE flag on the underlying socket. When
     * this flag is set on a socket, the system will attempt to verify that the
     * remote socket endpoint is still present if a sufficiently long period of
     * time passes with no data being exchanged. If the system is unable to
     * verify the presence of the remote endpoint, it will automatically close
     * the connection.
     *
     * This option is only functional on certain kinds of sockets. (Notably,
     * %G_SOCKET_PROTOCOL_TCP sockets.)
     *
     * The exact time between pings is system- and protocol-dependent, but will
     * normally be at least two hours. Most commonly, you would set this flag
     * on a server socket if you want to allow clients to remain idle for long
     * periods of time, but also want to ensure that connections are eventually
     * garbage-collected if clients crash or become unreachable.
     * @param keepalive Value for the keepalive flag
     */
    setKeepalive(keepalive: boolean): void
    /**
     * Sets the maximum number of outstanding connections allowed
     * when listening on this socket. If more clients than this are
     * connecting to the socket and the application is not handling them
     * on time then the new connections will be refused.
     *
     * Note that this must be called before g_socket_listen() and has no
     * effect if called after that.
     * @param backlog the maximum number of pending connections.
     */
    setListenBacklog(backlog: number): void
    /**
     * Sets whether outgoing multicast packets will be received by sockets
     * listening on that multicast address on the same host. This is %TRUE
     * by default.
     * @param loopback whether `socket` should receive messages sent to its   multicast groups from the local host
     */
    setMulticastLoopback(loopback: boolean): void
    /**
     * Sets the time-to-live for outgoing multicast datagrams on `socket`.
     * By default, this is 1, meaning that multicast packets will not leave
     * the local network.
     * @param ttl the time-to-live value for all multicast datagrams on `socket`
     */
    setMulticastTtl(ttl: number): void
    /**
     * Sets the value of an integer-valued option on `socket,` as with
     * setsockopt(). (If you need to set a non-integer-valued option,
     * you will need to call setsockopt() directly.)
     *
     * The [<gio/gnetworking.h>][gio-gnetworking.h]
     * header pulls in system headers that will define most of the
     * standard/portable socket options. For unusual socket protocols or
     * platform-dependent options, you may need to include additional
     * headers.
     * @param level the "API level" of the option (eg, `SOL_SOCKET`)
     * @param optname the "name" of the option (eg, `SO_BROADCAST`)
     * @param value the value to set the option to
     * @returns success or failure. On failure, @error will be set, and   the system error value (`errno` or WSAGetLastError()) will still   be set to the result of the setsockopt() call.
     */
    setOption(level: number, optname: number, value: number): boolean
    /**
     * Sets the time in seconds after which I/O operations on `socket` will
     * time out if they have not yet completed.
     *
     * On a blocking socket, this means that any blocking #GSocket
     * operation will time out after `timeout` seconds of inactivity,
     * returning %G_IO_ERROR_TIMED_OUT.
     *
     * On a non-blocking socket, calls to g_socket_condition_wait() will
     * also fail with %G_IO_ERROR_TIMED_OUT after the given time. Sources
     * created with g_socket_create_source() will trigger after
     * `timeout` seconds of inactivity, with the requested condition
     * set, at which point calling g_socket_receive(), g_socket_send(),
     * g_socket_check_connect_result(), etc, will fail with
     * %G_IO_ERROR_TIMED_OUT.
     *
     * If `timeout` is 0 (the default), operations will never time out
     * on their own.
     *
     * Note that if an I/O operation is interrupted by a signal, this may
     * cause the timeout to be reset.
     * @param timeout the timeout for `socket,` in seconds, or 0 for none
     */
    setTimeout(timeout: number): void
    /**
     * Sets the time-to-live for outgoing unicast packets on `socket`.
     * By default the platform-specific default value is used.
     * @param ttl the time-to-live value for all unicast packets on `socket`
     */
    setTtl(ttl: number): void
    /**
     * Shut down part or all of a full-duplex connection.
     *
     * If `shutdown_read` is %TRUE then the receiving side of the connection
     * is shut down, and further reading is disallowed.
     *
     * If `shutdown_write` is %TRUE then the sending side of the connection
     * is shut down, and further writing is disallowed.
     *
     * It is allowed for both `shutdown_read` and `shutdown_write` to be %TRUE.
     *
     * One example where it is useful to shut down only one side of a connection is
     * graceful disconnect for TCP connections where you close the sending side,
     * then wait for the other side to close the connection, thus ensuring that the
     * other side saw all sent data.
     * @param shutdownRead whether to shut down the read side
     * @param shutdownWrite whether to shut down the write side
     * @returns %TRUE on success, %FALSE on error
     */
    shutdown(shutdownRead: boolean, shutdownWrite: boolean): boolean
    /**
     * Checks if a socket is capable of speaking IPv4.
     *
     * IPv4 sockets are capable of speaking IPv4.  On some operating systems
     * and under some combinations of circumstances IPv6 sockets are also
     * capable of speaking IPv4.  See RFC 3493 section 3.7 for more
     * information.
     *
     * No other types of sockets are currently considered as being capable
     * of speaking IPv4.
     * @returns %TRUE if this socket can be used with IPv4.
     */
    speaksIpv4(): boolean

    // Class property signals of Gio-2.0.Gio.Socket

    connect(
      sigName: "notify::blocking",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::blocking",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::blocking",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::blocking",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::blocking", ...args: any[]): void
    connect(
      sigName: "notify::broadcast",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::broadcast",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::broadcast",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::broadcast",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::broadcast", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(sigName: "notify::fd", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fd",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fd", ...args: any[]): void
    connect(
      sigName: "notify::keepalive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::keepalive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::keepalive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::keepalive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::keepalive", ...args: any[]): void
    connect(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::listen-backlog", ...args: any[]): void
    connect(
      sigName: "notify::local-address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::local-address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::local-address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::local-address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::local-address", ...args: any[]): void
    connect(
      sigName: "notify::multicast-loopback",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::multicast-loopback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::multicast-loopback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::multicast-loopback",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::multicast-loopback", ...args: any[]): void
    connect(
      sigName: "notify::multicast-ttl",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::multicast-ttl",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::multicast-ttl",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::multicast-ttl",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::multicast-ttl", ...args: any[]): void
    connect(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol", ...args: any[]): void
    connect(
      sigName: "notify::remote-address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::remote-address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::remote-address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::remote-address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::remote-address", ...args: any[]): void
    connect(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::timeout", ...args: any[]): void
    connect(sigName: "notify::ttl", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ttl",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ttl",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ttl",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ttl", ...args: any[]): void
    connect(sigName: "notify::type", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GSocket` is a low-level networking primitive. It is a more or less
   * direct mapping of the BSD socket API in a portable GObject based API.
   * It supports both the UNIX socket implementations and winsock2 on Windows.
   *
   * `GSocket` is the platform independent base upon which the higher level
   * network primitives are based. Applications are not typically meant to
   * use it directly, but rather through classes like [class`Gio`.SocketClient],
   * [class`Gio`.SocketService] and [class`Gio`.SocketConnection]. However there may
   * be cases where direct use of `GSocket` is useful.
   *
   * `GSocket` implements the [iface`Gio`.Initable] interface, so if it is manually
   * constructed by e.g. [ctor`GObject`.Object.new] you must call
   * [method`Gio`.Initable.init] and check the results before using the object.
   * This is done automatically in [ctor`Gio`.Socket.new] and
   * [ctor`Gio`.Socket.new_from_fd], so these functions can return `NULL`.
   *
   * Sockets operate in two general modes, blocking or non-blocking. When
   * in blocking mode all operations (which don’t take an explicit blocking
   * parameter) block until the requested operation
   * is finished or there is an error. In non-blocking mode all calls that
   * would block return immediately with a `G_IO_ERROR_WOULD_BLOCK` error.
   * To know when a call would successfully run you can call
   * [method`Gio`.Socket.condition_check], or [method`Gio`.Socket.condition_wait].
   * You can also use [method`Gio`.Socket.create_source] and attach it to a
   * [type`GLib`.MainContext] to get callbacks when I/O is possible.
   * Note that all sockets are always set to non blocking mode in the system, and
   * blocking mode is emulated in `GSocket`.
   *
   * When working in non-blocking mode applications should always be able to
   * handle getting a `G_IO_ERROR_WOULD_BLOCK` error even when some other
   * function said that I/O was possible. This can easily happen in case
   * of a race condition in the application, but it can also happen for other
   * reasons. For instance, on Windows a socket is always seen as writable
   * until a write returns `G_IO_ERROR_WOULD_BLOCK`.
   *
   * `GSocket`s can be either connection oriented or datagram based.
   * For connection oriented types you must first establish a connection by
   * either connecting to an address or accepting a connection from another
   * address. For connectionless socket types the target/source address is
   * specified or received in each I/O operation.
   *
   * All socket file descriptors are set to be close-on-exec.
   *
   * Note that creating a `GSocket` causes the signal `SIGPIPE` to be
   * ignored for the remainder of the program. If you are writing a
   * command-line utility that uses `GSocket`, you may need to take into
   * account the fact that your program will not automatically be killed
   * if it tries to write to `stdout` after it has been closed.
   *
   * Like most other APIs in GLib, `GSocket` is not inherently thread safe. To use
   * a `GSocket` concurrently from multiple threads, you must implement your own
   * locking.
   *
   * ## Nagle’s algorithm
   *
   * Since GLib 2.80, `GSocket` will automatically set the `TCP_NODELAY` option on
   * all `G_SOCKET_TYPE_STREAM` sockets. This disables
   * [Nagle’s algorithm](https://en.wikipedia.org/wiki/Nagle%27s_algorithm) as it
   * typically does more harm than good on modern networks.
   *
   * If your application needs Nagle’s algorithm enabled, call
   * [method`Gio`.Socket.set_option] after constructing a `GSocket` to enable it:
   * ```c
   * socket = g_socket_new (…, G_SOCKET_TYPE_STREAM, …);
   * if (socket != NULL)
   *   {
   *     g_socket_set_option (socket, IPPROTO_TCP, TCP_NODELAY, FALSE, &local_error);
   *     // handle error if needed
   *   }
   * ```
   * @class
   */
  class Socket extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Socket

    static name: string

    // Constructors of Gio-2.0.Gio.Socket

    constructor(config?: Socket.ConstructorProperties)
    /**
     * Creates a new #GSocket with the defined family, type and protocol.
     * If `protocol` is 0 (%G_SOCKET_PROTOCOL_DEFAULT) the default protocol type
     * for the family and type is used.
     *
     * The `protocol` is a family and type specific int that specifies what
     * kind of protocol to use. #GSocketProtocol lists several common ones.
     * Many families only support one protocol, and use 0 for this, others
     * support several and using 0 means to use the default protocol for
     * the family and type.
     *
     * The protocol id is passed directly to the operating
     * system, so you can use protocols not listed in #GSocketProtocol if you
     * know the protocol number used for it.
     * @constructor
     * @param family the socket family to use, e.g. %G_SOCKET_FAMILY_IPV4.
     * @param type the socket type to use.
     * @param protocol the id of the protocol to use, or 0 for default.
     * @returns a #GSocket or %NULL on error.     Free the returned object with g_object_unref().
     */
    constructor(
      family: SocketFamily,
      type: SocketType,
      protocol: SocketProtocol
    )
    /**
     * Creates a new #GSocket with the defined family, type and protocol.
     * If `protocol` is 0 (%G_SOCKET_PROTOCOL_DEFAULT) the default protocol type
     * for the family and type is used.
     *
     * The `protocol` is a family and type specific int that specifies what
     * kind of protocol to use. #GSocketProtocol lists several common ones.
     * Many families only support one protocol, and use 0 for this, others
     * support several and using 0 means to use the default protocol for
     * the family and type.
     *
     * The protocol id is passed directly to the operating
     * system, so you can use protocols not listed in #GSocketProtocol if you
     * know the protocol number used for it.
     * @constructor
     * @param family the socket family to use, e.g. %G_SOCKET_FAMILY_IPV4.
     * @param type the socket type to use.
     * @param protocol the id of the protocol to use, or 0 for default.
     * @returns a #GSocket or %NULL on error.     Free the returned object with g_object_unref().
     */
    static new(
      family: SocketFamily,
      type: SocketType,
      protocol: SocketProtocol
    ): Socket
    /**
     * Creates a new #GSocket from a native file descriptor
     * or winsock SOCKET handle.
     *
     * This reads all the settings from the file descriptor so that
     * all properties should work. Note that the file descriptor
     * will be set to non-blocking mode, independent on the blocking
     * mode of the #GSocket.
     *
     * On success, the returned #GSocket takes ownership of `fd`. On failure, the
     * caller must close `fd` themselves.
     *
     * Since GLib 2.46, it is no longer a fatal error to call this on a non-socket
     * descriptor.  Instead, a GError will be set with code %G_IO_ERROR_FAILED
     * @constructor
     * @param fd a native socket file descriptor.
     * @returns a #GSocket or %NULL on error.     Free the returned object with g_object_unref().
     */
    static newFromFd(fd: number): Socket
    _init(config?: Socket.ConstructorProperties): void
  }

  module SocketAddress {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnectable.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface SocketAddress extends SocketConnectable {
    // Own properties of Gio-2.0.Gio.SocketAddress

    /**
     * The family of the socket address.
     */
    readonly family: SocketFamily
    __gtype__: number

    // Own fields of Gio-2.0.Gio.SocketAddress

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.SocketAddress

    // Has conflict: getFamily(): SocketFamily
    // Has conflict: getNativeSize(): number
    // Has conflict: toNative(dest: any | null, destlen: number): boolean

    // Own virtual methods of Gio-2.0.Gio.SocketAddress

    /**
     * Gets the socket family type of `address`.
     * @virtual
     * @returns the socket family type of @address
     */
    getFamily(): SocketFamily
    /**
     * Gets the size of `address'`s native struct sockaddr.
     * You can use this to allocate memory to pass to
     * g_socket_address_to_native().
     * @virtual
     * @returns the size of the native struct sockaddr that     @address represents
     */
    getNativeSize(): number
    /**
     * Converts a #GSocketAddress to a native struct sockaddr, which can
     * be passed to low-level functions like connect() or bind().
     *
     * If not enough space is available, a %G_IO_ERROR_NO_SPACE error
     * is returned. If the address type is not known on the system
     * then a %G_IO_ERROR_NOT_SUPPORTED error is returned.
     * @virtual
     * @param dest a pointer to a memory location that will contain the native struct sockaddr
     * @param destlen the size of `dest`. Must be at least as large as     g_socket_address_get_native_size()
     * @returns %TRUE if @dest was filled in, %FALSE on error
     */
    toNative(dest: any | null, destlen: number): boolean

    // Class property signals of Gio-2.0.Gio.SocketAddress

    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSocketAddress` is the equivalent of
   * [`struct sockaddr`](man:sockaddr(3type)) and its subtypes in the BSD sockets
   * API. This is an abstract class; use [class`Gio`.InetSocketAddress] for
   * internet sockets, or [class`Gio`.UnixSocketAddress] for UNIX domain sockets.
   * @class
   */
  class SocketAddress extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SocketAddress

    static name: string

    // Constructors of Gio-2.0.Gio.SocketAddress

    constructor(config?: SocketAddress.ConstructorProperties)
    /**
     * Creates a #GSocketAddress subclass corresponding to the native
     * struct sockaddr `native`.
     * @constructor
     * @param native a pointer to a struct sockaddr
     * @param len the size of the memory location pointed to by `native`
     * @returns a new #GSocketAddress if @native could successfully     be converted, otherwise %NULL
     */
    static newFromNative(native: any, len: number): SocketAddress
    _init(config?: SocketAddress.ConstructorProperties): void
  }

  module SocketAddressEnumerator {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface SocketAddressEnumerator {
    // Own properties of Gio-2.0.Gio.SocketAddressEnumerator

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.SocketAddressEnumerator

    // Has conflict: next(cancellable: Cancellable | null): SocketAddress | null
    // Has conflict: nextAsync(cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: nextFinish(result: AsyncResult): SocketAddress | null

    // Own virtual methods of Gio-2.0.Gio.SocketAddressEnumerator

    /**
     * Retrieves the next #GSocketAddress from `enumerator`. Note that this
     * may block for some amount of time. (Eg, a #GNetworkAddress may need
     * to do a DNS lookup before it can return an address.) Use
     * g_socket_address_enumerator_next_async() if you need to avoid
     * blocking.
     *
     * If `enumerator` is expected to yield addresses, but for some reason
     * is unable to (eg, because of a DNS error), then the first call to
     * g_socket_address_enumerator_next() will return an appropriate error
     * in *`error`. However, if the first call to
     * g_socket_address_enumerator_next() succeeds, then any further
     * internal errors (other than `cancellable` being triggered) will be
     * ignored.
     * @virtual
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #GSocketAddress (owned by the caller), or %NULL on     error (in which case *@error will be set) or if there are no     more addresses.
     */
    next(cancellable: Cancellable | null): SocketAddress | null
    /**
     * Asynchronously retrieves the next #GSocketAddress from `enumerator`
     * and then calls `callback,` which must call
     * g_socket_address_enumerator_next_finish() to get the result.
     *
     * It is an error to call this multiple times before the previous callback has finished.
     * @virtual
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
     */
    nextAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Retrieves the result of a completed call to
     * g_socket_address_enumerator_next_async(). See
     * g_socket_address_enumerator_next() for more information about
     * error handling.
     * @virtual
     * @param result a #GAsyncResult
     * @returns a #GSocketAddress (owned by the caller), or %NULL on     error (in which case *@error will be set) or if there are no     more addresses.
     */
    nextFinish(result: AsyncResult): SocketAddress | null

    // Class property signals of Gio-2.0.Gio.SocketAddressEnumerator

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSocketAddressEnumerator` is an enumerator type for
   * [class`Gio`.SocketAddress] instances. It is returned by enumeration functions
   * such as [method`Gio`.SocketConnectable.enumerate], which returns a
   * `GSocketAddressEnumerator` to list each [class`Gio`.SocketAddress] which could
   * be used to connect to that [iface`Gio`.SocketConnectable].
   *
   * Enumeration is typically a blocking operation, so the asynchronous methods
   * [method`Gio`.SocketAddressEnumerator.next_async] and
   * [method`Gio`.SocketAddressEnumerator.next_finish] should be used where
   * possible.
   *
   * Each `GSocketAddressEnumerator` can only be enumerated once. Once
   * [method`Gio`.SocketAddressEnumerator.next] has returned `NULL`, further
   * enumeration with that `GSocketAddressEnumerator` is not possible, and it can
   * be unreffed.
   * @class
   */
  class SocketAddressEnumerator extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SocketAddressEnumerator

    static name: string

    // Constructors of Gio-2.0.Gio.SocketAddressEnumerator

    constructor(config?: SocketAddressEnumerator.ConstructorProperties)
    _init(config?: SocketAddressEnumerator.ConstructorProperties): void
  }

  module SocketClient {
    // Signal callback interfaces

    /**
     * Signal callback interface for `event`
     */
    interface EventSignalCallback {
      (
        event: SocketClientEvent,
        connectable: SocketConnectable,
        connection: IOStream | null
      ): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.SocketClient

      /**
       * Enable proxy support.
       */
      enable_proxy?: boolean | null
      /**
       * The address family to use for socket construction.
       */
      family?: SocketFamily | null
      /**
       * The local address constructed sockets will be bound to.
       */
      local_address?: SocketAddress | null
      /**
       * The protocol to use for socket construction, or `0` for default.
       */
      protocol?: SocketProtocol | null
      /**
       * The proxy resolver to use
       */
      proxy_resolver?: ProxyResolver | null
      /**
       * The I/O timeout for sockets, in seconds, or `0` for none.
       */
      timeout?: number | null
      /**
       * Whether to create TLS connections.
       */
      tls?: boolean | null
      /**
       * The TLS validation flags used when creating TLS connections. The
       * default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
       *
       * GLib guarantees that if certificate verification fails, at least one
       * flag will be set, but it does not guarantee that all possible flags
       * will be set. Accordingly, you may not safely decide to ignore any
       * particular type of error. For example, it would be incorrect to mask
       * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
       * because this could potentially be the only error flag set even if
       * other problems exist with the certificate. Therefore, there is no
       * safe way to use this property. This is not a horrible problem,
       * though, because you should not be attempting to ignore validation
       * errors anyway. If you really must ignore TLS certificate errors,
       * connect to the #GSocketClient::event signal, wait for it to be
       * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, and use that to
       * connect to #GTlsConnection::accept-certificate.
       */
      tls_validation_flags?: TlsCertificateFlags | null
      /**
       * The type to use for socket construction.
       */
      type?: SocketType | null
    }
  }

  interface SocketClient {
    // Own properties of Gio-2.0.Gio.SocketClient

    /**
     * Enable proxy support.
     */
    enableProxy: boolean
    /**
     * The address family to use for socket construction.
     */
    family: SocketFamily
    /**
     * The local address constructed sockets will be bound to.
     */
    localAddress: SocketAddress
    /**
     * The protocol to use for socket construction, or `0` for default.
     */
    protocol: SocketProtocol
    /**
     * The proxy resolver to use
     */
    proxyResolver: ProxyResolver
    /**
     * The I/O timeout for sockets, in seconds, or `0` for none.
     */
    timeout: number
    /**
     * Whether to create TLS connections.
     */
    tls: boolean
    /**
     * The TLS validation flags used when creating TLS connections. The
     * default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
     *
     * GLib guarantees that if certificate verification fails, at least one
     * flag will be set, but it does not guarantee that all possible flags
     * will be set. Accordingly, you may not safely decide to ignore any
     * particular type of error. For example, it would be incorrect to mask
     * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
     * because this could potentially be the only error flag set even if
     * other problems exist with the certificate. Therefore, there is no
     * safe way to use this property. This is not a horrible problem,
     * though, because you should not be attempting to ignore validation
     * errors anyway. If you really must ignore TLS certificate errors,
     * connect to the #GSocketClient::event signal, wait for it to be
     * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, and use that to
     * connect to #GTlsConnection::accept-certificate.
     */
    tlsValidationFlags: TlsCertificateFlags
    /**
     * The type to use for socket construction.
     */
    type: SocketType
    __gtype__: number

    // Own fields of Gio-2.0.Gio.SocketClient

    parentInstance: GObject.Object
    priv: SocketClientPrivate

    // Owm methods of Gio-2.0.Gio.SocketClient

    /**
     * Enable proxy protocols to be handled by the application. When the
     * indicated proxy protocol is returned by the #GProxyResolver,
     * #GSocketClient will consider this protocol as supported but will
     * not try to find a #GProxy instance to handle handshaking. The
     * application must check for this case by calling
     * g_socket_connection_get_remote_address() on the returned
     * #GSocketConnection, and seeing if it's a #GProxyAddress of the
     * appropriate type, to determine whether or not it needs to handle
     * the proxy handshaking itself.
     *
     * This should be used for proxy protocols that are dialects of
     * another protocol such as HTTP proxy. It also allows cohabitation of
     * proxy protocols that are reused between protocols. A good example
     * is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also
     * be use as generic socket proxy through the HTTP CONNECT method.
     *
     * When the proxy is detected as being an application proxy, TLS handshake
     * will be skipped. This is required to let the application do the proxy
     * specific handshake.
     * @param protocol The proxy protocol
     */
    addApplicationProxy(protocol: string): void
    /**
     * Tries to resolve the `connectable` and make a network connection to it.
     *
     * Upon a successful connection, a new #GSocketConnection is constructed
     * and returned.  The caller owns this new object and must drop their
     * reference to it when finished with it.
     *
     * The type of the #GSocketConnection object returned depends on the type of
     * the underlying socket that is used. For instance, for a TCP/IP connection
     * it will be a #GTcpConnection.
     *
     * The socket created will be the same family as the address that the
     * `connectable` resolves to, unless family is set with g_socket_client_set_family()
     * or indirectly via g_socket_client_set_local_address(). The socket type
     * defaults to %G_SOCKET_TYPE_STREAM but can be set with
     * g_socket_client_set_socket_type().
     *
     * If a local address is specified with g_socket_client_set_local_address() the
     * socket will be bound to this address before connecting.
     * @param connectable a #GSocketConnectable specifying the remote address.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    connect(
      connectable: SocketConnectable,
      cancellable: Cancellable | null
    ): SocketConnection
    /**
     * This is the asynchronous version of g_socket_client_connect().
     *
     * You may wish to prefer the asynchronous version even in synchronous
     * command line programs because, since 2.60, it implements
     * [RFC 8305](https://tools.ietf.org/html/rfc8305) "Happy Eyeballs"
     * recommendations to work around long connection timeouts in networks
     * where IPv6 is broken by performing an IPv4 connection simultaneously
     * without waiting for IPv6 to time out, which is not supported by the
     * synchronous call. (This is not an API guarantee, and may change in
     * the future.)
     *
     * When the operation is finished `callback` will be
     * called. You can then call g_socket_client_connect_finish() to get
     * the result of the operation.
     * @param connectable a #GSocketConnectable specifying the remote address.
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback
     */
    connectAsync(
      connectable: SocketConnectable,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async connect operation. See g_socket_client_connect_async()
     * @param result a #GAsyncResult.
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    connectFinish(result: AsyncResult): SocketConnection
    /**
     * This is a helper function for g_socket_client_connect().
     *
     * Attempts to create a TCP connection to the named host.
     *
     * `host_and_port` may be in any of a number of recognized formats; an IPv6
     * address, an IPv4 address, or a domain name (in which case a DNS
     * lookup is performed).  Quoting with [] is supported for all address
     * types.  A port override may be specified in the usual way with a
     * colon.  Ports may be given as decimal numbers or symbolic names (in
     * which case an /etc/services lookup is performed).
     *
     * If no port override is given in `host_and_port` then `default_port` will be
     * used as the port number to connect to.
     *
     * In general, `host_and_port` is expected to be provided by the user (allowing
     * them to give the hostname, and a port override if necessary) and
     * `default_port` is expected to be provided by the application.
     *
     * In the case that an IP address is given, a single connection
     * attempt is made.  In the case that a name is given, multiple
     * connection attempts may be made, in turn and according to the
     * number of address records in DNS, until a connection succeeds.
     *
     * Upon a successful connection, a new #GSocketConnection is constructed
     * and returned.  The caller owns this new object and must drop their
     * reference to it when finished with it.
     *
     * In the event of any failure (DNS error, service not found, no hosts
     * connectable) %NULL is returned and `error` (if non-%NULL) is set
     * accordingly.
     * @param hostAndPort the name and optionally port of the host to connect to
     * @param defaultPort the default port to connect to
     * @param cancellable a #GCancellable, or %NULL
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    connectToHost(
      hostAndPort: string,
      defaultPort: number,
      cancellable: Cancellable | null
    ): SocketConnection
    /**
     * This is the asynchronous version of g_socket_client_connect_to_host().
     *
     * When the operation is finished `callback` will be
     * called. You can then call g_socket_client_connect_to_host_finish() to get
     * the result of the operation.
     * @param hostAndPort the name and optionally the port of the host to connect to
     * @param defaultPort the default port to connect to
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback
     */
    connectToHostAsync(
      hostAndPort: string,
      defaultPort: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
     * @param result a #GAsyncResult.
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    connectToHostFinish(result: AsyncResult): SocketConnection
    /**
     * Attempts to create a TCP connection to a service.
     *
     * This call looks up the SRV record for `service` at `domain` for the
     * "tcp" protocol.  It then attempts to connect, in turn, to each of
     * the hosts providing the service until either a connection succeeds
     * or there are no hosts remaining.
     *
     * Upon a successful connection, a new #GSocketConnection is constructed
     * and returned.  The caller owns this new object and must drop their
     * reference to it when finished with it.
     *
     * In the event of any failure (DNS error, service not found, no hosts
     * connectable) %NULL is returned and `error` (if non-%NULL) is set
     * accordingly.
     * @param domain a domain name
     * @param service the name of the service to connect to
     * @param cancellable a #GCancellable, or %NULL
     * @returns a #GSocketConnection if successful, or %NULL on error
     */
    connectToService(
      domain: string,
      service: string,
      cancellable: Cancellable | null
    ): SocketConnection
    /**
     * This is the asynchronous version of
     * g_socket_client_connect_to_service().
     * @param domain a domain name
     * @param service the name of the service to connect to
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback
     */
    connectToServiceAsync(
      domain: string,
      service: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
     * @param result a #GAsyncResult.
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    connectToServiceFinish(result: AsyncResult): SocketConnection
    /**
     * This is a helper function for g_socket_client_connect().
     *
     * Attempts to create a TCP connection with a network URI.
     *
     * `uri` may be any valid URI containing an "authority" (hostname/port)
     * component. If a port is not specified in the URI, `default_port`
     * will be used. TLS will be negotiated if #GSocketClient:tls is %TRUE.
     * (#GSocketClient does not know to automatically assume TLS for
     * certain URI schemes.)
     *
     * Using this rather than g_socket_client_connect() or
     * g_socket_client_connect_to_host() allows #GSocketClient to
     * determine when to use application-specific proxy protocols.
     *
     * Upon a successful connection, a new #GSocketConnection is constructed
     * and returned.  The caller owns this new object and must drop their
     * reference to it when finished with it.
     *
     * In the event of any failure (DNS error, service not found, no hosts
     * connectable) %NULL is returned and `error` (if non-%NULL) is set
     * accordingly.
     * @param uri A network URI
     * @param defaultPort the default port to connect to
     * @param cancellable a #GCancellable, or %NULL
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    connectToUri(
      uri: string,
      defaultPort: number,
      cancellable: Cancellable | null
    ): SocketConnection
    /**
     * This is the asynchronous version of g_socket_client_connect_to_uri().
     *
     * When the operation is finished `callback` will be
     * called. You can then call g_socket_client_connect_to_uri_finish() to get
     * the result of the operation.
     * @param uri a network uri
     * @param defaultPort the default port to connect to
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback
     */
    connectToUriAsync(
      uri: string,
      defaultPort: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async connect operation. See g_socket_client_connect_to_uri_async()
     * @param result a #GAsyncResult.
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    connectToUriFinish(result: AsyncResult): SocketConnection
    /**
     * Gets the proxy enable state; see g_socket_client_set_enable_proxy()
     * @returns whether proxying is enabled
     */
    getEnableProxy(): boolean
    /**
     * Gets the socket family of the socket client.
     *
     * See g_socket_client_set_family() for details.
     * @returns a #GSocketFamily
     */
    getFamily(): SocketFamily
    /**
     * Gets the local address of the socket client.
     *
     * See g_socket_client_set_local_address() for details.
     * @returns a #GSocketAddress or %NULL. Do not free.
     */
    getLocalAddress(): SocketAddress | null
    /**
     * Gets the protocol name type of the socket client.
     *
     * See g_socket_client_set_protocol() for details.
     * @returns a #GSocketProtocol
     */
    getProtocol(): SocketProtocol
    /**
     * Gets the #GProxyResolver being used by `client`. Normally, this will
     * be the resolver returned by g_proxy_resolver_get_default(), but you
     * can override it with g_socket_client_set_proxy_resolver().
     * @returns The #GProxyResolver being used by   @client.
     */
    getProxyResolver(): ProxyResolver
    /**
     * Gets the socket type of the socket client.
     *
     * See g_socket_client_set_socket_type() for details.
     * @returns a #GSocketFamily
     */
    getSocketType(): SocketType
    /**
     * Gets the I/O timeout time for sockets created by `client`.
     *
     * See g_socket_client_set_timeout() for details.
     * @returns the timeout in seconds
     */
    getTimeout(): number
    /**
     * Gets whether `client` creates TLS connections. See
     * g_socket_client_set_tls() for details.
     * @returns whether @client uses TLS
     */
    getTls(): boolean
    /**
     * Gets the TLS validation flags used creating TLS connections via
     * `client`.
     *
     * This function does not work as originally designed and is impossible
     * to use correctly. See #GSocketClient:tls-validation-flags for more
     * information.
     * @returns the TLS validation flags
     */
    getTlsValidationFlags(): TlsCertificateFlags
    /**
     * Sets whether or not `client` attempts to make connections via a
     * proxy server. When enabled (the default), #GSocketClient will use a
     * #GProxyResolver to determine if a proxy protocol such as SOCKS is
     * needed, and automatically do the necessary proxy negotiation.
     *
     * See also g_socket_client_set_proxy_resolver().
     * @param enable whether to enable proxies
     */
    setEnableProxy(enable: boolean): void
    /**
     * Sets the socket family of the socket client.
     * If this is set to something other than %G_SOCKET_FAMILY_INVALID
     * then the sockets created by this object will be of the specified
     * family.
     *
     * This might be useful for instance if you want to force the local
     * connection to be an ipv4 socket, even though the address might
     * be an ipv6 mapped to ipv4 address.
     * @param family a #GSocketFamily
     */
    setFamily(family: SocketFamily): void
    /**
     * Sets the local address of the socket client.
     * The sockets created by this object will bound to the
     * specified address (if not %NULL) before connecting.
     *
     * This is useful if you want to ensure that the local
     * side of the connection is on a specific port, or on
     * a specific interface.
     * @param address a #GSocketAddress, or %NULL
     */
    setLocalAddress(address: SocketAddress | null): void
    /**
     * Sets the protocol of the socket client.
     * The sockets created by this object will use of the specified
     * protocol.
     *
     * If `protocol` is %G_SOCKET_PROTOCOL_DEFAULT that means to use the default
     * protocol for the socket family and type.
     * @param protocol a #GSocketProtocol
     */
    setProtocol(protocol: SocketProtocol): void
    /**
     * Overrides the #GProxyResolver used by `client`. You can call this if
     * you want to use specific proxies, rather than using the system
     * default proxy settings.
     *
     * Note that whether or not the proxy resolver is actually used
     * depends on the setting of #GSocketClient:enable-proxy, which is not
     * changed by this function (but which is %TRUE by default)
     * @param proxyResolver a #GProxyResolver, or %NULL for the   default.
     */
    setProxyResolver(proxyResolver: ProxyResolver | null): void
    /**
     * Sets the socket type of the socket client.
     * The sockets created by this object will be of the specified
     * type.
     *
     * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
     * as GSocketClient is used for connection oriented services.
     * @param type a #GSocketType
     */
    setSocketType(type: SocketType): void
    /**
     * Sets the I/O timeout for sockets created by `client`. `timeout` is a
     * time in seconds, or 0 for no timeout (the default).
     *
     * The timeout value affects the initial connection attempt as well,
     * so setting this may cause calls to g_socket_client_connect(), etc,
     * to fail with %G_IO_ERROR_TIMED_OUT.
     * @param timeout the timeout
     */
    setTimeout(timeout: number): void
    /**
     * Sets whether `client` creates TLS (aka SSL) connections. If `tls` is
     * %TRUE, `client` will wrap its connections in a #GTlsClientConnection
     * and perform a TLS handshake when connecting.
     *
     * Note that since #GSocketClient must return a #GSocketConnection,
     * but #GTlsClientConnection is not a #GSocketConnection, this
     * actually wraps the resulting #GTlsClientConnection in a
     * #GTcpWrapperConnection when returning it. You can use
     * g_tcp_wrapper_connection_get_base_io_stream() on the return value
     * to extract the #GTlsClientConnection.
     *
     * If you need to modify the behavior of the TLS handshake (eg, by
     * setting a client-side certificate to use, or connecting to the
     * #GTlsConnection::accept-certificate signal), you can connect to
     * `client'`s #GSocketClient::event signal and wait for it to be
     * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, which will give you
     * a chance to see the #GTlsClientConnection before the handshake
     * starts.
     * @param tls whether to use TLS
     */
    setTls(tls: boolean): void
    /**
     * Sets the TLS validation flags used when creating TLS connections
     * via `client`. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
     *
     * This function does not work as originally designed and is impossible
     * to use correctly. See #GSocketClient:tls-validation-flags for more
     * information.
     * @param flags the validation flags
     */
    setTlsValidationFlags(flags: TlsCertificateFlags): void

    // Own virtual methods of Gio-2.0.Gio.SocketClient

    event(
      event: SocketClientEvent,
      connectable: SocketConnectable,
      connection: IOStream
    ): void

    // Own signals of Gio-2.0.Gio.SocketClient

    connect(
      sigName: "event",
      callback: SocketClient.EventSignalCallback
    ): number
    on(
      sigName: "event",
      callback: SocketClient.EventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "event",
      callback: SocketClient.EventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "event",
      callback: SocketClient.EventSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "event",
      connectable: SocketConnectable,
      connection: IOStream | null,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.SocketClient

    connect(
      sigName: "notify::enable-proxy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-proxy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-proxy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-proxy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-proxy", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::local-address",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::local-address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::local-address",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::local-address",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::local-address", ...args: any[]): void
    connect(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol", ...args: any[]): void
    connect(
      sigName: "notify::proxy-resolver",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::proxy-resolver",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::proxy-resolver",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::proxy-resolver",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::proxy-resolver", ...args: any[]): void
    connect(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::timeout", ...args: any[]): void
    connect(sigName: "notify::tls", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tls",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tls",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tls",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tls", ...args: any[]): void
    connect(
      sigName: "notify::tls-validation-flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tls-validation-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tls-validation-flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tls-validation-flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tls-validation-flags", ...args: any[]): void
    connect(sigName: "notify::type", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSocketClient` is a lightweight high-level utility class for connecting to
   * a network host using a connection oriented socket type.
   *
   * You create a `GSocketClient` object, set any options you want, and then
   * call a sync or async connect operation, which returns a
   * [class`Gio`.SocketConnection] subclass on success.
   *
   * The type of the [class`Gio`.SocketConnection] object returned depends on the
   * type of the underlying socket that is in use. For instance, for a TCP/IP
   * connection it will be a [class`Gio`.TcpConnection].
   *
   * As `GSocketClient` is a lightweight object, you don't need to cache it. You
   * can just create a new one any time you need one.
   * @class
   */
  class SocketClient extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SocketClient

    static name: string

    // Constructors of Gio-2.0.Gio.SocketClient

    constructor(config?: SocketClient.ConstructorProperties)
    /**
     * Creates a new #GSocketClient with the default options.
     * @constructor
     * @returns a #GSocketClient.     Free the returned object with g_object_unref().
     */
    constructor()
    /**
     * Creates a new #GSocketClient with the default options.
     * @constructor
     * @returns a #GSocketClient.     Free the returned object with g_object_unref().
     */
    static new(): SocketClient
    _init(config?: SocketClient.ConstructorProperties): void
  }

  module SocketConnection {
    // Constructor properties interface

    interface ConstructorProperties extends IOStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.SocketConnection

      /**
       * The underlying [class`Gio`.Socket].
       */
      socket?: Socket | null
    }
  }

  interface SocketConnection {
    // Own properties of Gio-2.0.Gio.SocketConnection

    /**
     * The underlying [class`Gio`.Socket].
     */
    readonly socket: Socket
    __gtype__: number

    // Own fields of Gio-2.0.Gio.SocketConnection

    parentInstance: any
    priv: SocketConnectionPrivate

    // Owm methods of Gio-2.0.Gio.SocketConnection

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    /**
     * Asynchronously connect `connection` to the specified remote address.
     *
     * This clears the #GSocket:blocking flag on `connection'`s underlying
     * socket if it is currently set.
     *
     * If #GSocket:timeout is set, the operation will time out and return
     * %G_IO_ERROR_TIMED_OUT after that period. Otherwise, it will continue
     * indefinitely until operating system timeouts (if any) are hit.
     *
     * Use g_socket_connection_connect_finish() to retrieve the result.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @param callback a #GAsyncReadyCallback
     */
    connectAsync(
      address: SocketAddress,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Gets the result of a g_socket_connection_connect_async() call.
     * @param result the #GAsyncResult
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connectFinish(result: AsyncResult): boolean
    /**
     * Try to get the local address of a socket connection.
     * @returns a #GSocketAddress or %NULL on error.     Free the returned object with g_object_unref().
     */
    getLocalAddress(): SocketAddress
    /**
     * Try to get the remote address of a socket connection.
     *
     * Since GLib 2.40, when used with g_socket_client_connect() or
     * g_socket_client_connect_async(), during emission of
     * %G_SOCKET_CLIENT_CONNECTING, this function will return the remote
     * address that will be used for the connection.  This allows
     * applications to print e.g. "Connecting to example.com
     * (10.42.77.3)...".
     * @returns a #GSocketAddress or %NULL on error.     Free the returned object with g_object_unref().
     */
    getRemoteAddress(): SocketAddress
    /**
     * Gets the underlying #GSocket object of the connection.
     * This can be useful if you want to do something unusual on it
     * not supported by the #GSocketConnection APIs.
     * @returns a #GSocket or %NULL on error.
     */
    getSocket(): Socket
    /**
     * Checks if `connection` is connected. This is equivalent to calling
     * g_socket_is_connected() on `connection'`s underlying #GSocket.
     * @returns whether @connection is connected
     */
    isConnected(): boolean

    // Class property signals of Gio-2.0.Gio.SocketConnection

    connect(
      sigName: "notify::socket",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::socket",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::socket", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::output-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSocketConnection` is a [class`Gio`.IOStream] for a connected socket. They
   * can be created either by [class`Gio`.SocketClient] when connecting to a host,
   * or by [class`Gio`.SocketListener] when accepting a new client.
   *
   * The type of the `GSocketConnection` object returned from these calls
   * depends on the type of the underlying socket that is in use. For
   * instance, for a TCP/IP connection it will be a [class`Gio`.TcpConnection].
   *
   * Choosing what type of object to construct is done with the socket
   * connection factory, and it is possible for third parties to register
   * custom socket connection types for specific combination of socket
   * family/type/protocol using [func`Gio`.SocketConnection.factory_register_type].
   *
   * To close a `GSocketConnection`, use [method`Gio`.IOStream.close]. Closing both
   * substreams of the [class`Gio`.IOStream] separately will not close the
   * underlying [class`Gio`.Socket].
   * @class
   */
  class SocketConnection extends IOStream {
    // Own properties of Gio-2.0.Gio.SocketConnection

    static name: string

    // Constructors of Gio-2.0.Gio.SocketConnection

    constructor(config?: SocketConnection.ConstructorProperties)
    _init(config?: SocketConnection.ConstructorProperties): void
    /**
     * Looks up the #GType to be used when creating socket connections on
     * sockets with the specified `family,` `type` and `protocol_id`.
     *
     * If no type is registered, the #GSocketConnection base type is returned.
     * @param family a #GSocketFamily
     * @param type a #GSocketType
     * @param protocolId a protocol id
     * @returns a #GType
     */
    static factoryLookupType(
      family: SocketFamily,
      type: SocketType,
      protocolId: number
    ): GObject.GType
    /**
     * Looks up the #GType to be used when creating socket connections on
     * sockets with the specified `family,` `type` and `protocol`.
     *
     * If no type is registered, the #GSocketConnection base type is returned.
     * @param gType a #GType, inheriting from %G_TYPE_SOCKET_CONNECTION
     * @param family a #GSocketFamily
     * @param type a #GSocketType
     * @param protocol a protocol id
     */
    static factoryRegisterType(
      gType: GObject.GType,
      family: SocketFamily,
      type: SocketType,
      protocol: number
    ): void
  }

  module SocketControlMessage {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface SocketControlMessage {
    // Own properties of Gio-2.0.Gio.SocketControlMessage

    __gtype__: number

    // Own fields of Gio-2.0.Gio.SocketControlMessage

    parentInstance: GObject.Object
    priv: SocketControlMessagePrivate

    // Owm methods of Gio-2.0.Gio.SocketControlMessage

    // Has conflict: getLevel(): number
    /**
     * Returns the protocol specific type of the control message.
     * For instance, for UNIX fd passing this would be SCM_RIGHTS.
     * @returns an integer describing the type of control message
     */
    getMsgType(): number
    // Has conflict: getSize(): number
    // Has conflict: serialize(data: any): void

    // Own virtual methods of Gio-2.0.Gio.SocketControlMessage

    /**
     * Returns the "level" (i.e. the originating protocol) of the control message.
     * This is often SOL_SOCKET.
     * @virtual
     * @returns an integer describing the level
     */
    getLevel(): number
    /**
     * Returns the space required for the control message, not including
     * headers or alignment.
     * @virtual
     * @returns The number of bytes required.
     */
    getSize(): number
    /**
     * gets the protocol specific type of the message.
     * @virtual
     */
    getType(): number
    /**
     * Converts the data in the message to bytes placed in the
     * message.
     *
     * `data` is guaranteed to have enough space to fit the size
     * returned by g_socket_control_message_get_size() on this
     * object.
     * @virtual
     * @param data A buffer to write data to
     */
    serialize(data: any): void

    // Class property signals of Gio-2.0.Gio.SocketControlMessage

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GSocketControlMessage` is a special-purpose utility message that
   * can be sent to or received from a [class`Gio`.Socket]. These types of
   * messages are often called ‘ancillary data’.
   *
   * The message can represent some sort of special instruction to or
   * information from the socket or can represent a special kind of
   * transfer to the peer (for example, sending a file descriptor over
   * a UNIX socket).
   *
   * These messages are sent with [method`Gio`.Socket.send_message] and received
   * with [method`Gio`.Socket.receive_message].
   *
   * To extend the set of control message that can be sent, subclass this
   * class and override the `get_size`, `get_level`, `get_type` and `serialize`
   * methods.
   *
   * To extend the set of control messages that can be received, subclass
   * this class and implement the `deserialize` method. Also, make sure your
   * class is registered with the [type`GObject`.Type] type system before calling
   * [method`Gio`.Socket.receive_message] to read such a message.
   * @class
   */
  class SocketControlMessage extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SocketControlMessage

    static name: string

    // Constructors of Gio-2.0.Gio.SocketControlMessage

    constructor(config?: SocketControlMessage.ConstructorProperties)
    _init(config?: SocketControlMessage.ConstructorProperties): void
    /**
     * Tries to deserialize a socket control message of a given
     * `level` and `type`. This will ask all known (to GType) subclasses
     * of #GSocketControlMessage if they can understand this kind
     * of message and if so deserialize it into a #GSocketControlMessage.
     *
     * If there is no implementation for this kind of control message, %NULL
     * will be returned.
     * @param level a socket level
     * @param type a socket control message type for the given `level`
     * @param data pointer to the message data
     * @returns the deserialized message or %NULL
     */
    static deserialize(
      level: number,
      type: number,
      data: number[]
    ): SocketControlMessage | null
  }

  module SocketListener {
    // Signal callback interfaces

    /**
     * Signal callback interface for `event`
     */
    interface EventSignalCallback {
      (event: SocketListenerEvent, socket: Socket): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.SocketListener

      /**
       * The number of outstanding connections in the listen queue.
       */
      listen_backlog?: number | null
    }
  }

  interface SocketListener {
    // Own properties of Gio-2.0.Gio.SocketListener

    /**
     * The number of outstanding connections in the listen queue.
     */
    listenBacklog: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.SocketListener

    parentInstance: GObject.Object
    priv: SocketListenerPrivate

    // Owm methods of Gio-2.0.Gio.SocketListener

    /**
     * Blocks waiting for a client to connect to any of the sockets added
     * to the listener. Returns a #GSocketConnection for the socket that was
     * accepted.
     *
     * If `source_object` is not %NULL it will be filled out with the source
     * object specified when the corresponding socket or address was added
     * to the listener.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    accept(
      cancellable: Cancellable | null
    ): [
      /* returnType */ SocketConnection,
      /* sourceObject */ GObject.Object | null,
    ]
    /**
     * This is the asynchronous version of g_socket_listener_accept().
     *
     * When the operation is finished `callback` will be
     * called. You can then call g_socket_listener_accept_finish()
     * to get the result of the operation.
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback
     */
    acceptAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async accept operation. See g_socket_listener_accept_async()
     * @param result a #GAsyncResult.
     * @returns a #GSocketConnection on success, %NULL on error.
     */
    acceptFinish(
      result: AsyncResult
    ): [
      /* returnType */ SocketConnection,
      /* sourceObject */ GObject.Object | null,
    ]
    /**
     * Blocks waiting for a client to connect to any of the sockets added
     * to the listener. Returns the #GSocket that was accepted.
     *
     * If you want to accept the high-level #GSocketConnection, not a #GSocket,
     * which is often the case, then you should use g_socket_listener_accept()
     * instead.
     *
     * If `source_object` is not %NULL it will be filled out with the source
     * object specified when the corresponding socket or address was added
     * to the listener.
     *
     * If `cancellable` is not %NULL, then the operation can be cancelled by
     * triggering the cancellable object from another thread. If the operation
     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a #GSocket on success, %NULL on error.
     */
    acceptSocket(
      cancellable: Cancellable | null
    ): [/* returnType */ Socket, /* sourceObject */ GObject.Object | null]
    /**
     * This is the asynchronous version of g_socket_listener_accept_socket().
     *
     * When the operation is finished `callback` will be
     * called. You can then call g_socket_listener_accept_socket_finish()
     * to get the result of the operation.
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback
     */
    acceptSocketAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async accept operation. See g_socket_listener_accept_socket_async()
     * @param result a #GAsyncResult.
     * @returns a #GSocket on success, %NULL on error.
     */
    acceptSocketFinish(
      result: AsyncResult
    ): [/* returnType */ Socket, /* sourceObject */ GObject.Object | null]
    /**
     * Creates a socket of type `type` and protocol `protocol,` binds
     * it to `address` and adds it to the set of sockets we're accepting
     * sockets from.
     *
     * Note that adding an IPv6 address, depending on the platform,
     * may or may not result in a listener that also accepts IPv4
     * connections.  For more deterministic behavior, see
     * g_socket_listener_add_inet_port().
     *
     * `source_object` will be passed out in the various calls
     * to accept to identify this particular source, which is
     * useful if you're listening on multiple addresses and do
     * different things depending on what address is connected to.
     *
     * If successful and `effective_address` is non-%NULL then it will
     * be set to the address that the binding actually occurred at.  This
     * is helpful for determining the port number that was used for when
     * requesting a binding to port 0 (ie: "any port").  This address, if
     * requested, belongs to the caller and must be freed.
     *
     * Call g_socket_listener_close() to stop listening on `address;` this will not
     * be done automatically when you drop your final reference to `listener,` as
     * references may be held internally.
     * @param address a #GSocketAddress
     * @param type a #GSocketType
     * @param protocol a #GSocketProtocol
     * @param sourceObject Optional #GObject identifying this source
     * @returns %TRUE on success, %FALSE on error.
     */
    addAddress(
      address: SocketAddress,
      type: SocketType,
      protocol: SocketProtocol,
      sourceObject: GObject.Object | null
    ): [/* returnType */ boolean, /* effectiveAddress */ SocketAddress]
    /**
     * Listens for TCP connections on any available port number for both
     * IPv6 and IPv4 (if each is available).
     *
     * This is useful if you need to have a socket for incoming connections
     * but don't care about the specific port number.
     *
     * `source_object` will be passed out in the various calls
     * to accept to identify this particular source, which is
     * useful if you're listening on multiple addresses and do
     * different things depending on what address is connected to.
     * @param sourceObject Optional #GObject identifying this source
     * @returns the port number, or 0 in case of failure.
     */
    addAnyInetPort(sourceObject: GObject.Object | null): number
    /**
     * Helper function for g_socket_listener_add_address() that
     * creates a TCP/IP socket listening on IPv4 and IPv6 (if
     * supported) on the specified port on all interfaces.
     *
     * `source_object` will be passed out in the various calls
     * to accept to identify this particular source, which is
     * useful if you're listening on multiple addresses and do
     * different things depending on what address is connected to.
     *
     * Call g_socket_listener_close() to stop listening on `port;` this will not
     * be done automatically when you drop your final reference to `listener,` as
     * references may be held internally.
     * @param port an IP port number (non-zero)
     * @param sourceObject Optional #GObject identifying this source
     * @returns %TRUE on success, %FALSE on error.
     */
    addInetPort(port: number, sourceObject: GObject.Object | null): boolean
    /**
     * Adds `socket` to the set of sockets that we try to accept
     * new clients from. The socket must be bound to a local
     * address and listened to.
     *
     * `source_object` will be passed out in the various calls
     * to accept to identify this particular source, which is
     * useful if you're listening on multiple addresses and do
     * different things depending on what address is connected to.
     *
     * The `socket` will not be automatically closed when the `listener` is finalized
     * unless the listener held the final reference to the socket. Before GLib 2.42,
     * the `socket` was automatically closed on finalization of the `listener,` even
     * if references to it were held elsewhere.
     * @param socket a listening #GSocket
     * @param sourceObject Optional #GObject identifying this source
     * @returns %TRUE on success, %FALSE on error.
     */
    addSocket(socket: Socket, sourceObject: GObject.Object | null): boolean
    /**
     * Closes all the sockets in the listener.
     */
    close(): void
    /**
     * Sets the listen backlog on the sockets in the listener. This must be called
     * before adding any sockets, addresses or ports to the #GSocketListener (for
     * example, by calling g_socket_listener_add_inet_port()) to be effective.
     *
     * See g_socket_set_listen_backlog() for details
     * @param listenBacklog an integer
     */
    setBacklog(listenBacklog: number): void

    // Own virtual methods of Gio-2.0.Gio.SocketListener

    /**
     * virtual method called when the set of socket listened to changes
     * @virtual
     */
    changed(): void
    event(event: SocketListenerEvent, socket: Socket): void

    // Own signals of Gio-2.0.Gio.SocketListener

    connect(
      sigName: "event",
      callback: SocketListener.EventSignalCallback
    ): number
    on(
      sigName: "event",
      callback: SocketListener.EventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "event",
      callback: SocketListener.EventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "event",
      callback: SocketListener.EventSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "event", socket: Socket, ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.SocketListener

    connect(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::listen-backlog", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GSocketListener` is an object that keeps track of a set
   * of server sockets and helps you accept sockets from any of the
   * socket, either sync or async.
   *
   * Add addresses and ports to listen on using
   * [method`Gio`.SocketListener.add_address] and
   * [method`Gio`.SocketListener.add_inet_port]. These will be listened on until
   * [method`Gio`.SocketListener.close] is called. Dropping your final reference to
   * the `GSocketListener` will not cause [method`Gio`.SocketListener.close] to be
   * called implicitly, as some references to the `GSocketListener` may be held
   * internally.
   *
   * If you want to implement a network server, also look at
   * [class`Gio`.SocketService] and [class`Gio`.ThreadedSocketService] which are
   * subclasses of `GSocketListener` that make this even easier.
   * @class
   */
  class SocketListener extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SocketListener

    static name: string

    // Constructors of Gio-2.0.Gio.SocketListener

    constructor(config?: SocketListener.ConstructorProperties)
    /**
     * Creates a new #GSocketListener with no sockets to listen for.
     * New listeners can be added with e.g. g_socket_listener_add_address()
     * or g_socket_listener_add_inet_port().
     * @constructor
     * @returns a new #GSocketListener.
     */
    constructor()
    /**
     * Creates a new #GSocketListener with no sockets to listen for.
     * New listeners can be added with e.g. g_socket_listener_add_address()
     * or g_socket_listener_add_inet_port().
     * @constructor
     * @returns a new #GSocketListener.
     */
    static new(): SocketListener
    _init(config?: SocketListener.ConstructorProperties): void
  }

  module SocketService {
    // Signal callback interfaces

    /**
     * Signal callback interface for `incoming`
     */
    interface IncomingSignalCallback {
      (
        connection: SocketConnection,
        sourceObject: GObject.Object | null
      ): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends SocketListener.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.SocketService

      /**
       * Whether the service is currently accepting connections.
       */
      active?: boolean | null
    }
  }

  interface SocketService {
    // Own properties of Gio-2.0.Gio.SocketService

    /**
     * Whether the service is currently accepting connections.
     */
    active: boolean
    __gtype__: number

    // Own fields of Gio-2.0.Gio.SocketService

    parentInstance: any
    priv: any

    // Owm methods of Gio-2.0.Gio.SocketService

    /**
     * Check whether the service is active or not. An active
     * service will accept new clients that connect, while
     * a non-active service will let connecting clients queue
     * up until the service is started.
     * @returns %TRUE if the service is active, %FALSE otherwise
     */
    isActive(): boolean
    /**
     * Restarts the service, i.e. start accepting connections
     * from the added sockets when the mainloop runs. This only needs
     * to be called after the service has been stopped from
     * g_socket_service_stop().
     *
     * This call is thread-safe, so it may be called from a thread
     * handling an incoming client request.
     */
    start(): void
    /**
     * Stops the service, i.e. stops accepting connections
     * from the added sockets when the mainloop runs.
     *
     * This call is thread-safe, so it may be called from a thread
     * handling an incoming client request.
     *
     * Note that this only stops accepting new connections; it does not
     * close the listening sockets, and you can call
     * g_socket_service_start() again later to begin listening again. To
     * close the listening sockets, call g_socket_listener_close(). (This
     * will happen automatically when the #GSocketService is finalized.)
     *
     * This must be called before calling g_socket_listener_close() as
     * the socket service will start accepting connections immediately
     * when a new socket is added.
     */
    stop(): void

    // Own virtual methods of Gio-2.0.Gio.SocketService

    /**
     * signal emitted when new connections are accepted
     * @virtual
     * @param connection
     * @param sourceObject
     */
    incoming(
      connection: SocketConnection,
      sourceObject: GObject.Object
    ): boolean

    // Own signals of Gio-2.0.Gio.SocketService

    connect(
      sigName: "incoming",
      callback: SocketService.IncomingSignalCallback
    ): number
    on(
      sigName: "incoming",
      callback: SocketService.IncomingSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "incoming",
      callback: SocketService.IncomingSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "incoming",
      callback: SocketService.IncomingSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "incoming",
      sourceObject: GObject.Object | null,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.SocketService

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::listen-backlog", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GSocketService` is an object that represents a service that
   * is provided to the network or over local sockets.  When a new
   * connection is made to the service the [signal`Gio`.SocketService::incoming]
   * signal is emitted.
   *
   * A `GSocketService` is a subclass of [class`Gio`.SocketListener] and you need
   * to add the addresses you want to accept connections on with the
   * [class`Gio`.SocketListener] APIs.
   *
   * There are two options for implementing a network service based on
   * `GSocketService`. The first is to create the service using
   * [ctor`Gio`.SocketService.new] and to connect to the
   * [signal`Gio`.SocketService::incoming] signal. The second is to subclass
   * `GSocketService` and override the default signal handler implementation.
   *
   * In either case, the handler must immediately return, or else it
   * will block additional incoming connections from being serviced.
   * If you are interested in writing connection handlers that contain
   * blocking code then see [class`Gio`.ThreadedSocketService].
   *
   * The socket service runs on the main loop of the
   * thread-default context (see
   * [method`GLib`.MainContext.push_thread_default]) of the thread it is
   * created in, and is not threadsafe in general. However, the calls to start and
   * stop the service are thread-safe so these can be used from threads that
   * handle incoming clients.
   * @class
   */
  class SocketService extends SocketListener {
    // Own properties of Gio-2.0.Gio.SocketService

    static name: string

    // Constructors of Gio-2.0.Gio.SocketService

    constructor(config?: SocketService.ConstructorProperties)
    /**
     * Creates a new #GSocketService with no sockets to listen for.
     * New listeners can be added with e.g. g_socket_listener_add_address()
     * or g_socket_listener_add_inet_port().
     *
     * New services are created active, there is no need to call
     * g_socket_service_start(), unless g_socket_service_stop() has been
     * called before.
     * @constructor
     * @returns a new #GSocketService.
     */
    constructor()
    /**
     * Creates a new #GSocketService with no sockets to listen for.
     * New listeners can be added with e.g. g_socket_listener_add_address()
     * or g_socket_listener_add_inet_port().
     *
     * New services are created active, there is no need to call
     * g_socket_service_start(), unless g_socket_service_stop() has been
     * called before.
     * @constructor
     * @returns a new #GSocketService.
     */
    static new(): SocketService

    // Overloads of new

    /**
     * Creates a new #GSocketListener with no sockets to listen for.
     * New listeners can be added with e.g. g_socket_listener_add_address()
     * or g_socket_listener_add_inet_port().
     * @constructor
     * @returns a new #GSocketListener.
     */
    static new(): SocketListener
    _init(config?: SocketService.ConstructorProperties): void
  }

  module Subprocess {
    // Constructor properties interface

    interface ConstructorProperties
      extends Initable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.Subprocess

      /**
       * Argument vector.
       */
      argv?: string[] | null
      /**
       * Subprocess flags.
       */
      flags?: SubprocessFlags | null
    }
  }

  interface Subprocess extends Initable {
    // Own properties of Gio-2.0.Gio.Subprocess

    /**
     * Argument vector.
     */
    readonly argv: string[]
    /**
     * Subprocess flags.
     */
    readonly flags: SubprocessFlags
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Subprocess

    /**
     * Communicate with the subprocess until it terminates, and all input
     * and output has been completed.
     *
     * If `stdin_buf` is given, the subprocess must have been created with
     * %G_SUBPROCESS_FLAGS_STDIN_PIPE.  The given data is fed to the
     * stdin of the subprocess and the pipe is closed (ie: EOF).
     *
     * At the same time (as not to cause blocking when dealing with large
     * amounts of data), if %G_SUBPROCESS_FLAGS_STDOUT_PIPE or
     * %G_SUBPROCESS_FLAGS_STDERR_PIPE were used, reads from those
     * streams.  The data that was read is returned in `stdout` and/or
     * the `stderr`.
     *
     * If the subprocess was created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE,
     * `stdout_buf` will contain the data read from stdout.  Otherwise, for
     * subprocesses not created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE,
     * `stdout_buf` will be set to %NULL.  Similar provisions apply to
     * `stderr_buf` and %G_SUBPROCESS_FLAGS_STDERR_PIPE.
     *
     * As usual, any output variable may be given as %NULL to ignore it.
     *
     * If you desire the stdout and stderr data to be interleaved, create
     * the subprocess with %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
     * %G_SUBPROCESS_FLAGS_STDERR_MERGE.  The merged result will be returned
     * in `stdout_buf` and `stderr_buf` will be set to %NULL.
     *
     * In case of any error (including cancellation), %FALSE will be
     * returned with `error` set.  Some or all of the stdin data may have
     * been written.  Any stdout or stderr data that has been read will be
     * discarded. None of the out variables (aside from `error)` will have
     * been set to anything in particular and should not be inspected.
     *
     * In the case that %TRUE is returned, the subprocess has exited and the
     * exit status inspection APIs (eg: g_subprocess_get_if_exited(),
     * g_subprocess_get_exit_status()) may be used.
     *
     * You should not attempt to use any of the subprocess pipes after
     * starting this function, since they may be left in strange states,
     * even if the operation was cancelled.  You should especially not
     * attempt to interact with the pipes while the operation is in progress
     * (either from another thread or if using the asynchronous version).
     * @param stdinBuf data to send to the stdin of the subprocess, or %NULL
     * @param cancellable a #GCancellable
     * @returns %TRUE if successful
     */
    communicate(
      stdinBuf: any | null,
      cancellable: Cancellable | null
    ): [
      /* returnType */ boolean,
      /* stdoutBuf */ any | null,
      /* stderrBuf */ any | null,
    ]
    /**
     * Asynchronous version of g_subprocess_communicate().  Complete
     * invocation with g_subprocess_communicate_finish().
     * @param stdinBuf Input data, or %NULL
     * @param cancellable Cancellable
     * @param callback Callback
     */
    communicateAsync(
      stdinBuf: any | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Complete an invocation of g_subprocess_communicate_async().
     * @param result Result
     */
    communicateFinish(
      result: AsyncResult
    ): [
      /* returnType */ boolean,
      /* stdoutBuf */ any | null,
      /* stderrBuf */ any | null,
    ]
    /**
     * Like g_subprocess_communicate(), but validates the output of the
     * process as UTF-8, and returns it as a regular NUL terminated string.
     *
     * On error, `stdout_buf` and `stderr_buf` will be set to undefined values and
     * should not be used.
     * @param stdinBuf data to send to the stdin of the subprocess, or %NULL
     * @param cancellable a #GCancellable
     */
    communicateUtf8(
      stdinBuf: string | null,
      cancellable: Cancellable | null
    ): [
      /* returnType */ boolean,
      /* stdoutBuf */ string | null,
      /* stderrBuf */ string | null,
    ]
    /**
     * Asynchronous version of g_subprocess_communicate_utf8().  Complete
     * invocation with g_subprocess_communicate_utf8_finish().
     * @param stdinBuf Input data, or %NULL
     * @param cancellable Cancellable
     * @param callback Callback
     */
    communicateUtf8Async(
      stdinBuf: string | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Complete an invocation of g_subprocess_communicate_utf8_async().
     * @param result Result
     */
    communicateUtf8Finish(
      result: AsyncResult
    ): [
      /* returnType */ boolean,
      /* stdoutBuf */ string | null,
      /* stderrBuf */ string | null,
    ]
    /**
     * Use an operating-system specific method to attempt an immediate,
     * forceful termination of the process.  There is no mechanism to
     * determine whether or not the request itself was successful;
     * however, you can use g_subprocess_wait() to monitor the status of
     * the process after calling this function.
     *
     * On Unix, this function sends %SIGKILL.
     */
    forceExit(): void
    /**
     * Check the exit status of the subprocess, given that it exited
     * normally.  This is the value passed to the exit() system call or the
     * return value from main.
     *
     * This is equivalent to the system WEXITSTATUS macro.
     *
     * It is an error to call this function before g_subprocess_wait() and
     * unless g_subprocess_get_if_exited() returned %TRUE.
     * @returns the exit status
     */
    getExitStatus(): number
    /**
     * On UNIX, returns the process ID as a decimal string.
     * On Windows, returns the result of GetProcessId() also as a string.
     * If the subprocess has terminated, this will return %NULL.
     * @returns the subprocess identifier, or %NULL if the subprocess    has terminated
     */
    getIdentifier(): string | null
    /**
     * Check if the given subprocess exited normally (ie: by way of exit()
     * or return from main()).
     *
     * This is equivalent to the system WIFEXITED macro.
     *
     * It is an error to call this function before g_subprocess_wait() has
     * returned.
     * @returns %TRUE if the case of a normal exit
     */
    getIfExited(): boolean
    /**
     * Check if the given subprocess terminated in response to a signal.
     *
     * This is equivalent to the system WIFSIGNALED macro.
     *
     * It is an error to call this function before g_subprocess_wait() has
     * returned.
     * @returns %TRUE if the case of termination due to a signal
     */
    getIfSignaled(): boolean
    /**
     * Gets the raw status code of the process, as from waitpid().
     *
     * This value has no particular meaning, but it can be used with the
     * macros defined by the system headers such as WIFEXITED.  It can also
     * be used with g_spawn_check_wait_status().
     *
     * It is more likely that you want to use g_subprocess_get_if_exited()
     * followed by g_subprocess_get_exit_status().
     *
     * It is an error to call this function before g_subprocess_wait() has
     * returned.
     * @returns the (meaningless) waitpid() exit status from the kernel
     */
    getStatus(): number
    /**
     * Gets the #GInputStream from which to read the stderr output of
     * `subprocess`.
     *
     * The process must have been created with %G_SUBPROCESS_FLAGS_STDERR_PIPE,
     * otherwise %NULL will be returned.
     * @returns the stderr pipe
     */
    getStderrPipe(): InputStream | null
    /**
     * Gets the #GOutputStream that you can write to in order to give data
     * to the stdin of `subprocess`.
     *
     * The process must have been created with %G_SUBPROCESS_FLAGS_STDIN_PIPE and
     * not %G_SUBPROCESS_FLAGS_STDIN_INHERIT, otherwise %NULL will be returned.
     * @returns the stdout pipe
     */
    getStdinPipe(): OutputStream | null
    /**
     * Gets the #GInputStream from which to read the stdout output of
     * `subprocess`.
     *
     * The process must have been created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE,
     * otherwise %NULL will be returned.
     * @returns the stdout pipe
     */
    getStdoutPipe(): InputStream | null
    /**
     * Checks if the process was "successful".  A process is considered
     * successful if it exited cleanly with an exit status of 0, either by
     * way of the exit() system call or return from main().
     *
     * It is an error to call this function before g_subprocess_wait() has
     * returned.
     * @returns %TRUE if the process exited cleanly with a exit status of 0
     */
    getSuccessful(): boolean
    /**
     * Get the signal number that caused the subprocess to terminate, given
     * that it terminated due to a signal.
     *
     * This is equivalent to the system WTERMSIG macro.
     *
     * It is an error to call this function before g_subprocess_wait() and
     * unless g_subprocess_get_if_signaled() returned %TRUE.
     * @returns the signal causing termination
     */
    getTermSig(): number
    /**
     * Sends the UNIX signal `signal_num` to the subprocess, if it is still
     * running.
     *
     * This API is race-free.  If the subprocess has terminated, it will not
     * be signalled.
     *
     * This API is not available on Windows.
     * @param signalNum the signal number to send
     */
    sendSignal(signalNum: number): void
    /**
     * Synchronously wait for the subprocess to terminate.
     *
     * After the process terminates you can query its exit status with
     * functions such as g_subprocess_get_if_exited() and
     * g_subprocess_get_exit_status().
     *
     * This function does not fail in the case of the subprocess having
     * abnormal termination.  See g_subprocess_wait_check() for that.
     *
     * Cancelling `cancellable` doesn't kill the subprocess.  Call
     * g_subprocess_force_exit() if it is desirable.
     * @param cancellable a #GCancellable
     * @returns %TRUE on success, %FALSE if @cancellable was cancelled
     */
    wait(cancellable: Cancellable | null): boolean
    /**
     * Wait for the subprocess to terminate.
     *
     * This is the asynchronous version of g_subprocess_wait().
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback to call when the operation is complete
     */
    waitAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Combines g_subprocess_wait() with g_spawn_check_wait_status().
     * @param cancellable a #GCancellable
     * @returns %TRUE on success, %FALSE if process exited abnormally, or @cancellable was cancelled
     */
    waitCheck(cancellable: Cancellable | null): boolean
    /**
     * Combines g_subprocess_wait_async() with g_spawn_check_wait_status().
     *
     * This is the asynchronous version of g_subprocess_wait_check().
     * @param cancellable a #GCancellable, or %NULL
     * @param callback a #GAsyncReadyCallback to call when the operation is complete
     */
    waitCheckAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Collects the result of a previous call to
     * g_subprocess_wait_check_async().
     * @param result the #GAsyncResult passed to your #GAsyncReadyCallback
     * @returns %TRUE if successful, or %FALSE with @error set
     */
    waitCheckFinish(result: AsyncResult): boolean
    /**
     * Collects the result of a previous call to
     * g_subprocess_wait_async().
     * @param result the #GAsyncResult passed to your #GAsyncReadyCallback
     * @returns %TRUE if successful, or %FALSE with @error set
     */
    waitFinish(result: AsyncResult): boolean

    // Class property signals of Gio-2.0.Gio.Subprocess

    connect(sigName: "notify::argv", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::argv",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::argv",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::argv",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::argv", ...args: any[]): void
    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GSubprocess` allows the creation of and interaction with child
   * processes.
   *
   * Processes can be communicated with using standard GIO-style APIs (ie:
   * [class`Gio`.InputStream], [class`Gio`.OutputStream]). There are GIO-style APIs
   * to wait for process termination (ie: cancellable and with an asynchronous
   * variant).
   *
   * There is an API to force a process to terminate, as well as a
   * race-free API for sending UNIX signals to a subprocess.
   *
   * One major advantage that GIO brings over the core GLib library is
   * comprehensive API for asynchronous I/O, such
   * [method`Gio`.OutputStream.splice_async].  This makes `GSubprocess`
   * significantly more powerful and flexible than equivalent APIs in
   * some other languages such as the `subprocess.py`
   * included with Python.  For example, using `GSubprocess` one could
   * create two child processes, reading standard output from the first,
   * processing it, and writing to the input stream of the second, all
   * without blocking the main loop.
   *
   * A powerful [method`Gio`.Subprocess.communicate] API is provided similar to the
   * `communicate()` method of `subprocess.py`. This enables very easy
   * interaction with a subprocess that has been opened with pipes.
   *
   * `GSubprocess` defaults to tight control over the file descriptors open
   * in the child process, avoiding dangling-FD issues that are caused by
   * a simple `fork()`/`exec()`.  The only open file descriptors in the
   * spawned process are ones that were explicitly specified by the
   * `GSubprocess` API (unless `G_SUBPROCESS_FLAGS_INHERIT_FDS` was
   * specified).
   *
   * `GSubprocess` will quickly reap all child processes as they exit,
   * avoiding ‘zombie processes’ remaining around for long periods of
   * time.  [method`Gio`.Subprocess.wait] can be used to wait for this to happen,
   * but it will happen even without the call being explicitly made.
   *
   * As a matter of principle, `GSubprocess` has no API that accepts
   * shell-style space-separated strings.  It will, however, match the
   * typical shell behaviour of searching the `PATH` for executables that do
   * not contain a directory separator in their name. By default, the `PATH`
   * of the current process is used.  You can specify
   * `G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP` to use the `PATH` of the
   * launcher environment instead.
   *
   * `GSubprocess` attempts to have a very simple API for most uses (ie:
   * spawning a subprocess with arguments and support for most typical
   * kinds of input and output redirection).  See [ctor`Gio`.Subprocess.new]. The
   * [class`Gio`.SubprocessLauncher] API is provided for more complicated cases
   * (advanced types of redirection, environment variable manipulation,
   * change of working directory, child setup functions, etc).
   *
   * A typical use of `GSubprocess` will involve calling
   * [ctor`Gio`.Subprocess.new], followed by [method`Gio`.Subprocess.wait_async] or
   * [method`Gio`.Subprocess.wait].  After the process exits, the status can be
   * checked using functions such as [method`Gio`.Subprocess.get_if_exited] (which
   * are similar to the familiar `WIFEXITED`-style POSIX macros).
   * @class
   */
  class Subprocess extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Subprocess

    static name: string

    // Constructors of Gio-2.0.Gio.Subprocess

    constructor(config?: Subprocess.ConstructorProperties)
    /**
     * Create a new process with the given flags and argument list.
     *
     * The argument list is expected to be %NULL-terminated.
     * @constructor
     * @param argv commandline arguments for the subprocess
     * @param flags flags that define the behaviour of the subprocess
     * @returns A newly created #GSubprocess, or %NULL on error (and @error   will be set)
     */
    constructor(argv: string[], flags: SubprocessFlags)
    /**
     * Create a new process with the given flags and argument list.
     *
     * The argument list is expected to be %NULL-terminated.
     * @constructor
     * @param argv commandline arguments for the subprocess
     * @param flags flags that define the behaviour of the subprocess
     * @returns A newly created #GSubprocess, or %NULL on error (and @error   will be set)
     */
    static new(argv: string[], flags: SubprocessFlags): Subprocess
    _init(config?: Subprocess.ConstructorProperties): void
  }

  module SubprocessLauncher {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.SubprocessLauncher

      /**
       * [flags`Gio`.SubprocessFlags] for launched processes.
       */
      flags?: SubprocessFlags | null
    }
  }

  interface SubprocessLauncher {
    // Own properties of Gio-2.0.Gio.SubprocessLauncher

    /**
     * [flags`Gio`.SubprocessFlags] for launched processes.
     */
    readonly flags: SubprocessFlags
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.SubprocessLauncher

    /**
     * Closes all the file descriptors previously passed to the object with
     * g_subprocess_launcher_take_fd(), g_subprocess_launcher_take_stderr_fd(), etc.
     *
     * After calling this method, any subsequent calls to g_subprocess_launcher_spawn() or g_subprocess_launcher_spawnv() will
     * return %G_IO_ERROR_CLOSED. This method is idempotent if
     * called more than once.
     *
     * This function is called automatically when the #GSubprocessLauncher
     * is disposed, but is provided separately so that garbage collected
     * language bindings can call it earlier to guarantee when FDs are closed.
     */
    close(): void
    /**
     * Returns the value of the environment variable `variable` in the
     * environment of processes launched from this launcher.
     *
     * On UNIX, the returned string can be an arbitrary byte string.
     * On Windows, it will be UTF-8.
     * @param variable the environment variable to get
     * @returns the value of the environment variable,     %NULL if unset
     */
    getenv(variable: string): string | null
    /**
     * Sets the current working directory that processes will be launched
     * with.
     *
     * By default processes are launched with the current working directory
     * of the launching process at the time of launch.
     * @param cwd the cwd for launched processes
     */
    setCwd(cwd: string): void
    /**
     * Replace the entire environment of processes launched from this
     * launcher with the given 'environ' variable.
     *
     * Typically you will build this variable by using g_listenv() to copy
     * the process 'environ' and using the functions g_environ_setenv(),
     * g_environ_unsetenv(), etc.
     *
     * As an alternative, you can use g_subprocess_launcher_setenv(),
     * g_subprocess_launcher_unsetenv(), etc.
     *
     * Pass an empty array to set an empty environment. Pass %NULL to inherit the
     * parent process’ environment. As of GLib 2.54, the parent process’ environment
     * will be copied when g_subprocess_launcher_set_environ() is called.
     * Previously, it was copied when the subprocess was executed. This means the
     * copied environment may now be modified (using g_subprocess_launcher_setenv(),
     * etc.) before launching the subprocess.
     *
     * On UNIX, all strings in this array can be arbitrary byte strings.
     * On Windows, they should be in UTF-8.
     * @param env the replacement environment
     */
    setEnviron(env: string[]): void
    /**
     * Sets the flags on the launcher.
     *
     * The default flags are %G_SUBPROCESS_FLAGS_NONE.
     *
     * You may not set flags that specify conflicting options for how to
     * handle a particular stdio stream (eg: specifying both
     * %G_SUBPROCESS_FLAGS_STDIN_PIPE and
     * %G_SUBPROCESS_FLAGS_STDIN_INHERIT).
     *
     * You may also not set a flag that conflicts with a previous call to a
     * function like g_subprocess_launcher_set_stdin_file_path() or
     * g_subprocess_launcher_take_stdout_fd().
     * @param flags #GSubprocessFlags
     */
    setFlags(flags: SubprocessFlags): void
    /**
     * Sets the file path to use as the stderr for spawned processes.
     *
     * If `path` is %NULL then any previously given path is unset.
     *
     * The file will be created or truncated when the process is spawned, as
     * would be the case if using '2>' at the shell.
     *
     * If you want to send both stdout and stderr to the same file then use
     * %G_SUBPROCESS_FLAGS_STDERR_MERGE.
     *
     * You may not set a stderr file path if a stderr fd is already set or
     * if the launcher flags contain any flags directing stderr elsewhere.
     *
     * This feature is only available on UNIX.
     * @param path a filename or %NULL
     */
    setStderrFilePath(path: string | null): void
    /**
     * Sets the file path to use as the stdin for spawned processes.
     *
     * If `path` is %NULL then any previously given path is unset.
     *
     * The file must exist or spawning the process will fail.
     *
     * You may not set a stdin file path if a stdin fd is already set or if
     * the launcher flags contain any flags directing stdin elsewhere.
     *
     * This feature is only available on UNIX.
     * @param path a filename or %NULL
     */
    setStdinFilePath(path: string | null): void
    /**
     * Sets the file path to use as the stdout for spawned processes.
     *
     * If `path` is %NULL then any previously given path is unset.
     *
     * The file will be created or truncated when the process is spawned, as
     * would be the case if using '>' at the shell.
     *
     * You may not set a stdout file path if a stdout fd is already set or
     * if the launcher flags contain any flags directing stdout elsewhere.
     *
     * This feature is only available on UNIX.
     * @param path a filename or %NULL
     */
    setStdoutFilePath(path: string | null): void
    /**
     * Sets the environment variable `variable` in the environment of
     * processes launched from this launcher.
     *
     * On UNIX, both the variable's name and value can be arbitrary byte
     * strings, except that the variable's name cannot contain '='.
     * On Windows, they should be in UTF-8.
     * @param variable the environment variable to set,     must not contain '='
     * @param value the new value for the variable
     * @param overwrite whether to change the variable if it already exists
     */
    setenv(variable: string, value: string, overwrite: boolean): void
    /**
     * Creates a #GSubprocess given a provided array of arguments.
     * @param argv Command line arguments
     * @returns A new #GSubprocess, or %NULL on error (and @error will be set)
     */
    spawnv(argv: string[]): Subprocess
    /**
     * Transfer an arbitrary file descriptor from parent process to the
     * child.  This function takes ownership of the `source_fd;` it will be closed
     * in the parent when `self` is freed.
     *
     * By default, all file descriptors from the parent will be closed.
     * This function allows you to create (for example) a custom `pipe()` or
     * `socketpair()` before launching the process, and choose the target
     * descriptor in the child.
     *
     * An example use case is GNUPG, which has a command line argument
     * `--passphrase-fd` providing a file descriptor number where it expects
     * the passphrase to be written.
     * @param sourceFd File descriptor in parent process
     * @param targetFd Target descriptor for child process
     */
    takeFd(sourceFd: number, targetFd: number): void
    /**
     * Sets the file descriptor to use as the stderr for spawned processes.
     *
     * If `fd` is -1 then any previously given fd is unset.
     *
     * Note that the default behaviour is to pass stderr through to the
     * stderr of the parent process.
     *
     * The passed `fd` belongs to the #GSubprocessLauncher.  It will be
     * automatically closed when the launcher is finalized.  The file
     * descriptor will also be closed on the child side when executing the
     * spawned process.
     *
     * You may not set a stderr fd if a stderr file path is already set or
     * if the launcher flags contain any flags directing stderr elsewhere.
     *
     * This feature is only available on UNIX.
     * @param fd a file descriptor, or -1
     */
    takeStderrFd(fd: number): void
    /**
     * Sets the file descriptor to use as the stdin for spawned processes.
     *
     * If `fd` is -1 then any previously given fd is unset.
     *
     * Note that if your intention is to have the stdin of the calling
     * process inherited by the child then %G_SUBPROCESS_FLAGS_STDIN_INHERIT
     * is a better way to go about doing that.
     *
     * The passed `fd` is noted but will not be touched in the current
     * process.  It is therefore necessary that it be kept open by the
     * caller until the subprocess is spawned.  The file descriptor will
     * also not be explicitly closed on the child side, so it must be marked
     * O_CLOEXEC if that's what you want.
     *
     * You may not set a stdin fd if a stdin file path is already set or if
     * the launcher flags contain any flags directing stdin elsewhere.
     *
     * This feature is only available on UNIX.
     * @param fd a file descriptor, or -1
     */
    takeStdinFd(fd: number): void
    /**
     * Sets the file descriptor to use as the stdout for spawned processes.
     *
     * If `fd` is -1 then any previously given fd is unset.
     *
     * Note that the default behaviour is to pass stdout through to the
     * stdout of the parent process.
     *
     * The passed `fd` is noted but will not be touched in the current
     * process.  It is therefore necessary that it be kept open by the
     * caller until the subprocess is spawned.  The file descriptor will
     * also not be explicitly closed on the child side, so it must be marked
     * O_CLOEXEC if that's what you want.
     *
     * You may not set a stdout fd if a stdout file path is already set or
     * if the launcher flags contain any flags directing stdout elsewhere.
     *
     * This feature is only available on UNIX.
     * @param fd a file descriptor, or -1
     */
    takeStdoutFd(fd: number): void
    /**
     * Removes the environment variable `variable` from the environment of
     * processes launched from this launcher.
     *
     * On UNIX, the variable's name can be an arbitrary byte string not
     * containing '='. On Windows, it should be in UTF-8.
     * @param variable the environment variable to unset,     must not contain '='
     */
    unsetenv(variable: string): void

    // Class property signals of Gio-2.0.Gio.SubprocessLauncher

    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * This class contains a set of options for launching child processes,
   * such as where its standard input and output will be directed, the
   * argument list, the environment, and more.
   *
   * While the [class`Gio`.Subprocess] class has high level functions covering
   * popular cases, use of this class allows access to more advanced
   * options.  It can also be used to launch multiple subprocesses with
   * a similar configuration.
   * @class
   */
  class SubprocessLauncher extends GObject.Object {
    // Own properties of Gio-2.0.Gio.SubprocessLauncher

    static name: string

    // Constructors of Gio-2.0.Gio.SubprocessLauncher

    constructor(config?: SubprocessLauncher.ConstructorProperties)
    /**
     * Creates a new #GSubprocessLauncher.
     *
     * The launcher is created with the default options.  A copy of the
     * environment of the calling process is made at the time of this call
     * and will be used as the environment that the process is launched in.
     * @constructor
     * @param flags #GSubprocessFlags
     */
    constructor(flags: SubprocessFlags)
    /**
     * Creates a new #GSubprocessLauncher.
     *
     * The launcher is created with the default options.  A copy of the
     * environment of the calling process is made at the time of this call
     * and will be used as the environment that the process is launched in.
     * @constructor
     * @param flags #GSubprocessFlags
     */
    static new(flags: SubprocessFlags): SubprocessLauncher
    _init(config?: SubprocessLauncher.ConstructorProperties): void
  }

  module Task {
    // Constructor properties interface

    interface ConstructorProperties
      extends AsyncResult.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface Task extends AsyncResult {
    // Own properties of Gio-2.0.Gio.Task

    /**
     * Whether the task has completed, meaning its callback (if set) has been
     * invoked.
     *
     * This can only happen after g_task_return_pointer(),
     * g_task_return_error() or one of the other return functions have been called
     * on the task. However, it is not guaranteed to happen immediately after
     * those functions are called, as the task’s callback may need to be scheduled
     * to run in a different thread.
     *
     * That means it is **not safe** to use this property to track whether a
     * return function has been called on the #GTask. Callers must do that
     * tracking themselves, typically by linking the lifetime of the #GTask to the
     * control flow of their code.
     *
     * This property is guaranteed to change from %FALSE to %TRUE exactly once.
     *
     * The #GObject::notify signal for this change is emitted in the same main
     * context as the task’s callback, immediately after that callback is invoked.
     */
    readonly completed: boolean
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.Task

    /**
     * Gets `task'`s #GCancellable
     * @returns @task's #GCancellable
     */
    getCancellable(): Cancellable | null
    /**
     * Gets `task'`s check-cancellable flag. See
     * g_task_set_check_cancellable() for more details.
     */
    getCheckCancellable(): boolean
    /**
     * Gets the value of #GTask:completed. This changes from %FALSE to %TRUE after
     * the task’s callback is invoked, and will return %FALSE if called from inside
     * the callback.
     * @returns %TRUE if the task has completed, %FALSE otherwise.
     */
    getCompleted(): boolean
    /**
     * Gets the #GMainContext that `task` will return its result in (that
     * is, the context that was the
     * [thread-default main context][g-main-context-push-thread-default]
     * at the point when `task` was created).
     *
     * This will always return a non-%NULL value, even if the task's
     * context is the default #GMainContext.
     * @returns @task's #GMainContext
     */
    getContext(): GLib.MainContext
    /**
     * Gets `task’`s name. See g_task_set_name().
     * @returns @task’s name, or %NULL
     */
    getName(): string | null
    /**
     * Gets `task'`s priority
     * @returns @task's priority
     */
    getPriority(): number
    /**
     * Gets `task'`s return-on-cancel flag. See
     * g_task_set_return_on_cancel() for more details.
     */
    getReturnOnCancel(): boolean
    /**
     * Gets the source object from `task`. Like
     * g_async_result_get_source_object(), but does not ref the object.
     * @returns @task's source object, or %NULL
     */
    getSourceObject(): GObject.Object | null

    // Overloads of getSourceObject

    /**
     * Gets the source object from a #GAsyncResult.
     * @virtual
     * @returns a new reference to the source    object for the @res, or %NULL if there is none.
     */
    getSourceObject(): GObject.Object | null
    /**
     * Gets `task'`s source tag. See g_task_set_source_tag().
     * @returns @task's source tag
     */
    getSourceTag(): any | null
    /**
     * Gets `task'`s `task_data`.
     * @returns @task's `task_data`.
     */
    getTaskData(): any | null
    /**
     * Tests if `task` resulted in an error.
     * @returns %TRUE if the task resulted in an error, %FALSE otherwise.
     */
    hadError(): boolean
    /**
     * Gets the result of `task` as a #gboolean.
     *
     * If the task resulted in an error, or was cancelled, then this will
     * instead return %FALSE and set `error`.
     *
     * Since this method transfers ownership of the return value (or
     * error) to the caller, you may only call it once.
     * @returns the task result, or %FALSE on error
     */
    propagateBoolean(): boolean
    /**
     * Gets the result of `task` as an integer (#gssize).
     *
     * If the task resulted in an error, or was cancelled, then this will
     * instead return -1 and set `error`.
     *
     * Since this method transfers ownership of the return value (or
     * error) to the caller, you may only call it once.
     * @returns the task result, or -1 on error
     */
    propagateInt(): number
    /**
     * Gets the result of `task` as a pointer, and transfers ownership
     * of that value to the caller.
     *
     * If the task resulted in an error, or was cancelled, then this will
     * instead return %NULL and set `error`.
     *
     * Since this method transfers ownership of the return value (or
     * error) to the caller, you may only call it once.
     * @returns the task result, or %NULL on error
     */
    propagatePointer(): any | null
    /**
     * Gets the result of `task` as a #GValue, and transfers ownership of
     * that value to the caller. As with g_task_return_value(), this is
     * a generic low-level method; g_task_propagate_pointer() and the like
     * will usually be more useful for C code.
     *
     * If the task resulted in an error, or was cancelled, then this will
     * instead set `error` and return %FALSE.
     *
     * Since this method transfers ownership of the return value (or
     * error) to the caller, you may only call it once.
     * @returns %TRUE if @task succeeded, %FALSE on error.
     */
    propagateValue(): [/* returnType */ boolean, /* value */ any]
    /**
     * Sets `task'`s result to `result` and completes the task (see
     * g_task_return_pointer() for more discussion of exactly what this
     * means).
     * @param result the #gboolean result of a task function.
     */
    returnBoolean(result: boolean): void
    /**
     * Sets `task'`s result to `error` (which `task` assumes ownership of)
     * and completes the task (see g_task_return_pointer() for more
     * discussion of exactly what this means).
     *
     * Note that since the task takes ownership of `error,` and since the
     * task may be completed before returning from g_task_return_error(),
     * you cannot assume that `error` is still valid after calling this.
     * Call g_error_copy() on the error if you need to keep a local copy
     * as well.
     *
     * See also [method`Gio`.Task.return_new_error],
     * [method`Gio`.Task.return_new_error_literal].
     * @param error the #GError result of a task function.
     */
    returnError(error: GLib.Error): void
    /**
     * Checks if `task'`s #GCancellable has been cancelled, and if so, sets
     * `task'`s error accordingly and completes the task (see
     * g_task_return_pointer() for more discussion of exactly what this
     * means).
     * @returns %TRUE if @task has been cancelled, %FALSE if not
     */
    returnErrorIfCancelled(): boolean
    /**
     * Sets `task'`s result to `result` and completes the task (see
     * g_task_return_pointer() for more discussion of exactly what this
     * means).
     * @param result the integer (#gssize) result of a task function.
     */
    returnInt(result: number): void
    /**
     * Sets `task’`s result to a new [type`GLib`.Error] created from `domain,` `code,`
     * `message` and completes the task.
     *
     * See [method`Gio`.Task.return_pointer] for more discussion of exactly what
     * ‘completing the task’ means.
     *
     * See also [method`Gio`.Task.return_new_error].
     * @param domain a #GQuark.
     * @param code an error code.
     * @param message an error message
     */
    returnNewErrorLiteral(
      domain: GLib.Quark,
      code: number,
      message: string
    ): void
    /**
     * Sets `task'`s result to `result` and completes the task. If `result`
     * is not %NULL, then `result_destroy` will be used to free `result` if
     * the caller does not take ownership of it with
     * g_task_propagate_pointer().
     *
     * "Completes the task" means that for an ordinary asynchronous task
     * it will either invoke the task's callback, or else queue that
     * callback to be invoked in the proper #GMainContext, or in the next
     * iteration of the current #GMainContext. For a task run via
     * g_task_run_in_thread() or g_task_run_in_thread_sync(), calling this
     * method will save `result` to be returned to the caller later, but
     * the task will not actually be completed until the #GTaskThreadFunc
     * exits.
     *
     * Note that since the task may be completed before returning from
     * g_task_return_pointer(), you cannot assume that `result` is still
     * valid after calling this, unless you are still holding another
     * reference on it.
     * @param result the pointer result of a task     function
     * @param resultDestroy a #GDestroyNotify function.
     */
    returnPointer(
      result: any | null,
      resultDestroy: GLib.DestroyNotify | null
    ): void
    /**
     * Sets `task'`s result to `result` (by copying it) and completes the task.
     *
     * If `result` is %NULL then a #GValue of type %G_TYPE_POINTER
     * with a value of %NULL will be used for the result.
     *
     * This is a very generic low-level method intended primarily for use
     * by language bindings; for C code, g_task_return_pointer() and the
     * like will normally be much easier to use.
     * @param result the #GValue result of                                      a task function
     */
    returnValue(result: any | null): void
    /**
     * Runs `task_func` in another thread. When `task_func` returns, `task'`s
     * #GAsyncReadyCallback will be invoked in `task'`s #GMainContext.
     *
     * This takes a ref on `task` until the task completes.
     *
     * See #GTaskThreadFunc for more details about how `task_func` is handled.
     *
     * Although GLib currently rate-limits the tasks queued via
     * g_task_run_in_thread(), you should not assume that it will always
     * do this. If you have a very large number of tasks to run (several tens of
     * tasks), but don't want them to all run at once, you should only queue a
     * limited number of them (around ten) at a time.
     *
     * Be aware that if your task depends on other tasks to complete, use of this
     * function could lead to a livelock if the other tasks also use this function
     * and enough of them (around 10) execute in a dependency chain, as that will
     * exhaust the thread pool. If this situation is possible, consider using a
     * separate worker thread or thread pool explicitly, rather than using
     * g_task_run_in_thread().
     * @param taskFunc a #GTaskThreadFunc
     */
    runInThread(taskFunc: TaskThreadFunc): void
    /**
     * Runs `task_func` in another thread, and waits for it to return or be
     * cancelled. You can use g_task_propagate_pointer(), etc, afterward
     * to get the result of `task_func`.
     *
     * See #GTaskThreadFunc for more details about how `task_func` is handled.
     *
     * Normally this is used with tasks created with a %NULL
     * `callback`, but note that even if the task does
     * have a callback, it will not be invoked when `task_func` returns.
     * #GTask:completed will be set to %TRUE just before this function returns.
     *
     * Although GLib currently rate-limits the tasks queued via
     * g_task_run_in_thread_sync(), you should not assume that it will
     * always do this. If you have a very large number of tasks to run,
     * but don't want them to all run at once, you should only queue a
     * limited number of them at a time.
     * @param taskFunc a #GTaskThreadFunc
     */
    runInThreadSync(taskFunc: TaskThreadFunc): void
    /**
     * Sets or clears `task'`s check-cancellable flag. If this is %TRUE
     * (the default), then g_task_propagate_pointer(), etc, and
     * g_task_had_error() will check the task's #GCancellable first, and
     * if it has been cancelled, then they will consider the task to have
     * returned an "Operation was cancelled" error
     * (%G_IO_ERROR_CANCELLED), regardless of any other error or return
     * value the task may have had.
     *
     * If `check_cancellable` is %FALSE, then the #GTask will not check the
     * cancellable itself, and it is up to `task'`s owner to do this (eg,
     * via g_task_return_error_if_cancelled()).
     *
     * If you are using g_task_set_return_on_cancel() as well, then
     * you must leave check-cancellable set %TRUE.
     * @param checkCancellable whether #GTask will check the state of   its #GCancellable for you.
     */
    setCheckCancellable(checkCancellable: boolean): void
    /**
     * Sets `task’`s name, used in debugging and profiling. The name defaults to
     * %NULL.
     *
     * The task name should describe in a human readable way what the task does.
     * For example, ‘Open file’ or ‘Connect to network host’. It is used to set the
     * name of the #GSource used for idle completion of the task.
     *
     * This function may only be called before the `task` is first used in a thread
     * other than the one it was constructed in. It is called automatically by
     * g_task_set_source_tag() if not called already.
     * @param name a human readable name for the task, or %NULL to unset it
     */
    setName(name: string | null): void
    /**
     * Sets `task'`s priority. If you do not call this, it will default to
     * %G_PRIORITY_DEFAULT.
     *
     * This will affect the priority of #GSources created with
     * g_task_attach_source() and the scheduling of tasks run in threads,
     * and can also be explicitly retrieved later via
     * g_task_get_priority().
     * @param priority the [priority](iface.AsyncResult.html#io-priority) of the request
     */
    setPriority(priority: number): void
    /**
     * Sets or clears `task'`s return-on-cancel flag. This is only
     * meaningful for tasks run via g_task_run_in_thread() or
     * g_task_run_in_thread_sync().
     *
     * If `return_on_cancel` is %TRUE, then cancelling `task'`s
     * #GCancellable will immediately cause it to return, as though the
     * task's #GTaskThreadFunc had called
     * g_task_return_error_if_cancelled() and then returned.
     *
     * This allows you to create a cancellable wrapper around an
     * uninterruptible function. The #GTaskThreadFunc just needs to be
     * careful that it does not modify any externally-visible state after
     * it has been cancelled. To do that, the thread should call
     * g_task_set_return_on_cancel() again to (atomically) set
     * return-on-cancel %FALSE before making externally-visible changes;
     * if the task gets cancelled before the return-on-cancel flag could
     * be changed, g_task_set_return_on_cancel() will indicate this by
     * returning %FALSE.
     *
     * You can disable and re-enable this flag multiple times if you wish.
     * If the task's #GCancellable is cancelled while return-on-cancel is
     * %FALSE, then calling g_task_set_return_on_cancel() to set it %TRUE
     * again will cause the task to be cancelled at that point.
     *
     * If the task's #GCancellable is already cancelled before you call
     * g_task_run_in_thread()/g_task_run_in_thread_sync(), then the
     * #GTaskThreadFunc will still be run (for consistency), but the task
     * will also be completed right away.
     * @param returnOnCancel whether the task returns automatically when   it is cancelled.
     * @returns %TRUE if @task's return-on-cancel flag was changed to   match @return_on_cancel. %FALSE if @task has already been   cancelled.
     */
    setReturnOnCancel(returnOnCancel: boolean): boolean
    /**
     * Sets `task'`s source tag.
     *
     * You can use this to tag a task return
     * value with a particular pointer (usually a pointer to the function
     * doing the tagging) and then later check it using
     * g_task_get_source_tag() (or g_async_result_is_tagged()) in the
     * task's "finish" function, to figure out if the response came from a
     * particular place.
     *
     * A macro wrapper around this function will automatically set the
     * task’s name to the string form of `source_tag` if it’s not already
     * set, for convenience.
     * @param sourceTag an opaque pointer indicating the source of this task
     */
    setSourceTag(sourceTag: any | null): void
    /**
     * Sets `task’`s name, used in debugging and profiling.
     *
     * This is a variant of g_task_set_name() that avoids copying `name`.
     * @param name a human readable name for the task. Must be a string literal
     */
    setStaticName(name: string | null): void
    /**
     * Sets `task'`s task data (freeing the existing task data, if any).
     * @param taskData task-specific data
     * @param taskDataDestroy #GDestroyNotify for `task_data`
     */
    setTaskData(
      taskData: any | null,
      taskDataDestroy: GLib.DestroyNotify | null
    ): void

    // Class property signals of Gio-2.0.Gio.Task

    connect(
      sigName: "notify::completed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::completed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::completed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::completed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::completed", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GTask` represents and manages a cancellable ‘task’.
   *
   * ## Asynchronous operations
   *
   * The most common usage of `GTask` is as a [iface`Gio`.AsyncResult], to
   * manage data during an asynchronous operation. You call
   * [ctor`Gio`.Task.new] in the ‘start’ method, followed by
   * [method`Gio`.Task.set_task_data] and the like if you need to keep some
   * additional data associated with the task, and then pass the
   * task object around through your asynchronous operation.
   * Eventually, you will call a method such as
   * [method`Gio`.Task.return_pointer] or [method`Gio`.Task.return_error], which
   * will save the value you give it and then invoke the task’s callback
   * function in the thread-default main context (see
   * [method`GLib`.MainContext.push_thread_default])
   * where it was created (waiting until the next iteration of the main
   * loop first, if necessary). The caller will pass the `GTask` back to
   * the operation’s finish function (as a [iface`Gio`.AsyncResult]), and you can
   * use [method`Gio`.Task.propagate_pointer] or the like to extract the
   * return value.
   *
   * Using `GTask` requires the thread-default [struct`GLib`.MainContext] from when
   * the `GTask` was constructed to be running at least until the task has
   * completed and its data has been freed.
   *
   * If a `GTask` has been constructed and its callback set, it is an error to
   * not call `g_task_return_*()` on it. GLib will warn at runtime if this happens
   * (since 2.76).
   *
   * Here is an example for using `GTask` as a [iface`Gio`.AsyncResult]:
   * ```c
   * typedef struct {
   *   CakeFrostingType frosting;
   *   char *message;
   * } DecorationData;
   *
   * static void
   * decoration_data_free (DecorationData *decoration)
   * {
   *   g_free (decoration->message);
   *   g_slice_free (DecorationData, decoration);
   * }
   *
   * static void
   * baked_cb (Cake     *cake,
   *           gpointer  user_data)
   * {
   *   GTask *task = user_data;
   *   DecorationData *decoration = g_task_get_task_data (task);
   *   GError *error = NULL;
   *
   *   if (cake == NULL)
   *     {
   *       g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_NO_FLOUR,
   *                                "Go to the supermarket");
   *       g_object_unref (task);
   *       return;
   *     }
   *
   *   if (!cake_decorate (cake, decoration->frosting, decoration->message, &error))
   *     {
   *       g_object_unref (cake);
   *       // g_task_return_error() takes ownership of error
   *       g_task_return_error (task, error);
   *       g_object_unref (task);
   *       return;
   *     }
   *
   *   g_task_return_pointer (task, cake, g_object_unref);
   *   g_object_unref (task);
   * }
   *
   * void
   * baker_bake_cake_async (Baker               *self,
   *                        guint                radius,
   *                        CakeFlavor           flavor,
   *                        CakeFrostingType     frosting,
   *                        const char          *message,
   *                        GCancellable        *cancellable,
   *                        GAsyncReadyCallback  callback,
   *                        gpointer             user_data)
   * {
   *   GTask *task;
   *   DecorationData *decoration;
   *   Cake  *cake;
   *
   *   task = g_task_new (self, cancellable, callback, user_data);
   *   if (radius < 3)
   *     {
   *       g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_TOO_SMALL,
   *                                "%ucm radius cakes are silly",
   *                                radius);
   *       g_object_unref (task);
   *       return;
   *     }
   *
   *   cake = _baker_get_cached_cake (self, radius, flavor, frosting, message);
   *   if (cake != NULL)
   *     {
   *       // _baker_get_cached_cake() returns a reffed cake
   *       g_task_return_pointer (task, cake, g_object_unref);
   *       g_object_unref (task);
   *       return;
   *     }
   *
   *   decoration = g_slice_new (DecorationData);
   *   decoration->frosting = frosting;
   *   decoration->message = g_strdup (message);
   *   g_task_set_task_data (task, decoration, (GDestroyNotify) decoration_data_free);
   *
   *   _baker_begin_cake (self, radius, flavor, cancellable, baked_cb, task);
   * }
   *
   * Cake *
   * baker_bake_cake_finish (Baker         *self,
   *                         GAsyncResult  *result,
   *                         GError       **error)
   * {
   *   g_return_val_if_fail (g_task_is_valid (result, self), NULL);
   *
   *   return g_task_propagate_pointer (G_TASK (result), error);
   * }
   * ```
   *
   * ## Chained asynchronous operations
   *
   * `GTask` also tries to simplify asynchronous operations that
   * internally chain together several smaller asynchronous
   * operations. [method`Gio`.Task.get_cancellable], [method`Gio`.Task.get_context],
   * and [method`Gio`.Task.get_priority] allow you to get back the task’s
   * [class`Gio`.Cancellable], [struct`GLib`.MainContext], and
   * [I/O priority](iface.AsyncResult.html#io-priority)
   * when starting a new subtask, so you don’t have to keep track
   * of them yourself. [method`Gio`.Task.attach_source] simplifies the case
   * of waiting for a source to fire (automatically using the correct
   * [struct`GLib`.MainContext] and priority).
   *
   * Here is an example for chained asynchronous operations:
   * ```c
   * typedef struct {
   *   Cake *cake;
   *   CakeFrostingType frosting;
   *   char *message;
   * } BakingData;
   *
   * static void
   * decoration_data_free (BakingData *bd)
   * {
   *   if (bd->cake)
   *     g_object_unref (bd->cake);
   *   g_free (bd->message);
   *   g_slice_free (BakingData, bd);
   * }
   *
   * static void
   * decorated_cb (Cake         *cake,
   *               GAsyncResult *result,
   *               gpointer      user_data)
   * {
   *   GTask *task = user_data;
   *   GError *error = NULL;
   *
   *   if (!cake_decorate_finish (cake, result, &error))
   *     {
   *       g_object_unref (cake);
   *       g_task_return_error (task, error);
   *       g_object_unref (task);
   *       return;
   *     }
   *
   *   // baking_data_free() will drop its ref on the cake, so we have to
   *   // take another here to give to the caller.
   *   g_task_return_pointer (task, g_object_ref (cake), g_object_unref);
   *   g_object_unref (task);
   * }
   *
   * static gboolean
   * decorator_ready (gpointer user_data)
   * {
   *   GTask *task = user_data;
   *   BakingData *bd = g_task_get_task_data (task);
   *
   *   cake_decorate_async (bd->cake, bd->frosting, bd->message,
   *                        g_task_get_cancellable (task),
   *                        decorated_cb, task);
   *
   *   return G_SOURCE_REMOVE;
   * }
   *
   * static void
   * baked_cb (Cake     *cake,
   *           gpointer  user_data)
   * {
   *   GTask *task = user_data;
   *   BakingData *bd = g_task_get_task_data (task);
   *   GError *error = NULL;
   *
   *   if (cake == NULL)
   *     {
   *       g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_NO_FLOUR,
   *                                "Go to the supermarket");
   *       g_object_unref (task);
   *       return;
   *     }
   *
   *   bd->cake = cake;
   *
   *   // Bail out now if the user has already cancelled
   *   if (g_task_return_error_if_cancelled (task))
   *     {
   *       g_object_unref (task);
   *       return;
   *     }
   *
   *   if (cake_decorator_available (cake))
   *     decorator_ready (task);
   *   else
   *     {
   *       GSource *source;
   *
   *       source = cake_decorator_wait_source_new (cake);
   *       // Attach `source` to `task’`s GMainContext and have it call
   *       // decorator_ready() when it is ready.
   *       g_task_attach_source (task, source, decorator_ready);
   *       g_source_unref (source);
   *     }
   * }
   *
   * void
   * baker_bake_cake_async (Baker               *self,
   *                        guint                radius,
   *                        CakeFlavor           flavor,
   *                        CakeFrostingType     frosting,
   *                        const char          *message,
   *                        gint                 priority,
   *                        GCancellable        *cancellable,
   *                        GAsyncReadyCallback  callback,
   *                        gpointer             user_data)
   * {
   *   GTask *task;
   *   BakingData *bd;
   *
   *   task = g_task_new (self, cancellable, callback, user_data);
   *   g_task_set_priority (task, priority);
   *
   *   bd = g_slice_new0 (BakingData);
   *   bd->frosting = frosting;
   *   bd->message = g_strdup (message);
   *   g_task_set_task_data (task, bd, (GDestroyNotify) baking_data_free);
   *
   *   _baker_begin_cake (self, radius, flavor, cancellable, baked_cb, task);
   * }
   *
   * Cake *
   * baker_bake_cake_finish (Baker         *self,
   *                         GAsyncResult  *result,
   *                         GError       **error)
   * {
   *   g_return_val_if_fail (g_task_is_valid (result, self), NULL);
   *
   *   return g_task_propagate_pointer (G_TASK (result), error);
   * }
   * ```
   *
   * ## Asynchronous operations from synchronous ones
   *
   * You can use [method`Gio`.Task.run_in_thread] to turn a synchronous
   * operation into an asynchronous one, by running it in a thread.
   * When it completes, the result will be dispatched to the thread-default main
   * context (see [method`GLib`.MainContext.push_thread_default]) where the `GTask`
   * was created.
   *
   * Running a task in a thread:
   * ```c
   * typedef struct {
   *   guint radius;
   *   CakeFlavor flavor;
   *   CakeFrostingType frosting;
   *   char *message;
   * } CakeData;
   *
   * static void
   * cake_data_free (CakeData *cake_data)
   * {
   *   g_free (cake_data->message);
   *   g_slice_free (CakeData, cake_data);
   * }
   *
   * static void
   * bake_cake_thread (GTask         *task,
   *                   gpointer       source_object,
   *                   gpointer       task_data,
   *                   GCancellable  *cancellable)
   * {
   *   Baker *self = source_object;
   *   CakeData *cake_data = task_data;
   *   Cake *cake;
   *   GError *error = NULL;
   *
   *   cake = bake_cake (baker, cake_data->radius, cake_data->flavor,
   *                     cake_data->frosting, cake_data->message,
   *                     cancellable, &error);
   *   if (cake)
   *     g_task_return_pointer (task, cake, g_object_unref);
   *   else
   *     g_task_return_error (task, error);
   * }
   *
   * void
   * baker_bake_cake_async (Baker               *self,
   *                        guint                radius,
   *                        CakeFlavor           flavor,
   *                        CakeFrostingType     frosting,
   *                        const char          *message,
   *                        GCancellable        *cancellable,
   *                        GAsyncReadyCallback  callback,
   *                        gpointer             user_data)
   * {
   *   CakeData *cake_data;
   *   GTask *task;
   *
   *   cake_data = g_slice_new (CakeData);
   *   cake_data->radius = radius;
   *   cake_data->flavor = flavor;
   *   cake_data->frosting = frosting;
   *   cake_data->message = g_strdup (message);
   *   task = g_task_new (self, cancellable, callback, user_data);
   *   g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free);
   *   g_task_run_in_thread (task, bake_cake_thread);
   *   g_object_unref (task);
   * }
   *
   * Cake *
   * baker_bake_cake_finish (Baker         *self,
   *                         GAsyncResult  *result,
   *                         GError       **error)
   * {
   *   g_return_val_if_fail (g_task_is_valid (result, self), NULL);
   *
   *   return g_task_propagate_pointer (G_TASK (result), error);
   * }
   * ```
   *
   * ## Adding cancellability to uncancellable tasks
   *
   * Finally, [method`Gio`.Task.run_in_thread] and
   * [method`Gio`.Task.run_in_thread_sync] can be used to turn an uncancellable
   * operation into a cancellable one. If you call
   * [method`Gio`.Task.set_return_on_cancel], passing `TRUE`, then if the task’s
   * [class`Gio`.Cancellable] is cancelled, it will return control back to the
   * caller immediately, while allowing the task thread to continue running in the
   * background (and simply discarding its result when it finally does finish).
   * Provided that the task thread is careful about how it uses
   * locks and other externally-visible resources, this allows you
   * to make ‘GLib-friendly’ asynchronous and cancellable
   * synchronous variants of blocking APIs.
   *
   * Cancelling a task:
   * ```c
   * static void
   * bake_cake_thread (GTask         *task,
   *                   gpointer       source_object,
   *                   gpointer       task_data,
   *                   GCancellable  *cancellable)
   * {
   *   Baker *self = source_object;
   *   CakeData *cake_data = task_data;
   *   Cake *cake;
   *   GError *error = NULL;
   *
   *   cake = bake_cake (baker, cake_data->radius, cake_data->flavor,
   *                     cake_data->frosting, cake_data->message,
   *                     &error);
   *   if (error)
   *     {
   *       g_task_return_error (task, error);
   *       return;
   *     }
   *
   *   // If the task has already been cancelled, then we don’t want to add
   *   // the cake to the cake cache. Likewise, we don’t  want to have the
   *   // task get cancelled in the middle of updating the cache.
   *   // g_task_set_return_on_cancel() will return %TRUE here if it managed
   *   // to disable return-on-cancel, or %FALSE if the task was cancelled
   *   // before it could.
   *   if (g_task_set_return_on_cancel (task, FALSE))
   *     {
   *       // If the caller cancels at this point, their
   *       // GAsyncReadyCallback won’t be invoked until we return,
   *       // so we don’t have to worry that this code will run at
   *       // the same time as that code does. But if there were
   *       // other functions that might look at the cake cache,
   *       // then we’d probably need a GMutex here as well.
   *       baker_add_cake_to_cache (baker, cake);
   *       g_task_return_pointer (task, cake, g_object_unref);
   *     }
   * }
   *
   * void
   * baker_bake_cake_async (Baker               *self,
   *                        guint                radius,
   *                        CakeFlavor           flavor,
   *                        CakeFrostingType     frosting,
   *                        const char          *message,
   *                        GCancellable        *cancellable,
   *                        GAsyncReadyCallback  callback,
   *                        gpointer             user_data)
   * {
   *   CakeData *cake_data;
   *   GTask *task;
   *
   *   cake_data = g_slice_new (CakeData);
   *
   *   ...
   *
   *   task = g_task_new (self, cancellable, callback, user_data);
   *   g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free);
   *   g_task_set_return_on_cancel (task, TRUE);
   *   g_task_run_in_thread (task, bake_cake_thread);
   * }
   *
   * Cake *
   * baker_bake_cake_sync (Baker               *self,
   *                       guint                radius,
   *                       CakeFlavor           flavor,
   *                       CakeFrostingType     frosting,
   *                       const char          *message,
   *                       GCancellable        *cancellable,
   *                       GError             **error)
   * {
   *   CakeData *cake_data;
   *   GTask *task;
   *   Cake *cake;
   *
   *   cake_data = g_slice_new (CakeData);
   *
   *   ...
   *
   *   task = g_task_new (self, cancellable, NULL, NULL);
   *   g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free);
   *   g_task_set_return_on_cancel (task, TRUE);
   *   g_task_run_in_thread_sync (task, bake_cake_thread);
   *
   *   cake = g_task_propagate_pointer (task, error);
   *   g_object_unref (task);
   *   return cake;
   * }
   * ```
   *
   * ## Porting from [class`Gio`.SimpleAsyncResult]
   *
   * `GTask`’s API attempts to be simpler than [class`Gio`.SimpleAsyncResult]’s
   * in several ways:
   *
   * - You can save task-specific data with [method`Gio`.Task.set_task_data], and
   *   retrieve it later with [method`Gio`.Task.get_task_data]. This replaces the
   *   abuse of [method`Gio`.SimpleAsyncResult.set_op_res_gpointer] for the same
   *   purpose with [class`Gio`.SimpleAsyncResult].
   * - In addition to the task data, `GTask` also keeps track of the
   *   [priority](iface.AsyncResult.html#io-priority), [class`Gio`.Cancellable],
   *   and [struct`GLib`.MainContext] associated with the task, so tasks that
   *   consist of a chain of simpler asynchronous operations will have easy access
   *   to those values when starting each sub-task.
   * - [method`Gio`.Task.return_error_if_cancelled] provides simplified
   *   handling for cancellation. In addition, cancellation
   *   overrides any other `GTask` return value by default, like
   *   [class`Gio`.SimpleAsyncResult] does when
   *   [method`Gio`.SimpleAsyncResult.set_check_cancellable] is called.
   *   (You can use [method`Gio`.Task.set_check_cancellable] to turn off that
   *   behavior.) On the other hand, [method`Gio`.Task.run_in_thread]
   *   guarantees that it will always run your
   *   `task_func`, even if the task’s [class`Gio`.Cancellable]
   *   is already cancelled before the task gets a chance to run;
   *   you can start your `task_func` with a
   *   [method`Gio`.Task.return_error_if_cancelled] check if you need the
   *   old behavior.
   * - The ‘return’ methods (eg, [method`Gio`.Task.return_pointer])
   *   automatically cause the task to be ‘completed’ as well, and
   *   there is no need to worry about the ‘complete’ vs ‘complete in idle’
   *   distinction. (`GTask` automatically figures out
   *   whether the task’s callback can be invoked directly, or
   *   if it needs to be sent to another [struct`GLib`.MainContext], or delayed
   *   until the next iteration of the current [struct`GLib`.MainContext].)
   * - The ‘finish’ functions for `GTask` based operations are generally
   *   much simpler than [class`Gio`.SimpleAsyncResult] ones, normally consisting
   *   of only a single call to [method`Gio`.Task.propagate_pointer] or the like.
   *   Since [method`Gio`.Task.propagate_pointer] ‘steals’ the return value from
   *   the `GTask`, it is not necessary to juggle pointers around to
   *   prevent it from being freed twice.
   * - With [class`Gio`.SimpleAsyncResult], it was common to call
   *   [method`Gio`.SimpleAsyncResult.propagate_error] from the
   *   `_finish()` wrapper function, and have
   *   virtual method implementations only deal with successful
   *   returns. This behavior is deprecated, because it makes it
   *   difficult for a subclass to chain to a parent class’s async
   *   methods. Instead, the wrapper function should just be a
   *   simple wrapper, and the virtual method should call an
   *   appropriate `g_task_propagate_` function.
   *   Note that wrapper methods can now use
   *   [method`Gio`.AsyncResult.legacy_propagate_error] to do old-style
   *   [class`Gio`.SimpleAsyncResult] error-returning behavior, and
   *   [method`Gio`.AsyncResult.is_tagged] to check if a result is tagged as
   *   having come from the `_async()` wrapper
   *   function (for ‘short-circuit’ results, such as when passing
   *   `0` to [method`Gio`.InputStream.read_async]).
   *
   * ## Thread-safety considerations
   *
   * Due to some infelicities in the API design, there is a
   * thread-safety concern that users of `GTask` have to be aware of:
   *
   * If the `main` thread drops its last reference to the source object
   * or the task data before the task is finalized, then the finalizers
   * of these objects may be called on the worker thread.
   *
   * This is a problem if the finalizers use non-threadsafe API, and
   * can lead to hard-to-debug crashes. Possible workarounds include:
   *
   * - Clear task data in a signal handler for `notify::completed`
   * - Keep iterating a main context in the main thread and defer
   *   dropping the reference to the source object to that main
   *   context when the task is finalized
   * @class
   */
  class Task extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Task

    static name: string

    // Constructors of Gio-2.0.Gio.Task

    constructor(config?: Task.ConstructorProperties)
    /**
     * Creates a #GTask acting on `source_object,` which will eventually be
     * used to invoke `callback` in the current
     * [thread-default main context][g-main-context-push-thread-default].
     *
     * Call this in the "start" method of your asynchronous method, and
     * pass the #GTask around throughout the asynchronous operation. You
     * can use g_task_set_task_data() to attach task-specific data to the
     * object, which you can retrieve later via g_task_get_task_data().
     *
     * By default, if `cancellable` is cancelled, then the return value of
     * the task will always be %G_IO_ERROR_CANCELLED, even if the task had
     * already completed before the cancellation. This allows for
     * simplified handling in cases where cancellation may imply that
     * other objects that the task depends on have been destroyed. If you
     * do not want this behavior, you can use
     * g_task_set_check_cancellable() to change it.
     * @constructor
     * @param sourceObject the #GObject that owns   this task, or %NULL.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback.
     * @returns a #GTask.
     */
    constructor(
      sourceObject: GObject.Object | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    )
    /**
     * Creates a #GTask acting on `source_object,` which will eventually be
     * used to invoke `callback` in the current
     * [thread-default main context][g-main-context-push-thread-default].
     *
     * Call this in the "start" method of your asynchronous method, and
     * pass the #GTask around throughout the asynchronous operation. You
     * can use g_task_set_task_data() to attach task-specific data to the
     * object, which you can retrieve later via g_task_get_task_data().
     *
     * By default, if `cancellable` is cancelled, then the return value of
     * the task will always be %G_IO_ERROR_CANCELLED, even if the task had
     * already completed before the cancellation. This allows for
     * simplified handling in cases where cancellation may imply that
     * other objects that the task depends on have been destroyed. If you
     * do not want this behavior, you can use
     * g_task_set_check_cancellable() to change it.
     * @constructor
     * @param sourceObject the #GObject that owns   this task, or %NULL.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback.
     * @returns a #GTask.
     */
    static new(
      sourceObject: GObject.Object | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): Task
    _init(config?: Task.ConstructorProperties): void
    /**
     * Checks that `result` is a #GTask, and that `source_object` is its
     * source object (or that `source_object` is %NULL and `result` has no
     * source object). This can be used in g_return_if_fail() checks.
     * @param result A #GAsyncResult
     * @param sourceObject the source object   expected to be associated with the task
     * @returns %TRUE if @result and @source_object are valid, %FALSE if not
     */
    static isValid(
      result: AsyncResult,
      sourceObject: GObject.Object | null
    ): boolean
    /**
     * Creates a #GTask and then immediately calls g_task_return_error()
     * on it. Use this in the wrapper function of an asynchronous method
     * when you want to avoid even calling the virtual method. You can
     * then use g_async_result_is_tagged() in the finish method wrapper to
     * check if the result there is tagged as having been created by the
     * wrapper method, and deal with it appropriately if so.
     *
     * See also g_task_report_new_error().
     * @param sourceObject the #GObject that owns   this task, or %NULL.
     * @param callback a #GAsyncReadyCallback.
     * @param sourceTag an opaque pointer indicating the source of this task
     * @param error error to report
     */
    static reportError(
      sourceObject: GObject.Object | null,
      callback: AsyncReadyCallback | null,
      sourceTag: any | null,
      error: GLib.Error
    ): void
  }

  module TcpConnection {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnection.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TcpConnection

      /**
       * Whether [method`Gio`.IOStream.close] does a graceful disconnect.
       */
      graceful_disconnect?: boolean | null
    }
  }

  interface TcpConnection {
    // Own properties of Gio-2.0.Gio.TcpConnection

    /**
     * Whether [method`Gio`.IOStream.close] does a graceful disconnect.
     */
    gracefulDisconnect: boolean
    __gtype__: number

    // Own fields of Gio-2.0.Gio.TcpConnection

    parentInstance: any
    priv: any

    // Owm methods of Gio-2.0.Gio.TcpConnection

    /**
     * Checks if graceful disconnects are used. See
     * g_tcp_connection_set_graceful_disconnect().
     * @returns %TRUE if graceful disconnect is used on close, %FALSE otherwise
     */
    getGracefulDisconnect(): boolean
    /**
     * This enables graceful disconnects on close. A graceful disconnect
     * means that we signal the receiving end that the connection is terminated
     * and wait for it to close the connection before closing the connection.
     *
     * A graceful disconnect means that we can be sure that we successfully sent
     * all the outstanding data to the other end, or get an error reported.
     * However, it also means we have to wait for all the data to reach the
     * other side and for it to acknowledge this by closing the socket, which may
     * take a while. For this reason it is disabled by default.
     * @param gracefulDisconnect Whether to do graceful disconnects or not
     */
    setGracefulDisconnect(gracefulDisconnect: boolean): void

    // Class property signals of Gio-2.0.Gio.TcpConnection

    connect(
      sigName: "notify::graceful-disconnect",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::graceful-disconnect",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::graceful-disconnect",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::graceful-disconnect",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::graceful-disconnect", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::socket",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::socket",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::socket", ...args: any[]): void
    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::output-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * This is the subclass of [class`Gio`.SocketConnection] that is created
   * for TCP/IP sockets.
   * @class
   */
  class TcpConnection extends SocketConnection {
    // Own properties of Gio-2.0.Gio.TcpConnection

    static name: string

    // Constructors of Gio-2.0.Gio.TcpConnection

    constructor(config?: TcpConnection.ConstructorProperties)
    _init(config?: TcpConnection.ConstructorProperties): void
  }

  module TcpWrapperConnection {
    // Constructor properties interface

    interface ConstructorProperties
      extends TcpConnection.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TcpWrapperConnection

      /**
       * The wrapped [class`Gio`.IOStream].
       */
      base_io_stream?: IOStream | null
    }
  }

  interface TcpWrapperConnection {
    // Own properties of Gio-2.0.Gio.TcpWrapperConnection

    /**
     * The wrapped [class`Gio`.IOStream].
     */
    readonly baseIoStream: IOStream
    __gtype__: number

    // Own fields of Gio-2.0.Gio.TcpWrapperConnection

    parentInstance: any
    priv: any

    // Owm methods of Gio-2.0.Gio.TcpWrapperConnection

    /**
     * Gets `conn'`s base #GIOStream
     * @returns @conn's base #GIOStream
     */
    getBaseIoStream(): IOStream

    // Class property signals of Gio-2.0.Gio.TcpWrapperConnection

    connect(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::base-io-stream", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::graceful-disconnect",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::graceful-disconnect",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::graceful-disconnect",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::graceful-disconnect",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::graceful-disconnect", ...args: any[]): void
    connect(
      sigName: "notify::socket",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::socket",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::socket", ...args: any[]): void
    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::output-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GTcpWrapperConnection` can be used to wrap a [class`Gio`.IOStream] that is
   * based on a [class`Gio`.Socket], but which is not actually a
   * [class`Gio`.SocketConnection]. This is used by [class`Gio`.SocketClient] so
   * that it can always return a [class`Gio`.SocketConnection], even when the
   * connection it has actually created is not directly a
   * [class`Gio`.SocketConnection].
   * @class
   */
  class TcpWrapperConnection extends TcpConnection {
    // Own properties of Gio-2.0.Gio.TcpWrapperConnection

    static name: string

    // Constructors of Gio-2.0.Gio.TcpWrapperConnection

    constructor(config?: TcpWrapperConnection.ConstructorProperties)
    /**
     * Wraps `base_io_stream` and `socket` together as a #GSocketConnection.
     * @constructor
     * @param baseIoStream the #GIOStream to wrap
     * @param socket the #GSocket associated with `base_io_stream`
     * @returns the new #GSocketConnection.
     */
    constructor(baseIoStream: IOStream, socket: Socket)
    /**
     * Wraps `base_io_stream` and `socket` together as a #GSocketConnection.
     * @constructor
     * @param baseIoStream the #GIOStream to wrap
     * @param socket the #GSocket associated with `base_io_stream`
     * @returns the new #GSocketConnection.
     */
    static new(baseIoStream: IOStream, socket: Socket): TcpWrapperConnection
    _init(config?: TcpWrapperConnection.ConstructorProperties): void
  }

  module TestDBus {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TestDBus

      /**
       * #GTestDBusFlags specifying the behaviour of the D-Bus session.
       */
      flags?: TestDBusFlags | null
    }
  }

  interface TestDBus {
    // Own properties of Gio-2.0.Gio.TestDBus

    /**
     * #GTestDBusFlags specifying the behaviour of the D-Bus session.
     */
    readonly flags: TestDBusFlags
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.TestDBus

    /**
     * Add a path where dbus-daemon will look up .service files. This can't be
     * called after g_test_dbus_up().
     * @param path path to a directory containing .service files
     */
    addServiceDir(path: string): void
    /**
     * Stop the session bus started by g_test_dbus_up().
     *
     * This will wait for the singleton returned by g_bus_get() or g_bus_get_sync()
     * to be destroyed. This is done to ensure that the next unit test won't get a
     * leaked singleton from this test.
     */
    down(): void
    /**
     * Get the address on which dbus-daemon is running. If g_test_dbus_up() has not
     * been called yet, %NULL is returned. This can be used with
     * g_dbus_connection_new_for_address().
     * @returns the address of the bus, or %NULL.
     */
    getBusAddress(): string | null
    /**
     * Get the flags of the #GTestDBus object.
     * @returns the value of #GTestDBus:flags property
     */
    getFlags(): TestDBusFlags
    /**
     * Stop the session bus started by g_test_dbus_up().
     *
     * Unlike g_test_dbus_down(), this won't verify the #GDBusConnection
     * singleton returned by g_bus_get() or g_bus_get_sync() is destroyed. Unit
     * tests wanting to verify behaviour after the session bus has been stopped
     * can use this function but should still call g_test_dbus_down() when done.
     */
    stop(): void
    /**
     * Start a dbus-daemon instance and set DBUS_SESSION_BUS_ADDRESS. After this
     * call, it is safe for unit tests to start sending messages on the session bus.
     *
     * If this function is called from setup callback of g_test_add(),
     * g_test_dbus_down() must be called in its teardown callback.
     *
     * If this function is called from unit test's main(), then g_test_dbus_down()
     * must be called after g_test_run().
     */
    up(): void

    // Class property signals of Gio-2.0.Gio.TestDBus

    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A helper class for testing code which uses D-Bus without touching the user’s
   * session bus.
   *
   * Note that `GTestDBus` modifies the user’s environment, calling
   * [`setenv()`](man:setenv(3)). This is not thread-safe, so all `GTestDBus`
   * calls should be completed before threads are spawned, or should have
   * appropriate locking to ensure no access conflicts to environment variables
   * shared between `GTestDBus` and other threads.
   *
   * ## Creating unit tests using `GTestDBus`
   *
   * Testing of D-Bus services can be tricky because normally we only ever run
   * D-Bus services over an existing instance of the D-Bus daemon thus we
   * usually don’t activate D-Bus services that are not yet installed into the
   * target system. The `GTestDBus` object makes this easier for us by taking care
   * of the lower level tasks such as running a private D-Bus daemon and looking
   * up uninstalled services in customizable locations, typically in your source
   * code tree.
   *
   * The first thing you will need is a separate service description file for the
   * D-Bus daemon. Typically a `services` subdirectory of your `tests` directory
   * is a good place to put this file.
   *
   * The service file should list your service along with an absolute path to the
   * uninstalled service executable in your source tree. Using autotools we would
   * achieve this by adding a file such as `my-server.service.in` in the services
   * directory and have it processed by configure.
   *
   * ```
   * [D-BUS Service]
   * Name=org.gtk.GDBus.Examples.ObjectManager
   * Exec=`abs_top_builddir@`/gio/tests/gdbus-example-objectmanager-server
   * ```
   *
   * You will also need to indicate this service directory in your test
   * fixtures, so you will need to pass the path while compiling your
   * test cases. Typically this is done with autotools with an added
   * preprocessor flag specified to compile your tests such as:
   *
   * ```
   * -DTEST_SERVICES=\""$(abs_top_builddir)/tests/services"\"
   * ```
   *
   * Once you have a service definition file which is local to your source tree,
   * you can proceed to set up a GTest fixture using the `GTestDBus` scaffolding.
   *
   * An example of a test fixture for D-Bus services can be found
   * here:
   * [gdbus-test-fixture.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-test-fixture.c)
   *
   * Note that these examples only deal with isolating the D-Bus aspect of your
   * service. To successfully run isolated unit tests on your service you may need
   * some additional modifications to your test case fixture. For example; if your
   * service uses [class`Gio`.Settings] and installs a schema then it is important
   * that your test service not load the schema in the ordinary installed location
   * (chances are that your service and schema files are not yet installed, or
   * worse; there is an older version of the schema file sitting in the install
   * location).
   *
   * Most of the time we can work around these obstacles using the
   * environment. Since the environment is inherited by the D-Bus daemon
   * created by `GTestDBus` and then in turn inherited by any services the
   * D-Bus daemon activates, using the setup routine for your fixture is
   * a practical place to help sandbox your runtime environment. For the
   * rather typical GSettings case we can work around this by setting
   * `GSETTINGS_SCHEMA_DIR` to the in tree directory holding your schemas
   * in the above `fixture_setup()` routine.
   *
   * The GSettings schemas need to be locally pre-compiled for this to work. This
   * can be achieved by compiling the schemas locally as a step before running
   * test cases, an autotools setup might do the following in the directory
   * holding schemas:
   *
   * ```
   *     all-am:
   *             $(GLIB_COMPILE_SCHEMAS) .
   *
   *     CLEANFILES += gschemas.compiled
   * ```
   * @class
   */
  class TestDBus extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TestDBus

    static name: string

    // Constructors of Gio-2.0.Gio.TestDBus

    constructor(config?: TestDBus.ConstructorProperties)
    /**
     * Create a new #GTestDBus object.
     * @constructor
     * @param flags a #GTestDBusFlags
     * @returns a new #GTestDBus.
     */
    constructor(flags: TestDBusFlags)
    /**
     * Create a new #GTestDBus object.
     * @constructor
     * @param flags a #GTestDBusFlags
     * @returns a new #GTestDBus.
     */
    static new(flags: TestDBusFlags): TestDBus
    _init(config?: TestDBus.ConstructorProperties): void
    /**
     * Unset DISPLAY and DBUS_SESSION_BUS_ADDRESS env variables to ensure the test
     * won't use user's session bus.
     *
     * This is useful for unit tests that want to verify behaviour when no session
     * bus is running. It is not necessary to call this if unit test already calls
     * g_test_dbus_up() before acquiring the session bus.
     */
    static unset(): void
  }

  module ThemedIcon {
    // Constructor properties interface

    interface ConstructorProperties
      extends Icon.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ThemedIcon

      /**
       * The icon name.
       */
      name?: string | null
      /**
       * A %NULL-terminated array of icon names.
       */
      names?: string[] | null
      /**
       * Whether to use the default fallbacks found by shortening the icon name
       * at '-' characters. If the "names" array has more than one element,
       * ignores any past the first.
       *
       * For example, if the icon name was "gnome-dev-cdrom-audio", the array
       * would become
       *
       * ```c
       * {
       *   "gnome-dev-cdrom-audio",
       *   "gnome-dev-cdrom",
       *   "gnome-dev",
       *   "gnome",
       *   NULL
       * };
       * ```
       *
       */
      use_default_fallbacks?: boolean | null
    }
  }

  interface ThemedIcon extends Icon {
    // Own properties of Gio-2.0.Gio.ThemedIcon

    /**
     * The icon name.
     */
    readonly name: string | null
    /**
     * A %NULL-terminated array of icon names.
     */
    readonly names: string[]
    /**
     * Whether to use the default fallbacks found by shortening the icon name
     * at '-' characters. If the "names" array has more than one element,
     * ignores any past the first.
     *
     * For example, if the icon name was "gnome-dev-cdrom-audio", the array
     * would become
     *
     * ```c
     * {
     *   "gnome-dev-cdrom-audio",
     *   "gnome-dev-cdrom",
     *   "gnome-dev",
     *   "gnome",
     *   NULL
     * };
     * ```
     *
     */
    readonly useDefaultFallbacks: boolean
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ThemedIcon

    /**
     * Append a name to the list of icons from within `icon`.
     *
     * Note that doing so invalidates the hash computed by prior calls
     * to g_icon_hash().
     * @param iconname name of icon to append to list of icons from within `icon`.
     */
    appendName(iconname: string): void
    /**
     * Gets the names of icons from within `icon`.
     * @returns a list of icon names.
     */
    getNames(): string[]
    /**
     * Prepend a name to the list of icons from within `icon`.
     *
     * Note that doing so invalidates the hash computed by prior calls
     * to g_icon_hash().
     * @param iconname name of icon to prepend to list of icons from within `icon`.
     */
    prependName(iconname: string): void

    // Class property signals of Gio-2.0.Gio.ThemedIcon

    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::names",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::names",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::names",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::names",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::names", ...args: any[]): void
    connect(
      sigName: "notify::use-default-fallbacks",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-default-fallbacks",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-default-fallbacks",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-default-fallbacks",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-default-fallbacks", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GThemedIcon` is an implementation of [iface`Gio`.Icon] that supports icon
   * themes.
   *
   * `GThemedIcon` contains a list of all of the icons present in an icon
   * theme, so that icons can be looked up quickly. `GThemedIcon` does
   * not provide actual pixmaps for icons, just the icon names.
   * Ideally something like [method`Gtk`.IconTheme.choose_icon] should be used to
   * resolve the list of names so that fallback icons work nicely with
   * themes that inherit other themes.
   * @class
   */
  class ThemedIcon extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ThemedIcon

    static name: string

    // Constructors of Gio-2.0.Gio.ThemedIcon

    constructor(config?: ThemedIcon.ConstructorProperties)
    /**
     * Creates a new themed icon for `iconname`.
     * @constructor
     * @param iconname a string containing an icon name.
     * @returns a new #GThemedIcon.
     */
    constructor(iconname: string)
    /**
     * Creates a new themed icon for `iconname`.
     * @constructor
     * @param iconname a string containing an icon name.
     * @returns a new #GThemedIcon.
     */
    static new(iconname: string): ThemedIcon
    /**
     * Creates a new themed icon for `iconnames`.
     * @constructor
     * @param iconnames an array of strings containing icon names.
     * @returns a new #GThemedIcon
     */
    static newFromNames(iconnames: string[]): ThemedIcon
    /**
     * Creates a new themed icon for `iconname,` and all the names
     * that can be created by shortening `iconname` at '-' characters.
     *
     * In the following example, `icon1` and `icon2` are equivalent:
     *
     * ```c
     * const char *names[] = {
     *   "gnome-dev-cdrom-audio",
     *   "gnome-dev-cdrom",
     *   "gnome-dev",
     *   "gnome"
     * };
     *
     * icon1 = g_themed_icon_new_from_names (names, 4);
     * icon2 = g_themed_icon_new_with_default_fallbacks ("gnome-dev-cdrom-audio");
     * ```
     *
     * @constructor
     * @param iconname a string containing an icon name
     * @returns a new #GThemedIcon.
     */
    static newWithDefaultFallbacks(iconname: string): ThemedIcon
    _init(config?: ThemedIcon.ConstructorProperties): void
  }

  module ThreadedResolver {
    // Constructor properties interface

    interface ConstructorProperties extends Resolver.ConstructorProperties {}
  }

  interface ThreadedResolver {
    // Own properties of Gio-2.0.Gio.ThreadedResolver

    __gtype__: number

    // Class property signals of Gio-2.0.Gio.ThreadedResolver

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::timeout", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * #GThreadedResolver is an implementation of #GResolver which calls the libc
   * lookup functions in threads to allow them to run asynchronously.
   * @class
   */
  class ThreadedResolver extends Resolver {
    // Own properties of Gio-2.0.Gio.ThreadedResolver

    static name: string

    // Constructors of Gio-2.0.Gio.ThreadedResolver

    constructor(config?: ThreadedResolver.ConstructorProperties)
    _init(config?: ThreadedResolver.ConstructorProperties): void
  }

  module ThreadedSocketService {
    // Signal callback interfaces

    /**
     * Signal callback interface for `run`
     */
    interface RunSignalCallback {
      (
        connection: SocketConnection,
        sourceObject: GObject.Object | null
      ): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends SocketService.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ThreadedSocketService

      /**
       * The maximum number of threads handling clients for this service.
       */
      max_threads?: number | null
    }
  }

  interface ThreadedSocketService {
    // Own properties of Gio-2.0.Gio.ThreadedSocketService

    /**
     * The maximum number of threads handling clients for this service.
     */
    readonly maxThreads: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.ThreadedSocketService

    parentInstance: any
    priv: any

    // Own virtual methods of Gio-2.0.Gio.ThreadedSocketService

    run(connection: SocketConnection, sourceObject: GObject.Object): boolean

    // Own signals of Gio-2.0.Gio.ThreadedSocketService

    connect(
      sigName: "run",
      callback: ThreadedSocketService.RunSignalCallback
    ): number
    on(
      sigName: "run",
      callback: ThreadedSocketService.RunSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "run",
      callback: ThreadedSocketService.RunSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "run",
      callback: ThreadedSocketService.RunSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "run",
      sourceObject: GObject.Object | null,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.ThreadedSocketService

    connect(
      sigName: "notify::max-threads",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-threads",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-threads",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-threads",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-threads", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::listen-backlog",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::listen-backlog", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GThreadedSocketService` is a simple subclass of [class`Gio`.SocketService]
   * that handles incoming connections by creating a worker thread and
   * dispatching the connection to it by emitting the
   * [signal`Gio`.ThreadedSocketService::run signal] in the new thread.
   *
   * The signal handler may perform blocking I/O and need not return
   * until the connection is closed.
   *
   * The service is implemented using a thread pool, so there is a
   * limited amount of threads available to serve incoming requests.
   * The service automatically stops the [class`Gio`.SocketService] from accepting
   * new connections when all threads are busy.
   *
   * As with [class`Gio`.SocketService], you may connect to
   * [signal`Gio`.ThreadedSocketService::run], or subclass and override the default
   * handler.
   * @class
   */
  class ThreadedSocketService extends SocketService {
    // Own properties of Gio-2.0.Gio.ThreadedSocketService

    static name: string

    // Constructors of Gio-2.0.Gio.ThreadedSocketService

    constructor(config?: ThreadedSocketService.ConstructorProperties)
    /**
     * Creates a new #GThreadedSocketService with no listeners. Listeners
     * must be added with one of the #GSocketListener "add" methods.
     * @constructor
     * @param maxThreads the maximal number of threads to execute concurrently   handling incoming clients, -1 means no limit
     * @returns a new #GSocketService.
     */
    constructor(maxThreads: number)
    /**
     * Creates a new #GThreadedSocketService with no listeners. Listeners
     * must be added with one of the #GSocketListener "add" methods.
     * @constructor
     * @param maxThreads the maximal number of threads to execute concurrently   handling incoming clients, -1 means no limit
     * @returns a new #GSocketService.
     */
    static new(maxThreads: number): ThreadedSocketService

    // Overloads of new

    /**
     * Creates a new #GSocketService with no sockets to listen for.
     * New listeners can be added with e.g. g_socket_listener_add_address()
     * or g_socket_listener_add_inet_port().
     *
     * New services are created active, there is no need to call
     * g_socket_service_start(), unless g_socket_service_stop() has been
     * called before.
     * @constructor
     * @returns a new #GSocketService.
     */
    static new(): SocketService
    /**
     * Creates a new #GSocketListener with no sockets to listen for.
     * New listeners can be added with e.g. g_socket_listener_add_address()
     * or g_socket_listener_add_inet_port().
     * @constructor
     * @returns a new #GSocketListener.
     */
    static new(): SocketListener
    _init(config?: ThreadedSocketService.ConstructorProperties): void
  }

  module TlsCertificate {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TlsCertificate

      /**
       * The DER (binary) encoded representation of the certificate.
       * This property and the #GTlsCertificate:certificate-pem property
       * represent the same data, just in different forms.
       */
      certificate?: number[] | null
      /**
       * The PEM (ASCII) encoded representation of the certificate.
       * This property and the #GTlsCertificate:certificate
       * property represent the same data, just in different forms.
       */
      certificate_pem?: string | null
      /**
       * A #GTlsCertificate representing the entity that issued this
       * certificate. If %NULL, this means that the certificate is either
       * self-signed, or else the certificate of the issuer is not
       * available.
       *
       * Beware the issuer certificate may not be the same as the
       * certificate that would actually be used to construct a valid
       * certification path during certificate verification.
       * [RFC 4158](https://datatracker.ietf.org/doc/html/rfc4158) explains
       * why an issuer certificate cannot be naively assumed to be part of the
       * the certification path (though GLib's TLS backends may not follow the
       * path building strategies outlined in this RFC). Due to the complexity
       * of certification path building, GLib does not provide any way to know
       * which certification path will actually be used. Accordingly, this
       * property cannot be used to make security-related decisions. Only
       * GLib itself should make security decisions about TLS certificates.
       */
      issuer?: TlsCertificate | null
      /**
       * An optional password used when constructed with GTlsCertificate:pkcs12-data.
       */
      password?: string | null
      /**
       * A URI referencing the [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
       * objects containing an X.509 certificate and optionally a private key.
       *
       * If %NULL, the certificate is either not backed by PKCS \#11 or the
       * #GTlsBackend does not support PKCS \#11.
       */
      pkcs11_uri?: string | null
      /**
       * The PKCS #12 formatted data used to construct the object.
       *
       * See also: g_tls_certificate_new_from_pkcs12()
       */
      pkcs12_data?: number[] | null
      /**
       * The DER (binary) encoded representation of the certificate's
       * private key, in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
       * or unencrypted [PKCS \#8 format.](https://datatracker.ietf.org/doc/html/rfc5208)
       * PKCS \#8 format is supported since 2.32; earlier releases only
       * support PKCS \#1. You can use the `openssl rsa` tool to convert
       * PKCS \#8 keys to PKCS \#1.
       *
       * This property (or the #GTlsCertificate:private-key-pem property)
       * can be set when constructing a key (for example, from a file).
       * Since GLib 2.70, it is now also readable; however, be aware that if
       * the private key is backed by a PKCS \#11 URI – for example, if it
       * is stored on a smartcard – then this property will be %NULL. If so,
       * the private key must be referenced via its PKCS \#11 URI,
       * #GTlsCertificate:private-key-pkcs11-uri. You must check both
       * properties to see if the certificate really has a private key.
       * When this property is read, the output format will be unencrypted
       * PKCS \#8.
       */
      private_key?: number[] | null
      /**
       * The PEM (ASCII) encoded representation of the certificate's
       * private key in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
       * ("`BEGIN RSA PRIVATE KEY`") or unencrypted
       * [PKCS \#8 format](https://datatracker.ietf.org/doc/html/rfc5208)
       * ("`BEGIN PRIVATE KEY`"). PKCS \#8 format is supported since 2.32;
       * earlier releases only support PKCS \#1. You can use the `openssl rsa`
       * tool to convert PKCS \#8 keys to PKCS \#1.
       *
       * This property (or the #GTlsCertificate:private-key property)
       * can be set when constructing a key (for example, from a file).
       * Since GLib 2.70, it is now also readable; however, be aware that if
       * the private key is backed by a PKCS \#11 URI - for example, if it
       * is stored on a smartcard - then this property will be %NULL. If so,
       * the private key must be referenced via its PKCS \#11 URI,
       * #GTlsCertificate:private-key-pkcs11-uri. You must check both
       * properties to see if the certificate really has a private key.
       * When this property is read, the output format will be unencrypted
       * PKCS \#8.
       */
      private_key_pem?: string | null
      /**
       * A URI referencing a [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
       * object containing a private key.
       */
      private_key_pkcs11_uri?: string | null
    }
  }

  interface TlsCertificate {
    // Own properties of Gio-2.0.Gio.TlsCertificate

    /**
     * The DER (binary) encoded representation of the certificate.
     * This property and the #GTlsCertificate:certificate-pem property
     * represent the same data, just in different forms.
     */
    readonly certificate: number[]
    /**
     * The PEM (ASCII) encoded representation of the certificate.
     * This property and the #GTlsCertificate:certificate
     * property represent the same data, just in different forms.
     */
    readonly certificatePem: string | null
    /**
     * The DNS names from the certificate's Subject Alternative Names (SANs),
     * %NULL if unavailable.
     */
    readonly dnsNames: any[]
    /**
     * The IP addresses from the certificate's Subject Alternative Names (SANs),
     * %NULL if unavailable.
     */
    readonly ipAddresses: any[]
    /**
     * A #GTlsCertificate representing the entity that issued this
     * certificate. If %NULL, this means that the certificate is either
     * self-signed, or else the certificate of the issuer is not
     * available.
     *
     * Beware the issuer certificate may not be the same as the
     * certificate that would actually be used to construct a valid
     * certification path during certificate verification.
     * [RFC 4158](https://datatracker.ietf.org/doc/html/rfc4158) explains
     * why an issuer certificate cannot be naively assumed to be part of the
     * the certification path (though GLib's TLS backends may not follow the
     * path building strategies outlined in this RFC). Due to the complexity
     * of certification path building, GLib does not provide any way to know
     * which certification path will actually be used. Accordingly, this
     * property cannot be used to make security-related decisions. Only
     * GLib itself should make security decisions about TLS certificates.
     */
    readonly issuer: TlsCertificate
    /**
     * The issuer from the certificate,
     * %NULL if unavailable.
     */
    readonly issuerName: string | null
    /**
     * The time at which this cert is no longer valid,
     * %NULL if unavailable.
     */
    readonly notValidAfter: GLib.DateTime
    /**
     * The time at which this cert is considered to be valid,
     * %NULL if unavailable.
     */
    readonly notValidBefore: GLib.DateTime
    /**
     * An optional password used when constructed with GTlsCertificate:pkcs12-data.
     */
    readonly password: string | null
    /**
     * A URI referencing the [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
     * objects containing an X.509 certificate and optionally a private key.
     *
     * If %NULL, the certificate is either not backed by PKCS \#11 or the
     * #GTlsBackend does not support PKCS \#11.
     */
    readonly pkcs11Uri: string | null
    /**
     * The PKCS #12 formatted data used to construct the object.
     *
     * See also: g_tls_certificate_new_from_pkcs12()
     */
    readonly pkcs12Data: number[]
    /**
     * The DER (binary) encoded representation of the certificate's
     * private key, in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
     * or unencrypted [PKCS \#8 format.](https://datatracker.ietf.org/doc/html/rfc5208)
     * PKCS \#8 format is supported since 2.32; earlier releases only
     * support PKCS \#1. You can use the `openssl rsa` tool to convert
     * PKCS \#8 keys to PKCS \#1.
     *
     * This property (or the #GTlsCertificate:private-key-pem property)
     * can be set when constructing a key (for example, from a file).
     * Since GLib 2.70, it is now also readable; however, be aware that if
     * the private key is backed by a PKCS \#11 URI – for example, if it
     * is stored on a smartcard – then this property will be %NULL. If so,
     * the private key must be referenced via its PKCS \#11 URI,
     * #GTlsCertificate:private-key-pkcs11-uri. You must check both
     * properties to see if the certificate really has a private key.
     * When this property is read, the output format will be unencrypted
     * PKCS \#8.
     */
    readonly privateKey: number[]
    /**
     * The PEM (ASCII) encoded representation of the certificate's
     * private key in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
     * ("`BEGIN RSA PRIVATE KEY`") or unencrypted
     * [PKCS \#8 format](https://datatracker.ietf.org/doc/html/rfc5208)
     * ("`BEGIN PRIVATE KEY`"). PKCS \#8 format is supported since 2.32;
     * earlier releases only support PKCS \#1. You can use the `openssl rsa`
     * tool to convert PKCS \#8 keys to PKCS \#1.
     *
     * This property (or the #GTlsCertificate:private-key property)
     * can be set when constructing a key (for example, from a file).
     * Since GLib 2.70, it is now also readable; however, be aware that if
     * the private key is backed by a PKCS \#11 URI - for example, if it
     * is stored on a smartcard - then this property will be %NULL. If so,
     * the private key must be referenced via its PKCS \#11 URI,
     * #GTlsCertificate:private-key-pkcs11-uri. You must check both
     * properties to see if the certificate really has a private key.
     * When this property is read, the output format will be unencrypted
     * PKCS \#8.
     */
    readonly privateKeyPem: string | null
    /**
     * A URI referencing a [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
     * object containing a private key.
     */
    readonly privateKeyPkcs11Uri: string | null
    /**
     * The subject from the cert,
     * %NULL if unavailable.
     */
    readonly subjectName: string | null
    __gtype__: number

    // Own fields of Gio-2.0.Gio.TlsCertificate

    parentInstance: GObject.Object
    priv: TlsCertificatePrivate

    // Owm methods of Gio-2.0.Gio.TlsCertificate

    /**
     * Gets the value of #GTlsCertificate:dns-names.
     * @returns A #GPtrArray of #GBytes elements, or %NULL if it's not available.
     */
    getDnsNames(): any[] | null
    /**
     * Gets the value of #GTlsCertificate:ip-addresses.
     * @returns A #GPtrArray of #GInetAddress elements, or %NULL if it's not available.
     */
    getIpAddresses(): InetAddress[] | null
    /**
     * Gets the #GTlsCertificate representing `cert'`s issuer, if known
     * @returns The certificate of @cert's issuer, or %NULL if @cert is self-signed or signed with an unknown certificate.
     */
    getIssuer(): TlsCertificate | null
    /**
     * Returns the issuer name from the certificate.
     * @returns The issuer name, or %NULL if it's not available.
     */
    getIssuerName(): string | null
    /**
     * Returns the time at which the certificate became or will become invalid.
     * @returns The not-valid-after date, or %NULL if it's not available.
     */
    getNotValidAfter(): GLib.DateTime | null
    /**
     * Returns the time at which the certificate became or will become valid.
     * @returns The not-valid-before date, or %NULL if it's not available.
     */
    getNotValidBefore(): GLib.DateTime | null
    /**
     * Returns the subject name from the certificate.
     * @returns The subject name, or %NULL if it's not available.
     */
    getSubjectName(): string | null
    /**
     * Check if two #GTlsCertificate objects represent the same certificate.
     * The raw DER byte data of the two certificates are checked for equality.
     * This has the effect that two certificates may compare equal even if
     * their #GTlsCertificate:issuer, #GTlsCertificate:private-key, or
     * #GTlsCertificate:private-key-pem properties differ.
     * @param certTwo second certificate to compare
     * @returns whether the same or not
     */
    isSame(certTwo: TlsCertificate): boolean
    // Has conflict: verify(identity: SocketConnectable | null, trustedCa: TlsCertificate | null): TlsCertificateFlags

    // Own virtual methods of Gio-2.0.Gio.TlsCertificate

    /**
     * This verifies `cert` and returns a set of #GTlsCertificateFlags
     * indicating any problems found with it. This can be used to verify a
     * certificate outside the context of making a connection, or to
     * check a certificate against a CA that is not part of the system
     * CA database.
     *
     * If `cert` is valid, %G_TLS_CERTIFICATE_NO_FLAGS is returned.
     *
     * If `identity` is not %NULL, `cert'`s name(s) will be compared against
     * it, and %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return
     * value if it does not match. If `identity` is %NULL, that bit will
     * never be set in the return value.
     *
     * If `trusted_ca` is not %NULL, then `cert` (or one of the certificates
     * in its chain) must be signed by it, or else
     * %G_TLS_CERTIFICATE_UNKNOWN_CA will be set in the return value. If
     * `trusted_ca` is %NULL, that bit will never be set in the return
     * value.
     *
     * GLib guarantees that if certificate verification fails, at least one
     * error will be set in the return value, but it does not guarantee
     * that all possible errors will be set. Accordingly, you may not safely
     * decide to ignore any particular type of error. For example, it would
     * be incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
     * expired certificates, because this could potentially be the only
     * error flag set even if other problems exist with the certificate.
     *
     * Because TLS session context is not used, #GTlsCertificate may not
     * perform as many checks on the certificates as #GTlsConnection would.
     * For example, certificate constraints may not be honored, and
     * revocation checks may not be performed. The best way to verify TLS
     * certificates used by a TLS connection is to let #GTlsConnection
     * handle the verification.
     * @virtual
     * @param identity the expected peer identity
     * @param trustedCa the certificate of a trusted authority
     * @returns the appropriate #GTlsCertificateFlags
     */
    verify(
      identity: SocketConnectable | null,
      trustedCa: TlsCertificate | null
    ): TlsCertificateFlags

    // Class property signals of Gio-2.0.Gio.TlsCertificate

    connect(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::certificate", ...args: any[]): void
    connect(
      sigName: "notify::certificate-pem",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::certificate-pem",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::certificate-pem",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::certificate-pem",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::certificate-pem", ...args: any[]): void
    connect(
      sigName: "notify::dns-names",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::dns-names",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::dns-names",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::dns-names",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::dns-names", ...args: any[]): void
    connect(
      sigName: "notify::ip-addresses",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ip-addresses",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ip-addresses",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ip-addresses",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ip-addresses", ...args: any[]): void
    connect(
      sigName: "notify::issuer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::issuer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::issuer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::issuer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::issuer", ...args: any[]): void
    connect(
      sigName: "notify::issuer-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::issuer-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::issuer-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::issuer-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::issuer-name", ...args: any[]): void
    connect(
      sigName: "notify::not-valid-after",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::not-valid-after",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::not-valid-after",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::not-valid-after",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::not-valid-after", ...args: any[]): void
    connect(
      sigName: "notify::not-valid-before",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::not-valid-before",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::not-valid-before",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::not-valid-before",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::not-valid-before", ...args: any[]): void
    connect(
      sigName: "notify::password",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::password",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::password",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::password",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::password", ...args: any[]): void
    connect(
      sigName: "notify::pkcs11-uri",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pkcs11-uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pkcs11-uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pkcs11-uri",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pkcs11-uri", ...args: any[]): void
    connect(
      sigName: "notify::pkcs12-data",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pkcs12-data",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pkcs12-data",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pkcs12-data",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pkcs12-data", ...args: any[]): void
    connect(
      sigName: "notify::private-key",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::private-key",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::private-key",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::private-key",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::private-key", ...args: any[]): void
    connect(
      sigName: "notify::private-key-pem",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::private-key-pem",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::private-key-pem",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::private-key-pem",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::private-key-pem", ...args: any[]): void
    connect(
      sigName: "notify::private-key-pkcs11-uri",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::private-key-pkcs11-uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::private-key-pkcs11-uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::private-key-pkcs11-uri",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::private-key-pkcs11-uri", ...args: any[]): void
    connect(
      sigName: "notify::subject-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::subject-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::subject-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::subject-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::subject-name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A certificate used for TLS authentication and encryption.
   * This can represent either a certificate only (eg, the certificate
   * received by a client from a server), or the combination of
   * a certificate and a private key (which is needed when acting as a
   * [iface`Gio`.TlsServerConnection]).
   * @class
   */
  class TlsCertificate extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TlsCertificate

    static name: string

    // Constructors of Gio-2.0.Gio.TlsCertificate

    constructor(config?: TlsCertificate.ConstructorProperties)
    /**
     * Creates a #GTlsCertificate from the data in `file`.
     *
     * As of 2.72, if the filename ends in `.p12` or `.pfx` the data is loaded by
     * g_tls_certificate_new_from_pkcs12() otherwise it is loaded by
     * g_tls_certificate_new_from_pem(). See those functions for
     * exact details.
     *
     * If `file` cannot be read or parsed, the function will return %NULL and
     * set `error`.
     * @constructor
     * @param file file containing a certificate to import
     * @returns the new certificate, or %NULL on error
     */
    static newFromFile(file: string): TlsCertificate
    /**
     * Creates a #GTlsCertificate from the data in `file`.
     *
     * If `file` cannot be read or parsed, the function will return %NULL and
     * set `error`.
     *
     * Any unknown file types will error with %G_IO_ERROR_NOT_SUPPORTED.
     * Currently only `.p12` and `.pfx` files are supported.
     * See g_tls_certificate_new_from_pkcs12() for more details.
     * @constructor
     * @param file file containing a certificate to import
     * @param password password for PKCS #12 files
     * @returns the new certificate, or %NULL on error
     */
    static newFromFileWithPassword(
      file: string,
      password: string
    ): TlsCertificate
    /**
     * Creates a #GTlsCertificate from the PEM-encoded data in `cert_file`
     * and `key_file`. The returned certificate will be the first certificate
     * found in `cert_file`. As of GLib 2.44, if `cert_file` contains more
     * certificates it will try to load a certificate chain. All
     * certificates will be verified in the order found (top-level
     * certificate should be the last one in the file) and the
     * #GTlsCertificate:issuer property of each certificate will be set
     * accordingly if the verification succeeds. If any certificate in the
     * chain cannot be verified, the first certificate in the file will
     * still be returned.
     *
     * If either file cannot be read or parsed, the function will return
     * %NULL and set `error`. Otherwise, this behaves like
     * g_tls_certificate_new_from_pem().
     * @constructor
     * @param certFile file containing one or more PEM-encoded     certificates to import
     * @param keyFile file containing a PEM-encoded private key     to import
     * @returns the new certificate, or %NULL on error
     */
    static newFromFiles(certFile: string, keyFile: string): TlsCertificate
    /**
     * Creates a #GTlsCertificate from the PEM-encoded data in `data`. If
     * `data` includes both a certificate and a private key, then the
     * returned certificate will include the private key data as well. (See
     * the #GTlsCertificate:private-key-pem property for information about
     * supported formats.)
     *
     * The returned certificate will be the first certificate found in
     * `data`. As of GLib 2.44, if `data` contains more certificates it will
     * try to load a certificate chain. All certificates will be verified in
     * the order found (top-level certificate should be the last one in the
     * file) and the #GTlsCertificate:issuer property of each certificate
     * will be set accordingly if the verification succeeds. If any
     * certificate in the chain cannot be verified, the first certificate in
     * the file will still be returned.
     * @constructor
     * @param data PEM-encoded certificate data
     * @param length the length of `data,` or -1 if it's 0-terminated.
     * @returns the new certificate, or %NULL if @data is invalid
     */
    static newFromPem(data: string, length: number): TlsCertificate
    /**
     * Creates a #GTlsCertificate from a
     * [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html) URI.
     *
     * An example `pkcs1`1_uri would be `pkcs11:model=Model;manufacturer=Manufacture;serial=1;token=My%20Client%20Certificate;id=%01`
     *
     * Where the token’s layout is:
     *
     *
     * ```
     * Object 0:
     *   URL: pkcs11:model=Model;manufacturer=Manufacture;serial=1;token=My%20Client%20Certificate;id=%01;object=private%20key;type=private
     *   Type: Private key (RSA-2048)
     *   ID: 01
     *
     * Object 1:
     *   URL: pkcs11:model=Model;manufacturer=Manufacture;serial=1;token=My%20Client%20Certificate;id=%01;object=Certificate%20for%20Authentication;type=cert
     *   Type: X.509 Certificate (RSA-2048)
     *   ID: 01
     * ```
     *
     *
     * In this case the certificate and private key would both be detected and used as expected.
     * `pkcs_uri` may also just reference an X.509 certificate object and then optionally
     * `private_key_pkcs1`1_uri allows using a private key exposed under a different URI.
     *
     * Note that the private key is not accessed until usage and may fail or require a PIN later.
     * @constructor
     * @param pkcs11Uri A PKCS \#11 URI
     * @param privateKeyPkcs11Uri A PKCS \#11 URI
     * @returns the new certificate, or %NULL on error
     */
    static newFromPkcs11Uris(
      pkcs11Uri: string,
      privateKeyPkcs11Uri: string | null
    ): TlsCertificate
    /**
     * Creates a #GTlsCertificate from the data in `data`. It must contain
     * a certificate and matching private key.
     *
     * If extra certificates are included they will be verified as a chain
     * and the #GTlsCertificate:issuer property will be set.
     * All other data will be ignored.
     *
     * You can pass as single password for all of the data which will be
     * used both for the PKCS #12 container as well as encrypted
     * private keys. If decryption fails it will error with
     * %G_TLS_ERROR_BAD_CERTIFICATE_PASSWORD.
     *
     * This constructor requires support in the current #GTlsBackend.
     * If support is missing it will error with
     * %G_IO_ERROR_NOT_SUPPORTED.
     *
     * Other parsing failures will error with %G_TLS_ERROR_BAD_CERTIFICATE.
     * @constructor
     * @param data DER-encoded PKCS #12 format certificate data
     * @param password optional password for encrypted certificate data
     * @returns the new certificate, or %NULL if @data is invalid
     */
    static newFromPkcs12(
      data: number[],
      password: string | null
    ): TlsCertificate
    _init(config?: TlsCertificate.ConstructorProperties): void
    /**
     * Creates one or more #GTlsCertificates from the PEM-encoded
     * data in `file`. If `file` cannot be read or parsed, the function will
     * return %NULL and set `error`. If `file` does not contain any
     * PEM-encoded certificates, this will return an empty list and not
     * set `error`.
     * @param file file containing PEM-encoded certificates to import
     * @returns a #GList containing #GTlsCertificate objects. You must free the list and its contents when you are done with it.
     */
    static listNewFromFile(file: string): TlsCertificate[]
  }

  module TlsConnection {
    // Signal callback interfaces

    /**
     * Signal callback interface for `accept-certificate`
     */
    interface AcceptCertificateSignalCallback {
      (peerCert: TlsCertificate, errors: TlsCertificateFlags): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends IOStream.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TlsConnection

      /**
       * The list of application-layer protocols that the connection
       * advertises that it is willing to speak. See
       * g_tls_connection_set_advertised_protocols().
       */
      advertised_protocols?: string[] | null
      /**
       * The #GIOStream that the connection wraps. The connection holds a reference
       * to this stream, and may run operations on the stream from other threads
       * throughout its lifetime. Consequently, after the #GIOStream has been
       * constructed, application code may only run its own operations on this
       * stream when no #GIOStream operations are running.
       */
      base_io_stream?: IOStream | null
      /**
       * The connection's certificate; see
       * g_tls_connection_set_certificate().
       */
      certificate?: TlsCertificate | null
      /**
       * The certificate database to use when verifying this TLS connection.
       * If no certificate database is set, then the default database will be
       * used. See g_tls_backend_get_default_database().
       *
       * When using a non-default database, #GTlsConnection must fall back to using
       * the #GTlsDatabase to perform certificate verification using
       * g_tls_database_verify_chain(), which means certificate verification will
       * not be able to make use of TLS session context. This may be less secure.
       * For example, if you create your own #GTlsDatabase that just wraps the
       * default #GTlsDatabase, you might expect that you have not changed anything,
       * but this is not true because you may have altered the behavior of
       * #GTlsConnection by causing it to use g_tls_database_verify_chain(). See the
       * documentation of g_tls_database_verify_chain() for more details on specific
       * security checks that may not be performed. Accordingly, setting a
       * non-default database is discouraged except for specialty applications with
       * unusual security requirements.
       */
      database?: TlsDatabase | null
      /**
       * A #GTlsInteraction object to be used when the connection or certificate
       * database need to interact with the user. This will be used to prompt the
       * user for passwords where necessary.
       */
      interaction?: TlsInteraction | null
      /**
       * The rehandshaking mode. See
       * g_tls_connection_set_rehandshake_mode().
       */
      rehandshake_mode?: TlsRehandshakeMode | null
      /**
       * Whether or not proper TLS close notification is required.
       * See g_tls_connection_set_require_close_notify().
       */
      require_close_notify?: boolean | null
      /**
       * Whether or not the system certificate database will be used to
       * verify peer certificates. See
       * g_tls_connection_set_use_system_certdb().
       */
      use_system_certdb?: boolean | null
    }
  }

  interface TlsConnection {
    // Own properties of Gio-2.0.Gio.TlsConnection

    /**
     * The list of application-layer protocols that the connection
     * advertises that it is willing to speak. See
     * g_tls_connection_set_advertised_protocols().
     */
    advertisedProtocols: string[]
    /**
     * The #GIOStream that the connection wraps. The connection holds a reference
     * to this stream, and may run operations on the stream from other threads
     * throughout its lifetime. Consequently, after the #GIOStream has been
     * constructed, application code may only run its own operations on this
     * stream when no #GIOStream operations are running.
     */
    readonly baseIoStream: IOStream
    /**
     * The connection's certificate; see
     * g_tls_connection_set_certificate().
     */
    certificate: TlsCertificate
    /**
     * The name of the TLS ciphersuite in use. See g_tls_connection_get_ciphersuite_name().
     */
    readonly ciphersuiteName: string | null
    /**
     * The certificate database to use when verifying this TLS connection.
     * If no certificate database is set, then the default database will be
     * used. See g_tls_backend_get_default_database().
     *
     * When using a non-default database, #GTlsConnection must fall back to using
     * the #GTlsDatabase to perform certificate verification using
     * g_tls_database_verify_chain(), which means certificate verification will
     * not be able to make use of TLS session context. This may be less secure.
     * For example, if you create your own #GTlsDatabase that just wraps the
     * default #GTlsDatabase, you might expect that you have not changed anything,
     * but this is not true because you may have altered the behavior of
     * #GTlsConnection by causing it to use g_tls_database_verify_chain(). See the
     * documentation of g_tls_database_verify_chain() for more details on specific
     * security checks that may not be performed. Accordingly, setting a
     * non-default database is discouraged except for specialty applications with
     * unusual security requirements.
     */
    database: TlsDatabase
    /**
     * A #GTlsInteraction object to be used when the connection or certificate
     * database need to interact with the user. This will be used to prompt the
     * user for passwords where necessary.
     */
    interaction: TlsInteraction
    /**
     * The application-layer protocol negotiated during the TLS
     * handshake. See g_tls_connection_get_negotiated_protocol().
     */
    readonly negotiatedProtocol: string | null
    /**
     * The connection's peer's certificate, after the TLS handshake has
     * completed or failed. Note in particular that this is not yet set
     * during the emission of #GTlsConnection::accept-certificate.
     *
     * (You can watch for a #GObject::notify signal on this property to
     * detect when a handshake has occurred.)
     */
    readonly peerCertificate: TlsCertificate
    /**
     * The errors noticed while verifying
     * #GTlsConnection:peer-certificate. Normally this should be 0, but
     * it may not be if #GTlsClientConnection:validation-flags is not
     * %G_TLS_CERTIFICATE_VALIDATE_ALL, or if
     * #GTlsConnection::accept-certificate overrode the default
     * behavior.
     *
     * GLib guarantees that if certificate verification fails, at least
     * one error will be set, but it does not guarantee that all possible
     * errors will be set. Accordingly, you may not safely decide to
     * ignore any particular type of error. For example, it would be
     * incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
     * expired certificates, because this could potentially be the only
     * error flag set even if other problems exist with the certificate.
     */
    readonly peerCertificateErrors: TlsCertificateFlags
    /**
     * The TLS protocol version in use. See g_tls_connection_get_protocol_version().
     */
    readonly protocolVersion: TlsProtocolVersion
    /**
     * The rehandshaking mode. See
     * g_tls_connection_set_rehandshake_mode().
     */
    rehandshakeMode: TlsRehandshakeMode
    /**
     * Whether or not proper TLS close notification is required.
     * See g_tls_connection_set_require_close_notify().
     */
    requireCloseNotify: boolean
    /**
     * Whether or not the system certificate database will be used to
     * verify peer certificates. See
     * g_tls_connection_set_use_system_certdb().
     */
    useSystemCertdb: boolean
    __gtype__: number

    // Own fields of Gio-2.0.Gio.TlsConnection

    parentInstance: any
    priv: TlsConnectionPrivate

    // Owm methods of Gio-2.0.Gio.TlsConnection

    /**
     * Used by #GTlsConnection implementations to emit the
     * #GTlsConnection::accept-certificate signal.
     * @param peerCert the peer's #GTlsCertificate
     * @param errors the problems with `peer_cert`
     * @returns %TRUE if one of the signal handlers has returned     %TRUE to accept @peer_cert
     */
    emitAcceptCertificate(
      peerCert: TlsCertificate,
      errors: TlsCertificateFlags
    ): boolean
    /**
     * Gets `conn'`s certificate, as set by
     * g_tls_connection_set_certificate().
     * @returns @conn's certificate, or %NULL
     */
    getCertificate(): TlsCertificate | null
    /**
     * Query the TLS backend for TLS channel binding data of `type` for `conn`.
     *
     * This call retrieves TLS channel binding data as specified in RFC
     * [5056](https://tools.ietf.org/html/rfc5056), RFC
     * [5929](https://tools.ietf.org/html/rfc5929), and related RFCs.  The
     * binding data is returned in `data`.  The `data` is resized by the callee
     * using #GByteArray buffer management and will be freed when the `data`
     * is destroyed by g_byte_array_unref(). If `data` is %NULL, it will only
     * check whether TLS backend is able to fetch the data (e.g. whether `type`
     * is supported by the TLS backend). It does not guarantee that the data
     * will be available though.  That could happen if TLS connection does not
     * support `type` or the binding data is not available yet due to additional
     * negotiation or input required.
     * @param type #GTlsChannelBindingType type of data to fetch
     * @returns %TRUE on success, %FALSE otherwise
     */
    getChannelBindingData(
      type: TlsChannelBindingType
    ): [/* returnType */ boolean, /* data */ number[]]
    /**
     * Returns the name of the current TLS ciphersuite, or %NULL if the
     * connection has not handshaked or has been closed. Beware that the TLS
     * backend may use any of multiple different naming conventions, because
     * OpenSSL and GnuTLS have their own ciphersuite naming conventions that
     * are different from each other and different from the standard, IANA-
     * registered ciphersuite names. The ciphersuite name is intended to be
     * displayed to the user for informative purposes only, and parsing it
     * is not recommended.
     * @returns The name of the current TLS ciphersuite, or %NULL
     */
    getCiphersuiteName(): string | null
    /**
     * Gets the certificate database that `conn` uses to verify
     * peer certificates. See g_tls_connection_set_database().
     * @returns the certificate database that @conn uses or %NULL
     */
    getDatabase(): TlsDatabase | null
    /**
     * Get the object that will be used to interact with the user. It will be used
     * for things like prompting the user for passwords. If %NULL is returned, then
     * no user interaction will occur for this connection.
     * @returns The interaction object.
     */
    getInteraction(): TlsInteraction | null
    // Has conflict: getNegotiatedProtocol(): string | null
    /**
     * Gets `conn'`s peer's certificate after the handshake has completed
     * or failed. (It is not set during the emission of
     * #GTlsConnection::accept-certificate.)
     * @returns @conn's peer's certificate, or %NULL
     */
    getPeerCertificate(): TlsCertificate | null
    /**
     * Gets the errors associated with validating `conn'`s peer's
     * certificate, after the handshake has completed or failed. (It is
     * not set during the emission of #GTlsConnection::accept-certificate.)
     *
     * See #GTlsConnection:peer-certificate-errors for more information.
     * @returns @conn's peer's certificate errors
     */
    getPeerCertificateErrors(): TlsCertificateFlags
    /**
     * Returns the current TLS protocol version, which may be
     * %G_TLS_PROTOCOL_VERSION_UNKNOWN if the connection has not handshaked, or
     * has been closed, or if the TLS backend has implemented a protocol version
     * that is not a recognized #GTlsProtocolVersion.
     * @returns The current TLS protocol version
     */
    getProtocolVersion(): TlsProtocolVersion
    /**
     * Gets `conn` rehandshaking mode. See
     * g_tls_connection_set_rehandshake_mode() for details.
     * @returns %G_TLS_REHANDSHAKE_SAFELY
     */
    getRehandshakeMode(): TlsRehandshakeMode
    /**
     * Tests whether or not `conn` expects a proper TLS close notification
     * when the connection is closed. See
     * g_tls_connection_set_require_close_notify() for details.
     * @returns %TRUE if @conn requires a proper TLS close notification.
     */
    getRequireCloseNotify(): boolean
    /**
     * Gets whether `conn` uses the system certificate database to verify
     * peer certificates. See g_tls_connection_set_use_system_certdb().
     * @returns whether @conn uses the system certificate database
     */
    getUseSystemCertdb(): boolean
    // Has conflict: handshake(cancellable: Cancellable | null): boolean
    // Has conflict: handshakeAsync(ioPriority: number, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: handshakeFinish(result: AsyncResult): boolean
    /**
     * Sets the list of application-layer protocols to advertise that the
     * caller is willing to speak on this connection. The
     * Application-Layer Protocol Negotiation (ALPN) extension will be
     * used to negotiate a compatible protocol with the peer; use
     * g_tls_connection_get_negotiated_protocol() to find the negotiated
     * protocol after the handshake.  Specifying %NULL for the the value
     * of `protocols` will disable ALPN negotiation.
     *
     * See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)
     * for a list of registered protocol IDs.
     * @param protocols a %NULL-terminated   array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL
     */
    setAdvertisedProtocols(protocols: string[] | null): void
    /**
     * This sets the certificate that `conn` will present to its peer
     * during the TLS handshake. For a #GTlsServerConnection, it is
     * mandatory to set this, and that will normally be done at construct
     * time.
     *
     * For a #GTlsClientConnection, this is optional. If a handshake fails
     * with %G_TLS_ERROR_CERTIFICATE_REQUIRED, that means that the server
     * requires a certificate, and if you try connecting again, you should
     * call this method first. You can call
     * g_tls_client_connection_get_accepted_cas() on the failed connection
     * to get a list of Certificate Authorities that the server will
     * accept certificates from.
     *
     * (It is also possible that a server will allow the connection with
     * or without a certificate; in that case, if you don't provide a
     * certificate, you can tell that the server requested one by the fact
     * that g_tls_client_connection_get_accepted_cas() will return
     * non-%NULL.)
     * @param certificate the certificate to use for `conn`
     */
    setCertificate(certificate: TlsCertificate): void
    /**
     * Sets the certificate database that is used to verify peer certificates.
     * This is set to the default database by default. See
     * g_tls_backend_get_default_database(). If set to %NULL, then
     * peer certificate validation will always set the
     * %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning
     * #GTlsConnection::accept-certificate will always be emitted on
     * client-side connections, unless that bit is not set in
     * #GTlsClientConnection:validation-flags).
     *
     * There are nonintuitive security implications when using a non-default
     * database. See #GTlsConnection:database for details.
     * @param database a #GTlsDatabase
     */
    setDatabase(database: TlsDatabase | null): void
    /**
     * Set the object that will be used to interact with the user. It will be used
     * for things like prompting the user for passwords.
     *
     * The `interaction` argument will normally be a derived subclass of
     * #GTlsInteraction. %NULL can also be provided if no user interaction
     * should occur for this connection.
     * @param interaction an interaction object, or %NULL
     */
    setInteraction(interaction: TlsInteraction | null): void
    /**
     * Since GLib 2.64, changing the rehandshake mode is no longer supported
     * and will have no effect. With TLS 1.3, rehandshaking has been removed from
     * the TLS protocol, replaced by separate post-handshake authentication and
     * rekey operations.
     * @param mode the rehandshaking mode
     */
    setRehandshakeMode(mode: TlsRehandshakeMode): void
    /**
     * Sets whether or not `conn` expects a proper TLS close notification
     * before the connection is closed. If this is %TRUE (the default),
     * then `conn` will expect to receive a TLS close notification from its
     * peer before the connection is closed, and will return a
     * %G_TLS_ERROR_EOF error if the connection is closed without proper
     * notification (since this may indicate a network error, or
     * man-in-the-middle attack).
     *
     * In some protocols, the application will know whether or not the
     * connection was closed cleanly based on application-level data
     * (because the application-level data includes a length field, or is
     * somehow self-delimiting); in this case, the close notify is
     * redundant and sometimes omitted. (TLS 1.1 explicitly allows this;
     * in TLS 1.0 it is technically an error, but often done anyway.) You
     * can use g_tls_connection_set_require_close_notify() to tell `conn`
     * to allow an "unannounced" connection close, in which case the close
     * will show up as a 0-length read, as in a non-TLS
     * #GSocketConnection, and it is up to the application to check that
     * the data has been fully received.
     *
     * Note that this only affects the behavior when the peer closes the
     * connection; when the application calls g_io_stream_close() itself
     * on `conn,` this will send a close notification regardless of the
     * setting of this property. If you explicitly want to do an unclean
     * close, you can close `conn'`s #GTlsConnection:base-io-stream rather
     * than closing `conn` itself, but note that this may only be done when no other
     * operations are pending on `conn` or the base I/O stream.
     * @param requireCloseNotify whether or not to require close notification
     */
    setRequireCloseNotify(requireCloseNotify: boolean): void
    /**
     * Sets whether `conn` uses the system certificate database to verify
     * peer certificates. This is %TRUE by default. If set to %FALSE, then
     * peer certificate validation will always set the
     * %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning
     * #GTlsConnection::accept-certificate will always be emitted on
     * client-side connections, unless that bit is not set in
     * #GTlsClientConnection:validation-flags).
     * @param useSystemCertdb whether to use the system certificate database
     */
    setUseSystemCertdb(useSystemCertdb: boolean): void

    // Own virtual methods of Gio-2.0.Gio.TlsConnection

    /**
     * Check whether to accept a certificate.
     * @virtual
     * @param peerCert
     * @param errors
     */
    acceptCertificate(
      peerCert: TlsCertificate,
      errors: TlsCertificateFlags
    ): boolean
    /**
     * Retrieve TLS channel binding data (Since: 2.66)
     * @virtual
     * @param type
     * @param data
     */
    getBindingData(type: TlsChannelBindingType, data: number[]): boolean
    /**
     * Gets the name of the application-layer protocol negotiated during
     * the handshake.
     *
     * If the peer did not use the ALPN extension, or did not advertise a
     * protocol that matched one of `conn'`s protocols, or the TLS backend
     * does not support ALPN, then this will be %NULL. See
     * g_tls_connection_set_advertised_protocols().
     * @virtual
     * @returns the negotiated protocol, or %NULL
     */
    getNegotiatedProtocol(): string | null
    /**
     * Attempts a TLS handshake on `conn`.
     *
     * On the client side, it is never necessary to call this method;
     * although the connection needs to perform a handshake after
     * connecting (or after sending a "STARTTLS"-type command),
     * #GTlsConnection will handle this for you automatically when you try
     * to send or receive data on the connection. You can call
     * g_tls_connection_handshake() manually if you want to know whether
     * the initial handshake succeeded or failed (as opposed to just
     * immediately trying to use `conn` to read or write, in which case,
     * if it fails, it may not be possible to tell if it failed before or
     * after completing the handshake), but beware that servers may reject
     * client authentication after the handshake has completed, so a
     * successful handshake does not indicate the connection will be usable.
     *
     * Likewise, on the server side, although a handshake is necessary at
     * the beginning of the communication, you do not need to call this
     * function explicitly unless you want clearer error reporting.
     *
     * Previously, calling g_tls_connection_handshake() after the initial
     * handshake would trigger a rehandshake; however, this usage was
     * deprecated in GLib 2.60 because rehandshaking was removed from the
     * TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after
     * the initial handshake will no longer do anything.
     *
     * When using a #GTlsConnection created by #GSocketClient, the
     * #GSocketClient performs the initial handshake, so calling this
     * function manually is not recommended.
     *
     * #GTlsConnection::accept_certificate may be emitted during the
     * handshake.
     * @virtual
     * @param cancellable a #GCancellable, or %NULL
     * @returns success or failure
     */
    handshake(cancellable: Cancellable | null): boolean
    /**
     * Asynchronously performs a TLS handshake on `conn`. See
     * g_tls_connection_handshake() for more information.
     * @virtual
     * @param ioPriority the [I/O priority][io-priority] of the request
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call when the handshake is complete
     */
    handshakeAsync(
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous TLS handshake operation. See
     * g_tls_connection_handshake() for more information.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns %TRUE on success, %FALSE on failure, in which case @error will be set.
     */
    handshakeFinish(result: AsyncResult): boolean

    // Own signals of Gio-2.0.Gio.TlsConnection

    connect(
      sigName: "accept-certificate",
      callback: TlsConnection.AcceptCertificateSignalCallback
    ): number
    on(
      sigName: "accept-certificate",
      callback: TlsConnection.AcceptCertificateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "accept-certificate",
      callback: TlsConnection.AcceptCertificateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "accept-certificate",
      callback: TlsConnection.AcceptCertificateSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "accept-certificate",
      errors: TlsCertificateFlags,
      ...args: any[]
    ): void

    // Class property signals of Gio-2.0.Gio.TlsConnection

    connect(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::advertised-protocols",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::advertised-protocols", ...args: any[]): void
    connect(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::base-io-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::base-io-stream", ...args: any[]): void
    connect(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::certificate", ...args: any[]): void
    connect(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ciphersuite-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ciphersuite-name", ...args: any[]): void
    connect(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::database",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::database",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::database", ...args: any[]): void
    connect(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::interaction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::interaction", ...args: any[]): void
    connect(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::negotiated-protocol",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::negotiated-protocol", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate", ...args: any[]): void
    connect(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::peer-certificate-errors",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::peer-certificate-errors", ...args: any[]): void
    connect(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::protocol-version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::protocol-version", ...args: any[]): void
    connect(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rehandshake-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rehandshake-mode", ...args: any[]): void
    connect(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::require-close-notify",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::require-close-notify", ...args: any[]): void
    connect(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-system-certdb",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-system-certdb", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::output-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GTlsConnection` is the base TLS connection class type, which wraps
   * a [class`Gio`.IOStream] and provides TLS encryption on top of it. Its
   * subclasses, [iface`Gio`.TlsClientConnection] and
   * [iface`Gio`.TlsServerConnection], implement client-side and server-side TLS,
   * respectively.
   *
   * For DTLS (Datagram TLS) support, see [iface`Gio`.DtlsConnection].
   * @interface
   */
  class TlsConnection extends IOStream {
    // Own properties of Gio-2.0.Gio.TlsConnection

    static name: string

    // Constructors of Gio-2.0.Gio.TlsConnection

    constructor(config?: TlsConnection.ConstructorProperties)
    _init(config?: TlsConnection.ConstructorProperties): void
  }

  module TlsDatabase {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface TlsDatabase {
    // Own properties of Gio-2.0.Gio.TlsDatabase

    __gtype__: number

    // Own fields of Gio-2.0.Gio.TlsDatabase

    parentInstance: GObject.Object
    priv: TlsDatabasePrivate

    // Owm methods of Gio-2.0.Gio.TlsDatabase

    // Has conflict: createCertificateHandle(certificate: TlsCertificate): string | null
    // Has conflict: lookupCertificateForHandle(handle: string, interaction: TlsInteraction | null, flags: TlsDatabaseLookupFlags, cancellable: Cancellable | null): TlsCertificate | null
    // Has conflict: lookupCertificateForHandleAsync(handle: string, interaction: TlsInteraction | null, flags: TlsDatabaseLookupFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupCertificateForHandleFinish(result: AsyncResult): TlsCertificate
    // Has conflict: lookupCertificateIssuer(certificate: TlsCertificate, interaction: TlsInteraction | null, flags: TlsDatabaseLookupFlags, cancellable: Cancellable | null): TlsCertificate
    // Has conflict: lookupCertificateIssuerAsync(certificate: TlsCertificate, interaction: TlsInteraction | null, flags: TlsDatabaseLookupFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupCertificateIssuerFinish(result: AsyncResult): TlsCertificate
    // Has conflict: lookupCertificatesIssuedBy(issuerRawDn: number[], interaction: TlsInteraction | null, flags: TlsDatabaseLookupFlags, cancellable: Cancellable | null): TlsCertificate[]
    // Has conflict: lookupCertificatesIssuedByAsync(issuerRawDn: number[], interaction: TlsInteraction | null, flags: TlsDatabaseLookupFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: lookupCertificatesIssuedByFinish(result: AsyncResult): TlsCertificate[]
    // Has conflict: verifyChain(chain: TlsCertificate, purpose: string, identity: SocketConnectable | null, interaction: TlsInteraction | null, flags: TlsDatabaseVerifyFlags, cancellable: Cancellable | null): TlsCertificateFlags
    // Has conflict: verifyChainAsync(chain: TlsCertificate, purpose: string, identity: SocketConnectable | null, interaction: TlsInteraction | null, flags: TlsDatabaseVerifyFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: verifyChainFinish(result: AsyncResult): TlsCertificateFlags

    // Own virtual methods of Gio-2.0.Gio.TlsDatabase

    /**
     * Create a handle string for the certificate. The database will only be able
     * to create a handle for certificates that originate from the database. In
     * cases where the database cannot create a handle for a certificate, %NULL
     * will be returned.
     *
     * This handle should be stable across various instances of the application,
     * and between applications. If a certificate is modified in the database,
     * then it is not guaranteed that this handle will continue to point to it.
     * @virtual
     * @param certificate certificate for which to create a handle.
     * @returns a newly allocated string containing the handle.
     */
    createCertificateHandle(certificate: TlsCertificate): string | null
    /**
     * Look up a certificate by its handle.
     *
     * The handle should have been created by calling
     * g_tls_database_create_certificate_handle() on a #GTlsDatabase object of
     * the same TLS backend. The handle is designed to remain valid across
     * instantiations of the database.
     *
     * If the handle is no longer valid, or does not point to a certificate in
     * this database, then %NULL will be returned.
     *
     * This function can block, use g_tls_database_lookup_certificate_for_handle_async() to perform
     * the lookup operation asynchronously.
     * @virtual
     * @param handle a certificate handle
     * @param interaction used to interact with the user if necessary
     * @param flags Flags which affect the lookup.
     * @param cancellable a #GCancellable, or %NULL
     * @returns a newly allocated #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate.
     */
    lookupCertificateForHandle(
      handle: string,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null
    ): TlsCertificate | null
    /**
     * Asynchronously look up a certificate by its handle in the database. See
     * g_tls_database_lookup_certificate_for_handle() for more information.
     * @virtual
     * @param handle a certificate handle
     * @param interaction used to interact with the user if necessary
     * @param flags Flags which affect the lookup.
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call when the operation completes
     */
    lookupCertificateForHandleAsync(
      handle: string,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous lookup of a certificate by its handle. See
     * g_tls_database_lookup_certificate_for_handle() for more information.
     *
     * If the handle is no longer valid, or does not point to a certificate in
     * this database, then %NULL will be returned.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns a newly allocated #GTlsCertificate object. Use g_object_unref() to release the certificate.
     */
    lookupCertificateForHandleFinish(result: AsyncResult): TlsCertificate
    /**
     * Look up the issuer of `certificate` in the database. The
     * #GTlsCertificate:issuer property of `certificate` is not modified, and
     * the two certificates are not hooked into a chain.
     *
     * This function can block. Use g_tls_database_lookup_certificate_issuer_async()
     * to perform the lookup operation asynchronously.
     *
     * Beware this function cannot be used to build certification paths. The
     * issuer certificate returned by this function may not be the same as
     * the certificate that would actually be used to construct a valid
     * certification path during certificate verification.
     * [RFC 4158](https://datatracker.ietf.org/doc/html/rfc4158) explains
     * why an issuer certificate cannot be naively assumed to be part of the
     * the certification path (though GLib's TLS backends may not follow the
     * path building strategies outlined in this RFC). Due to the complexity
     * of certification path building, GLib does not provide any way to know
     * which certification path will actually be used when verifying a TLS
     * certificate. Accordingly, this function cannot be used to make
     * security-related decisions. Only GLib itself should make security
     * decisions about TLS certificates.
     * @virtual
     * @param certificate a #GTlsCertificate
     * @param interaction used to interact with the user if necessary
     * @param flags flags which affect the lookup operation
     * @param cancellable a #GCancellable, or %NULL
     * @returns a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate.
     */
    lookupCertificateIssuer(
      certificate: TlsCertificate,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null
    ): TlsCertificate
    /**
     * Asynchronously look up the issuer of `certificate` in the database. See
     * g_tls_database_lookup_certificate_issuer() for more information.
     * @virtual
     * @param certificate a #GTlsCertificate
     * @param interaction used to interact with the user if necessary
     * @param flags flags which affect the lookup operation
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call when the operation completes
     */
    lookupCertificateIssuerAsync(
      certificate: TlsCertificate,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous lookup issuer operation. See
     * g_tls_database_lookup_certificate_issuer() for more information.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate.
     */
    lookupCertificateIssuerFinish(result: AsyncResult): TlsCertificate
    /**
     * Look up certificates issued by this issuer in the database.
     *
     * This function can block, use g_tls_database_lookup_certificates_issued_by_async() to perform
     * the lookup operation asynchronously.
     * @virtual
     * @param issuerRawDn a #GByteArray which holds the DER encoded issuer DN.
     * @param interaction used to interact with the user if necessary
     * @param flags Flags which affect the lookup operation.
     * @param cancellable a #GCancellable, or %NULL
     * @returns a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list.
     */
    lookupCertificatesIssuedBy(
      issuerRawDn: number[],
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null
    ): TlsCertificate[]
    /**
     * Asynchronously look up certificates issued by this issuer in the database. See
     * g_tls_database_lookup_certificates_issued_by() for more information.
     *
     * The database may choose to hold a reference to the issuer byte array for the duration
     * of this asynchronous operation. The byte array should not be modified during
     * this time.
     * @virtual
     * @param issuerRawDn a #GByteArray which holds the DER encoded issuer DN.
     * @param interaction used to interact with the user if necessary
     * @param flags Flags which affect the lookup operation.
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call when the operation completes
     */
    lookupCertificatesIssuedByAsync(
      issuerRawDn: number[],
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous lookup of certificates. See
     * g_tls_database_lookup_certificates_issued_by() for more information.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list.
     */
    lookupCertificatesIssuedByFinish(result: AsyncResult): TlsCertificate[]
    /**
     * Determines the validity of a certificate chain, outside the context
     * of a TLS session.
     *
     * `chain` is a chain of #GTlsCertificate objects each pointing to the next
     * certificate in the chain by its #GTlsCertificate:issuer property.
     *
     * `purpose` describes the purpose (or usage) for which the certificate
     * is being used. Typically `purpose` will be set to %G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER
     * which means that the certificate is being used to authenticate a server
     * (and we are acting as the client).
     *
     * The `identity` is used to ensure the server certificate is valid for
     * the expected peer identity. If the identity does not match the
     * certificate, %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the
     * return value. If `identity` is %NULL, that bit will never be set in
     * the return value. The peer identity may also be used to check for
     * pinned certificates (trust exceptions) in the database. These may
     * override the normal verification process on a host-by-host basis.
     *
     * Currently there are no `flags,` and %G_TLS_DATABASE_VERIFY_NONE should be
     * used.
     *
     * If `chain` is found to be valid, then the return value will be 0. If
     * `chain` is found to be invalid, then the return value will indicate at
     * least one problem found. If the function is unable to determine
     * whether `chain` is valid (for example, because `cancellable` is
     * triggered before it completes) then the return value will be
     * %G_TLS_CERTIFICATE_GENERIC_ERROR and `error` will be set accordingly.
     * `error` is not set when `chain` is successfully analyzed but found to
     * be invalid.
     *
     * GLib guarantees that if certificate verification fails, at least one
     * error will be set in the return value, but it does not guarantee
     * that all possible errors will be set. Accordingly, you may not safely
     * decide to ignore any particular type of error. For example, it would
     * be incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
     * expired certificates, because this could potentially be the only
     * error flag set even if other problems exist with the certificate.
     *
     * Prior to GLib 2.48, GLib's default TLS backend modified `chain` to
     * represent the certification path built by #GTlsDatabase during
     * certificate verification by adjusting the #GTlsCertificate:issuer
     * property of each certificate in `chain`. Since GLib 2.48, this no
     * longer occurs, so you cannot rely on #GTlsCertificate:issuer to
     * represent the actual certification path used during certificate
     * verification.
     *
     * Because TLS session context is not used, #GTlsDatabase may not
     * perform as many checks on the certificates as #GTlsConnection would.
     * For example, certificate constraints may not be honored, and
     * revocation checks may not be performed. The best way to verify TLS
     * certificates used by a TLS connection is to let #GTlsConnection
     * handle the verification.
     *
     * The TLS backend may attempt to look up and add missing certificates
     * to the chain. This may involve HTTP requests to download missing
     * certificates.
     *
     * This function can block. Use g_tls_database_verify_chain_async() to
     * perform the verification operation asynchronously.
     * @virtual
     * @param chain a #GTlsCertificate chain
     * @param purpose the purpose that this certificate chain will be used for.
     * @param identity the expected peer identity
     * @param interaction used to interact with the user if necessary
     * @param flags additional verify flags
     * @param cancellable a #GCancellable, or %NULL
     * @returns the appropriate #GTlsCertificateFlags which represents the result of verification.
     */
    verifyChain(
      chain: TlsCertificate,
      purpose: string,
      identity: SocketConnectable | null,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseVerifyFlags,
      cancellable: Cancellable | null
    ): TlsCertificateFlags
    /**
     * Asynchronously determines the validity of a certificate chain after
     * looking up and adding any missing certificates to the chain. See
     * g_tls_database_verify_chain() for more information.
     * @virtual
     * @param chain a #GTlsCertificate chain
     * @param purpose the purpose that this certificate chain will be used for.
     * @param identity the expected peer identity
     * @param interaction used to interact with the user if necessary
     * @param flags additional verify flags
     * @param cancellable a #GCancellable, or %NULL
     * @param callback callback to call when the operation completes
     */
    verifyChainAsync(
      chain: TlsCertificate,
      purpose: string,
      identity: SocketConnectable | null,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseVerifyFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finish an asynchronous verify chain operation. See
     * g_tls_database_verify_chain() for more information.
     *
     * If `chain` is found to be valid, then the return value will be 0. If
     * `chain` is found to be invalid, then the return value will indicate
     * the problems found. If the function is unable to determine whether
     * `chain` is valid or not (eg, because `cancellable` is triggered
     * before it completes) then the return value will be
     * %G_TLS_CERTIFICATE_GENERIC_ERROR and `error` will be set
     * accordingly. `error` is not set when `chain` is successfully analyzed
     * but found to be invalid.
     * @virtual
     * @param result a #GAsyncResult.
     * @returns the appropriate #GTlsCertificateFlags which represents the result of verification.
     */
    verifyChainFinish(result: AsyncResult): TlsCertificateFlags

    // Class property signals of Gio-2.0.Gio.TlsDatabase

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GTlsDatabase` is used to look up certificates and other information
   * from a certificate or key store. It is an abstract base class which
   * TLS library specific subtypes override.
   *
   * A `GTlsDatabase` may be accessed from multiple threads by the TLS backend.
   * All implementations are required to be fully thread-safe.
   *
   * Most common client applications will not directly interact with
   * `GTlsDatabase`. It is used internally by [class`Gio`.TlsConnection].
   * @interface
   */
  class TlsDatabase extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TlsDatabase

    static name: string

    // Constructors of Gio-2.0.Gio.TlsDatabase

    constructor(config?: TlsDatabase.ConstructorProperties)
    _init(config?: TlsDatabase.ConstructorProperties): void
  }

  module TlsInteraction {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface TlsInteraction {
    // Own properties of Gio-2.0.Gio.TlsInteraction

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.TlsInteraction

    // Has conflict: askPassword(password: TlsPassword, cancellable: Cancellable | null): TlsInteractionResult
    // Has conflict: askPasswordAsync(password: TlsPassword, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: askPasswordFinish(result: AsyncResult): TlsInteractionResult
    /**
     * Invoke the interaction to ask the user for a password. It invokes this
     * interaction in the main loop, specifically the #GMainContext returned by
     * g_main_context_get_thread_default() when the interaction is created. This
     * is called by called by #GTlsConnection or #GTlsDatabase to ask the user
     * for a password.
     *
     * Derived subclasses usually implement a password prompt, although they may
     * also choose to provide a password from elsewhere. The `password` value will
     * be filled in and then `callback` will be called. Alternatively the user may
     * abort this password request, which will usually abort the TLS connection.
     *
     * The implementation can either be a synchronous (eg: modal dialog) or an
     * asynchronous one (eg: modeless dialog). This function will take care of
     * calling which ever one correctly.
     *
     * If the interaction is cancelled by the cancellation object, or by the
     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
     * not support immediate cancellation.
     * @param password a #GTlsPassword object
     * @param cancellable an optional #GCancellable cancellation object
     * @returns The status of the ask password interaction.
     */
    invokeAskPassword(
      password: TlsPassword,
      cancellable: Cancellable | null
    ): TlsInteractionResult
    /**
     * Invoke the interaction to ask the user to choose a certificate to
     * use with the connection. It invokes this interaction in the main
     * loop, specifically the #GMainContext returned by
     * g_main_context_get_thread_default() when the interaction is
     * created. This is called by called by #GTlsConnection when the peer
     * requests a certificate during the handshake.
     *
     * Derived subclasses usually implement a certificate selector,
     * although they may also choose to provide a certificate from
     * elsewhere. Alternatively the user may abort this certificate
     * request, which may or may not abort the TLS connection.
     *
     * The implementation can either be a synchronous (eg: modal dialog) or an
     * asynchronous one (eg: modeless dialog). This function will take care of
     * calling which ever one correctly.
     *
     * If the interaction is cancelled by the cancellation object, or by the
     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
     * not support immediate cancellation.
     * @param connection a #GTlsConnection object
     * @param flags flags providing more information about the request
     * @param cancellable an optional #GCancellable cancellation object
     * @returns The status of the certificate request interaction.
     */
    invokeRequestCertificate(
      connection: TlsConnection,
      flags: TlsCertificateRequestFlags,
      cancellable: Cancellable | null
    ): TlsInteractionResult
    // Has conflict: requestCertificate(connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable: Cancellable | null): TlsInteractionResult
    // Has conflict: requestCertificateAsync(connection: TlsConnection, flags: TlsCertificateRequestFlags, cancellable: Cancellable | null, callback: AsyncReadyCallback | null): void
    // Has conflict: requestCertificateFinish(result: AsyncResult): TlsInteractionResult

    // Own virtual methods of Gio-2.0.Gio.TlsInteraction

    /**
     * Run synchronous interaction to ask the user for a password. In general,
     * g_tls_interaction_invoke_ask_password() should be used instead of this
     * function.
     *
     * Derived subclasses usually implement a password prompt, although they may
     * also choose to provide a password from elsewhere. The `password` value will
     * be filled in and then `callback` will be called. Alternatively the user may
     * abort this password request, which will usually abort the TLS connection.
     *
     * If the interaction is cancelled by the cancellation object, or by the
     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
     * not support immediate cancellation.
     * @virtual
     * @param password a #GTlsPassword object
     * @param cancellable an optional #GCancellable cancellation object
     * @returns The status of the ask password interaction.
     */
    askPassword(
      password: TlsPassword,
      cancellable: Cancellable | null
    ): TlsInteractionResult
    /**
     * Run asynchronous interaction to ask the user for a password. In general,
     * g_tls_interaction_invoke_ask_password() should be used instead of this
     * function.
     *
     * Derived subclasses usually implement a password prompt, although they may
     * also choose to provide a password from elsewhere. The `password` value will
     * be filled in and then `callback` will be called. Alternatively the user may
     * abort this password request, which will usually abort the TLS connection.
     *
     * If the interaction is cancelled by the cancellation object, or by the
     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
     * not support immediate cancellation.
     *
     * Certain implementations may not support immediate cancellation.
     * @virtual
     * @param password a #GTlsPassword object
     * @param cancellable an optional #GCancellable cancellation object
     * @param callback will be called when the interaction completes
     */
    askPasswordAsync(
      password: TlsPassword,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Complete an ask password user interaction request. This should be once
     * the g_tls_interaction_ask_password_async() completion callback is called.
     *
     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed
     * to g_tls_interaction_ask_password() will have its password filled in.
     *
     * If the interaction is cancelled by the cancellation object, or by the
     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
     * contains a %G_IO_ERROR_CANCELLED error code.
     * @virtual
     * @param result the result passed to the callback
     * @returns The status of the ask password interaction.
     */
    askPasswordFinish(result: AsyncResult): TlsInteractionResult
    /**
     * Run synchronous interaction to ask the user to choose a certificate to use
     * with the connection. In general, g_tls_interaction_invoke_request_certificate()
     * should be used instead of this function.
     *
     * Derived subclasses usually implement a certificate selector, although they may
     * also choose to provide a certificate from elsewhere. Alternatively the user may
     * abort this certificate request, which will usually abort the TLS connection.
     *
     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
     * passed to g_tls_interaction_request_certificate() will have had its
     * #GTlsConnection:certificate filled in.
     *
     * If the interaction is cancelled by the cancellation object, or by the
     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
     * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
     * not support immediate cancellation.
     * @virtual
     * @param connection a #GTlsConnection object
     * @param flags flags providing more information about the request
     * @param cancellable an optional #GCancellable cancellation object
     * @returns The status of the request certificate interaction.
     */
    requestCertificate(
      connection: TlsConnection,
      flags: TlsCertificateRequestFlags,
      cancellable: Cancellable | null
    ): TlsInteractionResult
    /**
     * Run asynchronous interaction to ask the user for a certificate to use with
     * the connection. In general, g_tls_interaction_invoke_request_certificate() should
     * be used instead of this function.
     *
     * Derived subclasses usually implement a certificate selector, although they may
     * also choose to provide a certificate from elsewhere. `callback` will be called
     * when the operation completes. Alternatively the user may abort this certificate
     * request, which will usually abort the TLS connection.
     * @virtual
     * @param connection a #GTlsConnection object
     * @param flags flags providing more information about the request
     * @param cancellable an optional #GCancellable cancellation object
     * @param callback will be called when the interaction completes
     */
    requestCertificateAsync(
      connection: TlsConnection,
      flags: TlsCertificateRequestFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Complete a request certificate user interaction request. This should be once
     * the g_tls_interaction_request_certificate_async() completion callback is called.
     *
     * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
     * passed to g_tls_interaction_request_certificate_async() will have had its
     * #GTlsConnection:certificate filled in.
     *
     * If the interaction is cancelled by the cancellation object, or by the
     * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
     * contains a %G_IO_ERROR_CANCELLED error code.
     * @virtual
     * @param result the result passed to the callback
     * @returns The status of the request certificate interaction.
     */
    requestCertificateFinish(result: AsyncResult): TlsInteractionResult

    // Class property signals of Gio-2.0.Gio.TlsInteraction

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GTlsInteraction` provides a mechanism for the TLS connection and database
   * code to interact with the user. It can be used to ask the user for passwords.
   *
   * To use a `GTlsInteraction` with a TLS connection use
   * [method`Gio`.TlsConnection.set_interaction].
   *
   * Callers should instantiate a derived class that implements the various
   * interaction methods to show the required dialogs.
   *
   * Callers should use the 'invoke' functions like
   * [method`Gio`.TlsInteraction.invoke_ask_password] to run interaction methods.
   * These functions make sure that the interaction is invoked in the main loop
   * and not in the current thread, if the current thread is not running the
   * main loop.
   *
   * Derived classes can choose to implement whichever interactions methods they’d
   * like to support by overriding those virtual methods in their class
   * initialization function. Any interactions not implemented will return
   * `G_TLS_INTERACTION_UNHANDLED`. If a derived class implements an async method,
   * it must also implement the corresponding finish method.
   * @class
   */
  class TlsInteraction extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TlsInteraction

    static name: string

    // Constructors of Gio-2.0.Gio.TlsInteraction

    constructor(config?: TlsInteraction.ConstructorProperties)
    _init(config?: TlsInteraction.ConstructorProperties): void
  }

  module TlsPassword {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.TlsPassword

      /**
       * Description of what the password is for.
       */
      description?: string | null
      /**
       * Flags about the password.
       */
      flags?: TlsPasswordFlags | null
      /**
       * Warning about the password.
       */
      warning?: string | null
    }
  }

  interface TlsPassword {
    // Own properties of Gio-2.0.Gio.TlsPassword

    /**
     * Description of what the password is for.
     */
    description: string | null
    /**
     * Flags about the password.
     */
    flags: TlsPasswordFlags
    /**
     * Warning about the password.
     */
    warning: string | null
    __gtype__: number

    // Own fields of Gio-2.0.Gio.TlsPassword

    parentInstance: GObject.Object
    priv: TlsPasswordPrivate

    // Owm methods of Gio-2.0.Gio.TlsPassword

    /**
     * Get a description string about what the password will be used for.
     * @returns The description of the password.
     */
    getDescription(): string
    /**
     * Get flags about the password.
     * @returns The flags about the password.
     */
    getFlags(): TlsPasswordFlags
    // Has conflict: getValue(): number[]
    /**
     * Get a user readable translated warning. Usually this warning is a
     * representation of the password flags returned from
     * g_tls_password_get_flags().
     * @returns The warning.
     */
    getWarning(): string
    /**
     * Set a description string about what the password will be used for.
     * @param description The description of the password
     */
    setDescription(description: string): void
    /**
     * Set flags about the password.
     * @param flags The flags about the password
     */
    setFlags(flags: TlsPasswordFlags): void
    // Has conflict: setValue(value: number[]): void
    /**
     * Provide the value for this password.
     *
     * The `value` will be owned by the password object, and later freed using
     * the `destroy` function callback.
     *
     * Specify the `length,` for a non-nul-terminated password. Pass -1 as
     * `length` if using a nul-terminated password, and `length` will be
     * calculated automatically. (Note that the terminating nul is not
     * considered part of the password in this case.)
     * @param value the value for the password
     * @param destroy a function to use to free the password.
     */
    setValueFull(value: number[], destroy: GLib.DestroyNotify | null): void
    /**
     * Set a user readable translated warning. Usually this warning is a
     * representation of the password flags returned from
     * g_tls_password_get_flags().
     * @param warning The user readable warning
     */
    setWarning(warning: string): void

    // Own virtual methods of Gio-2.0.Gio.TlsPassword

    /**
     * virtual method for g_tls_password_get_warning() if no
     *  value has been set using g_tls_password_set_warning()
     * @virtual
     */
    getDefaultWarning(): string
    /**
     * Get the password value. If `length` is not %NULL then it will be
     * filled in with the length of the password value. (Note that the
     * password value is not nul-terminated, so you can only pass %NULL
     * for `length` in contexts where you know the password will have a
     * certain fixed length.)
     * @virtual
     * @returns The password value (owned by the password object).
     */
    getValue(): number[]
    /**
     * Provide the value for this password.
     *
     * The `value` will be owned by the password object, and later freed using
     * the `destroy` function callback.
     *
     * Specify the `length,` for a non-nul-terminated password. Pass -1 as
     * `length` if using a nul-terminated password, and `length` will be
     * calculated automatically. (Note that the terminating nul is not
     * considered part of the password in this case.)
     * @virtual
     * @param value the value for the password
     * @param destroy a function to use to free the password.
     */
    setValue(value: number[], destroy: GLib.DestroyNotify | null): void

    // Class property signals of Gio-2.0.Gio.TlsPassword

    connect(
      sigName: "notify::description",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::description",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::description", ...args: any[]): void
    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::warning",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::warning",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::warning",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::warning",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::warning", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An abstract interface representing a password used in TLS. Often used in
   * user interaction such as unlocking a key storage token.
   * @class
   */
  class TlsPassword extends GObject.Object {
    // Own properties of Gio-2.0.Gio.TlsPassword

    static name: string

    // Constructors of Gio-2.0.Gio.TlsPassword

    constructor(config?: TlsPassword.ConstructorProperties)
    /**
     * Create a new #GTlsPassword object.
     * @constructor
     * @param flags the password flags
     * @param description description of what the password is for
     * @returns The newly allocated password object
     */
    constructor(flags: TlsPasswordFlags, description: string)
    /**
     * Create a new #GTlsPassword object.
     * @constructor
     * @param flags the password flags
     * @param description description of what the password is for
     * @returns The newly allocated password object
     */
    static new(flags: TlsPasswordFlags, description: string): TlsPassword
    _init(config?: TlsPassword.ConstructorProperties): void
  }

  module UnixConnection {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnection.ConstructorProperties {}
  }

  interface UnixConnection {
    // Own properties of Gio-2.0.Gio.UnixConnection

    __gtype__: number

    // Own fields of Gio-2.0.Gio.UnixConnection

    parentInstance: any
    priv: any

    // Owm methods of Gio-2.0.Gio.UnixConnection

    /**
     * Receives credentials from the sending end of the connection.  The
     * sending end has to call g_unix_connection_send_credentials() (or
     * similar) for this to work.
     *
     * As well as reading the credentials this also reads (and discards) a
     * single byte from the stream, as this is required for credentials
     * passing to work on some implementations.
     *
     * This method can be expected to be available on the following platforms:
     *
     * - Linux since GLib 2.26
     * - FreeBSD since GLib 2.26
     * - GNU/kFreeBSD since GLib 2.36
     * - Solaris, Illumos and OpenSolaris since GLib 2.40
     * - GNU/Hurd since GLib 2.40
     *
     * Other ways to exchange credentials with a foreign peer includes the
     * #GUnixCredentialsMessage type and g_socket_get_credentials() function.
     * @param cancellable A #GCancellable or %NULL.
     * @returns Received credentials on success (free with g_object_unref()), %NULL if @error is set.
     */
    receiveCredentials(cancellable: Cancellable | null): Credentials
    /**
     * Asynchronously receive credentials.
     *
     * For more details, see g_unix_connection_receive_credentials() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called. You can then call
     * g_unix_connection_receive_credentials_finish() to get the result of the operation.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    receiveCredentialsAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous receive credentials operation started with
     * g_unix_connection_receive_credentials_async().
     * @param result a #GAsyncResult.
     * @returns a #GCredentials, or %NULL on error.     Free the returned object with g_object_unref().
     */
    receiveCredentialsFinish(result: AsyncResult): Credentials
    /**
     * Receives a file descriptor from the sending end of the connection.
     * The sending end has to call g_unix_connection_send_fd() for this
     * to work.
     *
     * As well as reading the fd this also reads a single byte from the
     * stream, as this is required for fd passing to work on some
     * implementations.
     * @param cancellable optional #GCancellable object, %NULL to ignore
     * @returns a file descriptor on success, -1 on error.
     */
    receiveFd(cancellable: Cancellable | null): number
    /**
     * Passes the credentials of the current user the receiving side
     * of the connection. The receiving end has to call
     * g_unix_connection_receive_credentials() (or similar) to accept the
     * credentials.
     *
     * As well as sending the credentials this also writes a single NUL
     * byte to the stream, as this is required for credentials passing to
     * work on some implementations.
     *
     * This method can be expected to be available on the following platforms:
     *
     * - Linux since GLib 2.26
     * - FreeBSD since GLib 2.26
     * - GNU/kFreeBSD since GLib 2.36
     * - Solaris, Illumos and OpenSolaris since GLib 2.40
     * - GNU/Hurd since GLib 2.40
     *
     * Other ways to exchange credentials with a foreign peer includes the
     * #GUnixCredentialsMessage type and g_socket_get_credentials() function.
     * @param cancellable A #GCancellable or %NULL.
     * @returns %TRUE on success, %FALSE if @error is set.
     */
    sendCredentials(cancellable: Cancellable | null): boolean
    /**
     * Asynchronously send credentials.
     *
     * For more details, see g_unix_connection_send_credentials() which is
     * the synchronous version of this call.
     *
     * When the operation is finished, `callback` will be called. You can then call
     * g_unix_connection_send_credentials_finish() to get the result of the operation.
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
     */
    sendCredentialsAsync(
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous send credentials operation started with
     * g_unix_connection_send_credentials_async().
     * @param result a #GAsyncResult.
     * @returns %TRUE if the operation was successful, otherwise %FALSE.
     */
    sendCredentialsFinish(result: AsyncResult): boolean
    /**
     * Passes a file descriptor to the receiving side of the
     * connection. The receiving end has to call g_unix_connection_receive_fd()
     * to accept the file descriptor.
     *
     * As well as sending the fd this also writes a single byte to the
     * stream, as this is required for fd passing to work on some
     * implementations.
     * @param fd a file descriptor
     * @param cancellable optional #GCancellable object, %NULL to ignore.
     * @returns a %TRUE on success, %NULL on error.
     */
    sendFd(fd: number, cancellable: Cancellable | null): boolean

    // Class property signals of Gio-2.0.Gio.UnixConnection

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::socket",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::socket",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::socket",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::socket", ...args: any[]): void
    connect(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::closed", ...args: any[]): void
    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::output-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::output-stream", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number

    // Overloads of connect

    /**
     * Connect `connection` to the specified remote address.
     * @param address a #GSocketAddress specifying the remote address.
     * @param cancellable a %GCancellable or %NULL
     * @returns %TRUE if the connection succeeded, %FALSE on error
     */
    connect(address: SocketAddress, cancellable: Cancellable | null): boolean
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * This is the subclass of [class`Gio`.SocketConnection] that is created
   * for UNIX domain sockets.
   *
   * It contains functions to do some of the UNIX socket specific
   * functionality like passing file descriptors.
   *
   * Since GLib 2.72, `GUnixConnection` is available on all platforms. It requires
   * underlying system support (such as Windows 10 with `AF_UNIX`) at run time.
   *
   * Before GLib 2.72, `<gio/gunixconnection.h>` belonged to the UNIX-specific GIO
   * interfaces, thus you had to use the `gio-unix-2.0.pc` pkg-config file when
   * using it. This is no longer necessary since GLib 2.72.
   * @class
   */
  class UnixConnection extends SocketConnection {
    // Own properties of Gio-2.0.Gio.UnixConnection

    static name: string

    // Constructors of Gio-2.0.Gio.UnixConnection

    constructor(config?: UnixConnection.ConstructorProperties)
    _init(config?: UnixConnection.ConstructorProperties): void
  }

  module UnixCredentialsMessage {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketControlMessage.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.UnixCredentialsMessage

      /**
       * The credentials stored in the message.
       */
      credentials?: Credentials | null
    }
  }

  interface UnixCredentialsMessage {
    // Own properties of Gio-2.0.Gio.UnixCredentialsMessage

    /**
     * The credentials stored in the message.
     */
    readonly credentials: Credentials
    __gtype__: number

    // Own fields of Gio-2.0.Gio.UnixCredentialsMessage

    parentInstance: any
    priv: any

    // Owm methods of Gio-2.0.Gio.UnixCredentialsMessage

    /**
     * Gets the credentials stored in `message`.
     * @returns A #GCredentials instance. Do not free, it is owned by @message.
     */
    getCredentials(): Credentials

    // Class property signals of Gio-2.0.Gio.UnixCredentialsMessage

    connect(
      sigName: "notify::credentials",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::credentials",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::credentials",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::credentials",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::credentials", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * This [class`Gio`.SocketControlMessage] contains a [class`Gio`.Credentials]
   * instance.  It may be sent using [method`Gio`.Socket.send_message] and received
   * using [method`Gio`.Socket.receive_message] over UNIX sockets (ie: sockets in
   * the `G_SOCKET_FAMILY_UNIX` family).
   *
   * For an easier way to send and receive credentials over
   * stream-oriented UNIX sockets, see
   * [method`Gio`.UnixConnection.send_credentials] and
   * [method`Gio`.UnixConnection.receive_credentials]. To receive credentials of
   * a foreign process connected to a socket, use
   * [method`Gio`.Socket.get_credentials].
   *
   * Since GLib 2.72, `GUnixCredentialMessage` is available on all platforms. It
   * requires underlying system support (such as Windows 10 with `AF_UNIX`) at run
   * time.
   *
   * Before GLib 2.72, `<gio/gunixcredentialsmessage.h>` belonged to the UNIX-specific
   * GIO interfaces, thus you had to use the `gio-unix-2.0.pc` pkg-config file
   * when using it. This is no longer necessary since GLib 2.72.
   * @class
   */
  class UnixCredentialsMessage extends SocketControlMessage {
    // Own properties of Gio-2.0.Gio.UnixCredentialsMessage

    static name: string

    // Constructors of Gio-2.0.Gio.UnixCredentialsMessage

    constructor(config?: UnixCredentialsMessage.ConstructorProperties)
    /**
     * Creates a new #GUnixCredentialsMessage with credentials matching the current processes.
     * @constructor
     * @returns a new #GUnixCredentialsMessage
     */
    constructor()
    /**
     * Creates a new #GUnixCredentialsMessage with credentials matching the current processes.
     * @constructor
     * @returns a new #GUnixCredentialsMessage
     */
    static new(): UnixCredentialsMessage
    /**
     * Creates a new #GUnixCredentialsMessage holding `credentials`.
     * @constructor
     * @param credentials A #GCredentials object.
     * @returns a new #GUnixCredentialsMessage
     */
    static newWithCredentials(credentials: Credentials): UnixCredentialsMessage
    _init(config?: UnixCredentialsMessage.ConstructorProperties): void
    /**
     * Checks if passing #GCredentials on a #GSocket is supported on this platform.
     * @returns %TRUE if supported, %FALSE otherwise
     */
    static isSupported(): boolean
  }

  module UnixFDList {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface UnixFDList {
    // Own properties of Gio-2.0.Gio.UnixFDList

    __gtype__: number

    // Own fields of Gio-2.0.Gio.UnixFDList

    parentInstance: GObject.Object
    priv: UnixFDListPrivate

    // Owm methods of Gio-2.0.Gio.UnixFDList

    /**
     * Adds a file descriptor to `list`.
     *
     * The file descriptor is duplicated using dup(). You keep your copy
     * of the descriptor and the copy contained in `list` will be closed
     * when `list` is finalized.
     *
     * A possible cause of failure is exceeding the per-process or
     * system-wide file descriptor limit.
     *
     * The index of the file descriptor in the list is returned.  If you use
     * this index with g_unix_fd_list_get() then you will receive back a
     * duplicated copy of the same file descriptor.
     * @param fd a valid open file descriptor
     * @returns the index of the appended fd in case of success, else -1          (and @error is set)
     */
    append(fd: number): number
    /**
     * Gets a file descriptor out of `list`.
     *
     * `index_` specifies the index of the file descriptor to get.  It is a
     * programmer error for `index_` to be out of range; see
     * g_unix_fd_list_get_length().
     *
     * The file descriptor is duplicated using dup() and set as
     * close-on-exec before being returned.  You must call close() on it
     * when you are done.
     *
     * A possible cause of failure is exceeding the per-process or
     * system-wide file descriptor limit.
     * @param index the index into the list
     * @returns the file descriptor, or -1 in case of error
     */
    get(index: number): number
    /**
     * Gets the length of `list` (ie: the number of file descriptors
     * contained within).
     * @returns the length of @list
     */
    getLength(): number
    /**
     * Returns the array of file descriptors that is contained in this
     * object.
     *
     * After this call, the descriptors remain the property of `list`.  The
     * caller must not close them and must not free the array.  The array is
     * valid only until `list` is changed in any way.
     *
     * If `length` is non-%NULL then it is set to the number of file
     * descriptors in the returned array. The returned array is also
     * terminated with -1.
     *
     * This function never returns %NULL. In case there are no file
     * descriptors contained in `list,` an empty array is returned.
     * @returns an array of file     descriptors
     */
    peekFds(): number[]
    /**
     * Returns the array of file descriptors that is contained in this
     * object.
     *
     * After this call, the descriptors are no longer contained in
     * `list`. Further calls will return an empty list (unless more
     * descriptors have been added).
     *
     * The return result of this function must be freed with g_free().
     * The caller is also responsible for closing all of the file
     * descriptors.  The file descriptors in the array are set to
     * close-on-exec.
     *
     * If `length` is non-%NULL then it is set to the number of file
     * descriptors in the returned array. The returned array is also
     * terminated with -1.
     *
     * This function never returns %NULL. In case there are no file
     * descriptors contained in `list,` an empty array is returned.
     * @returns an array of file     descriptors
     */
    stealFds(): number[]

    // Class property signals of Gio-2.0.Gio.UnixFDList

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GUnixFDList` contains a list of file descriptors.  It owns the file
   * descriptors that it contains, closing them when finalized.
   *
   * It may be wrapped in a
   * [`GUnixFDMessage`](../gio-unix/class.UnixFDMessage.html) and sent over a
   * [class`Gio`.Socket] in the `G_SOCKET_FAMILY_UNIX` family by using
   * [method`Gio`.Socket.send_message] and received using
   * [method`Gio`.Socket.receive_message].
   *
   * Before 2.74, `<gio/gunixfdlist.h>` belonged to the UNIX-specific GIO
   * interfaces, thus you had to use the `gio-unix-2.0.pc` pkg-config file when
   * using it.
   *
   * Since 2.74, the API is available for Windows.
   * @class
   */
  class UnixFDList extends GObject.Object {
    // Own properties of Gio-2.0.Gio.UnixFDList

    static name: string

    // Constructors of Gio-2.0.Gio.UnixFDList

    constructor(config?: UnixFDList.ConstructorProperties)
    /**
     * Creates a new #GUnixFDList containing no file descriptors.
     * @constructor
     * @returns a new #GUnixFDList
     */
    constructor()
    /**
     * Creates a new #GUnixFDList containing no file descriptors.
     * @constructor
     * @returns a new #GUnixFDList
     */
    static new(): UnixFDList
    /**
     * Creates a new #GUnixFDList containing the file descriptors given in
     * `fds`.  The file descriptors become the property of the new list and
     * may no longer be used by the caller.  The array itself is owned by
     * the caller.
     *
     * Each file descriptor in the array should be set to close-on-exec.
     *
     * If `n_fds` is -1 then `fds` must be terminated with -1.
     * @constructor
     * @param fds the initial list of file descriptors
     * @returns a new #GUnixFDList
     */
    static newFromArray(fds: number[]): UnixFDList
    _init(config?: UnixFDList.ConstructorProperties): void
  }

  module UnixFDMessage {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketControlMessage.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.UnixFDMessage

      /**
       * The [class`Gio`.UnixFDList] object to send with the message.
       */
      fd_list?: UnixFDList | null
    }
  }

  interface UnixFDMessage {
    // Own properties of Gio-2.0.Gio.UnixFDMessage

    /**
     * The [class`Gio`.UnixFDList] object to send with the message.
     */
    readonly fdList: UnixFDList
    __gtype__: number

    // Own fields of Gio-2.0.Gio.UnixFDMessage

    parentInstance: any
    priv: any

    // Owm methods of Gio-2.0.Gio.UnixFDMessage

    /**
     * Adds a file descriptor to `message`.
     *
     * The file descriptor is duplicated using dup(). You keep your copy
     * of the descriptor and the copy contained in `message` will be closed
     * when `message` is finalized.
     *
     * A possible cause of failure is exceeding the per-process or
     * system-wide file descriptor limit.
     * @param fd a valid open file descriptor
     * @returns %TRUE in case of success, else %FALSE (and @error is set)
     */
    appendFd(fd: number): boolean
    /**
     * Gets the #GUnixFDList contained in `message`.  This function does not
     * return a reference to the caller, but the returned list is valid for
     * the lifetime of `message`.
     * @returns the #GUnixFDList from @message
     */
    getFdList(): UnixFDList
    /**
     * Returns the array of file descriptors that is contained in this
     * object.
     *
     * After this call, the descriptors are no longer contained in
     * `message`. Further calls will return an empty list (unless more
     * descriptors have been added).
     *
     * The return result of this function must be freed with g_free().
     * The caller is also responsible for closing all of the file
     * descriptors.
     *
     * If `length` is non-%NULL then it is set to the number of file
     * descriptors in the returned array. The returned array is also
     * terminated with -1.
     *
     * This function never returns %NULL. In case there are no file
     * descriptors contained in `message,` an empty array is returned.
     * @returns an array of file     descriptors
     */
    stealFds(): number[]

    // Class property signals of Gio-2.0.Gio.UnixFDMessage

    connect(
      sigName: "notify::fd-list",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fd-list",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fd-list",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fd-list",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fd-list", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * This [class`Gio`.SocketControlMessage] contains a [class`Gio`.UnixFDList].
   * It may be sent using [method`Gio`.Socket.send_message] and received using
   * [method`Gio`.Socket.receive_message] over UNIX sockets (ie: sockets in the
   * `G_SOCKET_FAMILY_UNIX` family). The file descriptors are copied
   * between processes by the kernel.
   *
   * For an easier way to send and receive file descriptors over
   * stream-oriented UNIX sockets, see [method`Gio`.UnixConnection.send_fd] and
   * [method`Gio`.UnixConnection.receive_fd].
   *
   * Note that `<gio/gunixfdmessage.h>` belongs to the UNIX-specific GIO
   * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
   * file or the `GioUnix-2.0` GIR namespace when using it.
   * @class
   */
  class UnixFDMessage extends SocketControlMessage {
    // Own properties of Gio-2.0.Gio.UnixFDMessage

    static name: string

    // Constructors of Gio-2.0.Gio.UnixFDMessage

    constructor(config?: UnixFDMessage.ConstructorProperties)
    /**
     * Creates a new #GUnixFDMessage containing an empty file descriptor
     * list.
     * @constructor
     * @returns a new #GUnixFDMessage
     */
    constructor()
    /**
     * Creates a new #GUnixFDMessage containing an empty file descriptor
     * list.
     * @constructor
     * @returns a new #GUnixFDMessage
     */
    static new(): UnixFDMessage
    /**
     * Creates a new #GUnixFDMessage containing `list`.
     * @constructor
     * @param fdList a #GUnixFDList
     * @returns a new #GUnixFDMessage
     */
    static newWithFdList(fdList: UnixFDList): UnixFDMessage
    _init(config?: UnixFDMessage.ConstructorProperties): void
  }

  module UnixInputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends FileDescriptorBased.ConstructorProperties,
        PollableInputStream.ConstructorProperties,
        InputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.UnixInputStream

      /**
       * Whether to close the file descriptor when the stream is closed.
       */
      close_fd?: boolean | null
      /**
       * The file descriptor that the stream reads from.
       */
      fd?: number | null
    }
  }

  interface UnixInputStream extends FileDescriptorBased, PollableInputStream {
    // Own properties of Gio-2.0.Gio.UnixInputStream

    /**
     * Whether to close the file descriptor when the stream is closed.
     */
    closeFd: boolean
    /**
     * The file descriptor that the stream reads from.
     */
    readonly fd: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.UnixInputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.UnixInputStream

    /**
     * Returns whether the file descriptor of `stream` will be
     * closed when the stream is closed.
     * @returns %TRUE if the file descriptor is closed when done
     */
    getCloseFd(): boolean
    /**
     * Return the UNIX file descriptor that the stream reads from.
     * @returns The file descriptor of @stream
     */
    getFd(): number

    // Overloads of getFd

    /**
     * Gets the underlying file descriptor.
     * @virtual
     * @returns The file descriptor
     */
    getFd(): number
    /**
     * Sets whether the file descriptor of `stream` shall be closed
     * when the stream is closed.
     * @param closeFd %TRUE to close the file descriptor when done
     */
    setCloseFd(closeFd: boolean): void

    // Class property signals of Gio-2.0.Gio.UnixInputStream

    connect(
      sigName: "notify::close-fd",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-fd",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-fd", ...args: any[]): void
    connect(sigName: "notify::fd", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fd",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fd", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GUnixInputStream` implements [class`Gio`.InputStream] for reading from a UNIX
   * file descriptor, including asynchronous operations. (If the file
   * descriptor refers to a socket or pipe, this will use `poll()` to do
   * asynchronous I/O. If it refers to a regular file, it will fall back
   * to doing asynchronous I/O in another thread.)
   *
   * Note that `<gio/gunixinputstream.h>` belongs to the UNIX-specific GIO
   * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
   * file or the `GioUnix-2.0` GIR namespace when using it.
   * @class
   */
  class UnixInputStream extends InputStream {
    // Own properties of Gio-2.0.Gio.UnixInputStream

    static name: string

    // Constructors of Gio-2.0.Gio.UnixInputStream

    constructor(config?: UnixInputStream.ConstructorProperties)
    /**
     * Creates a new #GUnixInputStream for the given `fd`.
     *
     * If `close_fd` is %TRUE, the file descriptor will be closed
     * when the stream is closed.
     * @constructor
     * @param fd a UNIX file descriptor
     * @param closeFd %TRUE to close the file descriptor when done
     * @returns a new #GUnixInputStream
     */
    constructor(fd: number, closeFd: boolean)
    /**
     * Creates a new #GUnixInputStream for the given `fd`.
     *
     * If `close_fd` is %TRUE, the file descriptor will be closed
     * when the stream is closed.
     * @constructor
     * @param fd a UNIX file descriptor
     * @param closeFd %TRUE to close the file descriptor when done
     * @returns a new #GUnixInputStream
     */
    static new(fd: number, closeFd: boolean): UnixInputStream
    _init(config?: UnixInputStream.ConstructorProperties): void
  }

  module UnixMountMonitor {
    // Signal callback interfaces

    /**
     * Signal callback interface for `mountpoints-changed`
     */
    interface MountpointsChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `mounts-changed`
     */
    interface MountsChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface UnixMountMonitor {
    // Own properties of Gio-2.0.Gio.UnixMountMonitor

    __gtype__: number

    // Owm methods of Gio-2.0.Gio.UnixMountMonitor

    /**
     * This function does nothing.
     *
     * Before 2.44, this was a partially-effective way of controlling the
     * rate at which events would be reported under some uncommon
     * circumstances.  Since `mount_monitor` is a singleton, it also meant
     * that calling this function would have side effects for other users of
     * the monitor.
     * @param limitMsec a integer with the limit in milliseconds to     poll for changes.
     */
    setRateLimit(limitMsec: number): void

    // Own signals of Gio-2.0.Gio.UnixMountMonitor

    connect(
      sigName: "mountpoints-changed",
      callback: UnixMountMonitor.MountpointsChangedSignalCallback
    ): number
    on(
      sigName: "mountpoints-changed",
      callback: UnixMountMonitor.MountpointsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mountpoints-changed",
      callback: UnixMountMonitor.MountpointsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mountpoints-changed",
      callback: UnixMountMonitor.MountpointsChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mountpoints-changed", ...args: any[]): void
    connect(
      sigName: "mounts-changed",
      callback: UnixMountMonitor.MountsChangedSignalCallback
    ): number
    on(
      sigName: "mounts-changed",
      callback: UnixMountMonitor.MountsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mounts-changed",
      callback: UnixMountMonitor.MountsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mounts-changed",
      callback: UnixMountMonitor.MountsChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mounts-changed", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.UnixMountMonitor

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Watches #GUnixMounts for changes.
   * @class
   */
  class UnixMountMonitor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.UnixMountMonitor

    static name: string

    // Constructors of Gio-2.0.Gio.UnixMountMonitor

    constructor(config?: UnixMountMonitor.ConstructorProperties)
    /**
     * Deprecated alias for g_unix_mount_monitor_get().
     *
     * This function was never a true constructor, which is why it was
     * renamed.
     * @constructor
     * @returns a #GUnixMountMonitor.
     */
    constructor()
    /**
     * Deprecated alias for g_unix_mount_monitor_get().
     *
     * This function was never a true constructor, which is why it was
     * renamed.
     * @constructor
     * @returns a #GUnixMountMonitor.
     */
    static new(): UnixMountMonitor
    _init(config?: UnixMountMonitor.ConstructorProperties): void
    /**
     * Gets the #GUnixMountMonitor for the current thread-default main
     * context.
     *
     * The mount monitor can be used to monitor for changes to the list of
     * mounted filesystems as well as the list of mount points (ie: fstab
     * entries).
     *
     * You must only call g_object_unref() on the return value from under
     * the same main context as you called this function.
     * @returns the #GUnixMountMonitor.
     */
    static get(): UnixMountMonitor
  }

  module UnixOutputStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends FileDescriptorBased.ConstructorProperties,
        PollableOutputStream.ConstructorProperties,
        OutputStream.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.UnixOutputStream

      /**
       * Whether to close the file descriptor when the stream is closed.
       */
      close_fd?: boolean | null
      /**
       * The file descriptor that the stream writes to.
       */
      fd?: number | null
    }
  }

  interface UnixOutputStream extends FileDescriptorBased, PollableOutputStream {
    // Own properties of Gio-2.0.Gio.UnixOutputStream

    /**
     * Whether to close the file descriptor when the stream is closed.
     */
    closeFd: boolean
    /**
     * The file descriptor that the stream writes to.
     */
    readonly fd: number
    __gtype__: number

    // Own fields of Gio-2.0.Gio.UnixOutputStream

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.UnixOutputStream

    /**
     * Returns whether the file descriptor of `stream` will be
     * closed when the stream is closed.
     * @returns %TRUE if the file descriptor is closed when done
     */
    getCloseFd(): boolean
    /**
     * Return the UNIX file descriptor that the stream writes to.
     * @returns The file descriptor of @stream
     */
    getFd(): number

    // Overloads of getFd

    /**
     * Gets the underlying file descriptor.
     * @virtual
     * @returns The file descriptor
     */
    getFd(): number
    /**
     * Sets whether the file descriptor of `stream` shall be closed
     * when the stream is closed.
     * @param closeFd %TRUE to close the file descriptor when done
     */
    setCloseFd(closeFd: boolean): void

    // Class property signals of Gio-2.0.Gio.UnixOutputStream

    connect(
      sigName: "notify::close-fd",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::close-fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::close-fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::close-fd",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::close-fd", ...args: any[]): void
    connect(sigName: "notify::fd", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fd",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fd",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fd", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GUnixOutputStream` implements [class`Gio`.OutputStream] for writing to a UNIX
   * file descriptor, including asynchronous operations. (If the file
   * descriptor refers to a socket or pipe, this will use `poll()` to do
   * asynchronous I/O. If it refers to a regular file, it will fall back
   * to doing asynchronous I/O in another thread.)
   *
   * Note that `<gio/gunixoutputstream.h>` belongs to the UNIX-specific GIO
   * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file
   * file or the `GioUnix-2.0` GIR namespace when using it.
   * @class
   */
  class UnixOutputStream extends OutputStream {
    // Own properties of Gio-2.0.Gio.UnixOutputStream

    static name: string

    // Constructors of Gio-2.0.Gio.UnixOutputStream

    constructor(config?: UnixOutputStream.ConstructorProperties)
    /**
     * Creates a new #GUnixOutputStream for the given `fd`.
     *
     * If `close_fd,` is %TRUE, the file descriptor will be closed when
     * the output stream is destroyed.
     * @constructor
     * @param fd a UNIX file descriptor
     * @param closeFd %TRUE to close the file descriptor when done
     * @returns a new #GOutputStream
     */
    constructor(fd: number, closeFd: boolean)
    /**
     * Creates a new #GUnixOutputStream for the given `fd`.
     *
     * If `close_fd,` is %TRUE, the file descriptor will be closed when
     * the output stream is destroyed.
     * @constructor
     * @param fd a UNIX file descriptor
     * @param closeFd %TRUE to close the file descriptor when done
     * @returns a new #GOutputStream
     */
    static new(fd: number, closeFd: boolean): UnixOutputStream
    _init(config?: UnixOutputStream.ConstructorProperties): void
  }

  module UnixSocketAddress {
    // Constructor properties interface

    interface ConstructorProperties
      extends SocketConnectable.ConstructorProperties,
        SocketAddress.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.UnixSocketAddress

      /**
       * Whether or not this is an abstract address
       */
      abstract?: boolean | null
      /**
       * The type of Unix socket address.
       */
      address_type?: UnixSocketAddressType | null
      /**
       * Unix socket path.
       */
      path?: string | null
      /**
       * Unix socket path, as a byte array.
       */
      path_as_array?: number[] | null
    }
  }

  interface UnixSocketAddress extends SocketConnectable {
    // Own properties of Gio-2.0.Gio.UnixSocketAddress

    /**
     * Whether or not this is an abstract address
     */
    readonly abstract: boolean
    /**
     * The type of Unix socket address.
     */
    readonly addressType: UnixSocketAddressType
    /**
     * Unix socket path.
     */
    readonly path: string | null
    /**
     * Unix socket path, as a byte array.
     */
    readonly pathAsArray: number[]
    __gtype__: number

    // Own fields of Gio-2.0.Gio.UnixSocketAddress

    parentInstance: any

    // Owm methods of Gio-2.0.Gio.UnixSocketAddress

    /**
     * Gets `address'`s type.
     * @returns a #GUnixSocketAddressType
     */
    getAddressType(): UnixSocketAddressType
    /**
     * Tests if `address` is abstract.
     * @returns %TRUE if the address is abstract, %FALSE otherwise
     */
    getIsAbstract(): boolean
    /**
     * Gets `address'`s path, or for abstract sockets the "name".
     *
     * Guaranteed to be zero-terminated, but an abstract socket
     * may contain embedded zeros, and thus you should use
     * g_unix_socket_address_get_path_len() to get the true length
     * of this string.
     * @returns the path for @address
     */
    getPath(): string
    /**
     * Gets the length of `address'`s path.
     *
     * For details, see g_unix_socket_address_get_path().
     * @returns the length of the path
     */
    getPathLen(): number

    // Class property signals of Gio-2.0.Gio.UnixSocketAddress

    connect(
      sigName: "notify::abstract",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::abstract",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::abstract",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::abstract",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::abstract", ...args: any[]): void
    connect(
      sigName: "notify::address-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::address-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::address-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::address-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::address-type", ...args: any[]): void
    connect(sigName: "notify::path", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::path", ...args: any[]): void
    connect(
      sigName: "notify::path-as-array",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::path-as-array",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::path-as-array",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::path-as-array",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::path-as-array", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Support for UNIX-domain (also known as local) sockets, corresponding to
   * `struct sockaddr_un`.
   *
   * UNIX domain sockets are generally visible in the filesystem.
   * However, some systems support abstract socket names which are not
   * visible in the filesystem and not affected by the filesystem
   * permissions, visibility, etc. Currently this is only supported
   * under Linux. If you attempt to use abstract sockets on other
   * systems, function calls may return `G_IO_ERROR_NOT_SUPPORTED`
   * errors. You can use [func`Gio`.UnixSocketAddress.abstract_names_supported]
   * to see if abstract names are supported.
   *
   * Since GLib 2.72, `GUnixSocketAddress` is available on all platforms. It
   * requires underlying system support (such as Windows 10 with `AF_UNIX`) at
   * run time.
   *
   * Before GLib 2.72, `<gio/gunixsocketaddress.h>` belonged to the UNIX-specific
   * GIO interfaces, thus you had to use the `gio-unix-2.0.pc` pkg-config file
   * when using it. This is no longer necessary since GLib 2.72.
   * @class
   */
  class UnixSocketAddress extends SocketAddress {
    // Own properties of Gio-2.0.Gio.UnixSocketAddress

    static name: string

    // Constructors of Gio-2.0.Gio.UnixSocketAddress

    constructor(config?: UnixSocketAddress.ConstructorProperties)
    /**
     * Creates a new #GUnixSocketAddress for `path`.
     *
     * To create abstract socket addresses, on systems that support that,
     * use g_unix_socket_address_new_abstract().
     * @constructor
     * @param path the socket path
     * @returns a new #GUnixSocketAddress
     */
    constructor(path: string)
    /**
     * Creates a new #GUnixSocketAddress for `path`.
     *
     * To create abstract socket addresses, on systems that support that,
     * use g_unix_socket_address_new_abstract().
     * @constructor
     * @param path the socket path
     * @returns a new #GUnixSocketAddress
     */
    static new(path: string): UnixSocketAddress
    /**
     * Creates a new %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED
     * #GUnixSocketAddress for `path`.
     * @constructor
     * @param path the abstract name
     * @returns a new #GUnixSocketAddress
     */
    static newAbstract(path: number[]): UnixSocketAddress
    /**
     * Creates a new #GUnixSocketAddress of type `type` with name `path`.
     *
     * If `type` is %G_UNIX_SOCKET_ADDRESS_PATH, this is equivalent to
     * calling g_unix_socket_address_new().
     *
     * If `type` is %G_UNIX_SOCKET_ADDRESS_ANONYMOUS, `path` and `path_len` will be
     * ignored.
     *
     * If `path_type` is %G_UNIX_SOCKET_ADDRESS_ABSTRACT, then `path_len`
     * bytes of `path` will be copied to the socket's path, and only those
     * bytes will be considered part of the name. (If `path_len` is -1,
     * then `path` is assumed to be NUL-terminated.) For example, if `path`
     * was "test", then calling g_socket_address_get_native_size() on the
     * returned socket would return 7 (2 bytes of overhead, 1 byte for the
     * abstract-socket indicator byte, and 4 bytes for the name "test").
     *
     * If `path_type` is %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED, then
     * `path_len` bytes of `path` will be copied to the socket's path, the
     * rest of the path will be padded with 0 bytes, and the entire
     * zero-padded buffer will be considered the name. (As above, if
     * `path_len` is -1, then `path` is assumed to be NUL-terminated.) In
     * this case, g_socket_address_get_native_size() will always return
     * the full size of a `struct sockaddr_un`, although
     * g_unix_socket_address_get_path_len() will still return just the
     * length of `path`.
     *
     * %G_UNIX_SOCKET_ADDRESS_ABSTRACT is preferred over
     * %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED for new programs. Of course,
     * when connecting to a server created by another process, you must
     * use the appropriate type corresponding to how that process created
     * its listening socket.
     * @constructor
     * @param path the name
     * @param type a #GUnixSocketAddressType
     * @returns a new #GUnixSocketAddress
     */
    static newWithType(
      path: number[],
      type: UnixSocketAddressType
    ): UnixSocketAddress
    _init(config?: UnixSocketAddress.ConstructorProperties): void
    /**
     * Checks if abstract UNIX domain socket names are supported.
     * @returns %TRUE if supported, %FALSE otherwise
     */
    static abstractNamesSupported(): boolean
  }

  module Vfs {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Vfs {
    // Own properties of Gio-2.0.Gio.Vfs

    __gtype__: number

    // Own fields of Gio-2.0.Gio.Vfs

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.Vfs

    // Has conflict: getFileForPath(path: string): File
    // Has conflict: getFileForUri(uri: string): File
    // Has conflict: getSupportedUriSchemes(): string[]
    // Has conflict: isActive(): boolean
    // Has conflict: parseName(parseName: string): File
    /**
     * Registers `uri_func` and `parse_name_func` as the #GFile URI and parse name
     * lookup functions for URIs with a scheme matching `scheme`.
     * Note that `scheme` is registered only within the running application, as
     * opposed to desktop-wide as it happens with GVfs backends.
     *
     * When a #GFile is requested with an URI containing `scheme` (e.g. through
     * g_file_new_for_uri()), `uri_func` will be called to allow a custom
     * constructor. The implementation of `uri_func` should not be blocking, and
     * must not call g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme().
     *
     * When g_file_parse_name() is called with a parse name obtained from such file,
     * `parse_name_func` will be called to allow the #GFile to be created again. In
     * that case, it's responsibility of `parse_name_func` to make sure the parse
     * name matches what the custom #GFile implementation returned when
     * g_file_get_parse_name() was previously called. The implementation of
     * `parse_name_func` should not be blocking, and must not call
     * g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme().
     *
     * It's an error to call this function twice with the same scheme. To unregister
     * a custom URI scheme, use g_vfs_unregister_uri_scheme().
     * @param scheme an URI scheme, e.g. "http"
     * @param uriFunc a #GVfsFileLookupFunc
     * @param parseNameFunc a #GVfsFileLookupFunc
     * @returns %TRUE if @scheme was successfully registered, or %FALSE if a handler     for @scheme already exists.
     */
    registerUriScheme(
      scheme: string,
      uriFunc: VfsFileLookupFunc | null,
      parseNameFunc: VfsFileLookupFunc | null
    ): boolean
    /**
     * Unregisters the URI handler for `scheme` previously registered with
     * g_vfs_register_uri_scheme().
     * @param scheme an URI scheme, e.g. "http"
     * @returns %TRUE if @scheme was successfully unregistered, or %FALSE if a     handler for @scheme does not exist.
     */
    unregisterUriScheme(scheme: string): boolean

    // Own virtual methods of Gio-2.0.Gio.Vfs

    addWritableNamespaces(list: FileAttributeInfoList): void
    /**
     * Gets a #GFile for `path`.
     * @virtual
     * @param path a string containing a VFS path.
     * @returns a #GFile.     Free the returned object with g_object_unref().
     */
    getFileForPath(path: string): File
    /**
     * Gets a #GFile for `uri`.
     *
     * This operation never fails, but the returned object
     * might not support any I/O operation if the URI
     * is malformed or if the URI scheme is not supported.
     * @virtual
     * @param uri a string containing a URI
     * @returns a #GFile.     Free the returned object with g_object_unref().
     */
    getFileForUri(uri: string): File
    /**
     * Gets a list of URI schemes supported by `vfs`.
     * @virtual
     * @returns a %NULL-terminated array of strings.     The returned array belongs to GIO and must     not be freed or modified.
     */
    getSupportedUriSchemes(): string[]
    /**
     * Checks if the VFS is active.
     * @virtual
     * @returns %TRUE if construction of the @vfs was successful     and it is now active.
     */
    isActive(): boolean
    localFileAddInfo(
      filename: string,
      device: number,
      attributeMatcher: FileAttributeMatcher,
      info: FileInfo,
      cancellable: Cancellable | null,
      extraData: any | null,
      freeExtraData: GLib.DestroyNotify
    ): void
    localFileMoved(source: string, dest: string): void
    localFileRemoved(filename: string): void
    localFileSetAttributes(
      filename: string,
      info: FileInfo,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ): boolean
    /**
     * This operation never fails, but the returned object might
     * not support any I/O operations if the `parse_name` cannot
     * be parsed by the #GVfs module.
     * @virtual
     * @param parseName a string to be parsed by the VFS module.
     * @returns a #GFile for the given @parse_name.     Free the returned object with g_object_unref().
     */
    parseName(parseName: string): File

    // Class property signals of Gio-2.0.Gio.Vfs

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Entry point for using GIO functionality.
   * @class
   */
  class Vfs extends GObject.Object {
    // Own properties of Gio-2.0.Gio.Vfs

    static name: string

    // Constructors of Gio-2.0.Gio.Vfs

    constructor(config?: Vfs.ConstructorProperties)
    _init(config?: Vfs.ConstructorProperties): void
    /**
     * Gets the default #GVfs for the system.
     * @returns a #GVfs, which will be the local     file system #GVfs if no other implementation is available.
     */
    static getDefault(): Vfs
    /**
     * Gets the local #GVfs for the system.
     * @returns a #GVfs.
     */
    static getLocal(): Vfs
  }

  module VolumeMonitor {
    // Signal callback interfaces

    /**
     * Signal callback interface for `drive-changed`
     */
    interface DriveChangedSignalCallback {
      (drive: Drive): void
    }

    /**
     * Signal callback interface for `drive-connected`
     */
    interface DriveConnectedSignalCallback {
      (drive: Drive): void
    }

    /**
     * Signal callback interface for `drive-disconnected`
     */
    interface DriveDisconnectedSignalCallback {
      (drive: Drive): void
    }

    /**
     * Signal callback interface for `drive-eject-button`
     */
    interface DriveEjectButtonSignalCallback {
      (drive: Drive): void
    }

    /**
     * Signal callback interface for `drive-stop-button`
     */
    interface DriveStopButtonSignalCallback {
      (drive: Drive): void
    }

    /**
     * Signal callback interface for `mount-added`
     */
    interface MountAddedSignalCallback {
      (mount: Mount): void
    }

    /**
     * Signal callback interface for `mount-changed`
     */
    interface MountChangedSignalCallback {
      (mount: Mount): void
    }

    /**
     * Signal callback interface for `mount-pre-unmount`
     */
    interface MountPreUnmountSignalCallback {
      (mount: Mount): void
    }

    /**
     * Signal callback interface for `mount-removed`
     */
    interface MountRemovedSignalCallback {
      (mount: Mount): void
    }

    /**
     * Signal callback interface for `volume-added`
     */
    interface VolumeAddedSignalCallback {
      (volume: Volume): void
    }

    /**
     * Signal callback interface for `volume-changed`
     */
    interface VolumeChangedSignalCallback {
      (volume: Volume): void
    }

    /**
     * Signal callback interface for `volume-removed`
     */
    interface VolumeRemovedSignalCallback {
      (volume: Volume): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface VolumeMonitor {
    // Own properties of Gio-2.0.Gio.VolumeMonitor

    __gtype__: number

    // Own fields of Gio-2.0.Gio.VolumeMonitor

    parentInstance: GObject.Object

    // Owm methods of Gio-2.0.Gio.VolumeMonitor

    // Has conflict: getConnectedDrives(): Drive[]
    // Has conflict: getMountForUuid(uuid: string): Mount | null
    // Has conflict: getMounts(): Mount[]
    // Has conflict: getVolumeForUuid(uuid: string): Volume | null
    // Has conflict: getVolumes(): Volume[]

    // Own virtual methods of Gio-2.0.Gio.VolumeMonitor

    driveChanged(drive: Drive): void
    driveConnected(drive: Drive): void
    driveDisconnected(drive: Drive): void
    driveEjectButton(drive: Drive): void
    driveStopButton(drive: Drive): void
    /**
     * Gets a list of drives connected to the system.
     *
     * The returned list should be freed with g_list_free(), after
     * its elements have been unreffed with g_object_unref().
     * @virtual
     * @returns a #GList of connected #GDrive objects.
     */
    getConnectedDrives(): Drive[]
    /**
     * Finds a #GMount object by its UUID (see g_mount_get_uuid())
     * @virtual
     * @param uuid the UUID to look for
     * @returns a #GMount or %NULL if no such mount is available.     Free the returned object with g_object_unref().
     */
    getMountForUuid(uuid: string): Mount | null
    /**
     * Gets a list of the mounts on the system.
     *
     * The returned list should be freed with g_list_free(), after
     * its elements have been unreffed with g_object_unref().
     * @virtual
     * @returns a #GList of #GMount objects.
     */
    getMounts(): Mount[]
    /**
     * Finds a #GVolume object by its UUID (see g_volume_get_uuid())
     * @virtual
     * @param uuid the UUID to look for
     * @returns a #GVolume or %NULL if no such volume is available.     Free the returned object with g_object_unref().
     */
    getVolumeForUuid(uuid: string): Volume | null
    /**
     * Gets a list of the volumes on the system.
     *
     * The returned list should be freed with g_list_free(), after
     * its elements have been unreffed with g_object_unref().
     * @virtual
     * @returns a #GList of #GVolume objects.
     */
    getVolumes(): Volume[]
    mountAdded(mount: Mount): void
    mountChanged(mount: Mount): void
    mountPreUnmount(mount: Mount): void
    mountRemoved(mount: Mount): void
    volumeAdded(volume: Volume): void
    volumeChanged(volume: Volume): void
    volumeRemoved(volume: Volume): void

    // Own signals of Gio-2.0.Gio.VolumeMonitor

    connect(
      sigName: "drive-changed",
      callback: VolumeMonitor.DriveChangedSignalCallback
    ): number
    on(
      sigName: "drive-changed",
      callback: VolumeMonitor.DriveChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drive-changed",
      callback: VolumeMonitor.DriveChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drive-changed",
      callback: VolumeMonitor.DriveChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drive-changed", ...args: any[]): void
    connect(
      sigName: "drive-connected",
      callback: VolumeMonitor.DriveConnectedSignalCallback
    ): number
    on(
      sigName: "drive-connected",
      callback: VolumeMonitor.DriveConnectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drive-connected",
      callback: VolumeMonitor.DriveConnectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drive-connected",
      callback: VolumeMonitor.DriveConnectedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drive-connected", ...args: any[]): void
    connect(
      sigName: "drive-disconnected",
      callback: VolumeMonitor.DriveDisconnectedSignalCallback
    ): number
    on(
      sigName: "drive-disconnected",
      callback: VolumeMonitor.DriveDisconnectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drive-disconnected",
      callback: VolumeMonitor.DriveDisconnectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drive-disconnected",
      callback: VolumeMonitor.DriveDisconnectedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drive-disconnected", ...args: any[]): void
    connect(
      sigName: "drive-eject-button",
      callback: VolumeMonitor.DriveEjectButtonSignalCallback
    ): number
    on(
      sigName: "drive-eject-button",
      callback: VolumeMonitor.DriveEjectButtonSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drive-eject-button",
      callback: VolumeMonitor.DriveEjectButtonSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drive-eject-button",
      callback: VolumeMonitor.DriveEjectButtonSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drive-eject-button", ...args: any[]): void
    connect(
      sigName: "drive-stop-button",
      callback: VolumeMonitor.DriveStopButtonSignalCallback
    ): number
    on(
      sigName: "drive-stop-button",
      callback: VolumeMonitor.DriveStopButtonSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drive-stop-button",
      callback: VolumeMonitor.DriveStopButtonSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drive-stop-button",
      callback: VolumeMonitor.DriveStopButtonSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drive-stop-button", ...args: any[]): void
    connect(
      sigName: "mount-added",
      callback: VolumeMonitor.MountAddedSignalCallback
    ): number
    on(
      sigName: "mount-added",
      callback: VolumeMonitor.MountAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mount-added",
      callback: VolumeMonitor.MountAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mount-added",
      callback: VolumeMonitor.MountAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mount-added", ...args: any[]): void
    connect(
      sigName: "mount-changed",
      callback: VolumeMonitor.MountChangedSignalCallback
    ): number
    on(
      sigName: "mount-changed",
      callback: VolumeMonitor.MountChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mount-changed",
      callback: VolumeMonitor.MountChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mount-changed",
      callback: VolumeMonitor.MountChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mount-changed", ...args: any[]): void
    connect(
      sigName: "mount-pre-unmount",
      callback: VolumeMonitor.MountPreUnmountSignalCallback
    ): number
    on(
      sigName: "mount-pre-unmount",
      callback: VolumeMonitor.MountPreUnmountSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mount-pre-unmount",
      callback: VolumeMonitor.MountPreUnmountSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mount-pre-unmount",
      callback: VolumeMonitor.MountPreUnmountSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mount-pre-unmount", ...args: any[]): void
    connect(
      sigName: "mount-removed",
      callback: VolumeMonitor.MountRemovedSignalCallback
    ): number
    on(
      sigName: "mount-removed",
      callback: VolumeMonitor.MountRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mount-removed",
      callback: VolumeMonitor.MountRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mount-removed",
      callback: VolumeMonitor.MountRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mount-removed", ...args: any[]): void
    connect(
      sigName: "volume-added",
      callback: VolumeMonitor.VolumeAddedSignalCallback
    ): number
    on(
      sigName: "volume-added",
      callback: VolumeMonitor.VolumeAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "volume-added",
      callback: VolumeMonitor.VolumeAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "volume-added",
      callback: VolumeMonitor.VolumeAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "volume-added", ...args: any[]): void
    connect(
      sigName: "volume-changed",
      callback: VolumeMonitor.VolumeChangedSignalCallback
    ): number
    on(
      sigName: "volume-changed",
      callback: VolumeMonitor.VolumeChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "volume-changed",
      callback: VolumeMonitor.VolumeChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "volume-changed",
      callback: VolumeMonitor.VolumeChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "volume-changed", ...args: any[]): void
    connect(
      sigName: "volume-removed",
      callback: VolumeMonitor.VolumeRemovedSignalCallback
    ): number
    on(
      sigName: "volume-removed",
      callback: VolumeMonitor.VolumeRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "volume-removed",
      callback: VolumeMonitor.VolumeRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "volume-removed",
      callback: VolumeMonitor.VolumeRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "volume-removed", ...args: any[]): void

    // Class property signals of Gio-2.0.Gio.VolumeMonitor

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GVolumeMonitor` is for listing the user interesting devices and volumes
   * on the computer. In other words, what a file selector or file manager
   * would show in a sidebar.
   *
   * `GVolumeMonitor` is not
   * thread-default-context aware (see
   * [method`GLib`.MainContext.push_thread_default]), and so should not be used
   * other than from the main thread, with no thread-default-context active.
   *
   * In order to receive updates about volumes and mounts monitored through GVFS,
   * a main loop must be running.
   * @class
   */
  class VolumeMonitor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.VolumeMonitor

    static name: string

    // Constructors of Gio-2.0.Gio.VolumeMonitor

    constructor(config?: VolumeMonitor.ConstructorProperties)
    _init(config?: VolumeMonitor.ConstructorProperties): void
    /**
     * This function should be called by any #GVolumeMonitor
     * implementation when a new #GMount object is created that is not
     * associated with a #GVolume object. It must be called just before
     * emitting the `mount_added` signal.
     *
     * If the return value is not %NULL, the caller must associate the
     * returned #GVolume object with the #GMount. This involves returning
     * it in its g_mount_get_volume() implementation. The caller must
     * also listen for the "removed" signal on the returned object
     * and give up its reference when handling that signal
     *
     * Similarly, if implementing g_volume_monitor_adopt_orphan_mount(),
     * the implementor must take a reference to `mount` and return it in
     * its g_volume_get_mount() implemented. Also, the implementor must
     * listen for the "unmounted" signal on `mount` and give up its
     * reference upon handling that signal.
     *
     * There are two main use cases for this function.
     *
     * One is when implementing a user space file system driver that reads
     * blocks of a block device that is already represented by the native
     * volume monitor (for example a CD Audio file system driver). Such
     * a driver will generate its own #GMount object that needs to be
     * associated with the #GVolume object that represents the volume.
     *
     * The other is for implementing a #GVolumeMonitor whose sole purpose
     * is to return #GVolume objects representing entries in the users
     * "favorite servers" list or similar.
     * @param mount a #GMount object to find a parent for
     * @returns the #GVolume object that is the parent for @mount or %NULL if no wants to adopt the #GMount.
     */
    static adoptOrphanMount(mount: Mount): Volume
    /**
     * Gets the volume monitor used by gio.
     * @returns a reference to the #GVolumeMonitor used by gio. Call    g_object_unref() when done with it.
     */
    static get(): VolumeMonitor
  }

  module ZlibCompressor {
    // Constructor properties interface

    interface ConstructorProperties
      extends Converter.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ZlibCompressor

      /**
       * If set to a non-%NULL #GFileInfo object, and #GZlibCompressor:format is
       * %G_ZLIB_COMPRESSOR_FORMAT_GZIP, the compressor will write the file name
       * and modification time from the file info to the GZIP header.
       */
      file_info?: FileInfo | null
      /**
       * The format of the compressed data.
       */
      format?: ZlibCompressorFormat | null
      /**
       * The level of compression from `0` (no compression) to `9` (most
       * compression). `-1` for the default level.
       */
      level?: number | null
    }
  }

  interface ZlibCompressor extends Converter {
    // Own properties of Gio-2.0.Gio.ZlibCompressor

    /**
     * If set to a non-%NULL #GFileInfo object, and #GZlibCompressor:format is
     * %G_ZLIB_COMPRESSOR_FORMAT_GZIP, the compressor will write the file name
     * and modification time from the file info to the GZIP header.
     */
    fileInfo: FileInfo
    /**
     * The format of the compressed data.
     */
    readonly format: ZlibCompressorFormat
    /**
     * The level of compression from `0` (no compression) to `9` (most
     * compression). `-1` for the default level.
     */
    readonly level: number
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ZlibCompressor

    /**
     * Returns the #GZlibCompressor:file-info property.
     * @returns a #GFileInfo, or %NULL
     */
    getFileInfo(): FileInfo | null
    /**
     * Sets `file_info` in `compressor`. If non-%NULL, and `compressor'`s
     * #GZlibCompressor:format property is %G_ZLIB_COMPRESSOR_FORMAT_GZIP,
     * it will be used to set the file name and modification time in
     * the GZIP header of the compressed data.
     *
     * Note: it is an error to call this function while a compression is in
     * progress; it may only be called immediately after creation of `compressor,`
     * or after resetting it with g_converter_reset().
     * @param fileInfo a #GFileInfo
     */
    setFileInfo(fileInfo: FileInfo | null): void

    // Class property signals of Gio-2.0.Gio.ZlibCompressor

    connect(
      sigName: "notify::file-info",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::file-info",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file-info",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file-info",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file-info", ...args: any[]): void
    connect(
      sigName: "notify::format",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::format",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::format",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::format",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::format", ...args: any[]): void
    connect(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::level", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GZlibCompressor` is an implementation of [iface`Gio`.Converter] that
   * compresses data using zlib.
   * @class
   */
  class ZlibCompressor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ZlibCompressor

    static name: string

    // Constructors of Gio-2.0.Gio.ZlibCompressor

    constructor(config?: ZlibCompressor.ConstructorProperties)
    /**
     * Creates a new #GZlibCompressor.
     * @constructor
     * @param format The format to use for the compressed data
     * @param level compression level (0-9), -1 for default
     * @returns a new #GZlibCompressor
     */
    constructor(format: ZlibCompressorFormat, level: number)
    /**
     * Creates a new #GZlibCompressor.
     * @constructor
     * @param format The format to use for the compressed data
     * @param level compression level (0-9), -1 for default
     * @returns a new #GZlibCompressor
     */
    static new(format: ZlibCompressorFormat, level: number): ZlibCompressor
    _init(config?: ZlibCompressor.ConstructorProperties): void
  }

  module ZlibDecompressor {
    // Constructor properties interface

    interface ConstructorProperties
      extends Converter.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gio-2.0.Gio.ZlibDecompressor

      /**
       * The format of the compressed data.
       */
      format?: ZlibCompressorFormat | null
    }
  }

  interface ZlibDecompressor extends Converter {
    // Own properties of Gio-2.0.Gio.ZlibDecompressor

    /**
     * A #GFileInfo containing the information found in the GZIP header
     * of the data stream processed, or %NULL if the header was not yet
     * fully processed, is not present at all, or the compressor's
     * #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP.
     */
    readonly fileInfo: FileInfo
    /**
     * The format of the compressed data.
     */
    readonly format: ZlibCompressorFormat
    __gtype__: number

    // Owm methods of Gio-2.0.Gio.ZlibDecompressor

    /**
     * Retrieves the #GFileInfo constructed from the GZIP header data
     * of compressed data processed by `compressor,` or %NULL if `decompressor'`s
     * #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP,
     * or the header data was not fully processed yet, or it not present in the
     * data stream at all.
     * @returns a #GFileInfo, or %NULL
     */
    getFileInfo(): FileInfo | null

    // Class property signals of Gio-2.0.Gio.ZlibDecompressor

    connect(
      sigName: "notify::file-info",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::file-info",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file-info",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file-info",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file-info", ...args: any[]): void
    connect(
      sigName: "notify::format",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::format",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::format",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::format",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::format", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GZlibDecompressor` is an implementation of [iface`Gio`.Converter] that
   * decompresses data compressed with zlib.
   * @class
   */
  class ZlibDecompressor extends GObject.Object {
    // Own properties of Gio-2.0.Gio.ZlibDecompressor

    static name: string

    // Constructors of Gio-2.0.Gio.ZlibDecompressor

    constructor(config?: ZlibDecompressor.ConstructorProperties)
    /**
     * Creates a new #GZlibDecompressor.
     * @constructor
     * @param format The format to use for the compressed data
     * @returns a new #GZlibDecompressor
     */
    constructor(format: ZlibCompressorFormat)
    /**
     * Creates a new #GZlibDecompressor.
     * @constructor
     * @param format The format to use for the compressed data
     * @returns a new #GZlibDecompressor
     */
    static new(format: ZlibCompressorFormat): ZlibDecompressor
    _init(config?: ZlibDecompressor.ConstructorProperties): void
  }

  interface ActionEntry {
    // Own fields of Gio-2.0.Gio.ActionEntry

    /**
     * the name of the action
     * @field
     */
    name: string
    /**
     * the callback to connect to the "activate" signal of the
     *            action.  Since GLib 2.40, this can be %NULL for stateful
     *            actions, in which case the default handler is used.  For
     *            boolean-stated actions with no parameter, this is a
     *            toggle.  For other state types (and parameter type equal
     *            to the state type) this will be a function that
     *            just calls `change_state` (which you should provide).
     * @field
     */
    activate: (action: SimpleAction, parameter: GLib.Variant) => void
    /**
     * the type of the parameter that must be passed to the
     *                  activate function for this action, given as a single
     *                  GVariant type string (or %NULL for no parameter)
     * @field
     */
    parameterType: string
    /**
     * the initial state for this action, given in
     *         [GVariant text format][gvariant-text].  The state is parsed
     *         with no extra type information, so type tags must be added to
     *         the string if they are necessary.  Stateless actions should
     *         give %NULL here.
     * @field
     */
    state: string
    /**
     * the callback to connect to the "change-state" signal
     *                of the action.  All stateful actions should provide a
     *                handler here; stateless actions should not.
     * @field
     */
    changeState: (action: SimpleAction, value: GLib.Variant) => void
  }

  /**
   * This struct defines a single action.  It is for use with
   * g_action_map_add_action_entries().
   *
   * The order of the items in the structure are intended to reflect
   * frequency of use.  It is permissible to use an incomplete initialiser
   * in order to leave some of the later values as %NULL.  All values
   * after `name` are optional.  Additional optional fields may be added in
   * the future.
   *
   * See g_action_map_add_action_entries() for an example.
   * @record
   */
  class ActionEntry {
    // Own properties of Gio-2.0.Gio.ActionEntry

    static name: string
  }

  interface ActionGroupInterface {
    // Own fields of Gio-2.0.Gio.ActionGroupInterface

    gIface: GObject.TypeInterface
    /**
     * the virtual function pointer for g_action_group_has_action()
     * @field
     */
    hasAction: (actionGroup: ActionGroup, actionName: string) => boolean
    /**
     * the virtual function pointer for g_action_group_list_actions()
     * @field
     */
    listActions: (actionGroup: ActionGroup) => string[]
    /**
     * the virtual function pointer for g_action_group_get_action_enabled()
     * @field
     */
    getActionEnabled: (actionGroup: ActionGroup, actionName: string) => boolean
    /**
     * the virtual function pointer for g_action_group_get_action_parameter_type()
     * @field
     */
    getActionParameterType: (
      actionGroup: ActionGroup,
      actionName: string
    ) => GLib.VariantType | null
    /**
     * the virtual function pointer for g_action_group_get_action_state_type()
     * @field
     */
    getActionStateType: (
      actionGroup: ActionGroup,
      actionName: string
    ) => GLib.VariantType | null
    /**
     * the virtual function pointer for g_action_group_get_action_state_hint()
     * @field
     */
    getActionStateHint: (
      actionGroup: ActionGroup,
      actionName: string
    ) => GLib.Variant | null
    /**
     * the virtual function pointer for g_action_group_get_action_state()
     * @field
     */
    getActionState: (
      actionGroup: ActionGroup,
      actionName: string
    ) => GLib.Variant | null
    /**
     * the virtual function pointer for g_action_group_change_action_state()
     * @field
     */
    changeActionState: (
      actionGroup: ActionGroup,
      actionName: string,
      value: GLib.Variant
    ) => void
    /**
     * the virtual function pointer for g_action_group_activate_action()
     * @field
     */
    activateAction: (
      actionGroup: ActionGroup,
      actionName: string,
      parameter: GLib.Variant | null
    ) => void
    /**
     * the class closure for the #GActionGroup::action-added signal
     * @field
     */
    actionAdded: (actionGroup: ActionGroup, actionName: string) => void
    /**
     * the class closure for the #GActionGroup::action-removed signal
     * @field
     */
    actionRemoved: (actionGroup: ActionGroup, actionName: string) => void
    /**
     * the class closure for the #GActionGroup::action-enabled-changed signal
     * @field
     */
    actionEnabledChanged: (
      actionGroup: ActionGroup,
      actionName: string,
      enabled: boolean
    ) => void
    /**
     * the class closure for the #GActionGroup::action-enabled-changed signal
     * @field
     */
    actionStateChanged: (
      actionGroup: ActionGroup,
      actionName: string,
      state: GLib.Variant
    ) => void
    /**
     * the virtual function pointer for g_action_group_query_action()
     * @field
     */
    queryAction: (
      actionGroup: ActionGroup,
      actionName: string
    ) => [
      /* returnType */ boolean,
      /* enabled */ boolean,
      /* parameterType */ GLib.VariantType,
      /* stateType */ GLib.VariantType,
      /* stateHint */ GLib.Variant,
      /* state */ GLib.Variant,
    ]
  }

  /**
   * The virtual function table for #GActionGroup.
   * @record
   */
  abstract class ActionGroupInterface {
    // Own properties of Gio-2.0.Gio.ActionGroupInterface

    static name: string
  }

  interface ActionInterface {
    // Own fields of Gio-2.0.Gio.ActionInterface

    gIface: GObject.TypeInterface
    /**
     * the virtual function pointer for g_action_get_name()
     * @field
     */
    getName: (action: Action) => string
    /**
     * the virtual function pointer for g_action_get_parameter_type()
     * @field
     */
    getParameterType: (action: Action) => GLib.VariantType | null
    /**
     * the virtual function pointer for g_action_get_state_type()
     * @field
     */
    getStateType: (action: Action) => GLib.VariantType | null
    /**
     * the virtual function pointer for g_action_get_state_hint()
     * @field
     */
    getStateHint: (action: Action) => GLib.Variant | null
    /**
     * the virtual function pointer for g_action_get_enabled()
     * @field
     */
    getEnabled: (action: Action) => boolean
    /**
     * the virtual function pointer for g_action_get_state()
     * @field
     */
    getState: (action: Action) => GLib.Variant | null
    /**
     * the virtual function pointer for g_action_change_state()
     * @field
     */
    changeState: (action: Action, value: GLib.Variant) => void
    /**
     * the virtual function pointer for g_action_activate().  Note that #GAction does not have an
     *            'activate' signal but that implementations of it may have one.
     * @field
     */
    activate: (action: Action, parameter: GLib.Variant | null) => void
  }

  /**
   * The virtual function table for #GAction.
   * @record
   */
  abstract class ActionInterface {
    // Own properties of Gio-2.0.Gio.ActionInterface

    static name: string
  }

  interface ActionMapInterface {
    // Own fields of Gio-2.0.Gio.ActionMapInterface

    gIface: GObject.TypeInterface
    /**
     * the virtual function pointer for g_action_map_lookup_action()
     * @field
     */
    lookupAction: (actionMap: ActionMap, actionName: string) => Action | null
    /**
     * the virtual function pointer for g_action_map_add_action()
     * @field
     */
    addAction: (actionMap: ActionMap, action: Action) => void
    /**
     * the virtual function pointer for g_action_map_remove_action()
     * @field
     */
    removeAction: (actionMap: ActionMap, actionName: string) => void
  }

  /**
   * The virtual function table for #GActionMap.
   * @record
   */
  abstract class ActionMapInterface {
    // Own properties of Gio-2.0.Gio.ActionMapInterface

    static name: string
  }

  interface AppInfoIface {
    // Own fields of Gio-2.0.Gio.AppInfoIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Copies a #GAppInfo.
     * @field
     */
    dup: (appinfo: AppInfo) => AppInfo
    /**
     * Checks two #GAppInfos for equality.
     * @field
     */
    equal: (appinfo1: AppInfo, appinfo2: AppInfo) => boolean
    /**
     * Gets a string identifier for a #GAppInfo.
     * @field
     */
    getId: (appinfo: AppInfo) => string | null
    /**
     * Gets the name of the application for a #GAppInfo.
     * @field
     */
    getName: (appinfo: AppInfo) => string
    /**
     * Gets a short description for the application described by the #GAppInfo.
     * @field
     */
    getDescription: (appinfo: AppInfo) => string | null
    /**
     * Gets the executable name for the #GAppInfo.
     * @field
     */
    getExecutable: (appinfo: AppInfo) => string
    /**
     * Gets the #GIcon for the #GAppInfo.
     * @field
     */
    getIcon: (appinfo: AppInfo) => Icon | null
    /**
     * Launches an application specified by the #GAppInfo.
     * @field
     */
    launch: (
      appinfo: AppInfo,
      files: File[] | null,
      context: AppLaunchContext | null
    ) => boolean
    /**
     * Indicates whether the application specified supports launching URIs.
     * @field
     */
    supportsUris: (appinfo: AppInfo) => boolean
    /**
     * Indicates whether the application specified accepts filename arguments.
     * @field
     */
    supportsFiles: (appinfo: AppInfo) => boolean
    /**
     * Launches an application with a list of URIs.
     * @field
     */
    launchUris: (
      appinfo: AppInfo,
      uris: string[] | null,
      context: AppLaunchContext | null
    ) => boolean
    /**
     * Returns whether an application should be shown (e.g. when getting a list of installed applications).
     * [FreeDesktop.Org Startup Notification Specification](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt).
     * @field
     */
    shouldShow: (appinfo: AppInfo) => boolean
    /**
     * Sets an application as default for a given content type.
     * @field
     */
    setAsDefaultForType: (appinfo: AppInfo, contentType: string) => boolean
    /**
     * Sets an application as default for a given file extension.
     * @field
     */
    setAsDefaultForExtension: (appinfo: AppInfo, extension: string) => boolean
    /**
     * Adds to the #GAppInfo information about supported file types.
     * @field
     */
    addSupportsType: (appinfo: AppInfo, contentType: string) => boolean
    /**
     * Checks for support for removing supported file types from a #GAppInfo.
     * @field
     */
    canRemoveSupportsType: (appinfo: AppInfo) => boolean
    /**
     * Removes a supported application type from a #GAppInfo.
     * @field
     */
    removeSupportsType: (appinfo: AppInfo, contentType: string) => boolean
    /**
     * Checks if a #GAppInfo can be deleted. Since 2.20
     * @field
     */
    canDelete: (appinfo: AppInfo) => boolean
    /**
     * Deletes a #GAppInfo. Since 2.20
     * @field
     */
    doDelete: (appinfo: AppInfo) => boolean
    /**
     * Gets the commandline for the #GAppInfo. Since 2.20
     * @field
     */
    getCommandline: (appinfo: AppInfo) => string | null
    /**
     * Gets the display name for the #GAppInfo. Since 2.24
     * @field
     */
    getDisplayName: (appinfo: AppInfo) => string
    /**
     * Sets the application as the last used. See g_app_info_set_as_last_used_for_type().
     * @field
     */
    setAsLastUsedForType: (appinfo: AppInfo, contentType: string) => boolean
    /**
     * Retrieves the list of content types that `app_info` claims to support.
     * @field
     */
    getSupportedTypes: (appinfo: AppInfo) => string[]
    /**
     * Asynchronously launches an application with a list of URIs. (Since: 2.60)
     * @field
     */
    launchUrisAsync: (
      appinfo: AppInfo,
      uris: string[] | null,
      context: AppLaunchContext | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an operation started with `launch_uris_async`. (Since: 2.60)
     * @field
     */
    launchUrisFinish: (appinfo: AppInfo, result: AsyncResult) => boolean
  }

  /**
   * Application Information interface, for operating system portability.
   * @record
   */
  abstract class AppInfoIface {
    // Own properties of Gio-2.0.Gio.AppInfoIface

    static name: string
  }

  interface AppLaunchContextClass {
    // Own fields of Gio-2.0.Gio.AppLaunchContextClass

    parentClass: GObject.ObjectClass
    getDisplay: (
      context: AppLaunchContext,
      info: AppInfo,
      files: File[]
    ) => string | null
    getStartupNotifyId: (
      context: AppLaunchContext,
      info: AppInfo,
      files: File[]
    ) => string | null
    launchFailed: (context: AppLaunchContext, startupNotifyId: string) => void
    launched: (
      context: AppLaunchContext,
      info: AppInfo,
      platformData: GLib.Variant
    ) => void
    launchStarted: (
      context: AppLaunchContext,
      info: AppInfo,
      platformData: GLib.Variant
    ) => void
  }

  abstract class AppLaunchContextClass {
    // Own properties of Gio-2.0.Gio.AppLaunchContextClass

    static name: string
  }

  interface AppLaunchContextPrivate {}

  class AppLaunchContextPrivate {
    // Own properties of Gio-2.0.Gio.AppLaunchContextPrivate

    static name: string
  }

  interface ApplicationClass {
    // Own fields of Gio-2.0.Gio.ApplicationClass

    /**
     * invoked on the primary instance immediately after registration
     * @field
     */
    startup: (application: Application) => void
    /**
     * invoked on the primary instance when an activation occurs
     * @field
     */
    activate: (application: Application) => void
    /**
     * invoked on the primary instance when there are files to open
     * @field
     */
    open: (application: Application, files: File[], hint: string) => void
    /**
     * invoked on the primary instance when a command-line is
     *   not handled locally
     * @field
     */
    commandLine: (
      application: Application,
      commandLine: ApplicationCommandLine
    ) => number
    /**
     * invoked (locally). The virtual function has the chance
     *     to inspect (and possibly replace) command line arguments. See
     *     g_application_run() for more information. Also see the
     *     #GApplication::handle-local-options signal, which is a simpler
     *     alternative to handling some commandline options locally
     * @field
     */
    localCommandLine: (
      application: Application,
      arguments_: string[]
    ) => [
      /* returnType */ boolean,
      /* arguments_ */ string[],
      /* exitStatus */ number,
    ]
    /**
     * invoked on the primary instance before 'activate', 'open',
     *     'command-line' or any action invocation, gets the 'platform data' from
     *     the calling instance
     * @field
     */
    beforeEmit: (application: Application, platformData: GLib.Variant) => void
    /**
     * invoked on the primary instance after 'activate', 'open',
     *     'command-line' or any action invocation, gets the 'platform data' from
     *     the calling instance
     * @field
     */
    afterEmit: (application: Application, platformData: GLib.Variant) => void
    /**
     * invoked (locally) to add 'platform data' to be sent to
     *     the primary instance when activating, opening or invoking actions
     * @field
     */
    addPlatformData: (
      application: Application,
      builder: GLib.VariantBuilder
    ) => void
    /**
     * Used to be invoked on the primary instance when the use
     *     count of the application drops to zero (and after any inactivity
     *     timeout, if requested). Not used anymore since 2.32
     * @field
     */
    quitMainloop: (application: Application) => void
    /**
     * Used to be invoked on the primary instance from
     *     g_application_run() if the use-count is non-zero. Since 2.32,
     *     GApplication is iterating the main context directly and is not
     *     using `run_mainloop` anymore
     * @field
     */
    runMainloop: (application: Application) => void
    /**
     * invoked only on the registered primary instance immediately
     *      after the main loop terminates
     * @field
     */
    shutdown: (application: Application) => void
    /**
     * invoked locally during registration, if the application is
     *     using its D-Bus backend. You can use this to export extra objects on the
     *     bus, that need to exist before the application tries to own the bus name.
     *     The function is passed the #GDBusConnection to to session bus, and the
     *     object path that #GApplication will use to export its D-Bus API.
     *     If this function returns %TRUE, registration will proceed; otherwise
     *     registration will abort. Since: 2.34
     * @field
     */
    dbusRegister: (
      application: Application,
      connection: DBusConnection,
      objectPath: string
    ) => boolean
    /**
     * invoked locally during unregistration, if the application
     *     is using its D-Bus backend. Use this to undo anything done by
     *     the `dbus_register` vfunc. Since: 2.34
     * @field
     */
    dbusUnregister: (
      application: Application,
      connection: DBusConnection,
      objectPath: string
    ) => void
    /**
     * invoked locally after the parsing of the commandline
     *  options has occurred. Since: 2.40
     * @field
     */
    handleLocalOptions: (
      application: Application,
      options: GLib.VariantDict
    ) => number
    /**
     * invoked when another instance is taking over the name. Since: 2.60
     * @field
     */
    nameLost: (application: Application) => boolean
  }

  /**
   * Virtual function table for #GApplication.
   * @record
   */
  abstract class ApplicationClass {
    // Own properties of Gio-2.0.Gio.ApplicationClass

    static name: string
  }

  interface ApplicationCommandLineClass {
    // Own fields of Gio-2.0.Gio.ApplicationCommandLineClass

    printLiteral: (cmdline: ApplicationCommandLine, message: string) => void
    printerrLiteral: (cmdline: ApplicationCommandLine, message: string) => void
    getStdin: (cmdline: ApplicationCommandLine) => InputStream | null
    done: (cmdline: ApplicationCommandLine) => void
  }

  /**
   * The #GApplicationCommandLineClass-struct
   * contains private data only.
   * @record
   */
  abstract class ApplicationCommandLineClass {
    // Own properties of Gio-2.0.Gio.ApplicationCommandLineClass

    static name: string
  }

  interface ApplicationCommandLinePrivate {}

  class ApplicationCommandLinePrivate {
    // Own properties of Gio-2.0.Gio.ApplicationCommandLinePrivate

    static name: string
  }

  interface ApplicationPrivate {}

  class ApplicationPrivate {
    // Own properties of Gio-2.0.Gio.ApplicationPrivate

    static name: string
  }

  interface AsyncInitableIface {
    // Own fields of Gio-2.0.Gio.AsyncInitableIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Starts initialization of the object.
     * @field
     */
    initAsync: (
      initable: AsyncInitable,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes initialization of the object.
     * @field
     */
    initFinish: (initable: AsyncInitable, res: AsyncResult) => boolean
  }

  /**
   * Provides an interface for asynchronous initializing object such that
   * initialization may fail.
   * @record
   */
  abstract class AsyncInitableIface {
    // Own properties of Gio-2.0.Gio.AsyncInitableIface

    static name: string
  }

  interface AsyncResultIface {
    // Own fields of Gio-2.0.Gio.AsyncResultIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Gets the user data passed to the callback.
     * @field
     */
    getUserData: (res: AsyncResult) => any | null
    /**
     * Gets the source object that issued the asynchronous operation.
     * @field
     */
    getSourceObject: (res: AsyncResult) => GObject.Object | null
    /**
     * Checks if a result is tagged with a particular source.
     * @field
     */
    isTagged: (res: AsyncResult, sourceTag: any | null) => boolean
  }

  /**
   * Interface definition for #GAsyncResult.
   * @record
   */
  abstract class AsyncResultIface {
    // Own properties of Gio-2.0.Gio.AsyncResultIface

    static name: string
  }

  interface BufferedInputStreamClass {
    // Own fields of Gio-2.0.Gio.BufferedInputStreamClass

    parentClass: FilterInputStreamClass
    fill: (
      stream: BufferedInputStream,
      count: number,
      cancellable: Cancellable | null
    ) => number
    fillAsync: (
      stream: BufferedInputStream,
      count: number,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    fillFinish: (stream: BufferedInputStream, result: AsyncResult) => number
  }

  abstract class BufferedInputStreamClass {
    // Own properties of Gio-2.0.Gio.BufferedInputStreamClass

    static name: string
  }

  interface BufferedInputStreamPrivate {}

  class BufferedInputStreamPrivate {
    // Own properties of Gio-2.0.Gio.BufferedInputStreamPrivate

    static name: string
  }

  interface BufferedOutputStreamClass {
    // Own fields of Gio-2.0.Gio.BufferedOutputStreamClass

    parentClass: FilterOutputStreamClass
  }

  abstract class BufferedOutputStreamClass {
    // Own properties of Gio-2.0.Gio.BufferedOutputStreamClass

    static name: string
  }

  interface BufferedOutputStreamPrivate {}

  class BufferedOutputStreamPrivate {
    // Own properties of Gio-2.0.Gio.BufferedOutputStreamPrivate

    static name: string
  }

  interface CancellableClass {
    // Own fields of Gio-2.0.Gio.CancellableClass

    parentClass: GObject.ObjectClass
    cancelled: (cancellable: Cancellable | null) => void
  }

  abstract class CancellableClass {
    // Own properties of Gio-2.0.Gio.CancellableClass

    static name: string
  }

  interface CancellablePrivate {}

  class CancellablePrivate {
    // Own properties of Gio-2.0.Gio.CancellablePrivate

    static name: string
  }

  interface CharsetConverterClass {
    // Own fields of Gio-2.0.Gio.CharsetConverterClass

    parentClass: GObject.ObjectClass
  }

  abstract class CharsetConverterClass {
    // Own properties of Gio-2.0.Gio.CharsetConverterClass

    static name: string
  }

  interface ConverterIface {
    // Own fields of Gio-2.0.Gio.ConverterIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Converts data.
     * @field
     */
    convert: (
      converter: Converter,
      inbuf: number[] | null,
      outbuf: number[],
      flags: ConverterFlags
    ) => [
      /* returnType */ ConverterResult,
      /* bytesRead */ number,
      /* bytesWritten */ number,
    ]
    /**
     * Reverts the internal state of the converter to its initial state.
     * @field
     */
    reset: (converter: Converter) => void
  }

  /**
   * Provides an interface for converting data from one type
   * to another type. The conversion can be stateful
   * and may fail at any place.
   * @record
   */
  abstract class ConverterIface {
    // Own properties of Gio-2.0.Gio.ConverterIface

    static name: string
  }

  interface ConverterInputStreamClass {
    // Own fields of Gio-2.0.Gio.ConverterInputStreamClass

    parentClass: FilterInputStreamClass
  }

  abstract class ConverterInputStreamClass {
    // Own properties of Gio-2.0.Gio.ConverterInputStreamClass

    static name: string
  }

  interface ConverterInputStreamPrivate {}

  class ConverterInputStreamPrivate {
    // Own properties of Gio-2.0.Gio.ConverterInputStreamPrivate

    static name: string
  }

  interface ConverterOutputStreamClass {
    // Own fields of Gio-2.0.Gio.ConverterOutputStreamClass

    parentClass: FilterOutputStreamClass
  }

  abstract class ConverterOutputStreamClass {
    // Own properties of Gio-2.0.Gio.ConverterOutputStreamClass

    static name: string
  }

  interface ConverterOutputStreamPrivate {}

  class ConverterOutputStreamPrivate {
    // Own properties of Gio-2.0.Gio.ConverterOutputStreamPrivate

    static name: string
  }

  interface CredentialsClass {}

  /**
   * Class structure for #GCredentials.
   * @record
   */
  abstract class CredentialsClass {
    // Own properties of Gio-2.0.Gio.CredentialsClass

    static name: string
  }

  interface DBusAnnotationInfo {
    // Own fields of Gio-2.0.Gio.DBusAnnotationInfo

    /**
     * The reference count or -1 if statically allocated.
     * @field
     */
    refCount: number
    /**
     * The name of the annotation, e.g. "org.freedesktop.DBus.Deprecated".
     * @field
     */
    key: string | null
    /**
     * The value of the annotation.
     * @field
     */
    value: string | null
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
     * @field
     */
    annotations: DBusAnnotationInfo[]

    // Owm methods of Gio-2.0.Gio.DBusAnnotationInfo

    /**
     * If `info` is statically allocated does nothing. Otherwise increases
     * the reference count.
     * @returns The same @info.
     */
    ref(): DBusAnnotationInfo
    /**
     * If `info` is statically allocated, does nothing. Otherwise decreases
     * the reference count of `info`. When its reference count drops to 0,
     * the memory used is freed.
     */
    unref(): void
  }

  /**
   * Information about an annotation.
   * @record
   */
  class DBusAnnotationInfo {
    // Own properties of Gio-2.0.Gio.DBusAnnotationInfo

    static name: string

    // Constructors of Gio-2.0.Gio.DBusAnnotationInfo

    /**
     * Looks up the value of an annotation.
     *
     * The cost of this function is O(n) in number of annotations.
     * @param annotations A %NULL-terminated array of annotations or %NULL.
     * @param name The name of the annotation to look up.
     * @returns The value or %NULL if not found. Do not free, it is owned by @annotations.
     */
    static lookup(
      annotations: DBusAnnotationInfo[] | null,
      name: string
    ): string | null
  }

  interface DBusArgInfo {
    // Own fields of Gio-2.0.Gio.DBusArgInfo

    /**
     * The reference count or -1 if statically allocated.
     * @field
     */
    refCount: number
    /**
     * Name of the argument, e.g. `unix_user_id`.
     * @field
     */
    name: string | null
    /**
     * D-Bus signature of the argument (a single complete type).
     * @field
     */
    signature: string | null
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
     * @field
     */
    annotations: DBusAnnotationInfo[]

    // Owm methods of Gio-2.0.Gio.DBusArgInfo

    /**
     * If `info` is statically allocated does nothing. Otherwise increases
     * the reference count.
     * @returns The same @info.
     */
    ref(): DBusArgInfo
    /**
     * If `info` is statically allocated, does nothing. Otherwise decreases
     * the reference count of `info`. When its reference count drops to 0,
     * the memory used is freed.
     */
    unref(): void
  }

  /**
   * Information about an argument for a method or a signal.
   * @record
   */
  class DBusArgInfo {
    // Own properties of Gio-2.0.Gio.DBusArgInfo

    static name: string
  }

  interface DBusErrorEntry {
    // Own fields of Gio-2.0.Gio.DBusErrorEntry

    /**
     * An error code.
     * @field
     */
    errorCode: number
    /**
     * The D-Bus error name to associate with `error_code`.
     * @field
     */
    dbusErrorName: string
  }

  /**
   * Struct used in g_dbus_error_register_error_domain().
   * @record
   */
  class DBusErrorEntry {
    // Own properties of Gio-2.0.Gio.DBusErrorEntry

    static name: string
  }

  interface DBusInterfaceIface {
    // Own fields of Gio-2.0.Gio.DBusInterfaceIface

    /**
     * The parent interface.
     * @field
     */
    parentIface: GObject.TypeInterface
    /**
     * Returns a #GDBusInterfaceInfo. See g_dbus_interface_get_info().
     * @field
     */
    getInfo: (interface: DBusInterface) => DBusInterfaceInfo
    /**
     * Gets the enclosing #GDBusObject. See g_dbus_interface_get_object().
     * @field
     */
    getObject: (interface: DBusInterface) => DBusObject | null
    /**
     * Sets the enclosing #GDBusObject. See g_dbus_interface_set_object().
     * @field
     */
    setObject: (interface: DBusInterface, object: DBusObject | null) => void
    /**
     * Gets a reference to the enclosing #GDBusObject. See g_dbus_interface_dup_object(). Added in 2.32.
     * @field
     */
    dupObject: (interface: DBusInterface) => DBusObject | null
  }

  /**
   * Base type for D-Bus interfaces.
   * @record
   */
  abstract class DBusInterfaceIface {
    // Own properties of Gio-2.0.Gio.DBusInterfaceIface

    static name: string
  }

  interface DBusInterfaceInfo {
    // Own fields of Gio-2.0.Gio.DBusInterfaceInfo

    /**
     * The reference count or -1 if statically allocated.
     * @field
     */
    refCount: number
    /**
     * The name of the D-Bus interface, e.g. "org.freedesktop.DBus.Properties".
     * @field
     */
    name: string | null
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusMethodInfo structures or %NULL if there are no methods.
     * @field
     */
    methods: DBusMethodInfo[]
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusSignalInfo structures or %NULL if there are no signals.
     * @field
     */
    signals: DBusSignalInfo[]
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusPropertyInfo structures or %NULL if there are no properties.
     * @field
     */
    properties: DBusPropertyInfo[]
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
     * @field
     */
    annotations: DBusAnnotationInfo[]

    // Owm methods of Gio-2.0.Gio.DBusInterfaceInfo

    /**
     * Builds a lookup-cache to speed up
     * g_dbus_interface_info_lookup_method(),
     * g_dbus_interface_info_lookup_signal() and
     * g_dbus_interface_info_lookup_property().
     *
     * If this has already been called with `info,` the existing cache is
     * used and its use count is increased.
     *
     * Note that `info` cannot be modified until
     * g_dbus_interface_info_cache_release() is called.
     */
    cacheBuild(): void
    /**
     * Decrements the usage count for the cache for `info` built by
     * g_dbus_interface_info_cache_build() (if any) and frees the
     * resources used by the cache if the usage count drops to zero.
     */
    cacheRelease(): void
    /**
     * Appends an XML representation of `info` (and its children) to `string_builder`.
     *
     * This function is typically used for generating introspection XML
     * documents at run-time for handling the
     * `org.freedesktop.DBus.Introspectable.Introspect`
     * method.
     * @param indent Indentation level.
     * @param stringBuilder A #GString to to append XML data to.
     */
    generateXml(indent: number, stringBuilder: GLib.String): void
    /**
     * Looks up information about a method.
     *
     * The cost of this function is O(n) in number of methods unless
     * g_dbus_interface_info_cache_build() has been used on `info`.
     * @param name A D-Bus method name (typically in CamelCase)
     * @returns A #GDBusMethodInfo or %NULL if not found. Do not free, it is owned by @info.
     */
    lookupMethod(name: string): DBusMethodInfo | null
    /**
     * Looks up information about a property.
     *
     * The cost of this function is O(n) in number of properties unless
     * g_dbus_interface_info_cache_build() has been used on `info`.
     * @param name A D-Bus property name (typically in CamelCase).
     * @returns A #GDBusPropertyInfo or %NULL if not found. Do not free, it is owned by @info.
     */
    lookupProperty(name: string): DBusPropertyInfo | null
    /**
     * Looks up information about a signal.
     *
     * The cost of this function is O(n) in number of signals unless
     * g_dbus_interface_info_cache_build() has been used on `info`.
     * @param name A D-Bus signal name (typically in CamelCase)
     * @returns A #GDBusSignalInfo or %NULL if not found. Do not free, it is owned by @info.
     */
    lookupSignal(name: string): DBusSignalInfo | null
    /**
     * If `info` is statically allocated does nothing. Otherwise increases
     * the reference count.
     * @returns The same @info.
     */
    ref(): DBusInterfaceInfo
    /**
     * If `info` is statically allocated, does nothing. Otherwise decreases
     * the reference count of `info`. When its reference count drops to 0,
     * the memory used is freed.
     */
    unref(): void
  }

  /**
   * Information about a D-Bus interface.
   * @record
   */
  class DBusInterfaceInfo {
    // Own properties of Gio-2.0.Gio.DBusInterfaceInfo

    static name: string
  }

  interface DBusInterfaceSkeletonClass {
    // Own fields of Gio-2.0.Gio.DBusInterfaceSkeletonClass

    /**
     * The parent class.
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * Returns a #GDBusInterfaceInfo. See g_dbus_interface_skeleton_get_info() for details.
     * @field
     */
    getInfo: (interface: DBusInterfaceSkeleton) => DBusInterfaceInfo
    /**
     * Returns a #GDBusInterfaceVTable. See g_dbus_interface_skeleton_get_vtable() for details.
     * @field
     */
    getVtable: (interface: DBusInterfaceSkeleton) => DBusInterfaceVTable
    /**
     * Returns a #GVariant with all properties. See g_dbus_interface_skeleton_get_properties().
     * @field
     */
    getProperties: (interface: DBusInterfaceSkeleton) => GLib.Variant
    /**
     * Emits outstanding changes, if any. See g_dbus_interface_skeleton_flush().
     * @field
     */
    flush: (interface: DBusInterfaceSkeleton) => void
    /**
     * Signal class handler for the #GDBusInterfaceSkeleton::g-authorize-method signal.
     * @field
     */
    gAuthorizeMethod: (
      interface: DBusInterfaceSkeleton,
      invocation: DBusMethodInvocation
    ) => boolean
  }

  /**
   * Class structure for #GDBusInterfaceSkeleton.
   * @record
   */
  abstract class DBusInterfaceSkeletonClass {
    // Own properties of Gio-2.0.Gio.DBusInterfaceSkeletonClass

    static name: string
  }

  interface DBusInterfaceSkeletonPrivate {}

  class DBusInterfaceSkeletonPrivate {
    // Own properties of Gio-2.0.Gio.DBusInterfaceSkeletonPrivate

    static name: string
  }

  interface DBusInterfaceVTable {
    // Own fields of Gio-2.0.Gio.DBusInterfaceVTable

    /**
     * Function for handling incoming method calls.
     * @field
     */
    methodCall: DBusInterfaceMethodCallFunc
    /**
     * Function for getting a property.
     * @field
     */
    getProperty: DBusInterfaceGetPropertyFunc
    /**
     * Function for setting a property.
     * @field
     */
    setProperty: DBusInterfaceSetPropertyFunc
  }

  /**
   * Virtual table for handling properties and method calls for a D-Bus
   * interface.
   *
   * Since 2.38, if you want to handle getting/setting D-Bus properties
   * asynchronously, give %NULL as your get_property() or set_property()
   * function. The D-Bus call will be directed to your `method_call` function,
   * with the provided `interface_name` set to "org.freedesktop.DBus.Properties".
   *
   * Ownership of the #GDBusMethodInvocation object passed to the
   * method_call() function is transferred to your handler; you must
   * call one of the methods of #GDBusMethodInvocation to return a reply
   * (possibly empty), or an error. These functions also take ownership
   * of the passed-in invocation object, so unless the invocation
   * object has otherwise been referenced, it will be then be freed.
   * Calling one of these functions may be done within your
   * method_call() implementation but it also can be done at a later
   * point to handle the method asynchronously.
   *
   * The usual checks on the validity of the calls is performed. For
   * `Get` calls, an error is automatically returned if the property does
   * not exist or the permissions do not allow access. The same checks are
   * performed for `Set` calls, and the provided value is also checked for
   * being the correct type.
   *
   * For both `Get` and `Set` calls, the #GDBusMethodInvocation
   * passed to the `method_call` handler can be queried with
   * g_dbus_method_invocation_get_property_info() to get a pointer
   * to the #GDBusPropertyInfo of the property.
   *
   * If you have readable properties specified in your interface info,
   * you must ensure that you either provide a non-%NULL `get_property(`)
   * function or provide implementations of both the `Get` and `GetAll`
   * methods on org.freedesktop.DBus.Properties interface in your `method_call`
   * function. Note that the required return type of the `Get` call is
   * `(v)`, not the type of the property. `GetAll` expects a return value
   * of type `a{sv}`.
   *
   * If you have writable properties specified in your interface info,
   * you must ensure that you either provide a non-%NULL `set_property(`)
   * function or provide an implementation of the `Set` call. If implementing
   * the call, you must return the value of type %G_VARIANT_TYPE_UNIT.
   * @record
   */
  class DBusInterfaceVTable {
    // Own properties of Gio-2.0.Gio.DBusInterfaceVTable

    static name: string
  }

  interface DBusMethodInfo {
    // Own fields of Gio-2.0.Gio.DBusMethodInfo

    /**
     * The reference count or -1 if statically allocated.
     * @field
     */
    refCount: number
    /**
     * The name of the D-Bus method, e.g. `RequestName`.
     * @field
     */
    name: string | null
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no in arguments.
     * @field
     */
    inArgs: DBusArgInfo[]
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no out arguments.
     * @field
     */
    outArgs: DBusArgInfo[]
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
     * @field
     */
    annotations: DBusAnnotationInfo[]

    // Owm methods of Gio-2.0.Gio.DBusMethodInfo

    /**
     * If `info` is statically allocated does nothing. Otherwise increases
     * the reference count.
     * @returns The same @info.
     */
    ref(): DBusMethodInfo
    /**
     * If `info` is statically allocated, does nothing. Otherwise decreases
     * the reference count of `info`. When its reference count drops to 0,
     * the memory used is freed.
     */
    unref(): void
  }

  /**
   * Information about a method on an D-Bus interface.
   * @record
   */
  class DBusMethodInfo {
    // Own properties of Gio-2.0.Gio.DBusMethodInfo

    static name: string
  }

  interface DBusNodeInfo {
    // Own fields of Gio-2.0.Gio.DBusNodeInfo

    /**
     * The reference count or -1 if statically allocated.
     * @field
     */
    refCount: number
    /**
     * The path of the node or %NULL if omitted. Note that this may be a relative path. See the D-Bus specification for more details.
     * @field
     */
    path: string | null
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusInterfaceInfo structures or %NULL if there are no interfaces.
     * @field
     */
    interfaces: DBusInterfaceInfo[]
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusNodeInfo structures or %NULL if there are no nodes.
     * @field
     */
    nodes: DBusNodeInfo[]
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
     * @field
     */
    annotations: DBusAnnotationInfo[]

    // Owm methods of Gio-2.0.Gio.DBusNodeInfo

    /**
     * Appends an XML representation of `info` (and its children) to `string_builder`.
     *
     * This function is typically used for generating introspection XML documents at run-time for
     * handling the `org.freedesktop.DBus.Introspectable.Introspect`  method.
     * @param indent Indentation level.
     * @param stringBuilder A #GString to to append XML data to.
     */
    generateXml(indent: number, stringBuilder: GLib.String): void
    /**
     * Looks up information about an interface.
     *
     * The cost of this function is O(n) in number of interfaces.
     * @param name A D-Bus interface name.
     * @returns A #GDBusInterfaceInfo or %NULL if not found. Do not free, it is owned by @info.
     */
    lookupInterface(name: string): DBusInterfaceInfo | null
    /**
     * If `info` is statically allocated does nothing. Otherwise increases
     * the reference count.
     * @returns The same @info.
     */
    ref(): DBusNodeInfo
    /**
     * If `info` is statically allocated, does nothing. Otherwise decreases
     * the reference count of `info`. When its reference count drops to 0,
     * the memory used is freed.
     */
    unref(): void
  }

  /**
   * Information about nodes in a remote object hierarchy.
   * @record
   */
  class DBusNodeInfo {
    // Own properties of Gio-2.0.Gio.DBusNodeInfo

    static name: string

    // Constructors of Gio-2.0.Gio.DBusNodeInfo

    /**
     * Parses `xml_data` and returns a #GDBusNodeInfo representing the data.
     *
     * The introspection XML must contain exactly one top-level
     * <node> element.
     *
     * Note that this routine is using a
     * [GMarkup][glib-Simple-XML-Subset-Parser.description]-based
     * parser that only accepts a subset of valid XML documents.
     * @constructor
     * @param xmlData Valid D-Bus introspection XML.
     * @returns A #GDBusNodeInfo structure or %NULL if @error is set. Free with g_dbus_node_info_unref().
     */
    static newForXml(xmlData: string): DBusNodeInfo
  }

  interface DBusObjectIface {
    // Own fields of Gio-2.0.Gio.DBusObjectIface

    /**
     * The parent interface.
     * @field
     */
    parentIface: GObject.TypeInterface
    /**
     * Returns the object path. See g_dbus_object_get_object_path().
     * @field
     */
    getObjectPath: (object: DBusObject) => string
    /**
     * Returns all interfaces. See g_dbus_object_get_interfaces().
     * @field
     */
    getInterfaces: (object: DBusObject) => DBusInterface[]
    /**
     * Returns an interface by name. See g_dbus_object_get_interface().
     * @field
     */
    getInterface: (
      object: DBusObject,
      interfaceName: string
    ) => DBusInterface | null
    /**
     * Signal handler for the #GDBusObject::interface-added signal.
     * @field
     */
    interfaceAdded: (object: DBusObject, interface: DBusInterface) => void
    /**
     * Signal handler for the #GDBusObject::interface-removed signal.
     * @field
     */
    interfaceRemoved: (object: DBusObject, interface: DBusInterface) => void
  }

  /**
   * Base object type for D-Bus objects.
   * @record
   */
  abstract class DBusObjectIface {
    // Own properties of Gio-2.0.Gio.DBusObjectIface

    static name: string
  }

  interface DBusObjectManagerClientClass {
    // Own fields of Gio-2.0.Gio.DBusObjectManagerClientClass

    /**
     * The parent class.
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * Signal class handler for the #GDBusObjectManagerClient::interface-proxy-signal signal.
     * @field
     */
    interfaceProxySignal: (
      manager: DBusObjectManagerClient,
      objectProxy: DBusObjectProxy,
      interfaceProxy: DBusProxy,
      senderName: string,
      signalName: string,
      parameters: GLib.Variant
    ) => void
    /**
     * Signal class handler for the #GDBusObjectManagerClient::interface-proxy-properties-changed signal.
     * @field
     */
    interfaceProxyPropertiesChanged: (
      manager: DBusObjectManagerClient,
      objectProxy: DBusObjectProxy,
      interfaceProxy: DBusProxy,
      changedProperties: GLib.Variant,
      invalidatedProperties: string
    ) => void
  }

  /**
   * Class structure for #GDBusObjectManagerClient.
   * @record
   */
  abstract class DBusObjectManagerClientClass {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerClientClass

    static name: string
  }

  interface DBusObjectManagerClientPrivate {}

  class DBusObjectManagerClientPrivate {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerClientPrivate

    static name: string
  }

  interface DBusObjectManagerIface {
    // Own fields of Gio-2.0.Gio.DBusObjectManagerIface

    /**
     * The parent interface.
     * @field
     */
    parentIface: GObject.TypeInterface
    /**
     * Virtual function for g_dbus_object_manager_get_object_path().
     * @field
     */
    getObjectPath: (manager: DBusObjectManager) => string
    /**
     * Virtual function for g_dbus_object_manager_get_objects().
     * @field
     */
    getObjects: (manager: DBusObjectManager) => DBusObject[]
    /**
     * Virtual function for g_dbus_object_manager_get_object().
     * @field
     */
    getObject: (
      manager: DBusObjectManager,
      objectPath: string
    ) => DBusObject | null
    /**
     * Virtual function for g_dbus_object_manager_get_interface().
     * @field
     */
    getInterface: (
      manager: DBusObjectManager,
      objectPath: string,
      interfaceName: string
    ) => DBusInterface | null
    /**
     * Signal handler for the #GDBusObjectManager::object-added signal.
     * @field
     */
    objectAdded: (manager: DBusObjectManager, object: DBusObject) => void
    /**
     * Signal handler for the #GDBusObjectManager::object-removed signal.
     * @field
     */
    objectRemoved: (manager: DBusObjectManager, object: DBusObject) => void
    /**
     * Signal handler for the #GDBusObjectManager::interface-added signal.
     * @field
     */
    interfaceAdded: (
      manager: DBusObjectManager,
      object: DBusObject,
      interface: DBusInterface
    ) => void
    /**
     * Signal handler for the #GDBusObjectManager::interface-removed signal.
     * @field
     */
    interfaceRemoved: (
      manager: DBusObjectManager,
      object: DBusObject,
      interface: DBusInterface
    ) => void
  }

  /**
   * Base type for D-Bus object managers.
   * @record
   */
  abstract class DBusObjectManagerIface {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerIface

    static name: string
  }

  interface DBusObjectManagerServerClass {
    // Own fields of Gio-2.0.Gio.DBusObjectManagerServerClass

    /**
     * The parent class.
     * @field
     */
    parentClass: GObject.ObjectClass
  }

  /**
   * Class structure for #GDBusObjectManagerServer.
   * @record
   */
  abstract class DBusObjectManagerServerClass {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerServerClass

    static name: string
  }

  interface DBusObjectManagerServerPrivate {}

  class DBusObjectManagerServerPrivate {
    // Own properties of Gio-2.0.Gio.DBusObjectManagerServerPrivate

    static name: string
  }

  interface DBusObjectProxyClass {
    // Own fields of Gio-2.0.Gio.DBusObjectProxyClass

    /**
     * The parent class.
     * @field
     */
    parentClass: GObject.ObjectClass
  }

  /**
   * Class structure for #GDBusObjectProxy.
   * @record
   */
  abstract class DBusObjectProxyClass {
    // Own properties of Gio-2.0.Gio.DBusObjectProxyClass

    static name: string
  }

  interface DBusObjectProxyPrivate {}

  class DBusObjectProxyPrivate {
    // Own properties of Gio-2.0.Gio.DBusObjectProxyPrivate

    static name: string
  }

  interface DBusObjectSkeletonClass {
    // Own fields of Gio-2.0.Gio.DBusObjectSkeletonClass

    /**
     * The parent class.
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * Signal class handler for the #GDBusObjectSkeleton::authorize-method signal.
     * @field
     */
    authorizeMethod: (
      object: DBusObjectSkeleton,
      interface: DBusInterfaceSkeleton,
      invocation: DBusMethodInvocation
    ) => boolean
  }

  /**
   * Class structure for #GDBusObjectSkeleton.
   * @record
   */
  abstract class DBusObjectSkeletonClass {
    // Own properties of Gio-2.0.Gio.DBusObjectSkeletonClass

    static name: string
  }

  interface DBusObjectSkeletonPrivate {}

  class DBusObjectSkeletonPrivate {
    // Own properties of Gio-2.0.Gio.DBusObjectSkeletonPrivate

    static name: string
  }

  interface DBusPropertyInfo {
    // Own fields of Gio-2.0.Gio.DBusPropertyInfo

    /**
     * The reference count or -1 if statically allocated.
     * @field
     */
    refCount: number
    /**
     * The name of the D-Bus property, e.g. "SupportedFilesystems".
     * @field
     */
    name: string | null
    /**
     * The D-Bus signature of the property (a single complete type).
     * @field
     */
    signature: string | null
    /**
     * Access control flags for the property.
     * @field
     */
    flags: DBusPropertyInfoFlags
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
     * @field
     */
    annotations: DBusAnnotationInfo[]

    // Owm methods of Gio-2.0.Gio.DBusPropertyInfo

    /**
     * If `info` is statically allocated does nothing. Otherwise increases
     * the reference count.
     * @returns The same @info.
     */
    ref(): DBusPropertyInfo
    /**
     * If `info` is statically allocated, does nothing. Otherwise decreases
     * the reference count of `info`. When its reference count drops to 0,
     * the memory used is freed.
     */
    unref(): void
  }

  /**
   * Information about a D-Bus property on a D-Bus interface.
   * @record
   */
  class DBusPropertyInfo {
    // Own properties of Gio-2.0.Gio.DBusPropertyInfo

    static name: string
  }

  interface DBusProxyClass {
    // Own fields of Gio-2.0.Gio.DBusProxyClass

    /**
     * Signal class handler for the #GDBusProxy::g-properties-changed signal.
     * @field
     */
    gPropertiesChanged: (
      proxy: DBusProxy,
      changedProperties: GLib.Variant,
      invalidatedProperties: string
    ) => void
    /**
     * Signal class handler for the #GDBusProxy::g-signal signal.
     * @field
     */
    gSignal: (
      proxy: DBusProxy,
      senderName: string,
      signalName: string,
      parameters: GLib.Variant
    ) => void
  }

  /**
   * Class structure for #GDBusProxy.
   * @record
   */
  abstract class DBusProxyClass {
    // Own properties of Gio-2.0.Gio.DBusProxyClass

    static name: string
  }

  interface DBusProxyPrivate {}

  class DBusProxyPrivate {
    // Own properties of Gio-2.0.Gio.DBusProxyPrivate

    static name: string
  }

  interface DBusSignalInfo {
    // Own fields of Gio-2.0.Gio.DBusSignalInfo

    /**
     * The reference count or -1 if statically allocated.
     * @field
     */
    refCount: number
    /**
     * The name of the D-Bus signal, e.g. "NameOwnerChanged".
     * @field
     */
    name: string | null
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusArgInfo structures or %NULL if there are no arguments.
     * @field
     */
    args: DBusArgInfo[]
    /**
     * A pointer to a %NULL-terminated array of pointers to #GDBusAnnotationInfo structures or %NULL if there are no annotations.
     * @field
     */
    annotations: DBusAnnotationInfo[]

    // Owm methods of Gio-2.0.Gio.DBusSignalInfo

    /**
     * If `info` is statically allocated does nothing. Otherwise increases
     * the reference count.
     * @returns The same @info.
     */
    ref(): DBusSignalInfo
    /**
     * If `info` is statically allocated, does nothing. Otherwise decreases
     * the reference count of `info`. When its reference count drops to 0,
     * the memory used is freed.
     */
    unref(): void
  }

  /**
   * Information about a signal on a D-Bus interface.
   * @record
   */
  class DBusSignalInfo {
    // Own properties of Gio-2.0.Gio.DBusSignalInfo

    static name: string
  }

  interface DBusSubtreeVTable {
    // Own fields of Gio-2.0.Gio.DBusSubtreeVTable

    /**
     * Function for enumerating child nodes.
     * @field
     */
    enumerate: DBusSubtreeEnumerateFunc
    /**
     * Function for introspecting a child node.
     * @field
     */
    introspect: DBusSubtreeIntrospectFunc
    /**
     * Function for dispatching a remote call on a child node.
     * @field
     */
    dispatch: DBusSubtreeDispatchFunc
  }

  /**
   * Virtual table for handling subtrees registered with g_dbus_connection_register_subtree().
   * @record
   */
  class DBusSubtreeVTable {
    // Own properties of Gio-2.0.Gio.DBusSubtreeVTable

    static name: string
  }

  interface DataInputStreamClass {
    // Own fields of Gio-2.0.Gio.DataInputStreamClass

    parentClass: BufferedInputStreamClass
  }

  abstract class DataInputStreamClass {
    // Own properties of Gio-2.0.Gio.DataInputStreamClass

    static name: string
  }

  interface DataInputStreamPrivate {}

  class DataInputStreamPrivate {
    // Own properties of Gio-2.0.Gio.DataInputStreamPrivate

    static name: string
  }

  interface DataOutputStreamClass {
    // Own fields of Gio-2.0.Gio.DataOutputStreamClass

    parentClass: FilterOutputStreamClass
  }

  abstract class DataOutputStreamClass {
    // Own properties of Gio-2.0.Gio.DataOutputStreamClass

    static name: string
  }

  interface DataOutputStreamPrivate {}

  class DataOutputStreamPrivate {
    // Own properties of Gio-2.0.Gio.DataOutputStreamPrivate

    static name: string
  }

  interface DatagramBasedInterface {
    // Own fields of Gio-2.0.Gio.DatagramBasedInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Virtual method for g_datagram_based_receive_messages().
     * @field
     */
    receiveMessages: (
      datagramBased: DatagramBased,
      messages: InputMessage[],
      flags: number,
      timeout: number,
      cancellable: Cancellable | null
    ) => number
    /**
     * Virtual method for g_datagram_based_send_messages().
     * @field
     */
    sendMessages: (
      datagramBased: DatagramBased,
      messages: OutputMessage[],
      flags: number,
      timeout: number,
      cancellable: Cancellable | null
    ) => number
    /**
     * Virtual method for g_datagram_based_create_source().
     * @field
     */
    createSource: (
      datagramBased: DatagramBased,
      condition: GLib.IOCondition,
      cancellable: Cancellable | null
    ) => GLib.Source
    /**
     * Virtual method for g_datagram_based_condition_check().
     * @field
     */
    conditionCheck: (
      datagramBased: DatagramBased,
      condition: GLib.IOCondition
    ) => GLib.IOCondition
    /**
     * Virtual method for
     *   g_datagram_based_condition_wait().
     * @field
     */
    conditionWait: (
      datagramBased: DatagramBased,
      condition: GLib.IOCondition,
      timeout: number,
      cancellable: Cancellable | null
    ) => boolean
  }

  /**
   * Provides an interface for socket-like objects which have datagram semantics,
   * following the Berkeley sockets API. The interface methods are thin wrappers
   * around the corresponding virtual methods, and no pre-processing of inputs is
   * implemented — so implementations of this API must handle all functionality
   * documented in the interface methods.
   * @record
   */
  abstract class DatagramBasedInterface {
    // Own properties of Gio-2.0.Gio.DatagramBasedInterface

    static name: string
  }

  interface DebugControllerDBusClass {
    // Own fields of Gio-2.0.Gio.DebugControllerDBusClass

    /**
     * The parent class.
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * Default handler for the #GDebugControllerDBus::authorize signal.
     * @field
     */
    authorize: (
      controller: DebugControllerDBus,
      invocation: DBusMethodInvocation
    ) => boolean
    padding: any[]
  }

  /**
   * The virtual function table for #GDebugControllerDBus.
   * @record
   */
  abstract class DebugControllerDBusClass {
    // Own properties of Gio-2.0.Gio.DebugControllerDBusClass

    static name: string
  }

  interface DebugControllerInterface {}

  /**
   * The virtual function table for #GDebugController.
   * @record
   */
  abstract class DebugControllerInterface {
    // Own properties of Gio-2.0.Gio.DebugControllerInterface

    static name: string
  }

  interface DesktopAppInfoClass {
    // Own fields of Gio-2.0.Gio.DesktopAppInfoClass

    parentClass: GObject.ObjectClass
  }

  abstract class DesktopAppInfoClass {
    // Own properties of Gio-2.0.Gio.DesktopAppInfoClass

    static name: string
  }

  interface DesktopAppInfoLookupIface {
    // Own fields of Gio-2.0.Gio.DesktopAppInfoLookupIface

    gIface: GObject.TypeInterface
    /**
     * Virtual method for
     *  g_desktop_app_info_lookup_get_default_for_uri_scheme().
     * @field
     */
    getDefaultForUriScheme: (
      lookup: DesktopAppInfoLookup,
      uriScheme: string
    ) => AppInfo | null
  }

  /**
   * Interface that is used by backends to associate default
   * handlers with URI schemes.
   * @record
   */
  abstract class DesktopAppInfoLookupIface {
    // Own properties of Gio-2.0.Gio.DesktopAppInfoLookupIface

    static name: string
  }

  interface DriveIface {
    // Own fields of Gio-2.0.Gio.DriveIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Signal emitted when the drive is changed.
     * @field
     */
    changed: (drive: Drive) => void
    /**
     * The removed signal that is emitted when the #GDrive have been disconnected. If the recipient is holding references to the object they should release them so the object can be finalized.
     * @field
     */
    disconnected: (drive: Drive) => void
    /**
     * Signal emitted when the physical eject button (if any) of a drive have been pressed.
     * @field
     */
    ejectButton: (drive: Drive) => void
    /**
     * Returns the name for the given #GDrive.
     * @field
     */
    getName: (drive: Drive) => string | null
    /**
     * Returns a #GIcon for the given #GDrive.
     * @field
     */
    getIcon: (drive: Drive) => Icon
    /**
     * Returns %TRUE if the #GDrive has mountable volumes.
     * @field
     */
    hasVolumes: (drive: Drive) => boolean
    /**
     * Returns a list #GList of #GVolume for the #GDrive.
     * @field
     */
    getVolumes: (drive: Drive) => Volume[]
    /**
     * Returns %TRUE if the #GDrive supports removal and insertion of media.
     * @field
     */
    isMediaRemovable: (drive: Drive) => boolean
    /**
     * Returns %TRUE if the #GDrive has media inserted.
     * @field
     */
    hasMedia: (drive: Drive) => boolean
    /**
     * Returns %TRUE if the #GDrive is capable of automatically detecting media changes.
     * @field
     */
    isMediaCheckAutomatic: (drive: Drive) => boolean
    /**
     * Returns %TRUE if the #GDrive can eject media.
     * @field
     */
    canEject: (drive: Drive) => boolean
    /**
     * Returns %TRUE if the #GDrive is capable of manually polling for media change.
     * @field
     */
    canPollForMedia: (drive: Drive) => boolean
    /**
     * Ejects a #GDrive.
     * @field
     */
    eject: (
      drive: Drive,
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an eject operation.
     * @field
     */
    ejectFinish: (drive: Drive, result: AsyncResult) => boolean
    /**
     * Poll for media insertion/removal on a #GDrive.
     * @field
     */
    pollForMedia: (
      drive: Drive,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a media poll operation.
     * @field
     */
    pollForMediaFinish: (drive: Drive, result: AsyncResult) => boolean
    /**
     * Returns the identifier of the given kind, or %NULL if
     *    the #GDrive doesn't have one.
     * @field
     */
    getIdentifier: (drive: Drive, kind: string) => string | null
    /**
     * Returns an array strings listing the kinds
     *    of identifiers which the #GDrive has.
     * @field
     */
    enumerateIdentifiers: (drive: Drive) => string[]
    /**
     * Gets a #GDriveStartStopType with details about starting/stopping the drive. Since 2.22.
     * @field
     */
    getStartStopType: (drive: Drive) => DriveStartStopType
    /**
     * Returns %TRUE if a #GDrive can be started. Since 2.22.
     * @field
     */
    canStart: (drive: Drive) => boolean
    /**
     * Returns %TRUE if a #GDrive can be started degraded. Since 2.22.
     * @field
     */
    canStartDegraded: (drive: Drive) => boolean
    /**
     * Starts a #GDrive. Since 2.22.
     * @field
     */
    start: (
      drive: Drive,
      flags: DriveStartFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a start operation. Since 2.22.
     * @field
     */
    startFinish: (drive: Drive, result: AsyncResult) => boolean
    /**
     * Returns %TRUE if a #GDrive can be stopped. Since 2.22.
     * @field
     */
    canStop: (drive: Drive) => boolean
    /**
     * Stops a #GDrive. Since 2.22.
     * @field
     */
    stop: (
      drive: Drive,
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a stop operation. Since 2.22.
     * @field
     */
    stopFinish: (drive: Drive, result: AsyncResult) => boolean
    /**
     * Signal emitted when the physical stop button (if any) of a drive have been pressed. Since 2.22.
     * @field
     */
    stopButton: (drive: Drive) => void
    /**
     * Starts ejecting a #GDrive using a #GMountOperation. Since 2.22.
     * @field
     */
    ejectWithOperation: (
      drive: Drive,
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an eject operation using a #GMountOperation. Since 2.22.
     * @field
     */
    ejectWithOperationFinish: (drive: Drive, result: AsyncResult) => boolean
    /**
     * Gets a key used for sorting #GDrive instances or %NULL if no such key exists. Since 2.32.
     * @field
     */
    getSortKey: (drive: Drive) => string | null
    /**
     * Returns a symbolic #GIcon for the given #GDrive. Since 2.34.
     * @field
     */
    getSymbolicIcon: (drive: Drive) => Icon
    /**
     * Returns %TRUE if the #GDrive and/or its media is considered removable by the user. Since 2.50.
     * @field
     */
    isRemovable: (drive: Drive) => boolean
  }

  /**
   * Interface for creating #GDrive implementations.
   * @record
   */
  abstract class DriveIface {
    // Own properties of Gio-2.0.Gio.DriveIface

    static name: string
  }

  interface DtlsClientConnectionInterface {
    // Own fields of Gio-2.0.Gio.DtlsClientConnectionInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
  }

  /**
   * vtable for a #GDtlsClientConnection implementation.
   * @record
   */
  abstract class DtlsClientConnectionInterface {
    // Own properties of Gio-2.0.Gio.DtlsClientConnectionInterface

    static name: string
  }

  interface DtlsConnectionInterface {
    // Own fields of Gio-2.0.Gio.DtlsConnectionInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Check whether to accept a certificate.
     * @field
     */
    acceptCertificate: (
      connection: DtlsConnection,
      peerCert: TlsCertificate,
      errors: TlsCertificateFlags
    ) => boolean
    /**
     * Perform a handshake operation.
     * @field
     */
    handshake: (
      conn: DtlsConnection,
      cancellable: Cancellable | null
    ) => boolean
    /**
     * Start an asynchronous handshake operation.
     * @field
     */
    handshakeAsync: (
      conn: DtlsConnection,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finish an asynchronous handshake operation.
     * @field
     */
    handshakeFinish: (conn: DtlsConnection, result: AsyncResult) => boolean
    /**
     * Shut down one or both directions of the connection.
     * @field
     */
    shutdown: (
      conn: DtlsConnection,
      shutdownRead: boolean,
      shutdownWrite: boolean,
      cancellable: Cancellable | null
    ) => boolean
    /**
     * Start an asynchronous shutdown operation.
     * @field
     */
    shutdownAsync: (
      conn: DtlsConnection,
      shutdownRead: boolean,
      shutdownWrite: boolean,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finish an asynchronous shutdown operation.
     * @field
     */
    shutdownFinish: (conn: DtlsConnection, result: AsyncResult) => boolean
    /**
     * Set APLN protocol list (Since: 2.60)
     * @field
     */
    setAdvertisedProtocols: (
      conn: DtlsConnection,
      protocols: string[] | null
    ) => void
    /**
     * Get ALPN-negotiated protocol (Since: 2.60)
     * @field
     */
    getNegotiatedProtocol: (conn: DtlsConnection) => string | null
    /**
     * Retrieve TLS channel binding data (Since: 2.66)
     * @field
     */
    getBindingData: (
      conn: DtlsConnection,
      type: TlsChannelBindingType,
      data: number[]
    ) => boolean
  }

  /**
   * Virtual method table for a #GDtlsConnection implementation.
   * @record
   */
  abstract class DtlsConnectionInterface {
    // Own properties of Gio-2.0.Gio.DtlsConnectionInterface

    static name: string
  }

  interface DtlsServerConnectionInterface {
    // Own fields of Gio-2.0.Gio.DtlsServerConnectionInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
  }

  /**
   * vtable for a #GDtlsServerConnection implementation.
   * @record
   */
  abstract class DtlsServerConnectionInterface {
    // Own properties of Gio-2.0.Gio.DtlsServerConnectionInterface

    static name: string
  }

  interface EmblemClass {}

  abstract class EmblemClass {
    // Own properties of Gio-2.0.Gio.EmblemClass

    static name: string
  }

  interface EmblemedIconClass {
    // Own fields of Gio-2.0.Gio.EmblemedIconClass

    parentClass: GObject.ObjectClass
  }

  abstract class EmblemedIconClass {
    // Own properties of Gio-2.0.Gio.EmblemedIconClass

    static name: string
  }

  interface EmblemedIconPrivate {}

  class EmblemedIconPrivate {
    // Own properties of Gio-2.0.Gio.EmblemedIconPrivate

    static name: string
  }

  interface FileAttributeInfo {
    // Own fields of Gio-2.0.Gio.FileAttributeInfo

    /**
     * the name of the attribute.
     * @field
     */
    name: string | null
    /**
     * the #GFileAttributeType type of the attribute.
     * @field
     */
    type: FileAttributeType
    /**
     * a set of #GFileAttributeInfoFlags.
     * @field
     */
    flags: FileAttributeInfoFlags
  }

  /**
   * Information about a specific attribute.
   * @record
   */
  class FileAttributeInfo {
    // Own properties of Gio-2.0.Gio.FileAttributeInfo

    static name: string
  }

  interface FileAttributeInfoList {
    // Own fields of Gio-2.0.Gio.FileAttributeInfoList

    /**
     * an array of #GFileAttributeInfos.
     * @field
     */
    infos: FileAttributeInfo
    /**
     * the number of values in the array.
     * @field
     */
    nInfos: number

    // Owm methods of Gio-2.0.Gio.FileAttributeInfoList

    /**
     * Adds a new attribute with `name` to the `list,` setting
     * its `type` and `flags`.
     * @param name the name of the attribute to add.
     * @param type the #GFileAttributeType for the attribute.
     * @param flags #GFileAttributeInfoFlags for the attribute.
     */
    add(
      name: string,
      type: FileAttributeType,
      flags: FileAttributeInfoFlags
    ): void
    /**
     * Makes a duplicate of a file attribute info list.
     * @returns a copy of the given @list.
     */
    dup(): FileAttributeInfoList
    /**
     * Gets the file attribute with the name `name` from `list`.
     * @param name the name of the attribute to look up.
     * @returns a #GFileAttributeInfo for the @name, or %NULL if an attribute isn't found.
     */
    lookup(name: string): FileAttributeInfo
    /**
     * References a file attribute info list.
     * @returns #GFileAttributeInfoList or %NULL on error.
     */
    ref(): FileAttributeInfoList
    /**
     * Removes a reference from the given `list`. If the reference count
     * falls to zero, the `list` is deleted.
     */
    unref(): void
  }

  /**
   * Acts as a lightweight registry for possible valid file attributes.
   * The registry stores Key-Value pair formats as #GFileAttributeInfos.
   * @record
   */
  class FileAttributeInfoList {
    // Own properties of Gio-2.0.Gio.FileAttributeInfoList

    static name: string

    // Constructors of Gio-2.0.Gio.FileAttributeInfoList

    /**
     * Creates a new file attribute info list.
     * @constructor
     * @returns a #GFileAttributeInfoList.
     */
    constructor()
    /**
     * Creates a new file attribute info list.
     * @constructor
     * @returns a #GFileAttributeInfoList.
     */
    static new(): FileAttributeInfoList
  }

  interface FileAttributeMatcher {
    // Owm methods of Gio-2.0.Gio.FileAttributeMatcher

    /**
     * Checks if the matcher will match all of the keys in a given namespace.
     * This will always return %TRUE if a wildcard character is in use (e.g. if
     * matcher was created with "standard::*" and `ns` is "standard", or if matcher was created
     * using "*" and namespace is anything.)
     *
     * TODO: this is awkwardly worded.
     * @param ns a string containing a file attribute namespace.
     * @returns %TRUE if the matcher matches all of the entries in the given @ns, %FALSE otherwise.
     */
    enumerateNamespace(ns: string): boolean
    /**
     * Gets the next matched attribute from a #GFileAttributeMatcher.
     * @returns a string containing the next attribute or, %NULL if no more attribute exist.
     */
    enumerateNext(): string | null
    /**
     * Checks if an attribute will be matched by an attribute matcher. If
     * the matcher was created with the "*" matching string, this function
     * will always return %TRUE.
     * @param attribute a file attribute key.
     * @returns %TRUE if @attribute matches @matcher. %FALSE otherwise.
     */
    matches(attribute: string): boolean
    /**
     * Checks if an attribute matcher only matches a given attribute. Always
     * returns %FALSE if "*" was used when creating the matcher.
     * @param attribute a file attribute key.
     * @returns %TRUE if the matcher only matches @attribute. %FALSE otherwise.
     */
    matchesOnly(attribute: string): boolean
    /**
     * References a file attribute matcher.
     * @returns a #GFileAttributeMatcher.
     */
    ref(): FileAttributeMatcher
    /**
     * Subtracts all attributes of `subtract` from `matcher` and returns
     * a matcher that supports those attributes.
     *
     * Note that currently it is not possible to remove a single
     * attribute when the `matcher` matches the whole namespace - or remove
     * a namespace or attribute when the matcher matches everything. This
     * is a limitation of the current implementation, but may be fixed
     * in the future.
     * @param subtract The matcher to subtract
     * @returns A file attribute matcher matching all attributes of     @matcher that are not matched by @subtract
     */
    subtract(subtract: FileAttributeMatcher | null): FileAttributeMatcher | null
    /**
     * Prints what the matcher is matching against. The format will be
     * equal to the format passed to g_file_attribute_matcher_new().
     * The output however, might not be identical, as the matcher may
     * decide to use a different order or omit needless parts.
     * @returns a string describing the attributes the matcher matches   against or %NULL if @matcher was %NULL.
     */
    toString(): string | null
    /**
     * Unreferences `matcher`. If the reference count falls below 1,
     * the `matcher` is automatically freed.
     */
    unref(): void
  }

  /**
   * Determines if a string matches a file attribute.
   * @record
   */
  class FileAttributeMatcher {
    // Own properties of Gio-2.0.Gio.FileAttributeMatcher

    static name: string

    // Constructors of Gio-2.0.Gio.FileAttributeMatcher

    /**
     * Creates a new file attribute matcher, which matches attributes
     * against a given string. #GFileAttributeMatchers are reference
     * counted structures, and are created with a reference count of 1. If
     * the number of references falls to 0, the #GFileAttributeMatcher is
     * automatically destroyed.
     *
     * The `attributes` string should be formatted with specific keys separated
     * from namespaces with a double colon. Several "namespace::key" strings may be
     * concatenated with a single comma (e.g. "standard::type,standard::is-hidden").
     * The wildcard "*" may be used to match all keys and namespaces, or
     * "namespace::*" will match all keys in a given namespace.
     *
     * ## Examples of file attribute matcher strings and results
     *
     * - `"*"`: matches all attributes.
     * - `"standard::is-hidden"`: matches only the key is-hidden in the
     *   standard namespace.
     * - `"standard::type,unix::*"`: matches the type key in the standard
     *   namespace and all keys in the unix namespace.
     * @constructor
     * @param attributes an attribute string to match.
     * @returns a #GFileAttributeMatcher
     */
    constructor(attributes: string)
    /**
     * Creates a new file attribute matcher, which matches attributes
     * against a given string. #GFileAttributeMatchers are reference
     * counted structures, and are created with a reference count of 1. If
     * the number of references falls to 0, the #GFileAttributeMatcher is
     * automatically destroyed.
     *
     * The `attributes` string should be formatted with specific keys separated
     * from namespaces with a double colon. Several "namespace::key" strings may be
     * concatenated with a single comma (e.g. "standard::type,standard::is-hidden").
     * The wildcard "*" may be used to match all keys and namespaces, or
     * "namespace::*" will match all keys in a given namespace.
     *
     * ## Examples of file attribute matcher strings and results
     *
     * - `"*"`: matches all attributes.
     * - `"standard::is-hidden"`: matches only the key is-hidden in the
     *   standard namespace.
     * - `"standard::type,unix::*"`: matches the type key in the standard
     *   namespace and all keys in the unix namespace.
     * @constructor
     * @param attributes an attribute string to match.
     * @returns a #GFileAttributeMatcher
     */
    static new(attributes: string): FileAttributeMatcher
  }

  interface FileDescriptorBasedIface {
    // Own fields of Gio-2.0.Gio.FileDescriptorBasedIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Gets the underlying file descriptor.
     * @field
     */
    getFd: (fdBased: FileDescriptorBased) => number
  }

  /**
   * An interface for file descriptor based io objects.
   * @record
   */
  abstract class FileDescriptorBasedIface {
    // Own properties of Gio-2.0.Gio.FileDescriptorBasedIface

    static name: string
  }

  interface FileEnumeratorClass {
    // Own fields of Gio-2.0.Gio.FileEnumeratorClass

    parentClass: GObject.ObjectClass
    nextFile: (
      enumerator: FileEnumerator,
      cancellable: Cancellable | null
    ) => FileInfo | null
    closeFn: (
      enumerator: FileEnumerator,
      cancellable: Cancellable | null
    ) => boolean
    nextFilesAsync: (
      enumerator: FileEnumerator,
      numFiles: number,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    nextFilesFinish: (
      enumerator: FileEnumerator,
      result: AsyncResult
    ) => FileInfo[]
    closeAsync: (
      enumerator: FileEnumerator,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    closeFinish: (enumerator: FileEnumerator, result: AsyncResult) => boolean
  }

  abstract class FileEnumeratorClass {
    // Own properties of Gio-2.0.Gio.FileEnumeratorClass

    static name: string
  }

  interface FileEnumeratorPrivate {}

  class FileEnumeratorPrivate {
    // Own properties of Gio-2.0.Gio.FileEnumeratorPrivate

    static name: string
  }

  interface FileIOStreamClass {
    // Own fields of Gio-2.0.Gio.FileIOStreamClass

    parentClass: IOStreamClass
    tell: (stream: FileIOStream) => number
    canSeek: (stream: FileIOStream) => boolean
    seek: (
      stream: FileIOStream,
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ) => boolean
    canTruncate: (stream: FileIOStream) => boolean
    truncateFn: (
      stream: FileIOStream,
      size: number,
      cancellable: Cancellable | null
    ) => boolean
    queryInfo: (
      stream: FileIOStream,
      attributes: string,
      cancellable: Cancellable | null
    ) => FileInfo
    queryInfoAsync: (
      stream: FileIOStream,
      attributes: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    queryInfoFinish: (stream: FileIOStream, result: AsyncResult) => FileInfo
    getEtag: (stream: FileIOStream) => string | null
  }

  abstract class FileIOStreamClass {
    // Own properties of Gio-2.0.Gio.FileIOStreamClass

    static name: string
  }

  interface FileIOStreamPrivate {}

  class FileIOStreamPrivate {
    // Own properties of Gio-2.0.Gio.FileIOStreamPrivate

    static name: string
  }

  interface FileIconClass {}

  abstract class FileIconClass {
    // Own properties of Gio-2.0.Gio.FileIconClass

    static name: string
  }

  interface FileIface {
    // Own fields of Gio-2.0.Gio.FileIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Duplicates a #GFile.
     * @field
     */
    dup: (file: File) => File
    /**
     * Creates a hash of a #GFile.
     * @field
     */
    hash: (file: File) => number
    /**
     * Checks equality of two given #GFiles.
     * @field
     */
    equal: (file1: File, file2: File) => boolean
    /**
     * Checks to see if a file is native to the system.
     * @field
     */
    isNative: (file: File) => boolean
    /**
     * Checks to see if a #GFile has a given URI scheme.
     * @field
     */
    hasUriScheme: (file: File, uriScheme: string) => boolean
    /**
     * Gets the URI scheme for a #GFile.
     * @field
     */
    getUriScheme: (file: File) => string | null
    /**
     * Gets the basename for a given #GFile.
     * @field
     */
    getBasename: (file: File) => string | null
    /**
     * Gets the current path within a #GFile.
     * @field
     */
    getPath: (file: File) => string | null
    /**
     * Gets a URI for the path within a #GFile.
     * @field
     */
    getUri: (file: File) => string | null
    /**
     * Gets the parsed name for the #GFile.
     * @field
     */
    getParseName: (file: File) => string | null
    /**
     * Gets the parent directory for the #GFile.
     * @field
     */
    getParent: (file: File) => File | null
    /**
     * Checks whether a #GFile contains a specified file.
     * @field
     */
    prefixMatches: (prefix: File, file: File) => boolean
    /**
     * Gets the path for a #GFile relative to a given path.
     * @field
     */
    getRelativePath: (parent: File, descendant: File) => string | null
    /**
     * Resolves a relative path for a #GFile to an absolute path.
     * @field
     */
    resolveRelativePath: (file: File, relativePath: string) => File
    /**
     * Gets the child #GFile for a given display name.
     * @field
     */
    getChildForDisplayName: (file: File, displayName: string) => File
    /**
     * Gets a #GFileEnumerator with the children of a #GFile.
     * @field
     */
    enumerateChildren: (
      file: File,
      attributes: string,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ) => FileEnumerator
    /**
     * Asynchronously gets a #GFileEnumerator with the children of a #GFile.
     * @field
     */
    enumerateChildrenAsync: (
      file: File,
      attributes: string,
      flags: FileQueryInfoFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes asynchronously enumerating the children.
     * @field
     */
    enumerateChildrenFinish: (file: File, res: AsyncResult) => FileEnumerator
    /**
     * Gets the #GFileInfo for a #GFile.
     * @field
     */
    queryInfo: (
      file: File,
      attributes: string,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ) => FileInfo
    /**
     * Asynchronously gets the #GFileInfo for a #GFile.
     * @field
     */
    queryInfoAsync: (
      file: File,
      attributes: string,
      flags: FileQueryInfoFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous query info operation.
     * @field
     */
    queryInfoFinish: (file: File, res: AsyncResult) => FileInfo
    /**
     * Gets a #GFileInfo for the file system #GFile is on.
     * @field
     */
    queryFilesystemInfo: (
      file: File,
      attributes: string,
      cancellable: Cancellable | null
    ) => FileInfo
    /**
     * Asynchronously gets a #GFileInfo for the file system #GFile is on.
     * @field
     */
    queryFilesystemInfoAsync: (
      file: File,
      attributes: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes asynchronously getting the file system info.
     * @field
     */
    queryFilesystemInfoFinish: (file: File, res: AsyncResult) => FileInfo
    /**
     * Gets a #GMount for the #GFile.
     * @field
     */
    findEnclosingMount: (file: File, cancellable: Cancellable | null) => Mount
    /**
     * Asynchronously gets the #GMount for a #GFile.
     * @field
     */
    findEnclosingMountAsync: (
      file: File,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes asynchronously getting the volume.
     * @field
     */
    findEnclosingMountFinish: (file: File, res: AsyncResult) => Mount
    /**
     * Sets the display name for a #GFile.
     * @field
     */
    setDisplayName: (
      file: File,
      displayName: string,
      cancellable: Cancellable | null
    ) => File
    /**
     * Asynchronously sets a #GFile's display name.
     * @field
     */
    setDisplayNameAsync: (
      file: File,
      displayName: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes asynchronously setting a #GFile's display name.
     * @field
     */
    setDisplayNameFinish: (file: File, res: AsyncResult) => File
    /**
     * Returns a list of #GFileAttributeInfos that can be set.
     * @field
     */
    querySettableAttributes: (
      file: File,
      cancellable: Cancellable | null
    ) => FileAttributeInfoList
    /**
     * Returns a list of #GFileAttributeInfo namespaces that are writable.
     * @field
     */
    queryWritableNamespaces: (
      file: File,
      cancellable: Cancellable | null
    ) => FileAttributeInfoList
    /**
     * Sets a #GFileAttributeInfo.
     * @field
     */
    setAttribute: (
      file: File,
      attribute: string,
      type: FileAttributeType,
      valueP: any | null,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ) => boolean
    /**
     * Sets a #GFileAttributeInfo with information from a #GFileInfo.
     * @field
     */
    setAttributesFromInfo: (
      file: File,
      info: FileInfo,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ) => boolean
    /**
     * Asynchronously sets a file's attributes.
     * @field
     */
    setAttributesAsync: (
      file: File,
      info: FileInfo,
      flags: FileQueryInfoFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes setting a file's attributes asynchronously.
     * @field
     */
    setAttributesFinish: (
      file: File,
      result: AsyncResult
    ) => [/* returnType */ boolean, /* info */ FileInfo]
    /**
     * Reads a file asynchronously.
     * @field
     */
    readFn: (file: File, cancellable: Cancellable | null) => FileInputStream
    /**
     * Asynchronously reads a file.
     * @field
     */
    readAsync: (
      file: File,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes asynchronously reading a file.
     * @field
     */
    readFinish: (file: File, res: AsyncResult) => FileInputStream
    /**
     * Writes to the end of a file.
     * @field
     */
    appendTo: (
      file: File,
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ) => FileOutputStream
    /**
     * Asynchronously writes to the end of a file.
     * @field
     */
    appendToAsync: (
      file: File,
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous file append operation.
     * @field
     */
    appendToFinish: (file: File, res: AsyncResult) => FileOutputStream
    /**
     * Creates a new file.
     * @field
     */
    create: (
      file: File,
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ) => FileOutputStream
    /**
     * Asynchronously creates a file.
     * @field
     */
    createAsync: (
      file: File,
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes asynchronously creating a file.
     * @field
     */
    createFinish: (file: File, res: AsyncResult) => FileOutputStream
    /**
     * Replaces the contents of a file.
     * @field
     */
    replace: (
      file: File,
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ) => FileOutputStream
    /**
     * Asynchronously replaces the contents of a file.
     * @field
     */
    replaceAsync: (
      file: File,
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes asynchronously replacing a file.
     * @field
     */
    replaceFinish: (file: File, res: AsyncResult) => FileOutputStream
    /**
     * Deletes a file.
     * @field
     */
    deleteFile: (file: File, cancellable: Cancellable | null) => boolean
    /**
     * Asynchronously deletes a file.
     * @field
     */
    deleteFileAsync: (
      file: File,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous delete.
     * @field
     */
    deleteFileFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Sends a #GFile to the Trash location.
     * @field
     */
    trash: (file: File, cancellable: Cancellable | null) => boolean
    /**
     * Asynchronously sends a #GFile to the Trash location.
     * @field
     */
    trashAsync: (
      file: File,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous file trashing operation.
     * @field
     */
    trashFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Makes a directory.
     * @field
     */
    makeDirectory: (file: File, cancellable: Cancellable | null) => boolean
    /**
     * Asynchronously makes a directory.
     * @field
     */
    makeDirectoryAsync: (
      file: File,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes making a directory asynchronously.
     * @field
     */
    makeDirectoryFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Makes a symbolic link. %NULL if symbolic
     *    links are unsupported.
     * @field
     */
    makeSymbolicLink: (
      file: File,
      symlinkValue: string,
      cancellable: Cancellable | null
    ) => boolean
    /**
     * Asynchronously makes a symbolic link
     * @field
     */
    makeSymbolicLinkAsync: (
      file: File,
      symlinkValue: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes making a symbolic link asynchronously.
     * @field
     */
    makeSymbolicLinkFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Copies a file. %NULL if copying is unsupported, which will
     *     cause `GFile` to use a fallback copy method where it reads from the
     *     source and writes to the destination.
     * @field
     */
    copy: (
      source: File,
      destination: File,
      flags: FileCopyFlags,
      cancellable: Cancellable | null,
      progressCallback: FileProgressCallback | null
    ) => boolean
    /**
     * Asynchronously copies a file.
     * @field
     */
    copyAsync: (
      source: File,
      destination: File,
      flags: FileCopyFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      progressCallback: FileProgressCallback | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous copy operation.
     * @field
     */
    copyFinish: (file: File, res: AsyncResult) => boolean
    /**
     * Moves a file.
     * @field
     */
    move: (
      source: File,
      destination: File,
      flags: FileCopyFlags,
      cancellable: Cancellable | null,
      progressCallback: FileProgressCallback | null
    ) => boolean
    /**
     * Asynchronously moves a file. Since: 2.72
     * @field
     */
    moveAsync: (
      source: File,
      destination: File,
      flags: FileCopyFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      progressCallback: FileProgressCallback | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous move operation. Since: 2.72
     * @field
     */
    moveFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Mounts a mountable object.
     * @field
     */
    mountMountable: (
      file: File,
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a mounting operation.
     * @field
     */
    mountMountableFinish: (file: File, result: AsyncResult) => File
    /**
     * Unmounts a mountable object.
     * @field
     */
    unmountMountable: (
      file: File,
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an unmount operation.
     * @field
     */
    unmountMountableFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Ejects a mountable.
     * @field
     */
    ejectMountable: (
      file: File,
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an eject operation.
     * @field
     */
    ejectMountableFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Mounts a specified location.
     * @field
     */
    mountEnclosingVolume: (
      location: File,
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes mounting a specified location.
     * @field
     */
    mountEnclosingVolumeFinish: (location: File, result: AsyncResult) => boolean
    /**
     * Creates a #GFileMonitor for the location.
     * @field
     */
    monitorDir: (
      file: File,
      flags: FileMonitorFlags,
      cancellable: Cancellable | null
    ) => FileMonitor
    /**
     * Creates a #GFileMonitor for the location.
     * @field
     */
    monitorFile: (
      file: File,
      flags: FileMonitorFlags,
      cancellable: Cancellable | null
    ) => FileMonitor
    /**
     * Open file read/write. Since 2.22.
     * @field
     */
    openReadwrite: (file: File, cancellable: Cancellable | null) => FileIOStream
    /**
     * Asynchronously opens file read/write. Since 2.22.
     * @field
     */
    openReadwriteAsync: (
      file: File,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous open read/write. Since 2.22.
     * @field
     */
    openReadwriteFinish: (file: File, res: AsyncResult) => FileIOStream
    /**
     * Creates file read/write. Since 2.22.
     * @field
     */
    createReadwrite: (
      file: File,
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ) => FileIOStream
    /**
     * Asynchronously creates file read/write. Since 2.22.
     * @field
     */
    createReadwriteAsync: (
      file: File,
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous creates read/write. Since 2.22.
     * @field
     */
    createReadwriteFinish: (file: File, res: AsyncResult) => FileIOStream
    /**
     * Replaces file read/write. Since 2.22.
     * @field
     */
    replaceReadwrite: (
      file: File,
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      cancellable: Cancellable | null
    ) => FileIOStream
    /**
     * Asynchronously replaces file read/write. Since 2.22.
     * @field
     */
    replaceReadwriteAsync: (
      file: File,
      etag: string | null,
      makeBackup: boolean,
      flags: FileCreateFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous replace read/write. Since 2.22.
     * @field
     */
    replaceReadwriteFinish: (file: File, res: AsyncResult) => FileIOStream
    /**
     * Starts a mountable object. Since 2.22.
     * @field
     */
    startMountable: (
      file: File,
      flags: DriveStartFlags,
      startOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a start operation. Since 2.22.
     * @field
     */
    startMountableFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Stops a mountable. Since 2.22.
     * @field
     */
    stopMountable: (
      file: File,
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a stop operation. Since 2.22.
     * @field
     */
    stopMountableFinish: (file: File, result: AsyncResult) => boolean
    /**
     * a boolean that indicates whether the #GFile implementation supports thread-default contexts. Since 2.22.
     * @field
     */
    supportsThreadContexts: boolean
    /**
     * Unmounts a mountable object using a #GMountOperation. Since 2.22.
     * @field
     */
    unmountMountableWithOperation: (
      file: File,
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an unmount operation using a #GMountOperation. Since 2.22.
     * @field
     */
    unmountMountableWithOperationFinish: (
      file: File,
      result: AsyncResult
    ) => boolean
    /**
     * Ejects a mountable object using a #GMountOperation. Since 2.22.
     * @field
     */
    ejectMountableWithOperation: (
      file: File,
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an eject operation using a #GMountOperation. Since 2.22.
     * @field
     */
    ejectMountableWithOperationFinish: (
      file: File,
      result: AsyncResult
    ) => boolean
    /**
     * Polls a mountable object for media changes. Since 2.22.
     * @field
     */
    pollMountable: (
      file: File,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a poll operation for media changes. Since 2.22.
     * @field
     */
    pollMountableFinish: (file: File, result: AsyncResult) => boolean
    /**
     * Recursively measures the disk usage of `file`. Since 2.38
     * @field
     */
    measureDiskUsage: (
      file: File,
      flags: FileMeasureFlags,
      cancellable: Cancellable | null,
      progressCallback: FileMeasureProgressCallback | null
    ) => [
      /* returnType */ boolean,
      /* diskUsage */ number,
      /* numDirs */ number,
      /* numFiles */ number,
    ]
    /**
     * Finishes an asynchronous recursive measurement of the disk usage of `file`. Since 2.38
     * @field
     */
    measureDiskUsageFinish: (
      file: File,
      result: AsyncResult
    ) => [
      /* returnType */ boolean,
      /* diskUsage */ number,
      /* numDirs */ number,
      /* numFiles */ number,
    ]
  }

  /**
   * An interface for writing VFS file handles.
   * @record
   */
  abstract class FileIface {
    // Own properties of Gio-2.0.Gio.FileIface

    static name: string
  }

  interface FileInfoClass {}

  abstract class FileInfoClass {
    // Own properties of Gio-2.0.Gio.FileInfoClass

    static name: string
  }

  interface FileInputStreamClass {
    // Own fields of Gio-2.0.Gio.FileInputStreamClass

    parentClass: InputStreamClass
    tell: (stream: FileInputStream) => number
    canSeek: (stream: FileInputStream) => boolean
    seek: (
      stream: FileInputStream,
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ) => boolean
    queryInfo: (
      stream: FileInputStream,
      attributes: string,
      cancellable: Cancellable | null
    ) => FileInfo
    queryInfoAsync: (
      stream: FileInputStream,
      attributes: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    queryInfoFinish: (stream: FileInputStream, result: AsyncResult) => FileInfo
  }

  abstract class FileInputStreamClass {
    // Own properties of Gio-2.0.Gio.FileInputStreamClass

    static name: string
  }

  interface FileInputStreamPrivate {}

  class FileInputStreamPrivate {
    // Own properties of Gio-2.0.Gio.FileInputStreamPrivate

    static name: string
  }

  interface FileMonitorClass {
    // Own fields of Gio-2.0.Gio.FileMonitorClass

    parentClass: GObject.ObjectClass
    changed: (
      monitor: FileMonitor,
      file: File,
      otherFile: File,
      eventType: FileMonitorEvent
    ) => void
    cancel: (monitor: FileMonitor) => boolean
  }

  abstract class FileMonitorClass {
    // Own properties of Gio-2.0.Gio.FileMonitorClass

    static name: string
  }

  interface FileMonitorPrivate {}

  class FileMonitorPrivate {
    // Own properties of Gio-2.0.Gio.FileMonitorPrivate

    static name: string
  }

  interface FileOutputStreamClass {
    // Own fields of Gio-2.0.Gio.FileOutputStreamClass

    parentClass: OutputStreamClass
    tell: (stream: FileOutputStream) => number
    canSeek: (stream: FileOutputStream) => boolean
    seek: (
      stream: FileOutputStream,
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ) => boolean
    canTruncate: (stream: FileOutputStream) => boolean
    truncateFn: (
      stream: FileOutputStream,
      size: number,
      cancellable: Cancellable | null
    ) => boolean
    queryInfo: (
      stream: FileOutputStream,
      attributes: string,
      cancellable: Cancellable | null
    ) => FileInfo
    queryInfoAsync: (
      stream: FileOutputStream,
      attributes: string,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    queryInfoFinish: (stream: FileOutputStream, result: AsyncResult) => FileInfo
    getEtag: (stream: FileOutputStream) => string | null
  }

  abstract class FileOutputStreamClass {
    // Own properties of Gio-2.0.Gio.FileOutputStreamClass

    static name: string
  }

  interface FileOutputStreamPrivate {}

  class FileOutputStreamPrivate {
    // Own properties of Gio-2.0.Gio.FileOutputStreamPrivate

    static name: string
  }

  interface FilenameCompleterClass {
    // Own fields of Gio-2.0.Gio.FilenameCompleterClass

    parentClass: GObject.ObjectClass
    gotCompletionData: (filenameCompleter: FilenameCompleter) => void
  }

  abstract class FilenameCompleterClass {
    // Own properties of Gio-2.0.Gio.FilenameCompleterClass

    static name: string
  }

  interface FilterInputStreamClass {
    // Own fields of Gio-2.0.Gio.FilterInputStreamClass

    parentClass: InputStreamClass
  }

  abstract class FilterInputStreamClass {
    // Own properties of Gio-2.0.Gio.FilterInputStreamClass

    static name: string
  }

  interface FilterOutputStreamClass {
    // Own fields of Gio-2.0.Gio.FilterOutputStreamClass

    parentClass: OutputStreamClass
  }

  abstract class FilterOutputStreamClass {
    // Own properties of Gio-2.0.Gio.FilterOutputStreamClass

    static name: string
  }

  interface IOExtension {
    // Owm methods of Gio-2.0.Gio.IOExtension

    /**
     * Gets the name under which `extension` was registered.
     *
     * Note that the same type may be registered as extension
     * for multiple extension points, under different names.
     * @returns the name of @extension.
     */
    getName(): string
    /**
     * Gets the priority with which `extension` was registered.
     * @returns the priority of @extension
     */
    getPriority(): number
    /**
     * Gets the type associated with `extension`.
     * @returns the type of @extension
     */
    getType(): GObject.GType
  }

  /**
   * #GIOExtension is an opaque data structure and can only be accessed
   * using the following functions.
   * @record
   */
  class IOExtension {
    // Own properties of Gio-2.0.Gio.IOExtension

    static name: string
  }

  interface IOExtensionPoint {
    // Owm methods of Gio-2.0.Gio.IOExtensionPoint

    /**
     * Finds a #GIOExtension for an extension point by name.
     * @param name the name of the extension to get
     * @returns the #GIOExtension for @extension_point that has the    given name, or %NULL if there is no extension with that name
     */
    getExtensionByName(name: string): IOExtension
    /**
     * Gets a list of all extensions that implement this extension point.
     * The list is sorted by priority, beginning with the highest priority.
     * @returns a #GList of     #GIOExtensions. The list is owned by GIO and should not be     modified.
     */
    getExtensions(): IOExtension[]
    /**
     * Gets the required type for `extension_point`.
     * @returns the #GType that all implementations must have,   or %G_TYPE_INVALID if the extension point has no required type
     */
    getRequiredType(): GObject.GType
    /**
     * Sets the required type for `extension_point` to `type`.
     * All implementations must henceforth have this type.
     * @param type the #GType to require
     */
    setRequiredType(type: GObject.GType): void
  }

  /**
   * `GIOExtensionPoint` provides a mechanism for modules to extend the
   * functionality of the library or application that loaded it in an
   * organized fashion.
   *
   * An extension point is identified by a name, and it may optionally
   * require that any implementation must be of a certain type (or derived
   * thereof). Use [func`Gio`.IOExtensionPoint.register] to register an
   * extension point, and [method`Gio`.IOExtensionPoint.set_required_type] to
   * set a required type.
   *
   * A module can implement an extension point by specifying the
   * [type`GObject`.Type] that implements the functionality. Additionally, each
   * implementation of an extension point has a name, and a priority. Use
   * [func`Gio`.IOExtensionPoint.implement] to implement an extension point.
   *
   * ```c
   * GIOExtensionPoint *ep;
   *
   * // Register an extension point
   * ep = g_io_extension_point_register ("my-extension-point");
   * g_io_extension_point_set_required_type (ep, MY_TYPE_EXAMPLE);
   * ```
   *
   * ```c
   * // Implement an extension point
   * G_DEFINE_TYPE (MyExampleImpl, my_example_impl, MY_TYPE_EXAMPLE)
   * g_io_extension_point_implement ("my-extension-point",
   *                                 my_example_impl_get_type (),
   *                                 "my-example",
   *                                 10);
   * ```
   *
   *  It is up to the code that registered the extension point how
   *  it uses the implementations that have been associated with it.
   *  Depending on the use case, it may use all implementations, or
   *  only the one with the highest priority, or pick a specific
   *  one by name.
   *
   *  To avoid opening all modules just to find out what extension
   *  points they implement, GIO makes use of a caching mechanism,
   *  see [gio-querymodules](gio-querymodules.html).
   *  You are expected to run this command after installing a
   *  GIO module.
   *
   *  The `GIO_EXTRA_MODULES` environment variable can be used to
   *  specify additional directories to automatically load modules
   *  from. This environment variable has the same syntax as the
   *  `PATH`. If two modules have the same base name in different
   *  directories, then the latter one will be ignored. If additional
   *  directories are specified GIO will load modules from the built-in
   *  directory last.
   * @record
   */
  class IOExtensionPoint {
    // Own properties of Gio-2.0.Gio.IOExtensionPoint

    static name: string

    // Constructors of Gio-2.0.Gio.IOExtensionPoint

    /**
     * Registers `type` as extension for the extension point with name
     * `extension_point_name`.
     *
     * If `type` has already been registered as an extension for this
     * extension point, the existing #GIOExtension object is returned.
     * @param extensionPointName the name of the extension point
     * @param type the #GType to register as extension
     * @param extensionName the name for the extension
     * @param priority the priority for the extension
     * @returns a #GIOExtension object for #GType
     */
    static implement(
      extensionPointName: string,
      type: GObject.GType,
      extensionName: string,
      priority: number
    ): IOExtension
    /**
     * Looks up an existing extension point.
     * @param name the name of the extension point
     * @returns the #GIOExtensionPoint, or %NULL if there    is no registered extension point with the given name.
     */
    static lookup(name: string): IOExtensionPoint
    /**
     * Registers an extension point.
     * @param name The name of the extension point
     * @returns the new #GIOExtensionPoint. This object is    owned by GIO and should not be freed.
     */
    static register(name: string): IOExtensionPoint
  }

  interface IOModuleClass {}

  abstract class IOModuleClass {
    // Own properties of Gio-2.0.Gio.IOModuleClass

    static name: string
  }

  interface IOModuleScope {
    // Owm methods of Gio-2.0.Gio.IOModuleScope

    /**
     * Block modules with the given `basename` from being loaded when
     * this scope is used with g_io_modules_scan_all_in_directory_with_scope()
     * or g_io_modules_load_all_in_directory_with_scope().
     * @param basename the basename to block
     */
    block(basename: string): void
    /**
     * Free a module scope.
     */
    free(): void
  }

  /**
   * Represents a scope for loading IO modules. A scope can be used for blocking
   * duplicate modules, or blocking a module you don't want to load.
   *
   * The scope can be used with g_io_modules_load_all_in_directory_with_scope()
   * or g_io_modules_scan_all_in_directory_with_scope().
   * @record
   */
  class IOModuleScope {
    // Own properties of Gio-2.0.Gio.IOModuleScope

    static name: string
  }

  interface IOSchedulerJob {
    // Owm methods of Gio-2.0.Gio.IOSchedulerJob

    /**
     * Used from an I/O job to send a callback to be run in the thread
     * that the job was started from, waiting for the result (and thus
     * blocking the I/O job).
     * @param func a #GSourceFunc callback that will be called in the original thread
     * @returns The return value of @func
     */
    sendToMainloop(func: GLib.SourceFunc): boolean
    /**
     * Used from an I/O job to send a callback to be run asynchronously in
     * the thread that the job was started from. The callback will be run
     * when the main loop is available, but at that time the I/O job might
     * have finished. The return value from the callback is ignored.
     *
     * Note that if you are passing the `user_data` from g_io_scheduler_push_job()
     * on to this function you have to ensure that it is not freed before
     * `func` is called, either by passing %NULL as `notify` to
     * g_io_scheduler_push_job() or by using refcounting for `user_data`.
     * @param func a #GSourceFunc callback that will be called in the original thread
     */
    sendToMainloopAsync(func: GLib.SourceFunc): void
  }

  /**
   * Opaque class for defining and scheduling IO jobs.
   * @record
   */
  class IOSchedulerJob {
    // Own properties of Gio-2.0.Gio.IOSchedulerJob

    static name: string
  }

  interface IOStreamAdapter {}

  class IOStreamAdapter {
    // Own properties of Gio-2.0.Gio.IOStreamAdapter

    static name: string
  }

  interface IOStreamClass {
    // Own fields of Gio-2.0.Gio.IOStreamClass

    parentClass: GObject.ObjectClass
    getInputStream: (stream: IOStream) => InputStream
    getOutputStream: (stream: IOStream) => OutputStream
    closeFn: (stream: IOStream, cancellable: Cancellable | null) => boolean
    closeAsync: (
      stream: IOStream,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    closeFinish: (stream: IOStream, result: AsyncResult) => boolean
  }

  abstract class IOStreamClass {
    // Own properties of Gio-2.0.Gio.IOStreamClass

    static name: string
  }

  interface IOStreamPrivate {}

  class IOStreamPrivate {
    // Own properties of Gio-2.0.Gio.IOStreamPrivate

    static name: string
  }

  interface IconIface {
    // Own fields of Gio-2.0.Gio.IconIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * A hash for a given #GIcon.
     * @field
     */
    hash: (icon: Icon) => number
    /**
     * Checks if two #GIcons are equal.
     * @field
     */
    equal: (icon1: Icon | null, icon2: Icon | null) => boolean
    /**
     * Serializes a #GIcon into tokens. The tokens must not
     * contain any whitespace. Don't implement if the #GIcon can't be
     * serialized (Since 2.20).
     * @field
     */
    toTokens: (
      icon: Icon
    ) => [
      /* returnType */ boolean,
      /* tokens */ string[],
      /* outVersion */ number,
    ]
    /**
     * Serializes a #GIcon into a #GVariant. Since: 2.38
     * @field
     */
    serialize: (icon: Icon) => GLib.Variant | null
  }

  /**
   * GIconIface is used to implement GIcon types for various
   * different systems. See #GThemedIcon and #GLoadableIcon for
   * examples of how to implement this interface.
   * @record
   */
  abstract class IconIface {
    // Own properties of Gio-2.0.Gio.IconIface

    static name: string
  }

  interface InetAddressClass {
    // Own fields of Gio-2.0.Gio.InetAddressClass

    parentClass: GObject.ObjectClass
    toString: (address: InetAddress) => string | null
    toBytes: (address: InetAddress) => number
  }

  abstract class InetAddressClass {
    // Own properties of Gio-2.0.Gio.InetAddressClass

    static name: string
  }

  interface InetAddressMaskClass {
    // Own fields of Gio-2.0.Gio.InetAddressMaskClass

    parentClass: GObject.ObjectClass
  }

  abstract class InetAddressMaskClass {
    // Own properties of Gio-2.0.Gio.InetAddressMaskClass

    static name: string
  }

  interface InetAddressMaskPrivate {}

  class InetAddressMaskPrivate {
    // Own properties of Gio-2.0.Gio.InetAddressMaskPrivate

    static name: string
  }

  interface InetAddressPrivate {}

  class InetAddressPrivate {
    // Own properties of Gio-2.0.Gio.InetAddressPrivate

    static name: string
  }

  interface InetSocketAddressClass {
    // Own fields of Gio-2.0.Gio.InetSocketAddressClass

    parentClass: SocketAddressClass
  }

  abstract class InetSocketAddressClass {
    // Own properties of Gio-2.0.Gio.InetSocketAddressClass

    static name: string
  }

  interface InetSocketAddressPrivate {}

  class InetSocketAddressPrivate {
    // Own properties of Gio-2.0.Gio.InetSocketAddressPrivate

    static name: string
  }

  interface InitableIface {
    // Own fields of Gio-2.0.Gio.InitableIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Initializes the object.
     * @field
     */
    init: (initable: Initable, cancellable: Cancellable | null) => boolean
  }

  /**
   * Provides an interface for initializing object such that initialization
   * may fail.
   * @record
   */
  abstract class InitableIface {
    // Own properties of Gio-2.0.Gio.InitableIface

    static name: string
  }

  interface InputMessage {
    // Own fields of Gio-2.0.Gio.InputMessage

    /**
     * return location
     *   for a #GSocketAddress, or %NULL
     * @field
     */
    address: SocketAddress
    /**
     * pointer to an
     *   array of input vectors
     * @field
     */
    vectors: InputVector[]
    /**
     * the number of input vectors pointed to by `vectors`
     * @field
     */
    numVectors: number
    /**
     * will be set to the number of bytes that have been
     *   received
     * @field
     */
    bytesReceived: number
    /**
     * collection of #GSocketMsgFlags for the received message,
     *   outputted by the call
     * @field
     */
    flags: number
    /**
     * return location for a
     *   caller-allocated array of #GSocketControlMessages, or %NULL
     * @field
     */
    controlMessages: SocketControlMessage[]
    /**
     * return location for the number of
     *   elements in `control_messages`
     * @field
     */
    numControlMessages: number
  }

  /**
   * Structure used for scatter/gather data input when receiving multiple
   * messages or packets in one go. You generally pass in an array of empty
   * #GInputVectors and the operation will use all the buffers as if they
   * were one buffer, and will set `bytes_received` to the total number of bytes
   * received across all #GInputVectors.
   *
   * This structure closely mirrors `struct mmsghdr` and `struct msghdr` from
   * the POSIX sockets API (see `man 2 recvmmsg`).
   *
   * If `address` is non-%NULL then it is set to the source address the message
   * was received from, and the caller must free it afterwards.
   *
   * If `control_messages` is non-%NULL then it is set to an array of control
   * messages received with the message (if any), and the caller must free it
   * afterwards. `num_control_messages` is set to the number of elements in
   * this array, which may be zero.
   *
   * Flags relevant to this message will be returned in `flags`. For example,
   * `MSG_EOR` or `MSG_TRUNC`.
   * @record
   */
  class InputMessage {
    // Own properties of Gio-2.0.Gio.InputMessage

    static name: string
  }

  interface InputStreamClass {
    // Own fields of Gio-2.0.Gio.InputStreamClass

    parentClass: GObject.ObjectClass
    readFn: (
      stream: InputStream,
      buffer: any | null,
      count: number,
      cancellable: Cancellable | null
    ) => number
    skip: (
      stream: InputStream,
      count: number,
      cancellable: Cancellable | null
    ) => number
    closeFn: (stream: InputStream, cancellable: Cancellable | null) => boolean
    readAsync: (
      stream: InputStream,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => /* buffer */ number[] | null
    readFinish: (stream: InputStream, result: AsyncResult) => number
    skipAsync: (
      stream: InputStream,
      count: number,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    skipFinish: (stream: InputStream, result: AsyncResult) => number
    closeAsync: (
      stream: InputStream,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    closeFinish: (stream: InputStream, result: AsyncResult) => boolean
  }

  abstract class InputStreamClass {
    // Own properties of Gio-2.0.Gio.InputStreamClass

    static name: string
  }

  interface InputStreamPrivate {}

  class InputStreamPrivate {
    // Own properties of Gio-2.0.Gio.InputStreamPrivate

    static name: string
  }

  interface InputVector {
    // Own fields of Gio-2.0.Gio.InputVector

    /**
     * Pointer to a buffer where data will be written.
     * @field
     */
    buffer: any
    /**
     * the available size in `buffer`.
     * @field
     */
    size: number
  }

  /**
   * Structure used for scatter/gather data input.
   * You generally pass in an array of #GInputVectors
   * and the operation will store the read data starting in the
   * first buffer, switching to the next as needed.
   * @record
   */
  class InputVector {
    // Own properties of Gio-2.0.Gio.InputVector

    static name: string
  }

  interface ListModelInterface {
    // Own fields of Gio-2.0.Gio.ListModelInterface

    /**
     * parent #GTypeInterface
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * the virtual function pointer for g_list_model_get_item_type()
     * @field
     */
    getItemType: (list: ListModel) => GObject.GType
    /**
     * the virtual function pointer for g_list_model_get_n_items()
     * @field
     */
    getNItems: (list: ListModel) => number
    /**
     * the virtual function pointer for g_list_model_get_item()
     * @field
     */
    getItem: (list: ListModel, position: number) => GObject.Object | null
  }

  /**
   * The virtual function table for #GListModel.
   * @record
   */
  abstract class ListModelInterface {
    // Own properties of Gio-2.0.Gio.ListModelInterface

    static name: string
  }

  interface ListStoreClass {
    // Own fields of Gio-2.0.Gio.ListStoreClass

    parentClass: GObject.ObjectClass
  }

  abstract class ListStoreClass {
    // Own properties of Gio-2.0.Gio.ListStoreClass

    static name: string
  }

  interface LoadableIconIface {
    // Own fields of Gio-2.0.Gio.LoadableIconIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Loads an icon.
     * @field
     */
    load: (
      icon: LoadableIcon,
      size: number,
      cancellable: Cancellable | null
    ) => [/* returnType */ InputStream, /* type */ string]
    /**
     * Loads an icon asynchronously.
     * @field
     */
    loadAsync: (
      icon: LoadableIcon,
      size: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an asynchronous icon load.
     * @field
     */
    loadFinish: (
      icon: LoadableIcon,
      res: AsyncResult
    ) => [/* returnType */ InputStream, /* type */ string]
  }

  /**
   * Interface for icons that can be loaded as a stream.
   * @record
   */
  abstract class LoadableIconIface {
    // Own properties of Gio-2.0.Gio.LoadableIconIface

    static name: string
  }

  interface MemoryInputStreamClass {
    // Own fields of Gio-2.0.Gio.MemoryInputStreamClass

    parentClass: InputStreamClass
  }

  abstract class MemoryInputStreamClass {
    // Own properties of Gio-2.0.Gio.MemoryInputStreamClass

    static name: string
  }

  interface MemoryInputStreamPrivate {}

  class MemoryInputStreamPrivate {
    // Own properties of Gio-2.0.Gio.MemoryInputStreamPrivate

    static name: string
  }

  interface MemoryMonitorInterface {
    // Own fields of Gio-2.0.Gio.MemoryMonitorInterface

    /**
     * the virtual function pointer for the
     *  #GMemoryMonitor::low-memory-warning signal.
     * @field
     */
    lowMemoryWarning: (
      monitor: MemoryMonitor,
      level: MemoryMonitorWarningLevel
    ) => void
  }

  /**
   * The virtual function table for #GMemoryMonitor.
   * @record
   */
  abstract class MemoryMonitorInterface {
    // Own properties of Gio-2.0.Gio.MemoryMonitorInterface

    static name: string
  }

  interface MemoryOutputStreamClass {
    // Own fields of Gio-2.0.Gio.MemoryOutputStreamClass

    parentClass: OutputStreamClass
  }

  abstract class MemoryOutputStreamClass {
    // Own properties of Gio-2.0.Gio.MemoryOutputStreamClass

    static name: string
  }

  interface MemoryOutputStreamPrivate {}

  class MemoryOutputStreamPrivate {
    // Own properties of Gio-2.0.Gio.MemoryOutputStreamPrivate

    static name: string
  }

  interface MenuAttributeIterClass {
    // Own fields of Gio-2.0.Gio.MenuAttributeIterClass

    parentClass: GObject.ObjectClass
    getNext: (
      iter: MenuAttributeIter
    ) => [
      /* returnType */ boolean,
      /* outName */ string,
      /* value */ GLib.Variant,
    ]
  }

  abstract class MenuAttributeIterClass {
    // Own properties of Gio-2.0.Gio.MenuAttributeIterClass

    static name: string
  }

  interface MenuAttributeIterPrivate {}

  class MenuAttributeIterPrivate {
    // Own properties of Gio-2.0.Gio.MenuAttributeIterPrivate

    static name: string
  }

  interface MenuLinkIterClass {
    // Own fields of Gio-2.0.Gio.MenuLinkIterClass

    parentClass: GObject.ObjectClass
    getNext: (
      iter: MenuLinkIter
    ) => [/* returnType */ boolean, /* outLink */ string, /* value */ MenuModel]
  }

  abstract class MenuLinkIterClass {
    // Own properties of Gio-2.0.Gio.MenuLinkIterClass

    static name: string
  }

  interface MenuLinkIterPrivate {}

  class MenuLinkIterPrivate {
    // Own properties of Gio-2.0.Gio.MenuLinkIterPrivate

    static name: string
  }

  interface MenuModelClass {
    // Own fields of Gio-2.0.Gio.MenuModelClass

    parentClass: GObject.ObjectClass
    isMutable: (model: MenuModel) => boolean
    getNItems: (model: MenuModel) => number
    getItemAttributes: (
      model: MenuModel,
      itemIndex: number
    ) => /* attributes */ GLib.HashTable
    iterateItemAttributes: (
      model: MenuModel,
      itemIndex: number
    ) => MenuAttributeIter
    getItemAttributeValue: (
      model: MenuModel,
      itemIndex: number,
      attribute: string,
      expectedType: GLib.VariantType | null
    ) => GLib.Variant | null
    getItemLinks: (
      model: MenuModel,
      itemIndex: number
    ) => /* links */ GLib.HashTable
    iterateItemLinks: (model: MenuModel, itemIndex: number) => MenuLinkIter
    getItemLink: (
      model: MenuModel,
      itemIndex: number,
      link: string
    ) => MenuModel | null
  }

  abstract class MenuModelClass {
    // Own properties of Gio-2.0.Gio.MenuModelClass

    static name: string
  }

  interface MenuModelPrivate {}

  class MenuModelPrivate {
    // Own properties of Gio-2.0.Gio.MenuModelPrivate

    static name: string
  }

  interface MountIface {
    // Own fields of Gio-2.0.Gio.MountIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Changed signal that is emitted when the mount's state has changed.
     * @field
     */
    changed: (mount: Mount) => void
    /**
     * The unmounted signal that is emitted when the #GMount have been unmounted. If the recipient is holding references to the object they should release them so the object can be finalized.
     * @field
     */
    unmounted: (mount: Mount) => void
    /**
     * Gets a #GFile to the root directory of the #GMount.
     * @field
     */
    getRoot: (mount: Mount) => File
    /**
     * Gets a string containing the name of the #GMount.
     * @field
     */
    getName: (mount: Mount) => string | null
    /**
     * Gets a #GIcon for the #GMount.
     * @field
     */
    getIcon: (mount: Mount) => Icon
    /**
     * Gets the UUID for the #GMount. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.
     * @field
     */
    getUuid: (mount: Mount) => string | null
    /**
     * Gets a #GVolume the mount is located on. Returns %NULL if the #GMount is not associated with a #GVolume.
     * @field
     */
    getVolume: (mount: Mount) => Volume | null
    /**
     * Gets a #GDrive the volume of the mount is located on. Returns %NULL if the #GMount is not associated with a #GDrive or a #GVolume. This is convenience method for getting the #GVolume and using that to get the #GDrive.
     * @field
     */
    getDrive: (mount: Mount) => Drive | null
    /**
     * Checks if a #GMount can be unmounted.
     * @field
     */
    canUnmount: (mount: Mount) => boolean
    /**
     * Checks if a #GMount can be ejected.
     * @field
     */
    canEject: (mount: Mount) => boolean
    /**
     * Starts unmounting a #GMount.
     * @field
     */
    unmount: (
      mount: Mount,
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an unmounting operation.
     * @field
     */
    unmountFinish: (mount: Mount, result: AsyncResult) => boolean
    /**
     * Starts ejecting a #GMount.
     * @field
     */
    eject: (
      mount: Mount,
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an eject operation.
     * @field
     */
    ejectFinish: (mount: Mount, result: AsyncResult) => boolean
    /**
     * Starts remounting a #GMount.
     * @field
     */
    remount: (
      mount: Mount,
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a remounting operation.
     * @field
     */
    remountFinish: (mount: Mount, result: AsyncResult) => boolean
    /**
     * Starts guessing the type of the content of a #GMount.
     *     See g_mount_guess_content_type() for more information on content
     *     type guessing. This operation was added in 2.18.
     * @field
     */
    guessContentType: (
      mount: Mount,
      forceRescan: boolean,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a content type guessing operation. Added in 2.18.
     * @field
     */
    guessContentTypeFinish: (mount: Mount, result: AsyncResult) => string[]
    /**
     * Synchronous variant of `guess_content_type`. Added in 2.18
     * @field
     */
    guessContentTypeSync: (
      mount: Mount,
      forceRescan: boolean,
      cancellable: Cancellable | null
    ) => string[]
    /**
     * The ::pre-unmount signal that is emitted when the #GMount will soon be emitted. If the recipient is somehow holding the mount open by keeping an open file on it it should close the file.
     * @field
     */
    preUnmount: (mount: Mount) => void
    /**
     * Starts unmounting a #GMount using a #GMountOperation. Since 2.22.
     * @field
     */
    unmountWithOperation: (
      mount: Mount,
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an unmounting operation using a #GMountOperation. Since 2.22.
     * @field
     */
    unmountWithOperationFinish: (mount: Mount, result: AsyncResult) => boolean
    /**
     * Starts ejecting a #GMount using a #GMountOperation. Since 2.22.
     * @field
     */
    ejectWithOperation: (
      mount: Mount,
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an eject operation using a #GMountOperation. Since 2.22.
     * @field
     */
    ejectWithOperationFinish: (mount: Mount, result: AsyncResult) => boolean
    /**
     * Gets a #GFile indication a start location that can be use as the entry point for this mount. Since 2.24.
     * @field
     */
    getDefaultLocation: (mount: Mount) => File
    /**
     * Gets a key used for sorting #GMount instance or %NULL if no such key exists. Since 2.32.
     * @field
     */
    getSortKey: (mount: Mount) => string | null
    /**
     * Gets a symbolic #GIcon for the #GMount. Since 2.34.
     * @field
     */
    getSymbolicIcon: (mount: Mount) => Icon
  }

  /**
   * Interface for implementing operations for mounts.
   * @record
   */
  abstract class MountIface {
    // Own properties of Gio-2.0.Gio.MountIface

    static name: string
  }

  interface MountOperationClass {
    // Own fields of Gio-2.0.Gio.MountOperationClass

    parentClass: GObject.ObjectClass
    askPassword: (
      op: MountOperation,
      message: string,
      defaultUser: string,
      defaultDomain: string,
      flags: AskPasswordFlags
    ) => void
    askQuestion: (
      op: MountOperation,
      message: string,
      choices: string[]
    ) => void
    reply: (op: MountOperation, result: MountOperationResult) => void
    aborted: (op: MountOperation) => void
    showProcesses: (
      op: MountOperation,
      message: string,
      processes: GLib.Pid[],
      choices: string[]
    ) => void
    showUnmountProgress: (
      op: MountOperation,
      message: string,
      timeLeft: number,
      bytesLeft: number
    ) => void
  }

  abstract class MountOperationClass {
    // Own properties of Gio-2.0.Gio.MountOperationClass

    static name: string
  }

  interface MountOperationPrivate {}

  class MountOperationPrivate {
    // Own properties of Gio-2.0.Gio.MountOperationPrivate

    static name: string
  }

  interface NativeSocketAddressClass {
    // Own fields of Gio-2.0.Gio.NativeSocketAddressClass

    parentClass: SocketAddressClass
  }

  abstract class NativeSocketAddressClass {
    // Own properties of Gio-2.0.Gio.NativeSocketAddressClass

    static name: string
  }

  interface NativeSocketAddressPrivate {}

  class NativeSocketAddressPrivate {
    // Own properties of Gio-2.0.Gio.NativeSocketAddressPrivate

    static name: string
  }

  interface NativeVolumeMonitorClass {
    // Own fields of Gio-2.0.Gio.NativeVolumeMonitorClass

    parentClass: VolumeMonitorClass
  }

  abstract class NativeVolumeMonitorClass {
    // Own properties of Gio-2.0.Gio.NativeVolumeMonitorClass

    static name: string
  }

  interface NetworkAddressClass {
    // Own fields of Gio-2.0.Gio.NetworkAddressClass

    parentClass: GObject.ObjectClass
  }

  abstract class NetworkAddressClass {
    // Own properties of Gio-2.0.Gio.NetworkAddressClass

    static name: string
  }

  interface NetworkAddressPrivate {}

  class NetworkAddressPrivate {
    // Own properties of Gio-2.0.Gio.NetworkAddressPrivate

    static name: string
  }

  interface NetworkMonitorInterface {
    // Own fields of Gio-2.0.Gio.NetworkMonitorInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * the virtual function pointer for the
     *  GNetworkMonitor::network-changed signal.
     * @field
     */
    networkChanged: (monitor: NetworkMonitor, networkAvailable: boolean) => void
    /**
     * the virtual function pointer for g_network_monitor_can_reach()
     * @field
     */
    canReach: (
      monitor: NetworkMonitor,
      connectable: SocketConnectable,
      cancellable: Cancellable | null
    ) => boolean
    /**
     * the virtual function pointer for
     *  g_network_monitor_can_reach_async()
     * @field
     */
    canReachAsync: (
      monitor: NetworkMonitor,
      connectable: SocketConnectable,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * the virtual function pointer for
     *  g_network_monitor_can_reach_finish()
     * @field
     */
    canReachFinish: (monitor: NetworkMonitor, result: AsyncResult) => boolean
  }

  /**
   * The virtual function table for #GNetworkMonitor.
   * @record
   */
  abstract class NetworkMonitorInterface {
    // Own properties of Gio-2.0.Gio.NetworkMonitorInterface

    static name: string
  }

  interface NetworkServiceClass {
    // Own fields of Gio-2.0.Gio.NetworkServiceClass

    parentClass: GObject.ObjectClass
  }

  abstract class NetworkServiceClass {
    // Own properties of Gio-2.0.Gio.NetworkServiceClass

    static name: string
  }

  interface NetworkServicePrivate {}

  class NetworkServicePrivate {
    // Own properties of Gio-2.0.Gio.NetworkServicePrivate

    static name: string
  }

  interface OutputMessage {
    // Own fields of Gio-2.0.Gio.OutputMessage

    /**
     * a #GSocketAddress, or %NULL
     * @field
     */
    address: SocketAddress
    /**
     * pointer to an array of output vectors
     * @field
     */
    vectors: OutputVector
    /**
     * the number of output vectors pointed to by `vectors`.
     * @field
     */
    numVectors: number
    /**
     * initialize to 0. Will be set to the number of bytes
     *     that have been sent
     * @field
     */
    bytesSent: number
    /**
     * a pointer
     *   to an array of #GSocketControlMessages, or %NULL.
     * @field
     */
    controlMessages: SocketControlMessage[]
    /**
     * number of elements in `control_messages`.
     * @field
     */
    numControlMessages: number
  }

  /**
   * Structure used for scatter/gather data output when sending multiple
   * messages or packets in one go. You generally pass in an array of
   * #GOutputVectors and the operation will use all the buffers as if they
   * were one buffer.
   *
   * If `address` is %NULL then the message is sent to the default receiver
   * (as previously set by g_socket_connect()).
   * @record
   */
  class OutputMessage {
    // Own properties of Gio-2.0.Gio.OutputMessage

    static name: string
  }

  interface OutputStreamClass {
    // Own fields of Gio-2.0.Gio.OutputStreamClass

    parentClass: GObject.ObjectClass
    writeFn: (
      stream: OutputStream,
      buffer: number[] | null,
      cancellable: Cancellable | null
    ) => number
    splice: (
      stream: OutputStream,
      source: InputStream,
      flags: OutputStreamSpliceFlags,
      cancellable: Cancellable | null
    ) => number
    flush: (stream: OutputStream, cancellable: Cancellable | null) => boolean
    closeFn: (stream: OutputStream, cancellable: Cancellable | null) => boolean
    writeAsync: (
      stream: OutputStream,
      buffer: number[] | null,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    writeFinish: (stream: OutputStream, result: AsyncResult) => number
    spliceAsync: (
      stream: OutputStream,
      source: InputStream,
      flags: OutputStreamSpliceFlags,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    spliceFinish: (stream: OutputStream, result: AsyncResult) => number
    flushAsync: (
      stream: OutputStream,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    flushFinish: (stream: OutputStream, result: AsyncResult) => boolean
    closeAsync: (
      stream: OutputStream,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    closeFinish: (stream: OutputStream, result: AsyncResult) => boolean
    writevFn: (
      stream: OutputStream,
      vectors: OutputVector[],
      cancellable: Cancellable | null
    ) => [/* returnType */ boolean, /* bytesWritten */ number]
    writevAsync: (
      stream: OutputStream,
      vectors: OutputVector[],
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    writevFinish: (
      stream: OutputStream,
      result: AsyncResult
    ) => [/* returnType */ boolean, /* bytesWritten */ number]
  }

  abstract class OutputStreamClass {
    // Own properties of Gio-2.0.Gio.OutputStreamClass

    static name: string
  }

  interface OutputStreamPrivate {}

  class OutputStreamPrivate {
    // Own properties of Gio-2.0.Gio.OutputStreamPrivate

    static name: string
  }

  interface OutputVector {
    // Own fields of Gio-2.0.Gio.OutputVector

    /**
     * Pointer to a buffer of data to read.
     * @field
     */
    buffer: any
    /**
     * the size of `buffer`.
     * @field
     */
    size: number
  }

  /**
   * Structure used for scatter/gather data output.
   * You generally pass in an array of #GOutputVectors
   * and the operation will use all the buffers as if they were
   * one buffer.
   * @record
   */
  class OutputVector {
    // Own properties of Gio-2.0.Gio.OutputVector

    static name: string
  }

  interface PermissionClass {
    // Own fields of Gio-2.0.Gio.PermissionClass

    parentClass: GObject.ObjectClass
    acquire: (
      permission: Permission,
      cancellable: Cancellable | null
    ) => boolean
    acquireAsync: (
      permission: Permission,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    acquireFinish: (permission: Permission, result: AsyncResult) => boolean
    release: (
      permission: Permission,
      cancellable: Cancellable | null
    ) => boolean
    releaseAsync: (
      permission: Permission,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    releaseFinish: (permission: Permission, result: AsyncResult) => boolean
    reserved: any[]
  }

  abstract class PermissionClass {
    // Own properties of Gio-2.0.Gio.PermissionClass

    static name: string
  }

  interface PermissionPrivate {}

  class PermissionPrivate {
    // Own properties of Gio-2.0.Gio.PermissionPrivate

    static name: string
  }

  interface PollableInputStreamInterface {
    // Own fields of Gio-2.0.Gio.PollableInputStreamInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Checks if the #GPollableInputStream instance is actually pollable
     * @field
     */
    canPoll: (stream: PollableInputStream) => boolean
    /**
     * Checks if the stream is readable
     * @field
     */
    isReadable: (stream: PollableInputStream) => boolean
    /**
     * Creates a #GSource to poll the stream
     * @field
     */
    createSource: (
      stream: PollableInputStream,
      cancellable: Cancellable | null
    ) => GLib.Source
    /**
     * Does a non-blocking read or returns
     *   %G_IO_ERROR_WOULD_BLOCK
     * @field
     */
    readNonblocking: (
      stream: PollableInputStream
    ) => [/* returnType */ number, /* buffer */ number[] | null]
  }

  /**
   * The interface for pollable input streams.
   *
   * The default implementation of `can_poll` always returns %TRUE.
   *
   * The default implementation of `read_nonblocking` calls
   * g_pollable_input_stream_is_readable(), and then calls
   * g_input_stream_read() if it returns %TRUE. This means you only need
   * to override it if it is possible that your `is_readable`
   * implementation may return %TRUE when the stream is not actually
   * readable.
   * @record
   */
  abstract class PollableInputStreamInterface {
    // Own properties of Gio-2.0.Gio.PollableInputStreamInterface

    static name: string
  }

  interface PollableOutputStreamInterface {
    // Own fields of Gio-2.0.Gio.PollableOutputStreamInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Checks if the #GPollableOutputStream instance is actually pollable
     * @field
     */
    canPoll: (stream: PollableOutputStream) => boolean
    /**
     * Checks if the stream is writable
     * @field
     */
    isWritable: (stream: PollableOutputStream) => boolean
    /**
     * Creates a #GSource to poll the stream
     * @field
     */
    createSource: (
      stream: PollableOutputStream,
      cancellable: Cancellable | null
    ) => GLib.Source
    /**
     * Does a non-blocking write or returns
     *   %G_IO_ERROR_WOULD_BLOCK
     * @field
     */
    writeNonblocking: (
      stream: PollableOutputStream,
      buffer: number[] | null
    ) => number
    /**
     * Does a vectored non-blocking write, or returns
     *   %G_POLLABLE_RETURN_WOULD_BLOCK
     * @field
     */
    writevNonblocking: (
      stream: PollableOutputStream,
      vectors: OutputVector[]
    ) => [/* returnType */ PollableReturn, /* bytesWritten */ number]
  }

  /**
   * The interface for pollable output streams.
   *
   * The default implementation of `can_poll` always returns %TRUE.
   *
   * The default implementation of `write_nonblocking` calls
   * g_pollable_output_stream_is_writable(), and then calls
   * g_output_stream_write() if it returns %TRUE. This means you only
   * need to override it if it is possible that your `is_writable`
   * implementation may return %TRUE when the stream is not actually
   * writable.
   *
   * The default implementation of `writev_nonblocking` calls
   * g_pollable_output_stream_write_nonblocking() for each vector, and converts
   * its return value and error (if set) to a #GPollableReturn. You should
   * override this where possible to avoid having to allocate a #GError to return
   * %G_IO_ERROR_WOULD_BLOCK.
   * @record
   */
  abstract class PollableOutputStreamInterface {
    // Own properties of Gio-2.0.Gio.PollableOutputStreamInterface

    static name: string
  }

  interface PowerProfileMonitorInterface {}

  /**
   * The virtual function table for #GPowerProfileMonitor.
   * @record
   */
  abstract class PowerProfileMonitorInterface {
    // Own properties of Gio-2.0.Gio.PowerProfileMonitorInterface

    static name: string
  }

  interface ProxyAddressClass {
    // Own fields of Gio-2.0.Gio.ProxyAddressClass

    parentClass: InetSocketAddressClass
  }

  /**
   * Class structure for #GProxyAddress.
   * @record
   */
  abstract class ProxyAddressClass {
    // Own properties of Gio-2.0.Gio.ProxyAddressClass

    static name: string
  }

  interface ProxyAddressEnumeratorClass {}

  /**
   * Class structure for #GProxyAddressEnumerator.
   * @record
   */
  abstract class ProxyAddressEnumeratorClass {
    // Own properties of Gio-2.0.Gio.ProxyAddressEnumeratorClass

    static name: string
  }

  interface ProxyAddressEnumeratorPrivate {}

  class ProxyAddressEnumeratorPrivate {
    // Own properties of Gio-2.0.Gio.ProxyAddressEnumeratorPrivate

    static name: string
  }

  interface ProxyAddressPrivate {}

  class ProxyAddressPrivate {
    // Own properties of Gio-2.0.Gio.ProxyAddressPrivate

    static name: string
  }

  interface ProxyInterface {
    // Own fields of Gio-2.0.Gio.ProxyInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    // Has conflict: connect: (proxy: Proxy, connection: IOStream, proxyAddress: ProxyAddress, cancellable: Cancellable | null) => IOStream
    /**
     * Same as connect() but asynchronous.
     * @field
     */
    connectAsync: (
      proxy: Proxy,
      connection: IOStream,
      proxyAddress: ProxyAddress,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Returns the result of connect_async()
     * @field
     */
    connectFinish: (proxy: Proxy, result: AsyncResult) => IOStream
    /**
     * Returns whether the proxy supports hostname lookups.
     * @field
     */
    supportsHostname: (proxy: Proxy) => boolean
  }

  /**
   * Provides an interface for handling proxy connection and payload.
   * @record
   */
  abstract class ProxyInterface {
    // Own properties of Gio-2.0.Gio.ProxyInterface

    static name: string
  }

  interface ProxyResolverInterface {
    // Own fields of Gio-2.0.Gio.ProxyResolverInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * the virtual function pointer for g_proxy_resolver_is_supported()
     * @field
     */
    isSupported: (resolver: ProxyResolver) => boolean
    /**
     * the virtual function pointer for g_proxy_resolver_lookup()
     * @field
     */
    lookup: (
      resolver: ProxyResolver,
      uri: string,
      cancellable: Cancellable | null
    ) => string[]
    /**
     * the virtual function pointer for
     *  g_proxy_resolver_lookup_async()
     * @field
     */
    lookupAsync: (
      resolver: ProxyResolver,
      uri: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * the virtual function pointer for
     *  g_proxy_resolver_lookup_finish()
     * @field
     */
    lookupFinish: (resolver: ProxyResolver, result: AsyncResult) => string[]
  }

  /**
   * The virtual function table for #GProxyResolver.
   * @record
   */
  abstract class ProxyResolverInterface {
    // Own properties of Gio-2.0.Gio.ProxyResolverInterface

    static name: string
  }

  interface RemoteActionGroupInterface {
    // Own fields of Gio-2.0.Gio.RemoteActionGroupInterface

    gIface: GObject.TypeInterface
    /**
     * the virtual function pointer for g_remote_action_group_activate_action_full()
     * @field
     */
    activateActionFull: (
      remote: RemoteActionGroup,
      actionName: string,
      parameter: GLib.Variant | null,
      platformData: GLib.Variant
    ) => void
    /**
     * the virtual function pointer for g_remote_action_group_change_action_state_full()
     * @field
     */
    changeActionStateFull: (
      remote: RemoteActionGroup,
      actionName: string,
      value: GLib.Variant,
      platformData: GLib.Variant
    ) => void
  }

  /**
   * The virtual function table for #GRemoteActionGroup.
   * @record
   */
  abstract class RemoteActionGroupInterface {
    // Own properties of Gio-2.0.Gio.RemoteActionGroupInterface

    static name: string
  }

  interface ResolverClass {
    // Own fields of Gio-2.0.Gio.ResolverClass

    parentClass: GObject.ObjectClass
    reload: (resolver: Resolver) => void
    lookupByName: (
      resolver: Resolver,
      hostname: string,
      cancellable: Cancellable | null
    ) => InetAddress[]
    lookupByNameAsync: (
      resolver: Resolver,
      hostname: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    lookupByNameFinish: (
      resolver: Resolver,
      result: AsyncResult
    ) => InetAddress[]
    lookupByAddress: (
      resolver: Resolver,
      address: InetAddress,
      cancellable: Cancellable | null
    ) => string | null
    lookupByAddressAsync: (
      resolver: Resolver,
      address: InetAddress,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    lookupByAddressFinish: (
      resolver: Resolver,
      result: AsyncResult
    ) => string | null
    lookupServiceAsync: (
      resolver: Resolver,
      rrname: string,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    lookupServiceFinish: (
      resolver: Resolver,
      result: AsyncResult
    ) => SrvTarget[]
    lookupRecords: (
      resolver: Resolver,
      rrname: string,
      recordType: ResolverRecordType,
      cancellable: Cancellable | null
    ) => GLib.Variant[]
    lookupRecordsAsync: (
      resolver: Resolver,
      rrname: string,
      recordType: ResolverRecordType,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    lookupRecordsFinish: (
      resolver: Resolver,
      result: AsyncResult
    ) => GLib.Variant[]
    lookupByNameWithFlagsAsync: (
      resolver: Resolver,
      hostname: string,
      flags: ResolverNameLookupFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    lookupByNameWithFlagsFinish: (
      resolver: Resolver,
      result: AsyncResult
    ) => InetAddress[]
    lookupByNameWithFlags: (
      resolver: Resolver,
      hostname: string,
      flags: ResolverNameLookupFlags,
      cancellable: Cancellable | null
    ) => InetAddress[]
  }

  abstract class ResolverClass {
    // Own properties of Gio-2.0.Gio.ResolverClass

    static name: string
  }

  interface ResolverPrivate {}

  class ResolverPrivate {
    // Own properties of Gio-2.0.Gio.ResolverPrivate

    static name: string
  }

  interface Resource {
    // Owm methods of Gio-2.0.Gio.Resource

    /**
     * Registers the resource with the process-global set of resources.
     * Once a resource is registered the files in it can be accessed
     * with the global resource lookup functions like g_resources_lookup_data().
     */
    register(): void
    /**
     * Unregisters the resource from the process-global set of resources.
     */
    unregister(): void
    /**
     * Returns all the names of children at the specified `path` in the resource.
     * The return result is a %NULL terminated list of strings which should
     * be released with g_strfreev().
     *
     * If `path` is invalid or does not exist in the #GResource,
     * %G_RESOURCE_ERROR_NOT_FOUND will be returned.
     *
     * `lookup_flags` controls the behaviour of the lookup.
     * @param path A pathname inside the resource
     * @param lookupFlags A #GResourceLookupFlags
     * @returns an array of constant strings
     */
    enumerateChildren(path: string, lookupFlags: ResourceLookupFlags): string[]
    /**
     * Looks for a file at the specified `path` in the resource and
     * if found returns information about it.
     *
     * `lookup_flags` controls the behaviour of the lookup.
     * @param path A pathname inside the resource
     * @param lookupFlags A #GResourceLookupFlags
     * @returns %TRUE if the file was found. %FALSE if there were errors
     */
    getInfo(
      path: string,
      lookupFlags: ResourceLookupFlags
    ): [/* returnType */ boolean, /* size */ number, /* flags */ number]
    /**
     * Looks for a file at the specified `path` in the resource and
     * returns a #GBytes that lets you directly access the data in
     * memory.
     *
     * The data is always followed by a zero byte, so you
     * can safely use the data as a C string. However, that byte
     * is not included in the size of the GBytes.
     *
     * For uncompressed resource files this is a pointer directly into
     * the resource bundle, which is typically in some readonly data section
     * in the program binary. For compressed files we allocate memory on
     * the heap and automatically uncompress the data.
     *
     * `lookup_flags` controls the behaviour of the lookup.
     * @param path A pathname inside the resource
     * @param lookupFlags A #GResourceLookupFlags
     * @returns #GBytes or %NULL on error.     Free the returned object with g_bytes_unref()
     */
    lookupData(path: string, lookupFlags: ResourceLookupFlags): any
    /**
     * Looks for a file at the specified `path` in the resource and
     * returns a #GInputStream that lets you read the data.
     *
     * `lookup_flags` controls the behaviour of the lookup.
     * @param path A pathname inside the resource
     * @param lookupFlags A #GResourceLookupFlags
     * @returns #GInputStream or %NULL on error.     Free the returned object with g_object_unref()
     */
    openStream(path: string, lookupFlags: ResourceLookupFlags): InputStream
    /**
     * Atomically increments the reference count of `resource` by one. This
     * function is MT-safe and may be called from any thread.
     * @returns The passed in #GResource
     */
    ref(): Resource
    /**
     * Atomically decrements the reference count of `resource` by one. If the
     * reference count drops to 0, all memory allocated by the resource is
     * released. This function is MT-safe and may be called from any
     * thread.
     */
    unref(): void
  }

  /**
   * Applications and libraries often contain binary or textual data that is
   * really part of the application, rather than user data. For instance
   * [`GtkBuilder`](https://docs.gtk.org/gtk4/class.Builder.html) `.ui` files,
   * splashscreen images, [class`Gio`.Menu] markup XML, CSS files, icons, etc.
   * These are often shipped as files in `$datadir/appname`, or manually
   * included as literal strings in the code.
   *
   * The `GResource` API and the
   * [`glib-compile-resources`](glib-compile-resources.html) program provide a
   * convenient and efficient alternative to this which has some nice properties.
   * You maintain the files as normal files, so it’s easy to edit them, but during
   * the build the files are combined into a binary bundle that is linked into the
   * executable. This means that loading the resource files are efficient (as they
   * are already in memory, shared with other instances) and simple (no need to
   * check for things like I/O errors or locate the files in the filesystem). It
   * also makes it easier to create relocatable applications.
   *
   * Resource files can also be marked as compressed. Such files will be included
   * in the resource bundle in a compressed form, but will be automatically
   * uncompressed when the resource is used. This is very useful e.g. for larger
   * text files that are parsed once (or rarely) and then thrown away.
   *
   * Resource files can also be marked to be preprocessed, by setting the value of the
   * `preprocess` attribute to a comma-separated list of preprocessing options.
   * The only options currently supported are:
   *
   *  - `xml-stripblanks` which will use the [`xmllint`](man:xmllint(1)) command
   *    to strip ignorable whitespace from the XML file. For this to work,
   *    the `XMLLINT` environment variable must be set to the full path to
   *    the xmllint executable, or xmllint must be in the `PATH`; otherwise
   *    the preprocessing step is skipped.
   *
   *  - `to-pixdata` (deprecated since gdk-pixbuf 2.32) which will use the
   *    `gdk-pixbuf-pixdata` command to convert images to the [`GdkPixdata`](https://docs.gtk.org/gdk-pixbuf/class.Pixdata.html)
   *    format, which allows you to create pixbufs directly using the data inside
   *    the resource file, rather than an (uncompressed) copy of it. For this, the
   *    `gdk-pixbuf-pixdata` program must be in the `PATH`, or the
   *    `GDK_PIXBUF_PIXDATA` environment variable must be set to the full path to
   *    the `gdk-pixbuf-pixdata` executable; otherwise the resource compiler will
   *    abort. `to-pixdata` has been deprecated since gdk-pixbuf 2.32, as
   *    `GResource` supports embedding modern image formats just as well. Instead
   *    of using it, embed a PNG or SVG file in your `GResource`.
   *
   *  - `json-stripblanks` which will use the
   *    [`json-glib-format`](man:json-glib-format(1)) command to strip ignorable
   *    whitespace from the JSON file. For this to work, the `JSON_GLIB_FORMAT`
   *    environment variable must be set to the full path to the
   *    `json-glib-format` executable, or it must be in the `PATH`; otherwise the
   *    preprocessing step is skipped. In addition, at least version 1.6 of
   *    `json-glib-format` is required.
   *
   * Resource files will be exported in the `GResource` namespace using the
   * combination of the given `prefix` and the filename from the `file` element.
   * The `alias` attribute can be used to alter the filename to expose them at a
   * different location in the resource namespace. Typically, this is used to
   * include files from a different source directory without exposing the source
   * directory in the resource namespace, as in the example below.
   *
   * Resource bundles are created by the
   * [`glib-compile-resources`](glib-compile-resources.html) program
   * which takes an XML file that describes the bundle, and a set of files that
   * the XML references. These are combined into a binary resource bundle.
   *
   * An example resource description:
   * ```xml
   * <?xml version="1.0" encoding="UTF-8"?>
   * <gresources>
   *   <gresource prefix="/org/gtk/Example">
   *     <file>data/splashscreen.png</file>
   *     <file compressed="true">dialog.ui</file>
   *     <file preprocess="xml-stripblanks">menumarkup.xml</file>
   *     <file alias="example.css">data/example.css</file>
   *   </gresource>
   * </gresources>
   * ```
   *
   * This will create a resource bundle with the following files:
   * ```
   * /org/gtk/Example/data/splashscreen.png
   * /org/gtk/Example/dialog.ui
   * /org/gtk/Example/menumarkup.xml
   * /org/gtk/Example/example.css
   * ```
   *
   * Note that all resources in the process share the same namespace, so use
   * Java-style path prefixes (like in the above example) to avoid conflicts.
   *
   * You can then use [`glib-compile-resources`](glib-compile-resources.html) to
   * compile the XML to a binary bundle that you can load with
   * [func`Gio`.Resource.load]. However, it’s more common to use the
   * `--generate-source` and `--generate-header` arguments to create a source file
   * and header to link directly into your application.
   * This will generate `get_resource()`, `register_resource()` and
   * `unregister_resource()` functions, prefixed by the `--c-name` argument passed
   * to [`glib-compile-resources`](glib-compile-resources.html). `get_resource()`
   * returns the generated `GResource` object. The register and unregister
   * functions register the resource so its files can be accessed using
   * [func`Gio`.resources_lookup_data].
   *
   * Once a `GResource` has been created and registered all the data in it can be
   * accessed globally in the process by using API calls like
   * [func`Gio`.resources_open_stream] to stream the data or
   * [func`Gio`.resources_lookup_data] to get a direct pointer to the data. You can
   * also use URIs like `resource:///org/gtk/Example/data/splashscreen.png` with
   * [iface`Gio`.File] to access the resource data.
   *
   * Some higher-level APIs, such as [`GtkApplication`](https://docs.gtk.org/gtk4/class.Application.html),
   * will automatically load resources from certain well-known paths in the
   * resource namespace as a convenience. See the documentation for those APIs
   * for details.
   *
   * There are two forms of the generated source, the default version uses the
   * compiler support for constructor and destructor functions (where available)
   * to automatically create and register the `GResource` on startup or library
   * load time. If you pass `--manual-register`, two functions to
   * register/unregister the resource are created instead. This requires an
   * explicit initialization call in your application/library, but it works on all
   * platforms, even on the minor ones where constructors are not supported.
   * (Constructor support is available for at least Win32, Mac OS and Linux.)
   *
   * Note that resource data can point directly into the data segment of e.g. a
   * library, so if you are unloading libraries during runtime you need to be very
   * careful with keeping around pointers to data from a resource, as this goes
   * away when the library is unloaded. However, in practice this is not generally
   * a problem, since most resource accesses are for your own resources, and
   * resource data is often used once, during parsing, and then released.
   *
   * # Overlays
   *
   * When debugging a program or testing a change to an installed version, it is
   * often useful to be able to replace resources in the program or library,
   * without recompiling, for debugging or quick hacking and testing purposes.
   * Since GLib 2.50, it is possible to use the `G_RESOURCE_OVERLAYS` environment
   * variable to selectively overlay resources with replacements from the
   * filesystem.  It is a `G_SEARCHPATH_SEPARATOR`-separated list of substitutions
   * to perform during resource lookups. It is ignored when running in a setuid
   * process.
   *
   * A substitution has the form
   *
   * ```
   * /org/gtk/libgtk=/home/desrt/gtk-overlay
   * ```
   *
   * The part before the `=` is the resource subpath for which the overlay
   * applies.  The part after is a filesystem path which contains files and
   * subdirectories as you would like to be loaded as resources with the
   * equivalent names.
   *
   * In the example above, if an application tried to load a resource with the
   * resource path `/org/gtk/libgtk/ui/gtkdialog.ui` then `GResource` would check
   * the filesystem path `/home/desrt/gtk-overlay/ui/gtkdialog.ui`.  If a file was
   * found there, it would be used instead.  This is an overlay, not an outright
   * replacement, which means that if a file is not found at that path, the
   * built-in version will be used instead.  Whiteouts are not currently
   * supported.
   *
   * Substitutions must start with a slash, and must not contain a trailing slash
   * before the `=`.  The path after the slash should ideally be absolute, but
   * this is not strictly required.  It is possible to overlay the location of a
   * single resource with an individual file.
   * @record
   */
  class Resource {
    // Own properties of Gio-2.0.Gio.Resource

    static name: string

    // Constructors of Gio-2.0.Gio.Resource

    /**
     * Creates a GResource from a reference to the binary resource bundle.
     * This will keep a reference to `data` while the resource lives, so
     * the data should not be modified or freed.
     *
     * If you want to use this resource in the global resource namespace you need
     * to register it with g_resources_register().
     *
     * Note: `data` must be backed by memory that is at least pointer aligned.
     * Otherwise this function will internally create a copy of the memory since
     * GLib 2.56, or in older versions fail and exit the process.
     *
     * If `data` is empty or corrupt, %G_RESOURCE_ERROR_INTERNAL will be returned.
     * @constructor
     * @param data A #GBytes
     * @returns a new #GResource, or %NULL on error
     */
    static newFromData(data: any): Resource
    /**
     * Loads a binary resource bundle and creates a #GResource representation of it, allowing
     * you to query it for data.
     *
     * If you want to use this resource in the global resource namespace you need
     * to register it with g_resources_register().
     *
     * If `filename` is empty or the data in it is corrupt,
     * %G_RESOURCE_ERROR_INTERNAL will be returned. If `filename` doesn’t exist, or
     * there is an error in reading it, an error from g_mapped_file_new() will be
     * returned.
     * @param filename the path of a filename to load, in the GLib filename encoding
     * @returns a new #GResource, or %NULL on error
     */
    static load(filename: string): Resource
  }

  interface SeekableIface {
    // Own fields of Gio-2.0.Gio.SeekableIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Tells the current location within a stream.
     * @field
     */
    tell: (seekable: Seekable) => number
    /**
     * Checks if seeking is supported by the stream.
     * @field
     */
    canSeek: (seekable: Seekable) => boolean
    /**
     * Seeks to a location within a stream.
     * @field
     */
    seek: (
      seekable: Seekable,
      offset: number,
      type: GLib.SeekType,
      cancellable: Cancellable | null
    ) => boolean
    /**
     * Checks if truncation is supported by the stream.
     * @field
     */
    canTruncate: (seekable: Seekable) => boolean
    /**
     * Truncates a stream.
     * @field
     */
    truncateFn: (
      seekable: Seekable,
      offset: number,
      cancellable: Cancellable | null
    ) => boolean
  }

  /**
   * Provides an interface for implementing seekable functionality on I/O Streams.
   * @record
   */
  abstract class SeekableIface {
    // Own properties of Gio-2.0.Gio.SeekableIface

    static name: string
  }

  interface SettingsBackendClass {
    // Own fields of Gio-2.0.Gio.SettingsBackendClass

    parentClass: GObject.ObjectClass
    /**
     * virtual method to read a key's value
     * @field
     */
    read: (
      backend: SettingsBackend,
      key: string,
      expectedType: GLib.VariantType,
      defaultValue: boolean
    ) => GLib.Variant
    /**
     * virtual method to get if a key is writable
     * @field
     */
    getWritable: (backend: SettingsBackend, key: string) => boolean
    /**
     * virtual method to change key's value
     * @field
     */
    write: (
      backend: SettingsBackend,
      key: string,
      value: GLib.Variant,
      originTag: any | null
    ) => boolean
    /**
     * virtual method to change a tree of keys
     * @field
     */
    writeTree: (
      backend: SettingsBackend,
      tree: GLib.Tree,
      originTag: any | null
    ) => boolean
    /**
     * virtual method to reset state
     * @field
     */
    reset: (
      backend: SettingsBackend,
      key: string,
      originTag: any | null
    ) => void
    /**
     * virtual method to subscribe to key changes
     * @field
     */
    subscribe: (backend: SettingsBackend, name: string) => void
    /**
     * virtual method to unsubscribe to key changes
     * @field
     */
    unsubscribe: (backend: SettingsBackend, name: string) => void
    /**
     * virtual method to sync state
     * @field
     */
    sync: (backend: SettingsBackend) => void
    /**
     * virtual method to read user's key value
     * @field
     */
    readUserValue: (
      backend: SettingsBackend,
      key: string,
      expectedType: GLib.VariantType
    ) => GLib.Variant
  }

  /**
   * Class structure for #GSettingsBackend.
   * @record
   */
  abstract class SettingsBackendClass {
    // Own properties of Gio-2.0.Gio.SettingsBackendClass

    static name: string
  }

  interface SettingsBackendPrivate {}

  class SettingsBackendPrivate {
    // Own properties of Gio-2.0.Gio.SettingsBackendPrivate

    static name: string
  }

  interface SettingsClass {
    // Own fields of Gio-2.0.Gio.SettingsClass

    parentClass: GObject.ObjectClass
    writableChanged: (settings: Settings, key: string) => void
    changed: (settings: Settings, key: string) => void
    writableChangeEvent: (settings: Settings, key: GLib.Quark) => boolean
    changeEvent: (
      settings: Settings,
      keys: GLib.Quark,
      nKeys: number
    ) => boolean
    padding: any[]
  }

  abstract class SettingsClass {
    // Own properties of Gio-2.0.Gio.SettingsClass

    static name: string
  }

  interface SettingsPrivate {}

  class SettingsPrivate {
    // Own properties of Gio-2.0.Gio.SettingsPrivate

    static name: string
  }

  interface SettingsSchema {
    // Owm methods of Gio-2.0.Gio.SettingsSchema

    /**
     * Get the ID of `schema`.
     * @returns the ID
     */
    getId(): string
    /**
     * Gets the key named `name` from `schema`.
     *
     * It is a programmer error to request a key that does not exist.  See
     * g_settings_schema_list_keys().
     * @param name the name of a key
     * @returns the #GSettingsSchemaKey for @name
     */
    getKey(name: string): SettingsSchemaKey
    /**
     * Gets the path associated with `schema,` or %NULL.
     *
     * Schemas may be single-instance or relocatable.  Single-instance
     * schemas correspond to exactly one set of keys in the backend
     * database: those located at the path returned by this function.
     *
     * Relocatable schemas can be referenced by other schemas and can
     * therefore describe multiple sets of keys at different locations.  For
     * relocatable schemas, this function will return %NULL.
     * @returns the path of the schema, or %NULL
     */
    getPath(): string | null
    /**
     * Checks if `schema` has a key named `name`.
     * @param name the name of a key
     * @returns %TRUE if such a key exists
     */
    hasKey(name: string): boolean
    /**
     * Gets the list of children in `schema`.
     *
     * You should free the return value with g_strfreev() when you are done
     * with it.
     * @returns a list of    the children on @settings, in no defined order
     */
    listChildren(): string[]
    /**
     * Introspects the list of keys on `schema`.
     *
     * You should probably not be calling this function from "normal" code
     * (since you should already know what keys are in your schema).  This
     * function is intended for introspection reasons.
     * @returns a list   of the keys on @schema, in no defined order
     */
    listKeys(): string[]
    /**
     * Increase the reference count of `schema,` returning a new reference.
     * @returns a new reference to @schema
     */
    ref(): SettingsSchema
    /**
     * Decrease the reference count of `schema,` possibly freeing it.
     */
    unref(): void
  }

  /**
   * The [struct`Gio`.SettingsSchemaSource] and `GSettingsSchema` APIs provide a
   * mechanism for advanced control over the loading of schemas and a
   * mechanism for introspecting their content.
   *
   * Plugin loading systems that wish to provide plugins a way to access
   * settings face the problem of how to make the schemas for these
   * settings visible to GSettings.  Typically, a plugin will want to ship
   * the schema along with itself and it won't be installed into the
   * standard system directories for schemas.
   *
   * [struct`Gio`.SettingsSchemaSource] provides a mechanism for dealing with this
   * by allowing the creation of a new ‘schema source’ from which schemas can
   * be acquired.  This schema source can then become part of the metadata
   * associated with the plugin and queried whenever the plugin requires
   * access to some settings.
   *
   * Consider the following example:
   *
   * ```c
   * typedef struct
   * {
   *    …
   *    GSettingsSchemaSource *schema_source;
   *    …
   * } Plugin;
   *
   * Plugin *
   * initialise_plugin (const gchar *dir)
   * {
   *   Plugin *plugin;
   *
   *   …
   *
   *   plugin->schema_source =
   *     g_settings_schema_source_new_from_directory (dir,
   *       g_settings_schema_source_get_default (), FALSE, NULL);
   *
   *   …
   *
   *   return plugin;
   * }
   *
   * …
   *
   * GSettings *
   * plugin_get_settings (Plugin      *plugin,
   *                      const gchar *schema_id)
   * {
   *   GSettingsSchema *schema;
   *
   *   if (schema_id == NULL)
   *     schema_id = plugin->identifier;
   *
   *   schema = g_settings_schema_source_lookup (plugin->schema_source,
   *                                             schema_id, FALSE);
   *
   *   if (schema == NULL)
   *     {
   *       … disable the plugin or abort, etc …
   *     }
   *
   *   return g_settings_new_full (schema, NULL, NULL);
   * }
   * ```
   *
   * The code above shows how hooks should be added to the code that
   * initialises (or enables) the plugin to create the schema source and
   * how an API can be added to the plugin system to provide a convenient
   * way for the plugin to access its settings, using the schemas that it
   * ships.
   *
   * From the standpoint of the plugin, it would need to ensure that it
   * ships a gschemas.compiled file as part of itself, and then simply do
   * the following:
   *
   * ```c
   * {
   *   GSettings *settings;
   *   gint some_value;
   *
   *   settings = plugin_get_settings (self, NULL);
   *   some_value = g_settings_get_int (settings, "some-value");
   *   …
   * }
   * ```
   *
   * It's also possible that the plugin system expects the schema source
   * files (ie: `.gschema.xml` files) instead of a `gschemas.compiled` file.
   * In that case, the plugin loading system must compile the schemas for
   * itself before attempting to create the settings source.
   * @record
   */
  class SettingsSchema {
    // Own properties of Gio-2.0.Gio.SettingsSchema

    static name: string
  }

  interface SettingsSchemaKey {
    // Owm methods of Gio-2.0.Gio.SettingsSchemaKey

    /**
     * Gets the default value for `key`.
     *
     * Note that this is the default value according to the schema.  System
     * administrator defaults and lockdown are not visible via this API.
     * @returns the default value for the key
     */
    getDefaultValue(): GLib.Variant
    /**
     * Gets the description for `key`.
     *
     * If no description has been provided in the schema for `key,` returns
     * %NULL.
     *
     * The description can be one sentence to several paragraphs in length.
     * Paragraphs are delimited with a double newline.  Descriptions can be
     * translated and the value returned from this function is is the
     * current locale.
     *
     * This function is slow.  The summary and description information for
     * the schemas is not stored in the compiled schema database so this
     * function has to parse all of the source XML files in the schema
     * directory.
     * @returns the description for @key, or %NULL
     */
    getDescription(): string | null
    /**
     * Gets the name of `key`.
     * @returns the name of @key.
     */
    getName(): string
    /**
     * Queries the range of a key.
     *
     * This function will return a #GVariant that fully describes the range
     * of values that are valid for `key`.
     *
     * The type of #GVariant returned is `(sv)`. The string describes
     * the type of range restriction in effect. The type and meaning of
     * the value contained in the variant depends on the string.
     *
     * If the string is `'type'` then the variant contains an empty array.
     * The element type of that empty array is the expected type of value
     * and all values of that type are valid.
     *
     * If the string is `'enum'` then the variant contains an array
     * enumerating the possible values. Each item in the array is
     * a possible valid value and no other values are valid.
     *
     * If the string is `'flags'` then the variant contains an array. Each
     * item in the array is a value that may appear zero or one times in an
     * array to be used as the value for this key. For example, if the
     * variant contained the array `['x', 'y']` then the valid values for
     * the key would be `[]`, `['x']`, `['y']`, `['x', 'y']` and
     * `['y', 'x']`.
     *
     * Finally, if the string is `'range'` then the variant contains a pair
     * of like-typed values -- the minimum and maximum permissible values
     * for this key.
     *
     * This information should not be used by normal programs.  It is
     * considered to be a hint for introspection purposes.  Normal programs
     * should already know what is permitted by their own schema.  The
     * format may change in any way in the future -- but particularly, new
     * forms may be added to the possibilities described above.
     *
     * You should free the returned value with g_variant_unref() when it is
     * no longer needed.
     * @returns a #GVariant describing the range
     */
    getRange(): GLib.Variant
    /**
     * Gets the summary for `key`.
     *
     * If no summary has been provided in the schema for `key,` returns
     * %NULL.
     *
     * The summary is a short description of the purpose of the key; usually
     * one short sentence.  Summaries can be translated and the value
     * returned from this function is is the current locale.
     *
     * This function is slow.  The summary and description information for
     * the schemas is not stored in the compiled schema database so this
     * function has to parse all of the source XML files in the schema
     * directory.
     * @returns the summary for @key, or %NULL
     */
    getSummary(): string | null
    /**
     * Gets the #GVariantType of `key`.
     * @returns the type of @key
     */
    getValueType(): GLib.VariantType
    /**
     * Checks if the given `value` is within the
     * permitted range for `key`.
     *
     * It is a programmer error if `value` is not of the correct type — you
     * must check for this first.
     * @param value the value to check
     * @returns %TRUE if @value is valid for @key
     */
    rangeCheck(value: GLib.Variant): boolean
    /**
     * Increase the reference count of `key,` returning a new reference.
     * @returns a new reference to @key
     */
    ref(): SettingsSchemaKey
    /**
     * Decrease the reference count of `key,` possibly freeing it.
     */
    unref(): void
  }

  /**
   * #GSettingsSchemaKey is an opaque data structure and can only be accessed
   * using the following functions.
   * @record
   */
  class SettingsSchemaKey {
    // Own properties of Gio-2.0.Gio.SettingsSchemaKey

    static name: string
  }

  interface SettingsSchemaSource {
    // Owm methods of Gio-2.0.Gio.SettingsSchemaSource

    /**
     * Lists the schemas in a given source.
     *
     * If `recursive` is %TRUE then include parent sources.  If %FALSE then
     * only include the schemas from one source (ie: one directory).  You
     * probably want %TRUE.
     *
     * Non-relocatable schemas are those for which you can call
     * g_settings_new().  Relocatable schemas are those for which you must
     * use g_settings_new_with_path().
     *
     * Do not call this function from normal programs.  This is designed for
     * use by database editors, commandline tools, etc.
     * @param recursive if we should recurse
     */
    listSchemas(
      recursive: boolean
    ): [/* nonRelocatable */ string[], /* relocatable */ string[]]
    /**
     * Looks up a schema with the identifier `schema_id` in `source`.
     *
     * This function is not required for normal uses of #GSettings but it
     * may be useful to authors of plugin management systems or to those who
     * want to introspect the content of schemas.
     *
     * If the schema isn't found directly in `source` and `recursive` is %TRUE
     * then the parent sources will also be checked.
     *
     * If the schema isn't found, %NULL is returned.
     * @param schemaId a schema ID
     * @param recursive %TRUE if the lookup should be recursive
     * @returns a new #GSettingsSchema
     */
    lookup(schemaId: string, recursive: boolean): SettingsSchema | null
    /**
     * Increase the reference count of `source,` returning a new reference.
     * @returns a new reference to @source
     */
    ref(): SettingsSchemaSource
    /**
     * Decrease the reference count of `source,` possibly freeing it.
     */
    unref(): void
  }

  /**
   * This is an opaque structure type.  You may not access it directly.
   * @record
   */
  class SettingsSchemaSource {
    // Own properties of Gio-2.0.Gio.SettingsSchemaSource

    static name: string

    // Constructors of Gio-2.0.Gio.SettingsSchemaSource

    /**
     * Attempts to create a new schema source corresponding to the contents
     * of the given directory.
     *
     * This function is not required for normal uses of #GSettings but it
     * may be useful to authors of plugin management systems.
     *
     * The directory should contain a file called `gschemas.compiled` as
     * produced by the [glib-compile-schemas][glib-compile-schemas] tool.
     *
     * If `trusted` is %TRUE then `gschemas.compiled` is trusted not to be
     * corrupted. This assumption has a performance advantage, but can result
     * in crashes or inconsistent behaviour in the case of a corrupted file.
     * Generally, you should set `trusted` to %TRUE for files installed by the
     * system and to %FALSE for files in the home directory.
     *
     * In either case, an empty file or some types of corruption in the file will
     * result in %G_FILE_ERROR_INVAL being returned.
     *
     * If `parent` is non-%NULL then there are two effects.
     *
     * First, if g_settings_schema_source_lookup() is called with the
     * `recursive` flag set to %TRUE and the schema can not be found in the
     * source, the lookup will recurse to the parent.
     *
     * Second, any references to other schemas specified within this
     * source (ie: `child` or `extends`) references may be resolved
     * from the `parent`.
     *
     * For this second reason, except in very unusual situations, the
     * `parent` should probably be given as the default schema source, as
     * returned by g_settings_schema_source_get_default().
     * @constructor
     * @param directory the filename of a directory
     * @param parent a #GSettingsSchemaSource, or %NULL
     * @param trusted %TRUE, if the directory is trusted
     */
    static newFromDirectory(
      directory: string,
      parent: SettingsSchemaSource | null,
      trusted: boolean
    ): SettingsSchemaSource
    /**
     * Gets the default system schema source.
     *
     * This function is not required for normal uses of #GSettings but it
     * may be useful to authors of plugin management systems or to those who
     * want to introspect the content of schemas.
     *
     * If no schemas are installed, %NULL will be returned.
     *
     * The returned source may actually consist of multiple schema sources
     * from different directories, depending on which directories were given
     * in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all
     * lookups performed against the default source should probably be done
     * recursively.
     * @returns the default schema source
     */
    static getDefault(): SettingsSchemaSource | null
  }

  interface SimpleActionGroupClass {}

  abstract class SimpleActionGroupClass {
    // Own properties of Gio-2.0.Gio.SimpleActionGroupClass

    static name: string
  }

  interface SimpleActionGroupPrivate {}

  class SimpleActionGroupPrivate {
    // Own properties of Gio-2.0.Gio.SimpleActionGroupPrivate

    static name: string
  }

  interface SimpleAsyncResultClass {}

  abstract class SimpleAsyncResultClass {
    // Own properties of Gio-2.0.Gio.SimpleAsyncResultClass

    static name: string
  }

  interface SimpleProxyResolverClass {
    // Own fields of Gio-2.0.Gio.SimpleProxyResolverClass

    parentClass: GObject.ObjectClass
  }

  abstract class SimpleProxyResolverClass {
    // Own properties of Gio-2.0.Gio.SimpleProxyResolverClass

    static name: string
  }

  interface SimpleProxyResolverPrivate {}

  class SimpleProxyResolverPrivate {
    // Own properties of Gio-2.0.Gio.SimpleProxyResolverPrivate

    static name: string
  }

  interface SocketAddressClass {
    // Own fields of Gio-2.0.Gio.SocketAddressClass

    parentClass: GObject.ObjectClass
    getFamily: (address: SocketAddress) => SocketFamily
    getNativeSize: (address: SocketAddress) => number
    toNative: (
      address: SocketAddress,
      dest: any | null,
      destlen: number
    ) => boolean
  }

  abstract class SocketAddressClass {
    // Own properties of Gio-2.0.Gio.SocketAddressClass

    static name: string
  }

  interface SocketAddressEnumeratorClass {
    // Own fields of Gio-2.0.Gio.SocketAddressEnumeratorClass

    /**
     * Virtual method for g_socket_address_enumerator_next().
     * @field
     */
    next: (
      enumerator: SocketAddressEnumerator,
      cancellable: Cancellable | null
    ) => SocketAddress | null
    /**
     * Virtual method for g_socket_address_enumerator_next_async().
     * @field
     */
    nextAsync: (
      enumerator: SocketAddressEnumerator,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Virtual method for g_socket_address_enumerator_next_finish().
     * @field
     */
    nextFinish: (
      enumerator: SocketAddressEnumerator,
      result: AsyncResult
    ) => SocketAddress | null
  }

  /**
   * Class structure for #GSocketAddressEnumerator.
   * @record
   */
  abstract class SocketAddressEnumeratorClass {
    // Own properties of Gio-2.0.Gio.SocketAddressEnumeratorClass

    static name: string
  }

  interface SocketClass {
    // Own fields of Gio-2.0.Gio.SocketClass

    parentClass: GObject.ObjectClass
  }

  abstract class SocketClass {
    // Own properties of Gio-2.0.Gio.SocketClass

    static name: string
  }

  interface SocketClientClass {
    // Own fields of Gio-2.0.Gio.SocketClientClass

    parentClass: GObject.ObjectClass
    event: (
      client: SocketClient,
      event: SocketClientEvent,
      connectable: SocketConnectable,
      connection: IOStream
    ) => void
  }

  abstract class SocketClientClass {
    // Own properties of Gio-2.0.Gio.SocketClientClass

    static name: string
  }

  interface SocketClientPrivate {}

  class SocketClientPrivate {
    // Own properties of Gio-2.0.Gio.SocketClientPrivate

    static name: string
  }

  interface SocketConnectableIface {
    // Own fields of Gio-2.0.Gio.SocketConnectableIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Creates a #GSocketAddressEnumerator
     * @field
     */
    enumerate: (connectable: SocketConnectable) => SocketAddressEnumerator
    /**
     * Creates a #GProxyAddressEnumerator
     * @field
     */
    proxyEnumerate: (connectable: SocketConnectable) => SocketAddressEnumerator
    /**
     * Format the connectable’s address as a string for debugging.
     *    Implementing this is optional. (Since: 2.48)
     * @field
     */
    toString: (connectable: SocketConnectable) => string | null
  }

  /**
   * Provides an interface for returning a #GSocketAddressEnumerator
   * and #GProxyAddressEnumerator
   * @record
   */
  abstract class SocketConnectableIface {
    // Own properties of Gio-2.0.Gio.SocketConnectableIface

    static name: string
  }

  interface SocketConnectionClass {
    // Own fields of Gio-2.0.Gio.SocketConnectionClass

    parentClass: IOStreamClass
  }

  abstract class SocketConnectionClass {
    // Own properties of Gio-2.0.Gio.SocketConnectionClass

    static name: string
  }

  interface SocketConnectionPrivate {}

  class SocketConnectionPrivate {
    // Own properties of Gio-2.0.Gio.SocketConnectionPrivate

    static name: string
  }

  interface SocketControlMessageClass {
    // Own fields of Gio-2.0.Gio.SocketControlMessageClass

    parentClass: GObject.ObjectClass
    /**
     * gets the size of the message.
     * @field
     */
    getSize: (message: SocketControlMessage) => number
    /**
     * gets the protocol of the message.
     * @field
     */
    getLevel: (message: SocketControlMessage) => number
    /**
     * gets the protocol specific type of the message.
     * @field
     */
    getType: (message: SocketControlMessage) => number
    /**
     * Writes out the message data.
     * @field
     */
    serialize: (message: SocketControlMessage, data: any) => void
  }

  /**
   * Class structure for #GSocketControlMessage.
   * @record
   */
  abstract class SocketControlMessageClass {
    // Own properties of Gio-2.0.Gio.SocketControlMessageClass

    static name: string
  }

  interface SocketControlMessagePrivate {}

  class SocketControlMessagePrivate {
    // Own properties of Gio-2.0.Gio.SocketControlMessagePrivate

    static name: string
  }

  interface SocketListenerClass {
    // Own fields of Gio-2.0.Gio.SocketListenerClass

    parentClass: GObject.ObjectClass
    /**
     * virtual method called when the set of socket listened to changes
     * @field
     */
    changed: (listener: SocketListener) => void
    event: (
      listener: SocketListener,
      event: SocketListenerEvent,
      socket: Socket
    ) => void
  }

  /**
   * Class structure for #GSocketListener.
   * @record
   */
  abstract class SocketListenerClass {
    // Own properties of Gio-2.0.Gio.SocketListenerClass

    static name: string
  }

  interface SocketListenerPrivate {}

  class SocketListenerPrivate {
    // Own properties of Gio-2.0.Gio.SocketListenerPrivate

    static name: string
  }

  interface SocketPrivate {}

  class SocketPrivate {
    // Own properties of Gio-2.0.Gio.SocketPrivate

    static name: string
  }

  interface SocketServiceClass {
    // Own fields of Gio-2.0.Gio.SocketServiceClass

    parentClass: SocketListenerClass
    /**
     * signal emitted when new connections are accepted
     * @field
     */
    incoming: (
      service: SocketService,
      connection: SocketConnection,
      sourceObject: GObject.Object
    ) => boolean
  }

  /**
   * Class structure for #GSocketService.
   * @record
   */
  abstract class SocketServiceClass {
    // Own properties of Gio-2.0.Gio.SocketServiceClass

    static name: string
  }

  interface SocketServicePrivate {}

  class SocketServicePrivate {
    // Own properties of Gio-2.0.Gio.SocketServicePrivate

    static name: string
  }

  interface SrvTarget {
    // Owm methods of Gio-2.0.Gio.SrvTarget

    /**
     * Copies `target`
     * @returns a copy of @target
     */
    copy(): SrvTarget
    /**
     * Frees `target`
     */
    free(): void
    /**
     * Gets `target'`s hostname (in ASCII form; if you are going to present
     * this to the user, you should use g_hostname_is_ascii_encoded() to
     * check if it contains encoded Unicode segments, and use
     * g_hostname_to_unicode() to convert it if it does.)
     * @returns @target's hostname
     */
    getHostname(): string
    /**
     * Gets `target'`s port
     * @returns @target's port
     */
    getPort(): number
    /**
     * Gets `target'`s priority. You should not need to look at this;
     * #GResolver already sorts the targets according to the algorithm in
     * RFC 2782.
     * @returns @target's priority
     */
    getPriority(): number
    /**
     * Gets `target'`s weight. You should not need to look at this;
     * #GResolver already sorts the targets according to the algorithm in
     * RFC 2782.
     * @returns @target's weight
     */
    getWeight(): number
  }

  /**
   * A single target host/port that a network service is running on.
   *
   * SRV (service) records are used by some network protocols to provide
   * service-specific aliasing and load-balancing. For example, XMPP
   * (Jabber) uses SRV records to locate the XMPP server for a domain;
   * rather than connecting directly to ‘example.com’ or assuming a
   * specific server hostname like ‘xmpp.example.com’, an XMPP client
   * would look up the `xmpp-client` SRV record for ‘example.com’, and
   * then connect to whatever host was pointed to by that record.
   *
   * You can use [method`Gio`.Resolver.lookup_service] or
   * [method`Gio`.Resolver.lookup_service_async] to find the `GSrvTarget`s
   * for a given service. However, if you are simply planning to connect
   * to the remote service, you can use [class`Gio`.NetworkService]’s
   * [iface`Gio`.SocketConnectable] interface and not need to worry about
   * `GSrvTarget` at all.
   * @record
   */
  class SrvTarget {
    // Own properties of Gio-2.0.Gio.SrvTarget

    static name: string

    // Constructors of Gio-2.0.Gio.SrvTarget

    /**
     * Creates a new #GSrvTarget with the given parameters.
     *
     * You should not need to use this; normally #GSrvTargets are
     * created by #GResolver.
     * @constructor
     * @param hostname the host that the service is running on
     * @param port the port that the service is running on
     * @param priority the target's priority
     * @param weight the target's weight
     * @returns a new #GSrvTarget.
     */
    constructor(
      hostname: string,
      port: number,
      priority: number,
      weight: number
    )
    /**
     * Creates a new #GSrvTarget with the given parameters.
     *
     * You should not need to use this; normally #GSrvTargets are
     * created by #GResolver.
     * @constructor
     * @param hostname the host that the service is running on
     * @param port the port that the service is running on
     * @param priority the target's priority
     * @param weight the target's weight
     * @returns a new #GSrvTarget.
     */
    static new(
      hostname: string,
      port: number,
      priority: number,
      weight: number
    ): SrvTarget
  }

  interface StaticResource {
    // Owm methods of Gio-2.0.Gio.StaticResource

    /**
     * Finalized a GResource initialized by g_static_resource_init().
     *
     * This is normally used by code generated by
     * [glib-compile-resources][glib-compile-resources]
     * and is not typically used by other code.
     */
    fini(): void
    /**
     * Gets the GResource that was registered by a call to g_static_resource_init().
     *
     * This is normally used by code generated by
     * [glib-compile-resources][glib-compile-resources]
     * and is not typically used by other code.
     * @returns a #GResource
     */
    getResource(): Resource
    /**
     * Initializes a GResource from static data using a
     * GStaticResource.
     *
     * This is normally used by code generated by
     * [glib-compile-resources][glib-compile-resources]
     * and is not typically used by other code.
     */
    init(): void
  }

  /**
   * #GStaticResource is an opaque data structure and can only be accessed
   * using the following functions.
   * @record
   */
  class StaticResource {
    // Own properties of Gio-2.0.Gio.StaticResource

    static name: string
  }

  interface TaskClass {}

  abstract class TaskClass {
    // Own properties of Gio-2.0.Gio.TaskClass

    static name: string
  }

  interface TcpConnectionClass {
    // Own fields of Gio-2.0.Gio.TcpConnectionClass

    parentClass: SocketConnectionClass
  }

  abstract class TcpConnectionClass {
    // Own properties of Gio-2.0.Gio.TcpConnectionClass

    static name: string
  }

  interface TcpConnectionPrivate {}

  class TcpConnectionPrivate {
    // Own properties of Gio-2.0.Gio.TcpConnectionPrivate

    static name: string
  }

  interface TcpWrapperConnectionClass {
    // Own fields of Gio-2.0.Gio.TcpWrapperConnectionClass

    parentClass: TcpConnectionClass
  }

  abstract class TcpWrapperConnectionClass {
    // Own properties of Gio-2.0.Gio.TcpWrapperConnectionClass

    static name: string
  }

  interface TcpWrapperConnectionPrivate {}

  class TcpWrapperConnectionPrivate {
    // Own properties of Gio-2.0.Gio.TcpWrapperConnectionPrivate

    static name: string
  }

  interface ThemedIconClass {}

  abstract class ThemedIconClass {
    // Own properties of Gio-2.0.Gio.ThemedIconClass

    static name: string
  }

  interface ThreadedResolverClass {
    // Own fields of Gio-2.0.Gio.ThreadedResolverClass

    parentClass: ResolverClass
  }

  abstract class ThreadedResolverClass {
    // Own properties of Gio-2.0.Gio.ThreadedResolverClass

    static name: string
  }

  interface ThreadedSocketServiceClass {
    // Own fields of Gio-2.0.Gio.ThreadedSocketServiceClass

    parentClass: SocketServiceClass
    run: (
      service: ThreadedSocketService,
      connection: SocketConnection,
      sourceObject: GObject.Object
    ) => boolean
  }

  abstract class ThreadedSocketServiceClass {
    // Own properties of Gio-2.0.Gio.ThreadedSocketServiceClass

    static name: string
  }

  interface ThreadedSocketServicePrivate {}

  class ThreadedSocketServicePrivate {
    // Own properties of Gio-2.0.Gio.ThreadedSocketServicePrivate

    static name: string
  }

  interface TlsBackendInterface {
    // Own fields of Gio-2.0.Gio.TlsBackendInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * returns whether the backend supports TLS.
     * @field
     */
    supportsTls: (backend: TlsBackend) => boolean
    /**
     * returns the #GTlsCertificate implementation type
     * @field
     */
    getCertificateType: () => GObject.GType
    /**
     * returns the #GTlsClientConnection implementation type
     * @field
     */
    getClientConnectionType: () => GObject.GType
    /**
     * returns the #GTlsServerConnection implementation type
     * @field
     */
    getServerConnectionType: () => GObject.GType
    /**
     * returns the #GTlsFileDatabase implementation type.
     * @field
     */
    getFileDatabaseType: () => GObject.GType
    /**
     * returns a default #GTlsDatabase instance.
     * @field
     */
    getDefaultDatabase: (backend: TlsBackend) => TlsDatabase
    /**
     * returns whether the backend supports DTLS
     * @field
     */
    supportsDtls: (backend: TlsBackend) => boolean
    /**
     * returns the #GDtlsClientConnection implementation type
     * @field
     */
    getDtlsClientConnectionType: () => GObject.GType
    /**
     * returns the #GDtlsServerConnection implementation type
     * @field
     */
    getDtlsServerConnectionType: () => GObject.GType
  }

  /**
   * Provides an interface for describing TLS-related types.
   * @record
   */
  abstract class TlsBackendInterface {
    // Own properties of Gio-2.0.Gio.TlsBackendInterface

    static name: string
  }

  interface TlsCertificateClass {
    // Own fields of Gio-2.0.Gio.TlsCertificateClass

    parentClass: GObject.ObjectClass
    verify: (
      cert: TlsCertificate,
      identity: SocketConnectable | null,
      trustedCa: TlsCertificate | null
    ) => TlsCertificateFlags
  }

  abstract class TlsCertificateClass {
    // Own properties of Gio-2.0.Gio.TlsCertificateClass

    static name: string
  }

  interface TlsCertificatePrivate {}

  class TlsCertificatePrivate {
    // Own properties of Gio-2.0.Gio.TlsCertificatePrivate

    static name: string
  }

  interface TlsClientConnectionInterface {
    // Own fields of Gio-2.0.Gio.TlsClientConnectionInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Copies session state from one #GTlsClientConnection to another.
     * @field
     */
    copySessionState: (
      conn: TlsClientConnection,
      source: TlsClientConnection
    ) => void
  }

  /**
   * vtable for a #GTlsClientConnection implementation.
   * @record
   */
  abstract class TlsClientConnectionInterface {
    // Own properties of Gio-2.0.Gio.TlsClientConnectionInterface

    static name: string
  }

  interface TlsConnectionClass {
    // Own fields of Gio-2.0.Gio.TlsConnectionClass

    /**
     * The parent class.
     * @field
     */
    parentClass: IOStreamClass
    /**
     * Check whether to accept a certificate.
     * @field
     */
    acceptCertificate: (
      connection: TlsConnection,
      peerCert: TlsCertificate,
      errors: TlsCertificateFlags
    ) => boolean
    /**
     * Perform a handshake operation.
     * @field
     */
    handshake: (conn: TlsConnection, cancellable: Cancellable | null) => boolean
    /**
     * Start an asynchronous handshake operation.
     * @field
     */
    handshakeAsync: (
      conn: TlsConnection,
      ioPriority: number,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finish an asynchronous handshake operation.
     * @field
     */
    handshakeFinish: (conn: TlsConnection, result: AsyncResult) => boolean
    /**
     * Retrieve TLS channel binding data (Since: 2.66)
     * @field
     */
    getBindingData: (
      conn: TlsConnection,
      type: TlsChannelBindingType,
      data: number[]
    ) => boolean
    /**
     * Get ALPN-negotiated protocol (Since: 2.70)
     * @field
     */
    getNegotiatedProtocol: (conn: TlsConnection) => string | null
  }

  /**
   * The class structure for the #GTlsConnection type.
   * @record
   */
  abstract class TlsConnectionClass {
    // Own properties of Gio-2.0.Gio.TlsConnectionClass

    static name: string
  }

  interface TlsConnectionPrivate {}

  class TlsConnectionPrivate {
    // Own properties of Gio-2.0.Gio.TlsConnectionPrivate

    static name: string
  }

  interface TlsDatabaseClass {
    // Own fields of Gio-2.0.Gio.TlsDatabaseClass

    parentClass: GObject.ObjectClass
    /**
     * Virtual method implementing
     *  g_tls_database_verify_chain().
     * @field
     */
    verifyChain: (
      self: TlsDatabase,
      chain: TlsCertificate,
      purpose: string,
      identity: SocketConnectable | null,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseVerifyFlags,
      cancellable: Cancellable | null
    ) => TlsCertificateFlags
    /**
     * Virtual method implementing
     *  g_tls_database_verify_chain_async().
     * @field
     */
    verifyChainAsync: (
      self: TlsDatabase,
      chain: TlsCertificate,
      purpose: string,
      identity: SocketConnectable | null,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseVerifyFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Virtual method implementing
     *  g_tls_database_verify_chain_finish().
     * @field
     */
    verifyChainFinish: (
      self: TlsDatabase,
      result: AsyncResult
    ) => TlsCertificateFlags
    /**
     * Virtual method implementing
     *  g_tls_database_create_certificate_handle().
     * @field
     */
    createCertificateHandle: (
      self: TlsDatabase,
      certificate: TlsCertificate
    ) => string | null
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificate_for_handle().
     * @field
     */
    lookupCertificateForHandle: (
      self: TlsDatabase,
      handle: string,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null
    ) => TlsCertificate | null
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificate_for_handle_async().
     * @field
     */
    lookupCertificateForHandleAsync: (
      self: TlsDatabase,
      handle: string,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificate_for_handle_finish().
     * @field
     */
    lookupCertificateForHandleFinish: (
      self: TlsDatabase,
      result: AsyncResult
    ) => TlsCertificate
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificate_issuer().
     * @field
     */
    lookupCertificateIssuer: (
      self: TlsDatabase,
      certificate: TlsCertificate,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null
    ) => TlsCertificate
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificate_issuer_async().
     * @field
     */
    lookupCertificateIssuerAsync: (
      self: TlsDatabase,
      certificate: TlsCertificate,
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificate_issuer_finish().
     * @field
     */
    lookupCertificateIssuerFinish: (
      self: TlsDatabase,
      result: AsyncResult
    ) => TlsCertificate
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificates_issued_by().
     * @field
     */
    lookupCertificatesIssuedBy: (
      self: TlsDatabase,
      issuerRawDn: number[],
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null
    ) => TlsCertificate[]
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificates_issued_by_async().
     * @field
     */
    lookupCertificatesIssuedByAsync: (
      self: TlsDatabase,
      issuerRawDn: number[],
      interaction: TlsInteraction | null,
      flags: TlsDatabaseLookupFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Virtual method implementing
     *  g_tls_database_lookup_certificates_issued_by_finish().
     * @field
     */
    lookupCertificatesIssuedByFinish: (
      self: TlsDatabase,
      result: AsyncResult
    ) => TlsCertificate[]
  }

  /**
   * The class for #GTlsDatabase. Derived classes should implement the various
   * virtual methods. _async and _finish methods have a default
   * implementation that runs the corresponding sync method in a thread.
   * @record
   */
  abstract class TlsDatabaseClass {
    // Own properties of Gio-2.0.Gio.TlsDatabaseClass

    static name: string
  }

  interface TlsDatabasePrivate {}

  class TlsDatabasePrivate {
    // Own properties of Gio-2.0.Gio.TlsDatabasePrivate

    static name: string
  }

  interface TlsFileDatabaseInterface {
    // Own fields of Gio-2.0.Gio.TlsFileDatabaseInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
  }

  /**
   * Provides an interface for #GTlsFileDatabase implementations.
   * @record
   */
  abstract class TlsFileDatabaseInterface {
    // Own properties of Gio-2.0.Gio.TlsFileDatabaseInterface

    static name: string
  }

  interface TlsInteractionClass {
    // Own fields of Gio-2.0.Gio.TlsInteractionClass

    /**
     * ask for a password synchronously. If the implementation
     *     returns %G_TLS_INTERACTION_HANDLED, then the password argument should
     *     have been filled in by using g_tls_password_set_value() or a similar
     *     function.
     * @field
     */
    askPassword: (
      interaction: TlsInteraction,
      password: TlsPassword,
      cancellable: Cancellable | null
    ) => TlsInteractionResult
    /**
     * ask for a password asynchronously.
     * @field
     */
    askPasswordAsync: (
      interaction: TlsInteraction,
      password: TlsPassword,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * complete operation to ask for a password asynchronously.
     *     If the implementation returns %G_TLS_INTERACTION_HANDLED, then the
     *     password argument of the async method should have been filled in by using
     *     g_tls_password_set_value() or a similar function.
     * @field
     */
    askPasswordFinish: (
      interaction: TlsInteraction,
      result: AsyncResult
    ) => TlsInteractionResult
    /**
     * ask for a certificate synchronously. If the
     *     implementation returns %G_TLS_INTERACTION_HANDLED, then the connection
     *     argument should have been filled in by using
     *     g_tls_connection_set_certificate().
     * @field
     */
    requestCertificate: (
      interaction: TlsInteraction,
      connection: TlsConnection,
      flags: TlsCertificateRequestFlags,
      cancellable: Cancellable | null
    ) => TlsInteractionResult
    /**
     * ask for a certificate asynchronously.
     * @field
     */
    requestCertificateAsync: (
      interaction: TlsInteraction,
      connection: TlsConnection,
      flags: TlsCertificateRequestFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * complete operation to ask for a certificate
     *     asynchronously. If the implementation returns %G_TLS_INTERACTION_HANDLED,
     *     then the connection argument of the async method should have been
     *     filled in by using g_tls_connection_set_certificate().
     * @field
     */
    requestCertificateFinish: (
      interaction: TlsInteraction,
      result: AsyncResult
    ) => TlsInteractionResult
  }

  /**
   * The class for #GTlsInteraction. Derived classes implement the various
   * virtual interaction methods to handle TLS interactions.
   *
   * Derived classes can choose to implement whichever interactions methods they'd
   * like to support by overriding those virtual methods in their class
   * initialization function. If a derived class implements an async method,
   * it must also implement the corresponding finish method.
   *
   * The synchronous interaction methods should implement to display modal dialogs,
   * and the asynchronous methods to display modeless dialogs.
   *
   * If the user cancels an interaction, then the result should be
   * %G_TLS_INTERACTION_FAILED and the error should be set with a domain of
   * %G_IO_ERROR and code of %G_IO_ERROR_CANCELLED.
   * @record
   */
  abstract class TlsInteractionClass {
    // Own properties of Gio-2.0.Gio.TlsInteractionClass

    static name: string
  }

  interface TlsInteractionPrivate {}

  class TlsInteractionPrivate {
    // Own properties of Gio-2.0.Gio.TlsInteractionPrivate

    static name: string
  }

  interface TlsPasswordClass {
    // Own fields of Gio-2.0.Gio.TlsPasswordClass

    parentClass: GObject.ObjectClass
    /**
     * virtual method for g_tls_password_get_value()
     * @field
     */
    getValue: (password: TlsPassword) => number[]
    /**
     * virtual method for g_tls_password_set_value()
     * @field
     */
    setValue: (
      password: TlsPassword,
      value: number[],
      destroy: GLib.DestroyNotify | null
    ) => void
    /**
     * virtual method for g_tls_password_get_warning() if no
     *  value has been set using g_tls_password_set_warning()
     * @field
     */
    getDefaultWarning: (password: TlsPassword) => string
  }

  /**
   * Class structure for #GTlsPassword.
   * @record
   */
  abstract class TlsPasswordClass {
    // Own properties of Gio-2.0.Gio.TlsPasswordClass

    static name: string
  }

  interface TlsPasswordPrivate {}

  class TlsPasswordPrivate {
    // Own properties of Gio-2.0.Gio.TlsPasswordPrivate

    static name: string
  }

  interface TlsServerConnectionInterface {
    // Own fields of Gio-2.0.Gio.TlsServerConnectionInterface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
  }

  /**
   * vtable for a #GTlsServerConnection implementation.
   * @record
   */
  abstract class TlsServerConnectionInterface {
    // Own properties of Gio-2.0.Gio.TlsServerConnectionInterface

    static name: string
  }

  interface UnixConnectionClass {
    // Own fields of Gio-2.0.Gio.UnixConnectionClass

    parentClass: SocketConnectionClass
  }

  abstract class UnixConnectionClass {
    // Own properties of Gio-2.0.Gio.UnixConnectionClass

    static name: string
  }

  interface UnixConnectionPrivate {}

  class UnixConnectionPrivate {
    // Own properties of Gio-2.0.Gio.UnixConnectionPrivate

    static name: string
  }

  interface UnixCredentialsMessageClass {
    // Own fields of Gio-2.0.Gio.UnixCredentialsMessageClass

    parentClass: SocketControlMessageClass
  }

  /**
   * Class structure for #GUnixCredentialsMessage.
   * @record
   */
  abstract class UnixCredentialsMessageClass {
    // Own properties of Gio-2.0.Gio.UnixCredentialsMessageClass

    static name: string
  }

  interface UnixCredentialsMessagePrivate {}

  class UnixCredentialsMessagePrivate {
    // Own properties of Gio-2.0.Gio.UnixCredentialsMessagePrivate

    static name: string
  }

  interface UnixFDListClass {
    // Own fields of Gio-2.0.Gio.UnixFDListClass

    parentClass: GObject.ObjectClass
  }

  abstract class UnixFDListClass {
    // Own properties of Gio-2.0.Gio.UnixFDListClass

    static name: string
  }

  interface UnixFDListPrivate {}

  class UnixFDListPrivate {
    // Own properties of Gio-2.0.Gio.UnixFDListPrivate

    static name: string
  }

  interface UnixFDMessageClass {
    // Own fields of Gio-2.0.Gio.UnixFDMessageClass

    parentClass: SocketControlMessageClass
  }

  abstract class UnixFDMessageClass {
    // Own properties of Gio-2.0.Gio.UnixFDMessageClass

    static name: string
  }

  interface UnixFDMessagePrivate {}

  class UnixFDMessagePrivate {
    // Own properties of Gio-2.0.Gio.UnixFDMessagePrivate

    static name: string
  }

  interface UnixInputStreamClass {
    // Own fields of Gio-2.0.Gio.UnixInputStreamClass

    parentClass: InputStreamClass
  }

  abstract class UnixInputStreamClass {
    // Own properties of Gio-2.0.Gio.UnixInputStreamClass

    static name: string
  }

  interface UnixInputStreamPrivate {}

  class UnixInputStreamPrivate {
    // Own properties of Gio-2.0.Gio.UnixInputStreamPrivate

    static name: string
  }

  interface UnixMountEntry {}

  /**
   * Defines a Unix mount entry (e.g. <filename>/media/cdrom</filename>).
   * This corresponds roughly to a mtab entry.
   * @record
   */
  class UnixMountEntry {
    // Own properties of Gio-2.0.Gio.UnixMountEntry

    static name: string
  }

  interface UnixMountMonitorClass {}

  abstract class UnixMountMonitorClass {
    // Own properties of Gio-2.0.Gio.UnixMountMonitorClass

    static name: string
  }

  interface UnixMountPoint {
    // Owm methods of Gio-2.0.Gio.UnixMountPoint

    /**
     * Compares two unix mount points.
     * @param mount2 a #GUnixMount.
     * @returns 1, 0 or -1 if @mount1 is greater than, equal to, or less than @mount2, respectively.
     */
    compare(mount2: UnixMountPoint): number
    /**
     * Makes a copy of `mount_point`.
     * @returns a new #GUnixMountPoint
     */
    copy(): UnixMountPoint
    /**
     * Frees a unix mount point.
     */
    free(): void
    /**
     * Gets the device path for a unix mount point.
     * @returns a string containing the device path.
     */
    getDevicePath(): string
    /**
     * Gets the file system type for the mount point.
     * @returns a string containing the file system type.
     */
    getFsType(): string
    /**
     * Gets the mount path for a unix mount point.
     * @returns a string containing the mount path.
     */
    getMountPath(): string
    /**
     * Gets the options for the mount point.
     * @returns a string containing the options.
     */
    getOptions(): string | null
    /**
     * Guesses whether a Unix mount point can be ejected.
     * @returns %TRUE if @mount_point is deemed to be ejectable.
     */
    guessCanEject(): boolean
    /**
     * Guesses the icon of a Unix mount point.
     * @returns a #GIcon
     */
    guessIcon(): Icon
    /**
     * Guesses the name of a Unix mount point.
     * The result is a translated string.
     * @returns A newly allocated string that must     be freed with g_free()
     */
    guessName(): string | null
    /**
     * Guesses the symbolic icon of a Unix mount point.
     * @returns a #GIcon
     */
    guessSymbolicIcon(): Icon
    /**
     * Checks if a unix mount point is a loopback device.
     * @returns %TRUE if the mount point is a loopback. %FALSE otherwise.
     */
    isLoopback(): boolean
    /**
     * Checks if a unix mount point is read only.
     * @returns %TRUE if a mount point is read only.
     */
    isReadonly(): boolean
    /**
     * Checks if a unix mount point is mountable by the user.
     * @returns %TRUE if the mount point is user mountable.
     */
    isUserMountable(): boolean
  }

  /**
   * Defines a Unix mount point (e.g. <filename>/dev</filename>).
   * This corresponds roughly to a fstab entry.
   * @record
   */
  class UnixMountPoint {
    // Own properties of Gio-2.0.Gio.UnixMountPoint

    static name: string

    // Constructors of Gio-2.0.Gio.UnixMountPoint

    /**
     * Gets a #GUnixMountPoint for a given mount path. If `time_read` is set, it
     * will be filled with a unix timestamp for checking if the mount points have
     * changed since with g_unix_mount_points_changed_since().
     *
     * If more mount points have the same mount path, the last matching mount point
     * is returned.
     * @param mountPath path for a possible unix mount point.
     * @returns a #GUnixMountPoint, or %NULL if no match is found.
     */
    static at(
      mountPath: string
    ): [/* returnType */ UnixMountPoint | null, /* timeRead */ number]
  }

  interface UnixOutputStreamClass {
    // Own fields of Gio-2.0.Gio.UnixOutputStreamClass

    parentClass: OutputStreamClass
  }

  abstract class UnixOutputStreamClass {
    // Own properties of Gio-2.0.Gio.UnixOutputStreamClass

    static name: string
  }

  interface UnixOutputStreamPrivate {}

  class UnixOutputStreamPrivate {
    // Own properties of Gio-2.0.Gio.UnixOutputStreamPrivate

    static name: string
  }

  interface UnixSocketAddressClass {
    // Own fields of Gio-2.0.Gio.UnixSocketAddressClass

    parentClass: SocketAddressClass
  }

  abstract class UnixSocketAddressClass {
    // Own properties of Gio-2.0.Gio.UnixSocketAddressClass

    static name: string
  }

  interface UnixSocketAddressPrivate {}

  class UnixSocketAddressPrivate {
    // Own properties of Gio-2.0.Gio.UnixSocketAddressPrivate

    static name: string
  }

  interface VfsClass {
    // Own fields of Gio-2.0.Gio.VfsClass

    parentClass: GObject.ObjectClass
    isActive: (vfs: Vfs) => boolean
    getFileForPath: (vfs: Vfs, path: string) => File
    getFileForUri: (vfs: Vfs, uri: string) => File
    getSupportedUriSchemes: (vfs: Vfs) => string[]
    parseName: (vfs: Vfs, parseName: string) => File
    localFileAddInfo: (
      vfs: Vfs,
      filename: string,
      device: number,
      attributeMatcher: FileAttributeMatcher,
      info: FileInfo,
      cancellable: Cancellable | null,
      extraData: any | null,
      freeExtraData: GLib.DestroyNotify
    ) => void
    addWritableNamespaces: (vfs: Vfs, list: FileAttributeInfoList) => void
    localFileSetAttributes: (
      vfs: Vfs,
      filename: string,
      info: FileInfo,
      flags: FileQueryInfoFlags,
      cancellable: Cancellable | null
    ) => boolean
    localFileRemoved: (vfs: Vfs, filename: string) => void
    localFileMoved: (vfs: Vfs, source: string, dest: string) => void
  }

  abstract class VfsClass {
    // Own properties of Gio-2.0.Gio.VfsClass

    static name: string
  }

  interface VolumeIface {
    // Own fields of Gio-2.0.Gio.VolumeIface

    /**
     * The parent interface.
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Changed signal that is emitted when the volume's state has changed.
     * @field
     */
    changed: (volume: Volume) => void
    /**
     * The removed signal that is emitted when the #GVolume have been removed. If the recipient is holding references to the object they should release them so the object can be finalized.
     * @field
     */
    removed: (volume: Volume) => void
    /**
     * Gets a string containing the name of the #GVolume.
     * @field
     */
    getName: (volume: Volume) => string | null
    /**
     * Gets a #GIcon for the #GVolume.
     * @field
     */
    getIcon: (volume: Volume) => Icon
    /**
     * Gets the UUID for the #GVolume. The reference is typically based on the file system UUID for the mount in question and should be considered an opaque string. Returns %NULL if there is no UUID available.
     * @field
     */
    getUuid: (volume: Volume) => string | null
    /**
     * Gets a #GDrive the volume is located on. Returns %NULL if the #GVolume is not associated with a #GDrive.
     * @field
     */
    getDrive: (volume: Volume) => Drive | null
    /**
     * Gets a #GMount representing the mounted volume. Returns %NULL if the #GVolume is not mounted.
     * @field
     */
    getMount: (volume: Volume) => Mount | null
    /**
     * Returns %TRUE if the #GVolume can be mounted.
     * @field
     */
    canMount: (volume: Volume) => boolean
    /**
     * Checks if a #GVolume can be ejected.
     * @field
     */
    canEject: (volume: Volume) => boolean
    /**
     * Mounts a given #GVolume.
     *     #GVolume implementations must emit the #GMountOperation::aborted
     *     signal before completing a mount operation that is aborted while
     *     awaiting input from the user through a #GMountOperation instance.
     * @field
     */
    mountFn: (
      volume: Volume,
      flags: MountMountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes a mount operation.
     * @field
     */
    mountFinish: (volume: Volume, result: AsyncResult) => boolean
    /**
     * Ejects a given #GVolume.
     * @field
     */
    eject: (
      volume: Volume,
      flags: MountUnmountFlags,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an eject operation.
     * @field
     */
    ejectFinish: (volume: Volume, result: AsyncResult) => boolean
    /**
     * Returns the [identifier](#volume-identifiers) of the given kind, or %NULL if
     *    the #GVolume doesn't have one.
     * @field
     */
    getIdentifier: (volume: Volume, kind: string) => string | null
    /**
     * Returns an array strings listing the kinds
     *    of [identifiers](#volume-identifiers) which the #GVolume has.
     * @field
     */
    enumerateIdentifiers: (volume: Volume) => string[]
    /**
     * Returns %TRUE if the #GVolume should be automatically mounted.
     * @field
     */
    shouldAutomount: (volume: Volume) => boolean
    /**
     * Returns the activation root for the #GVolume if it is known in advance or %NULL if
     *   it is not known.
     * @field
     */
    getActivationRoot: (volume: Volume) => File | null
    /**
     * Starts ejecting a #GVolume using a #GMountOperation. Since 2.22.
     * @field
     */
    ejectWithOperation: (
      volume: Volume,
      flags: MountUnmountFlags,
      mountOperation: MountOperation | null,
      cancellable: Cancellable | null,
      callback: AsyncReadyCallback | null
    ) => void
    /**
     * Finishes an eject operation using a #GMountOperation. Since 2.22.
     * @field
     */
    ejectWithOperationFinish: (volume: Volume, result: AsyncResult) => boolean
    /**
     * Gets a key used for sorting #GVolume instance or %NULL if no such key exists. Since 2.32.
     * @field
     */
    getSortKey: (volume: Volume) => string | null
    /**
     * Gets a symbolic #GIcon for the #GVolume. Since 2.34.
     * @field
     */
    getSymbolicIcon: (volume: Volume) => Icon
  }

  /**
   * Interface for implementing operations for mountable volumes.
   * @record
   */
  abstract class VolumeIface {
    // Own properties of Gio-2.0.Gio.VolumeIface

    static name: string
  }

  interface VolumeMonitorClass {
    // Own fields of Gio-2.0.Gio.VolumeMonitorClass

    parentClass: GObject.ObjectClass
    volumeAdded: (volumeMonitor: VolumeMonitor, volume: Volume) => void
    volumeRemoved: (volumeMonitor: VolumeMonitor, volume: Volume) => void
    volumeChanged: (volumeMonitor: VolumeMonitor, volume: Volume) => void
    mountAdded: (volumeMonitor: VolumeMonitor, mount: Mount) => void
    mountRemoved: (volumeMonitor: VolumeMonitor, mount: Mount) => void
    mountPreUnmount: (volumeMonitor: VolumeMonitor, mount: Mount) => void
    mountChanged: (volumeMonitor: VolumeMonitor, mount: Mount) => void
    driveConnected: (volumeMonitor: VolumeMonitor, drive: Drive) => void
    driveDisconnected: (volumeMonitor: VolumeMonitor, drive: Drive) => void
    driveChanged: (volumeMonitor: VolumeMonitor, drive: Drive) => void
    isSupported: () => boolean
    getConnectedDrives: (volumeMonitor: VolumeMonitor) => Drive[]
    getVolumes: (volumeMonitor: VolumeMonitor) => Volume[]
    getMounts: (volumeMonitor: VolumeMonitor) => Mount[]
    getVolumeForUuid: (
      volumeMonitor: VolumeMonitor,
      uuid: string
    ) => Volume | null
    getMountForUuid: (
      volumeMonitor: VolumeMonitor,
      uuid: string
    ) => Mount | null
    driveEjectButton: (volumeMonitor: VolumeMonitor, drive: Drive) => void
    driveStopButton: (volumeMonitor: VolumeMonitor, drive: Drive) => void
  }

  abstract class VolumeMonitorClass {
    // Own properties of Gio-2.0.Gio.VolumeMonitorClass

    static name: string
  }

  interface ZlibCompressorClass {
    // Own fields of Gio-2.0.Gio.ZlibCompressorClass

    parentClass: GObject.ObjectClass
  }

  abstract class ZlibCompressorClass {
    // Own properties of Gio-2.0.Gio.ZlibCompressorClass

    static name: string
  }

  interface ZlibDecompressorClass {
    // Own fields of Gio-2.0.Gio.ZlibDecompressorClass

    parentClass: GObject.ObjectClass
  }

  abstract class ZlibDecompressorClass {
    // Own properties of Gio-2.0.Gio.ZlibDecompressorClass

    static name: string
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace Pango {
  /**
   * `PangoAlignment` describes how to align the lines of a `PangoLayout`
   * within the available space.
   *
   * If the `PangoLayout` is set to justify using [method`Pango`.Layout.set_justify],
   * this only affects partial lines.
   *
   * See [method`Pango`.Layout.set_auto_dir] for how text direction affects
   * the interpretation of `PangoAlignment` values.
   */
  enum Alignment {
    /**
     * Put all available space on the right
     */
    LEFT,
    /**
     * Center the line within the available space
     */
    CENTER,
    /**
     * Put all available space on the left
     */
    RIGHT,
  }
  /**
   * The `PangoAttrType` distinguishes between different types of attributes.
   *
   * Along with the predefined values, it is possible to allocate additional
   * values for custom attributes using [func`AttrType`.register]. The predefined
   * values are given below. The type of structure used to store the attribute is
   * listed in parentheses after the description.
   */
  enum AttrType {
    /**
     * does not happen
     */
    INVALID,
    /**
     * language ([struct`Pango`.AttrLanguage])
     */
    LANGUAGE,
    /**
     * font family name list ([struct`Pango`.AttrString])
     */
    FAMILY,
    /**
     * font slant style ([struct`Pango`.AttrInt])
     */
    STYLE,
    /**
     * font weight ([struct`Pango`.AttrInt])
     */
    WEIGHT,
    /**
     * font variant (normal or small caps) ([struct`Pango`.AttrInt])
     */
    VARIANT,
    /**
     * font stretch ([struct`Pango`.AttrInt])
     */
    STRETCH,
    /**
     * font size in points scaled by %PANGO_SCALE ([struct`Pango`.AttrInt])
     */
    SIZE,
    /**
     * font description ([struct`Pango`.AttrFontDesc])
     */
    FONT_DESC,
    /**
     * foreground color ([struct`Pango`.AttrColor])
     */
    FOREGROUND,
    /**
     * background color ([struct`Pango`.AttrColor])
     */
    BACKGROUND,
    /**
     * whether the text has an underline ([struct`Pango`.AttrInt])
     */
    UNDERLINE,
    /**
     * whether the text is struck-through ([struct`Pango`.AttrInt])
     */
    STRIKETHROUGH,
    /**
     * baseline displacement ([struct`Pango`.AttrInt])
     */
    RISE,
    /**
     * shape ([struct`Pango`.AttrShape])
     */
    SHAPE,
    /**
     * font size scale factor ([struct`Pango`.AttrFloat])
     */
    SCALE,
    /**
     * whether fallback is enabled ([struct`Pango`.AttrInt])
     */
    FALLBACK,
    /**
     * letter spacing ([struct`PangoAttrInt]`)
     */
    LETTER_SPACING,
    /**
     * underline color ([struct`Pango`.AttrColor])
     */
    UNDERLINE_COLOR,
    /**
     * strikethrough color ([struct`Pango`.AttrColor])
     */
    STRIKETHROUGH_COLOR,
    /**
     * font size in pixels scaled by %PANGO_SCALE ([struct`Pango`.AttrInt])
     */
    ABSOLUTE_SIZE,
    /**
     * base text gravity ([struct`Pango`.AttrInt])
     */
    GRAVITY,
    /**
     * gravity hint ([struct`Pango`.AttrInt])
     */
    GRAVITY_HINT,
    /**
     * OpenType font features ([struct`Pango`.AttrFontFeatures]). Since 1.38
     */
    FONT_FEATURES,
    /**
     * foreground alpha ([struct`Pango`.AttrInt]). Since 1.38
     */
    FOREGROUND_ALPHA,
    /**
     * background alpha ([struct`Pango`.AttrInt]). Since 1.38
     */
    BACKGROUND_ALPHA,
    /**
     * whether breaks are allowed ([struct`Pango`.AttrInt]). Since 1.44
     */
    ALLOW_BREAKS,
    /**
     * how to render invisible characters ([struct`Pango`.AttrInt]). Since 1.44
     */
    SHOW,
    /**
     * whether to insert hyphens at intra-word line breaks ([struct`Pango`.AttrInt]). Since 1.44
     */
    INSERT_HYPHENS,
    /**
     * whether the text has an overline ([struct`Pango`.AttrInt]). Since 1.46
     */
    OVERLINE,
    /**
     * overline color ([struct`Pango`.AttrColor]). Since 1.46
     */
    OVERLINE_COLOR,
    /**
     * line height factor ([struct`Pango`.AttrFloat]). Since: 1.50
     */
    LINE_HEIGHT,
    /**
     * line height ([struct`Pango`.AttrInt]). Since: 1.50
     */
    ABSOLUTE_LINE_HEIGHT,
    TEXT_TRANSFORM,
    /**
     * override segmentation to classify the range of the attribute as a single word ([struct`Pango`.AttrInt]). Since 1.50
     */
    WORD,
    /**
     * override segmentation to classify the range of the attribute as a single sentence ([struct`Pango`.AttrInt]). Since 1.50
     */
    SENTENCE,
    /**
     * baseline displacement ([struct`Pango`.AttrInt]). Since 1.50
     */
    BASELINE_SHIFT,
    /**
     * font-relative size change ([struct`Pango`.AttrInt]). Since 1.50
     */
    FONT_SCALE,
  }
  /**
   * An enumeration that affects baseline shifts between runs.
   */
  enum BaselineShift {
    /**
     * Leave the baseline unchanged
     */
    NONE,
    /**
     * Shift the baseline to the superscript position,
     *   relative to the previous run
     */
    SUPERSCRIPT,
    /**
     * Shift the baseline to the subscript position,
     *   relative to the previous run
     */
    SUBSCRIPT,
  }
  /**
   * `PangoBidiType` represents the bidirectional character
   * type of a Unicode character.
   *
   * The values in this enumeration are specified by the
   * [Unicode bidirectional algorithm](http://www.unicode.org/reports/tr9/).
   */
  enum BidiType {
    /**
     * Left-to-Right
     */
    L,
    /**
     * Left-to-Right Embedding
     */
    LRE,
    /**
     * Left-to-Right Override
     */
    LRO,
    /**
     * Right-to-Left
     */
    R,
    /**
     * Right-to-Left Arabic
     */
    AL,
    /**
     * Right-to-Left Embedding
     */
    RLE,
    /**
     * Right-to-Left Override
     */
    RLO,
    /**
     * Pop Directional Format
     */
    PDF,
    /**
     * European Number
     */
    EN,
    /**
     * European Number Separator
     */
    ES,
    /**
     * European Number Terminator
     */
    ET,
    /**
     * Arabic Number
     */
    AN,
    /**
     * Common Number Separator
     */
    CS,
    /**
     * Nonspacing Mark
     */
    NSM,
    /**
     * Boundary Neutral
     */
    BN,
    /**
     * Paragraph Separator
     */
    B,
    /**
     * Segment Separator
     */
    S,
    /**
     * Whitespace
     */
    WS,
    /**
     * Other Neutrals
     */
    ON,
    /**
     * Left-to-Right isolate. Since 1.48.6
     */
    LRI,
    /**
     * Right-to-Left isolate. Since 1.48.6
     */
    RLI,
    /**
     * First strong isolate. Since 1.48.6
     */
    FSI,
    /**
     * Pop directional isolate. Since 1.48.6
     */
    PDI,
  }
  /**
   * `PangoCoverageLevel` is used to indicate how well a font can
   * represent a particular Unicode character for a particular script.
   *
   * Since 1.44, only %PANGO_COVERAGE_NONE and %PANGO_COVERAGE_EXACT
   * will be returned.
   */
  enum CoverageLevel {
    /**
     * The character is not representable with
     *   the font.
     */
    NONE,
    /**
     * The character is represented in a
     *   way that may be comprehensible but is not the correct
     *   graphical form. For instance, a Hangul character represented
     *   as a a sequence of Jamos, or a Latin transliteration of a
     *   Cyrillic word.
     */
    FALLBACK,
    /**
     * The character is represented as
     *   basically the correct graphical form, but with a stylistic
     *   variant inappropriate for the current script.
     */
    APPROXIMATE,
    /**
     * The character is represented as the
     *   correct graphical form.
     */
    EXACT,
  }
  /**
   * `PangoDirection` represents a direction in the Unicode bidirectional
   * algorithm.
   *
   * Not every value in this enumeration makes sense for every usage of
   * `PangoDirection`; for example, the return value of [func`unichar_direction]`
   * and [func`find_base_dir]` cannot be `PANGO_DIRECTION_WEAK_LTR` or
   * `PANGO_DIRECTION_WEAK_RTL`, since every character is either neutral
   * or has a strong direction; on the other hand `PANGO_DIRECTION_NEUTRAL`
   * doesn't make sense to pass to [func`itemize_with_base_dir]`.
   *
   * The `PANGO_DIRECTION_TTB_LTR`, `PANGO_DIRECTION_TTB_RTL` values come from
   * an earlier interpretation of this enumeration as the writing direction
   * of a block of text and are no longer used. See `PangoGravity` for how
   * vertical text is handled in Pango.
   *
   * If you are interested in text direction, you should really use fribidi
   * directly. `PangoDirection` is only retained because it is used in some
   * public apis.
   */
  enum Direction {
    /**
     * A strong left-to-right direction
     */
    LTR,
    /**
     * A strong right-to-left direction
     */
    RTL,
    /**
     * Deprecated value; treated the
     *   same as `PANGO_DIRECTION_RTL`.
     */
    TTB_LTR,
    /**
     * Deprecated value; treated the
     *   same as `PANGO_DIRECTION_LTR`
     */
    TTB_RTL,
    /**
     * A weak left-to-right direction
     */
    WEAK_LTR,
    /**
     * A weak right-to-left direction
     */
    WEAK_RTL,
    /**
     * No direction specified
     */
    NEUTRAL,
  }
  /**
   * `PangoEllipsizeMode` describes what sort of ellipsization
   * should be applied to text.
   *
   * In the ellipsization process characters are removed from the
   * text in order to make it fit to a given width and replaced
   * with an ellipsis.
   */
  enum EllipsizeMode {
    /**
     * No ellipsization
     */
    NONE,
    /**
     * Omit characters at the start of the text
     */
    START,
    /**
     * Omit characters in the middle of the text
     */
    MIDDLE,
    /**
     * Omit characters at the end of the text
     */
    END,
  }
  /**
   * An enumeration that affects font sizes for superscript
   * and subscript positioning and for (emulated) Small Caps.
   */
  enum FontScale {
    /**
     * Leave the font size unchanged
     */
    NONE,
    /**
     * Change the font to a size suitable for superscripts
     */
    SUPERSCRIPT,
    /**
     * Change the font to a size suitable for subscripts
     */
    SUBSCRIPT,
    /**
     * Change the font to a size suitable for Small Caps
     */
    SMALL_CAPS,
  }
  /**
   * `PangoGravity` represents the orientation of glyphs in a segment
   * of text.
   *
   * This is useful when rendering vertical text layouts. In those situations,
   * the layout is rotated using a non-identity [struct`Pango`.Matrix], and then
   * glyph orientation is controlled using `PangoGravity`.
   *
   * Not every value in this enumeration makes sense for every usage of
   * `PangoGravity`; for example, %PANGO_GRAVITY_AUTO only can be passed to
   * [method`Pango`.Context.set_base_gravity] and can only be returned by
   * [method`Pango`.Context.get_base_gravity].
   *
   * See also: [enum`Pango`.GravityHint]
   */
  enum Gravity {
    /**
     * Glyphs stand upright (default) <img align="right" valign="center" src="m-south.png">
     */
    SOUTH,
    /**
     * Glyphs are rotated 90 degrees counter-clockwise. <img align="right" valign="center" src="m-east.png">
     */
    EAST,
    /**
     * Glyphs are upside-down. <img align="right" valign="cener" src="m-north.png">
     */
    NORTH,
    /**
     * Glyphs are rotated 90 degrees clockwise. <img align="right" valign="center" src="m-west.png">
     */
    WEST,
    /**
     * Gravity is resolved from the context matrix
     */
    AUTO,
  }
  /**
   * `PangoGravityHint` defines how horizontal scripts should behave in a
   * vertical context.
   *
   * That is, English excerpts in a vertical paragraph for example.
   *
   * See also [enum`Pango`.Gravity]
   */
  enum GravityHint {
    /**
     * scripts will take their natural gravity based
     *   on the base gravity and the script.  This is the default.
     */
    NATURAL,
    /**
     * always use the base gravity set, regardless of
     *   the script.
     */
    STRONG,
    /**
     * for scripts not in their natural direction (eg.
     *   Latin in East gravity), choose per-script gravity such that every script
     *   respects the line progression. This means, Latin and Arabic will take
     *   opposite gravities and both flow top-to-bottom for example.
     */
    LINE,
  }
  /**
   * Errors that can be returned by [func`Pango`.Layout.deserialize].
   */
  enum LayoutDeserializeError {
    /**
     * Unspecified error
     */
    INVALID,
    /**
     * A JSon value could not be
     *   interpreted
     */
    INVALID_VALUE,
    /**
     * A required JSon member was
     *   not found
     */
    MISSING_VALUE,
  }
  /**
   * The `PangoOverline` enumeration is used to specify whether text
   * should be overlined, and if so, the type of line.
   */
  enum Overline {
    /**
     * no overline should be drawn
     */
    NONE,
    /**
     * Draw a single line above the ink
     *   extents of the text being underlined.
     */
    SINGLE,
  }
  /**
   * `PangoRenderPart` defines different items to render for such
   * purposes as setting colors.
   */
  enum RenderPart {
    /**
     * the text itself
     */
    FOREGROUND,
    /**
     * the area behind the text
     */
    BACKGROUND,
    /**
     * underlines
     */
    UNDERLINE,
    /**
     * strikethrough lines
     */
    STRIKETHROUGH,
    /**
     * overlines
     */
    OVERLINE,
  }
  /**
   * The `PangoScript` enumeration identifies different writing
   * systems.
   *
   * The values correspond to the names as defined in the Unicode standard. See
   * [Unicode Standard Annex 24: Script names](http://www.unicode.org/reports/tr24/)
   *
   * Note that this enumeration is deprecated and will not be updated to include values
   * in newer versions of the Unicode standard. Applications should use the
   * [enum`GLib`.UnicodeScript] enumeration instead,
   * whose values are interchangeable with `PangoScript`.
   */
  enum Script {
    /**
     * a value never returned from pango_script_for_unichar()
     */
    INVALID_CODE,
    /**
     * a character used by multiple different scripts
     */
    COMMON,
    /**
     * a mark glyph that takes its script from the
     * base glyph to which it is attached
     */
    INHERITED,
    /**
     * Arabic
     */
    ARABIC,
    /**
     * Armenian
     */
    ARMENIAN,
    /**
     * Bengali
     */
    BENGALI,
    /**
     * Bopomofo
     */
    BOPOMOFO,
    /**
     * Cherokee
     */
    CHEROKEE,
    /**
     * Coptic
     */
    COPTIC,
    /**
     * Cyrillic
     */
    CYRILLIC,
    /**
     * Deseret
     */
    DESERET,
    /**
     * Devanagari
     */
    DEVANAGARI,
    /**
     * Ethiopic
     */
    ETHIOPIC,
    /**
     * Georgian
     */
    GEORGIAN,
    /**
     * Gothic
     */
    GOTHIC,
    /**
     * Greek
     */
    GREEK,
    /**
     * Gujarati
     */
    GUJARATI,
    /**
     * Gurmukhi
     */
    GURMUKHI,
    /**
     * Han
     */
    HAN,
    /**
     * Hangul
     */
    HANGUL,
    /**
     * Hebrew
     */
    HEBREW,
    /**
     * Hiragana
     */
    HIRAGANA,
    /**
     * Kannada
     */
    KANNADA,
    /**
     * Katakana
     */
    KATAKANA,
    /**
     * Khmer
     */
    KHMER,
    /**
     * Lao
     */
    LAO,
    /**
     * Latin
     */
    LATIN,
    /**
     * Malayalam
     */
    MALAYALAM,
    /**
     * Mongolian
     */
    MONGOLIAN,
    /**
     * Myanmar
     */
    MYANMAR,
    /**
     * Ogham
     */
    OGHAM,
    /**
     * Old Italic
     */
    OLD_ITALIC,
    /**
     * Oriya
     */
    ORIYA,
    /**
     * Runic
     */
    RUNIC,
    /**
     * Sinhala
     */
    SINHALA,
    /**
     * Syriac
     */
    SYRIAC,
    /**
     * Tamil
     */
    TAMIL,
    /**
     * Telugu
     */
    TELUGU,
    /**
     * Thaana
     */
    THAANA,
    /**
     * Thai
     */
    THAI,
    /**
     * Tibetan
     */
    TIBETAN,
    /**
     * Canadian Aboriginal
     */
    CANADIAN_ABORIGINAL,
    /**
     * Yi
     */
    YI,
    /**
     * Tagalog
     */
    TAGALOG,
    /**
     * Hanunoo
     */
    HANUNOO,
    /**
     * Buhid
     */
    BUHID,
    /**
     * Tagbanwa
     */
    TAGBANWA,
    /**
     * Braille
     */
    BRAILLE,
    /**
     * Cypriot
     */
    CYPRIOT,
    /**
     * Limbu
     */
    LIMBU,
    /**
     * Osmanya
     */
    OSMANYA,
    /**
     * Shavian
     */
    SHAVIAN,
    /**
     * Linear B
     */
    LINEAR_B,
    /**
     * Tai Le
     */
    TAI_LE,
    /**
     * Ugaritic
     */
    UGARITIC,
    /**
     * New Tai Lue. Since 1.10
     */
    NEW_TAI_LUE,
    /**
     * Buginese. Since 1.10
     */
    BUGINESE,
    /**
     * Glagolitic. Since 1.10
     */
    GLAGOLITIC,
    /**
     * Tifinagh. Since 1.10
     */
    TIFINAGH,
    /**
     * Syloti Nagri. Since 1.10
     */
    SYLOTI_NAGRI,
    /**
     * Old Persian. Since 1.10
     */
    OLD_PERSIAN,
    /**
     * Kharoshthi. Since 1.10
     */
    KHAROSHTHI,
    /**
     * an unassigned code point. Since 1.14
     */
    UNKNOWN,
    /**
     * Balinese. Since 1.14
     */
    BALINESE,
    /**
     * Cuneiform. Since 1.14
     */
    CUNEIFORM,
    /**
     * Phoenician. Since 1.14
     */
    PHOENICIAN,
    /**
     * Phags-pa. Since 1.14
     */
    PHAGS_PA,
    /**
     * N'Ko. Since 1.14
     */
    NKO,
    /**
     * Kayah Li. Since 1.20.1
     */
    KAYAH_LI,
    /**
     * Lepcha. Since 1.20.1
     */
    LEPCHA,
    /**
     * Rejang. Since 1.20.1
     */
    REJANG,
    /**
     * Sundanese. Since 1.20.1
     */
    SUNDANESE,
    /**
     * Saurashtra. Since 1.20.1
     */
    SAURASHTRA,
    /**
     * Cham. Since 1.20.1
     */
    CHAM,
    /**
     * Ol Chiki. Since 1.20.1
     */
    OL_CHIKI,
    /**
     * Vai. Since 1.20.1
     */
    VAI,
    /**
     * Carian. Since 1.20.1
     */
    CARIAN,
    /**
     * Lycian. Since 1.20.1
     */
    LYCIAN,
    /**
     * Lydian. Since 1.20.1
     */
    LYDIAN,
    /**
     * Batak. Since 1.32
     */
    BATAK,
    /**
     * Brahmi. Since 1.32
     */
    BRAHMI,
    /**
     * Mandaic. Since 1.32
     */
    MANDAIC,
    /**
     * Chakma. Since: 1.32
     */
    CHAKMA,
    /**
     * Meroitic Cursive. Since: 1.32
     */
    MEROITIC_CURSIVE,
    /**
     * Meroitic Hieroglyphs. Since: 1.32
     */
    MEROITIC_HIEROGLYPHS,
    /**
     * Miao. Since: 1.32
     */
    MIAO,
    /**
     * Sharada. Since: 1.32
     */
    SHARADA,
    /**
     * Sora Sompeng. Since: 1.32
     */
    SORA_SOMPENG,
    /**
     * Takri. Since: 1.32
     */
    TAKRI,
    /**
     * Bassa. Since: 1.40
     */
    BASSA_VAH,
    /**
     * Caucasian Albanian. Since: 1.40
     */
    CAUCASIAN_ALBANIAN,
    /**
     * Duployan. Since: 1.40
     */
    DUPLOYAN,
    /**
     * Elbasan. Since: 1.40
     */
    ELBASAN,
    /**
     * Grantha. Since: 1.40
     */
    GRANTHA,
    /**
     * Kjohki. Since: 1.40
     */
    KHOJKI,
    /**
     * Khudawadi, Sindhi. Since: 1.40
     */
    KHUDAWADI,
    /**
     * Linear A. Since: 1.40
     */
    LINEAR_A,
    /**
     * Mahajani. Since: 1.40
     */
    MAHAJANI,
    /**
     * Manichaean. Since: 1.40
     */
    MANICHAEAN,
    /**
     * Mende Kikakui. Since: 1.40
     */
    MENDE_KIKAKUI,
    /**
     * Modi. Since: 1.40
     */
    MODI,
    /**
     * Mro. Since: 1.40
     */
    MRO,
    /**
     * Nabataean. Since: 1.40
     */
    NABATAEAN,
    /**
     * Old North Arabian. Since: 1.40
     */
    OLD_NORTH_ARABIAN,
    /**
     * Old Permic. Since: 1.40
     */
    OLD_PERMIC,
    /**
     * Pahawh Hmong. Since: 1.40
     */
    PAHAWH_HMONG,
    /**
     * Palmyrene. Since: 1.40
     */
    PALMYRENE,
    /**
     * Pau Cin Hau. Since: 1.40
     */
    PAU_CIN_HAU,
    /**
     * Psalter Pahlavi. Since: 1.40
     */
    PSALTER_PAHLAVI,
    /**
     * Siddham. Since: 1.40
     */
    SIDDHAM,
    /**
     * Tirhuta. Since: 1.40
     */
    TIRHUTA,
    /**
     * Warang Citi. Since: 1.40
     */
    WARANG_CITI,
    /**
     * Ahom. Since: 1.40
     */
    AHOM,
    /**
     * Anatolian Hieroglyphs. Since: 1.40
     */
    ANATOLIAN_HIEROGLYPHS,
    /**
     * Hatran. Since: 1.40
     */
    HATRAN,
    /**
     * Multani. Since: 1.40
     */
    MULTANI,
    /**
     * Old Hungarian. Since: 1.40
     */
    OLD_HUNGARIAN,
    /**
     * Signwriting. Since: 1.40
     */
    SIGNWRITING,
  }
  /**
   * An enumeration specifying the width of the font relative to other designs
   * within a family.
   */
  enum Stretch {
    /**
     * ultra condensed width
     */
    ULTRA_CONDENSED,
    /**
     * extra condensed width
     */
    EXTRA_CONDENSED,
    /**
     * condensed width
     */
    CONDENSED,
    /**
     * semi condensed width
     */
    SEMI_CONDENSED,
    /**
     * the normal width
     */
    NORMAL,
    /**
     * semi expanded width
     */
    SEMI_EXPANDED,
    /**
     * expanded width
     */
    EXPANDED,
    /**
     * extra expanded width
     */
    EXTRA_EXPANDED,
    /**
     * ultra expanded width
     */
    ULTRA_EXPANDED,
  }
  /**
   * An enumeration specifying the various slant styles possible for a font.
   */
  enum Style {
    /**
     * the font is upright.
     */
    NORMAL,
    /**
     * the font is slanted, but in a roman style.
     */
    OBLIQUE,
    /**
     * the font is slanted in an italic style.
     */
    ITALIC,
  }
  /**
   * `PangoTabAlign` specifies where the text appears relative to the tab stop
   * position.
   */
  enum TabAlign {
    /**
     * the text appears to the right of the tab stop position
     */
    LEFT,
    /**
     * the text appears to the left of the tab stop position
     *   until the available space is filled. Since: 1.50
     */
    RIGHT,
    /**
     * the text is centered at the tab stop position
     *   until the available space is filled. Since: 1.50
     */
    CENTER,
    /**
     * text before the first occurrence of the decimal point
     *   character appears to the left of the tab stop position (until the available
     *   space is filled), the rest to the right. Since: 1.50
     */
    DECIMAL,
  }
  /**
   * An enumeration that affects how Pango treats characters during shaping.
   */
  enum TextTransform {
    /**
     * Leave text unchanged
     */
    NONE,
    /**
     * Display letters and numbers as lowercase
     */
    LOWERCASE,
    /**
     * Display letters and numbers as uppercase
     */
    UPPERCASE,
    /**
     * Display the first character of a word
     *   in titlecase
     */
    CAPITALIZE,
  }
  /**
   * The `PangoUnderline` enumeration is used to specify whether text
   * should be underlined, and if so, the type of underlining.
   */
  enum Underline {
    /**
     * no underline should be drawn
     */
    NONE,
    /**
     * a single underline should be drawn
     */
    SINGLE,
    /**
     * a double underline should be drawn
     */
    DOUBLE,
    /**
     * a single underline should be drawn at a
     *   position beneath the ink extents of the text being
     *   underlined. This should be used only for underlining
     *   single characters, such as for keyboard accelerators.
     *   %PANGO_UNDERLINE_SINGLE should be used for extended
     *   portions of text.
     */
    LOW,
    /**
     * an underline indicating an error should
     *   be drawn below. The exact style of rendering is up to the
     *   `PangoRenderer` in use, but typical styles include wavy
     *   or dotted lines.
     *   This underline is typically used to indicate an error such
     *   as a possible mispelling; in some cases a contrasting color
     *   may automatically be used. This type of underlining is
     *   available since Pango 1.4.
     */
    ERROR,
    /**
     * Like `PANGO_UNDERLINE_SINGLE,` but
     *   drawn continuously across multiple runs. This type
     *   of underlining is available since Pango 1.46.
     */
    SINGLE_LINE,
    /**
     * Like `PANGO_UNDERLINE_DOUBLE,` but
     *   drawn continuously across multiple runs. This type
     *   of underlining is available since Pango 1.46.
     */
    DOUBLE_LINE,
    /**
     * Like `PANGO_UNDERLINE_ERROR,` but
     *   drawn continuously across multiple runs. This type
     *   of underlining is available since Pango 1.46.
     */
    ERROR_LINE,
  }
  /**
   * An enumeration specifying capitalization variant of the font.
   */
  enum Variant {
    /**
     * A normal font.
     */
    NORMAL,
    /**
     * A font with the lower case characters
     *   replaced by smaller variants of the capital characters.
     */
    SMALL_CAPS,
    /**
     * A font with all characters
     *   replaced by smaller variants of the capital characters. Since: 1.50
     */
    ALL_SMALL_CAPS,
    /**
     * A font with the lower case characters
     *   replaced by smaller variants of the capital characters.
     *   Petite Caps can be even smaller than Small Caps. Since: 1.50
     */
    PETITE_CAPS,
    /**
     * A font with all characters
     *   replaced by smaller variants of the capital characters.
     *   Petite Caps can be even smaller than Small Caps. Since: 1.50
     */
    ALL_PETITE_CAPS,
    /**
     * A font with the upper case characters
     *   replaced by smaller variants of the capital letters. Since: 1.50
     */
    UNICASE,
    /**
     * A font with capital letters that
     *   are more suitable for all-uppercase titles. Since: 1.50
     */
    TITLE_CAPS,
  }
  /**
   * An enumeration specifying the weight (boldness) of a font.
   *
   * Weight is specified as a numeric value ranging from 100 to 1000.
   * This enumeration simply provides some common, predefined values.
   */
  enum Weight {
    /**
     * the thin weight (= 100) Since: 1.24
     */
    THIN,
    /**
     * the ultralight weight (= 200)
     */
    ULTRALIGHT,
    /**
     * the light weight (= 300)
     */
    LIGHT,
    /**
     * the semilight weight (= 350) Since: 1.36.7
     */
    SEMILIGHT,
    /**
     * the book weight (= 380) Since: 1.24)
     */
    BOOK,
    /**
     * the default weight (= 400)
     */
    NORMAL,
    /**
     * the medium weight (= 500) Since: 1.24
     */
    MEDIUM,
    /**
     * the semibold weight (= 600)
     */
    SEMIBOLD,
    /**
     * the bold weight (= 700)
     */
    BOLD,
    /**
     * the ultrabold weight (= 800)
     */
    ULTRABOLD,
    /**
     * the heavy weight (= 900)
     */
    HEAVY,
    /**
     * the ultraheavy weight (= 1000) Since: 1.24
     */
    ULTRAHEAVY,
  }
  /**
   * `PangoWrapMode` describes how to wrap the lines of a `PangoLayout`
   * to the desired width.
   *
   * For `PANGO_WRAP_WORD,` Pango uses break opportunities that are determined
   * by the Unicode line breaking algorithm. For `PANGO_WRAP_CHAR,` Pango allows
   * breaking at grapheme boundaries that are determined by the Unicode text
   * segmentation algorithm.
   */
  enum WrapMode {
    /**
     * wrap lines at word boundaries.
     */
    WORD,
    /**
     * wrap lines at character boundaries.
     */
    CHAR,
    /**
     * wrap lines at word boundaries, but fall back to
     *   character boundaries if there is not enough space for a full word.
     */
    WORD_CHAR,
  }
  /**
   * The bits in a `PangoFontMask` correspond to the set fields in a
   * `PangoFontDescription`.
   * @bitfield
   */
  enum FontMask {
    /**
     * the font family is specified.
     */
    FAMILY,
    /**
     * the font style is specified.
     */
    STYLE,
    /**
     * the font variant is specified.
     */
    VARIANT,
    /**
     * the font weight is specified.
     */
    WEIGHT,
    /**
     * the font stretch is specified.
     */
    STRETCH,
    /**
     * the font size is specified.
     */
    SIZE,
    /**
     * the font gravity is specified (Since: 1.16.)
     */
    GRAVITY,
    /**
     * OpenType font variations are specified (Since: 1.42)
     */
    VARIATIONS,
  }
  /**
   * Flags that influence the behavior of [func`Pango`.Layout.deserialize].
   *
   * New members may be added to this enumeration over time.
   * @bitfield
   */
  enum LayoutDeserializeFlags {
    /**
     * Default behavior
     */
    DEFAULT,
    /**
     * Apply context information
     *   from the serialization to the `PangoContext`
     */
    CONTEXT,
  }
  /**
   * Flags that influence the behavior of [method`Pango`.Layout.serialize].
   *
   * New members may be added to this enumeration over time.
   * @bitfield
   */
  enum LayoutSerializeFlags {
    /**
     * Default behavior
     */
    DEFAULT,
    /**
     * Include context information
     */
    CONTEXT,
    /**
     * Include information about the formatted output
     */
    OUTPUT,
  }
  /**
   * Flags influencing the shaping process.
   *
   * `PangoShapeFlags` can be passed to [func`Pango`.shape_with_flags].
   * @bitfield
   */
  enum ShapeFlags {
    /**
     * Default value
     */
    NONE,
    /**
     * Round glyph positions and widths to whole device units
     *   This option should be set if the target renderer can't do subpixel positioning of glyphs
     */
    ROUND_POSITIONS,
  }
  /**
   * These flags affect how Pango treats characters that are normally
   * not visible in the output.
   * @bitfield
   */
  enum ShowFlags {
    /**
     * No special treatment for invisible characters
     */
    NONE,
    /**
     * Render spaces, tabs and newlines visibly
     */
    SPACES,
    /**
     * Render line breaks visibly
     */
    LINE_BREAKS,
    /**
     * Render default-ignorable Unicode
     *   characters visibly
     */
    IGNORABLES,
  }
  /**
   * Whether the segment should be shifted to center around the baseline.
   *
   * This is mainly used in vertical writing directions.
   */
  const ANALYSIS_FLAG_CENTERED_BASELINE: number
  /**
   * Whether this run holds ellipsized text.
   */
  const ANALYSIS_FLAG_IS_ELLIPSIS: number
  /**
   * Whether to add a hyphen at the end of the run during shaping.
   */
  const ANALYSIS_FLAG_NEED_HYPHEN: number
  /**
   * Value for `start_index` in `PangoAttribute` that indicates
   * the beginning of the text.
   */
  const ATTR_INDEX_FROM_TEXT_BEGINNING: number
  /**
   * Value for `end_index` in `PangoAttribute` that indicates
   * the end of the text.
   */
  const ATTR_INDEX_TO_TEXT_END: number
  /**
   * A `PangoGlyph` value that indicates a zero-width empty glpyh.
   *
   * This is useful for example in shaper modules, to use as the glyph for
   * various zero-width Unicode characters (those passing [func`is_zero_width]`).
   */
  const GLYPH_EMPTY: Glyph
  /**
   * A `PangoGlyph` value for invalid input.
   *
   * `PangoLayout` produces one such glyph per invalid input UTF-8 byte and such
   * a glyph is rendered as a crossed box.
   *
   * Note that this value is defined such that it has the %PANGO_GLYPH_UNKNOWN_FLAG
   * set.
   */
  const GLYPH_INVALID_INPUT: Glyph
  /**
   * Flag used in `PangoGlyph` to turn a `gunichar` value of a valid Unicode
   * character into an unknown-character glyph for that `gunichar`.
   *
   * Such unknown-character glyphs may be rendered as a 'hex box'.
   */
  const GLYPH_UNKNOWN_FLAG: Glyph
  /**
   * The scale between dimensions used for Pango distances and device units.
   *
   * The definition of device units is dependent on the output device; it will
   * typically be pixels for a screen, and points for a printer. %PANGO_SCALE is
   * currently 1024, but this may be changed in the future.
   *
   * When setting font sizes, device units are always considered to be
   * points (as in "12 point font"), rather than pixels.
   */
  const SCALE: number
  /**
   * The major component of the version of Pango available at compile-time.
   */
  const VERSION_MAJOR: number
  /**
   * The micro component of the version of Pango available at compile-time.
   */
  const VERSION_MICRO: number
  /**
   * The minor component of the version of Pango available at compile-time.
   */
  const VERSION_MINOR: number
  /**
   * A string literal containing the version of Pango available at compile-time.
   */
  const VERSION_STRING: string
  /**
   * Create a new allow-breaks attribute.
   *
   * If breaks are disabled, the range will be kept in a
   * single run, as far as possible.
   * @param allowBreaks %TRUE if we line breaks are allowed
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrAllowBreaksNew(allowBreaks: boolean): Attribute
  /**
   * Create a new background alpha attribute.
   * @param alpha the alpha value, between 1 and 65536
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrBackgroundAlphaNew(alpha: number): Attribute
  /**
   * Create a new background color attribute.
   * @param red the red value (ranging from 0 to 65535)
   * @param green the green value
   * @param blue the blue value
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrBackgroundNew(
    red: number,
    green: number,
    blue: number
  ): Attribute
  /**
   * Create a new baseline displacement attribute.
   *
   * The effect of this attribute is to shift the baseline of a run,
   * relative to the run of preceding run.
   *
   * <picture>
   *   <source srcset="baseline-shift-dark.png" media="(prefers-color-scheme: dark)">
   *   <img alt="Baseline Shift" src="baseline-shift-light.png">
   * </picture>
   * @param shift either a `PangoBaselineShift` enumeration value or an absolute value (> 1024)   in Pango units, relative to the baseline of the previous run.   Positive values displace the text upwards.
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrBaselineShiftNew(shift: number): Attribute
  /**
   * Apply customization from attributes to the breaks in `attrs`.
   *
   * The line breaks are assumed to have been produced
   * by [func`Pango`.default_break] and [func`Pango`.tailor_break].
   * @param text text to break. Must be valid UTF-8
   * @param length length of text in bytes (may be -1 if `text` is nul-terminated)
   * @param attrList `PangoAttrList` to apply
   * @param offset Byte offset of `text` from the beginning of the paragraph
   * @param attrs array with one `PangoLogAttr`   per character in `text,` plus one extra, to be filled in
   */
  function attrBreak(
    text: string,
    length: number,
    attrList: AttrList,
    offset: number,
    attrs: LogAttr[]
  ): void
  /**
   * Create a new font fallback attribute.
   *
   * If fallback is disabled, characters will only be
   * used from the closest matching font on the system.
   * No fallback will be done to other fonts on the system
   * that might contain the characters in the text.
   * @param enableFallback %TRUE if we should fall back on other fonts   for characters the active font is missing
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrFallbackNew(enableFallback: boolean): Attribute
  /**
   * Create a new font family attribute.
   * @param family the family or comma-separated list of families
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrFamilyNew(family: string): Attribute
  /**
   * Create a new font description attribute.
   *
   * This attribute allows setting family, style, weight, variant,
   * stretch, and size simultaneously.
   * @param desc the font description
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrFontDescNew(desc: FontDescription): Attribute
  /**
   * Create a new font features tag attribute.
   *
   * You can use this attribute to select OpenType font features like small-caps,
   * alternative glyphs, ligatures, etc. for fonts that support them.
   * @param features a string with OpenType font features, with the syntax of the [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc)
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrFontFeaturesNew(features: string): Attribute
  /**
   * Create a new font scale attribute.
   *
   * The effect of this attribute is to change the font size of a run,
   * relative to the size of preceding run.
   * @param scale a `PangoFontScale` value, which indicates font size change relative   to the size of the previous run.
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrFontScaleNew(scale: FontScale): Attribute
  /**
   * Create a new foreground alpha attribute.
   * @param alpha the alpha value, between 1 and 65536
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrForegroundAlphaNew(alpha: number): Attribute
  /**
   * Create a new foreground color attribute.
   * @param red the red value (ranging from 0 to 65535)
   * @param green the green value
   * @param blue the blue value
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrForegroundNew(
    red: number,
    green: number,
    blue: number
  ): Attribute
  /**
   * Create a new gravity hint attribute.
   * @param hint the gravity hint value
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrGravityHintNew(hint: GravityHint): Attribute
  /**
   * Create a new gravity attribute.
   * @param gravity the gravity value; should not be %PANGO_GRAVITY_AUTO
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrGravityNew(gravity: Gravity): Attribute
  /**
   * Create a new insert-hyphens attribute.
   *
   * Pango will insert hyphens when breaking lines in
   * the middle of a word. This attribute can be used
   * to suppress the hyphen.
   * @param insertHyphens %TRUE if hyphens should be inserted
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrInsertHyphensNew(insertHyphens: boolean): Attribute
  /**
   * Create a new language tag attribute.
   * @param language language tag
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrLanguageNew(language: Language): Attribute
  /**
   * Create a new letter-spacing attribute.
   * @param letterSpacing amount of extra space to add between   graphemes of the text, in Pango units
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrLetterSpacingNew(letterSpacing: number): Attribute
  /**
   * Modify the height of logical line extents by a factor.
   *
   * This affects the values returned by
   * [method`Pango`.LayoutLine.get_extents],
   * [method`Pango`.LayoutLine.get_pixel_extents] and
   * [method`Pango`.LayoutIter.get_line_extents].
   * @param factor the scaling factor to apply to the logical height
   */
  function attrLineHeightNew(factor: number): Attribute
  /**
   * Override the height of logical line extents to be `height`.
   *
   * This affects the values returned by
   * [method`Pango`.LayoutLine.get_extents],
   * [method`Pango`.LayoutLine.get_pixel_extents] and
   * [method`Pango`.LayoutIter.get_line_extents].
   * @param height the line height, in %PANGO_SCALE-ths of a point
   */
  function attrLineHeightNewAbsolute(height: number): Attribute
  /**
   * Deserializes a `PangoAttrList` from a string.
   *
   * This is the counterpart to [method`Pango`.AttrList.to_string].
   * See that functions for details about the format.
   * @param text a string
   * @returns a new `PangoAttrList`
   */
  function attrListFromString(text: string): AttrList | null
  /**
   * Create a new overline color attribute.
   *
   * This attribute modifies the color of overlines.
   * If not set, overlines will use the foreground color.
   * @param red the red value (ranging from 0 to 65535)
   * @param green the green value
   * @param blue the blue value
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrOverlineColorNew(
    red: number,
    green: number,
    blue: number
  ): Attribute
  /**
   * Create a new overline-style attribute.
   * @param overline the overline style
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrOverlineNew(overline: Overline): Attribute
  /**
   * Create a new baseline displacement attribute.
   * @param rise the amount that the text should be displaced vertically,   in Pango units. Positive values displace the text upwards.
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrRiseNew(rise: number): Attribute
  /**
   * Create a new font size scale attribute.
   *
   * The base font for the affected text will have
   * its size multiplied by `scale_factor`.
   * @param scaleFactor factor to scale the font
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrScaleNew(scaleFactor: number): Attribute
  /**
   * Marks the range of the attribute as a single sentence.
   *
   * Note that this may require adjustments to word and
   * sentence classification around the range.
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrSentenceNew(): Attribute
  /**
   * Create a new shape attribute.
   *
   * A shape is used to impose a particular ink and logical
   * rectangle on the result of shaping a particular glyph.
   * This might be used, for instance, for embedding a picture
   * or a widget inside a `PangoLayout`.
   * @param inkRect ink rectangle to assign to each character
   * @param logicalRect logical rectangle to assign to each character
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrShapeNew(inkRect: Rectangle, logicalRect: Rectangle): Attribute
  /**
   * Creates a new shape attribute.
   *
   * Like [func`Pango`.AttrShape.new], but a user data pointer
   * is also provided; this pointer can be accessed when later
   * rendering the glyph.
   * @param inkRect ink rectangle to assign to each character
   * @param logicalRect logical rectangle to assign to each character
   * @param data user data pointer
   * @param copyFunc function to copy `data` when the   attribute is copied. If %NULL, `data` is simply copied   as a pointer
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrShapeNewWithData(
    inkRect: Rectangle,
    logicalRect: Rectangle,
    data: any | null,
    copyFunc: AttrDataCopyFunc | null
  ): Attribute
  /**
   * Create a new attribute that influences how invisible
   * characters are rendered.
   * @param flags `PangoShowFlags` to apply
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrShowNew(flags: ShowFlags): Attribute
  /**
   * Create a new font-size attribute in fractional points.
   * @param size the font size, in %PANGO_SCALE-ths of a point
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrSizeNew(size: number): Attribute
  /**
   * Create a new font-size attribute in device units.
   * @param size the font size, in %PANGO_SCALE-ths of a device unit
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrSizeNewAbsolute(size: number): Attribute
  /**
   * Create a new font stretch attribute.
   * @param stretch the stretch
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrStretchNew(stretch: Stretch): Attribute
  /**
   * Create a new strikethrough color attribute.
   *
   * This attribute modifies the color of strikethrough lines.
   * If not set, strikethrough lines will use the foreground color.
   * @param red the red value (ranging from 0 to 65535)
   * @param green the green value
   * @param blue the blue value
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrStrikethroughColorNew(
    red: number,
    green: number,
    blue: number
  ): Attribute
  /**
   * Create a new strike-through attribute.
   * @param strikethrough %TRUE if the text should be struck-through
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrStrikethroughNew(strikethrough: boolean): Attribute
  /**
   * Create a new font slant style attribute.
   * @param style the slant style
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrStyleNew(style: Style): Attribute
  /**
   * Create a new attribute that influences how characters
   * are transformed during shaping.
   * @param transform `PangoTextTransform` to apply
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrTextTransformNew(transform: TextTransform): Attribute
  /**
   * Fetches the attribute type name.
   *
   * The attribute type name is the string passed in
   * when registering the type using
   * [func`Pango`.AttrType.register].
   *
   * The returned value is an interned string (see
   * g_intern_string() for what that means) that should
   * not be modified or freed.
   * @param type an attribute type ID to fetch the name for
   * @returns the type ID name (which   may be %NULL), or %NULL if @type is a built-in Pango   attribute type or invalid.
   */
  function attrTypeGetName(type: AttrType): string | null
  /**
   * Allocate a new attribute type ID.
   *
   * The attribute type name can be accessed later
   * by using [func`Pango`.AttrType.get_name].
   * @param name an identifier for the type
   * @returns the new type ID.
   */
  function attrTypeRegister(name: string): AttrType
  /**
   * Create a new underline color attribute.
   *
   * This attribute modifies the color of underlines.
   * If not set, underlines will use the foreground color.
   * @param red the red value (ranging from 0 to 65535)
   * @param green the green value
   * @param blue the blue value
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrUnderlineColorNew(
    red: number,
    green: number,
    blue: number
  ): Attribute
  /**
   * Create a new underline-style attribute.
   * @param underline the underline style
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrUnderlineNew(underline: Underline): Attribute
  /**
   * Create a new font variant attribute (normal or small caps).
   * @param variant the variant
   * @returns the newly allocated `PangoAttribute`,   which should be freed with [method@Pango.Attribute.destroy].
   */
  function attrVariantNew(variant: Variant): Attribute
  /**
   * Create a new font weight attribute.
   * @param weight the weight
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrWeightNew(weight: Weight): Attribute
  /**
   * Marks the range of the attribute as a single word.
   *
   * Note that this may require adjustments to word and
   * sentence classification around the range.
   * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
   */
  function attrWordNew(): Attribute
  /**
   * Determines the bidirectional type of a character.
   *
   * The bidirectional type is specified in the Unicode Character Database.
   *
   * A simplified version of this function is available as [func`unichar_direction]`.
   * @param ch a Unicode character
   * @returns the bidirectional character type, as used in the Unicode bidirectional algorithm.
   */
  function bidiTypeForUnichar(ch: string): BidiType
  /**
   * Determines possible line, word, and character breaks
   * for a string of Unicode text with a single analysis.
   *
   * For most purposes you may want to use [func`Pango`.get_log_attrs].
   * @param text the text to process. Must be valid UTF-8
   * @param length length of `text` in bytes (may be -1 if `text` is nul-terminated)
   * @param analysis `PangoAnalysis` structure for `text`
   * @param attrs an array to store character information in
   */
  function break_TODO(
    text: string,
    length: number,
    analysis: Analysis,
    attrs: LogAttr[]
  ): void
  /**
   * This is the default break algorithm.
   *
   * It applies rules from the [Unicode Line Breaking Algorithm](http://www.unicode.org/unicode/reports/tr14/)
   * without language-specific tailoring, therefore the `analyis` argument is unused
   * and can be %NULL.
   *
   * See [func`Pango`.tailor_break] for language-specific breaks.
   *
   * See [func`Pango`.attr_break] for attribute-based customization.
   * @param text text to break. Must be valid UTF-8
   * @param length length of text in bytes (may be -1 if `text` is nul-terminated)
   * @param analysis a `PangoAnalysis` structure for the `text`
   * @param attrs logical attributes to fill in
   * @param attrsLen size of the array passed as `attrs`
   */
  function defaultBreak(
    text: string,
    length: number,
    analysis: Analysis | null,
    attrs: LogAttr,
    attrsLen: number
  ): void
  /**
   * Converts extents from Pango units to device units.
   *
   * The conversion is done by dividing by the %PANGO_SCALE factor and
   * performing rounding.
   *
   * The `inclusive` rectangle is converted by flooring the x/y coordinates
   * and extending width/height, such that the final rectangle completely
   * includes the original rectangle.
   *
   * The `nearest` rectangle is converted by rounding the coordinates
   * of the rectangle to the nearest device unit (pixel).
   *
   * The rule to which argument to use is: if you want the resulting device-space
   * rectangle to completely contain the original rectangle, pass it in as
   * `inclusive`. If you want two touching-but-not-overlapping rectangles stay
   * touching-but-not-overlapping after rounding to device units, pass them in
   * as `nearest`.
   * @param inclusive rectangle to round to pixels inclusively
   * @param nearest rectangle to round to nearest pixels
   */
  function extentsToPixels(
    inclusive: Rectangle | null,
    nearest: Rectangle | null
  ): void
  /**
   * Searches a string the first character that has a strong
   * direction, according to the Unicode bidirectional algorithm.
   * @param text the text to process. Must be valid UTF-8
   * @param length length of `text` in bytes (may be -1 if `text` is nul-terminated)
   * @returns The direction corresponding to the first strong character.   If no such character is found, then %PANGO_DIRECTION_NEUTRAL is returned.
   */
  function findBaseDir(text: string, length: number): Direction
  /**
   * Locates a paragraph boundary in `text`.
   *
   * A boundary is caused by delimiter characters, such as
   * a newline, carriage return, carriage return-newline pair,
   * or Unicode paragraph separator character.
   *
   * The index of the run of delimiters is returned in
   * `paragraph_delimiter_index`. The index of the start of the
   * next paragraph (index after all delimiters) is stored n
   * `next_paragraph_start`.
   *
   * If no delimiters are found, both `paragraph_delimiter_index`
   * and `next_paragraph_start` are filled with the length of `text`
   * (an index one off the end).
   * @param text UTF-8 text
   * @param length length of `text` in bytes, or -1 if nul-terminated
   */
  function findParagraphBoundary(
    text: string,
    length: number
  ): [/* paragraphDelimiterIndex */ number, /* nextParagraphStart */ number]
  /**
   * Creates a new font description from a string representation.
   *
   * The string must have the form
   *
   *     "\[FAMILY-LIST] \[STYLE-OPTIONS] \[SIZE] \[VARIATIONS]",
   *
   * where FAMILY-LIST is a comma-separated list of families optionally
   * terminated by a comma, STYLE_OPTIONS is a whitespace-separated list
   * of words where each word describes one of style, variant, weight,
   * stretch, or gravity, and SIZE is a decimal number (size in points)
   * or optionally followed by the unit modifier "px" for absolute size.
   * VARIATIONS is a comma-separated list of font variation
   * specifications of the form "\`axis=`value" (the = sign is optional).
   *
   * The following words are understood as styles:
   * "Normal", "Roman", "Oblique", "Italic".
   *
   * The following words are understood as variants:
   * "Small-Caps", "All-Small-Caps", "Petite-Caps", "All-Petite-Caps",
   * "Unicase", "Title-Caps".
   *
   * The following words are understood as weights:
   * "Thin", "Ultra-Light", "Extra-Light", "Light", "Semi-Light",
   * "Demi-Light", "Book", "Regular", "Medium", "Semi-Bold", "Demi-Bold",
   * "Bold", "Ultra-Bold", "Extra-Bold", "Heavy", "Black", "Ultra-Black",
   * "Extra-Black".
   *
   * The following words are understood as stretch values:
   * "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed",
   * "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded".
   *
   * The following words are understood as gravity values:
   * "Not-Rotated", "South", "Upside-Down", "North", "Rotated-Left",
   * "East", "Rotated-Right", "West".
   *
   * Any one of the options may be absent. If FAMILY-LIST is absent, then
   * the family_name field of the resulting font description will be
   * initialized to %NULL. If STYLE-OPTIONS is missing, then all style
   * options will be set to the default values. If SIZE is missing, the
   * size in the resulting font description will be set to 0.
   *
   * A typical example:
   *
   *     "Cantarell Italic Light 15 \`wght=`200"
   * @param str string representation of a font description.
   * @returns a new `PangoFontDescription`.
   */
  function fontDescriptionFromString(str: string): FontDescription
  /**
   * Computes a `PangoLogAttr` for each character in `text`.
   *
   * The `attrs` array must have one `PangoLogAttr` for
   * each position in `text;` if `text` contains N characters,
   * it has N+1 positions, including the last position at the
   * end of the text. `text` should be an entire paragraph;
   * logical attributes can't be computed without context
   * (for example you need to see spaces on either side of
   * a word to know the word is a word).
   * @param text text to process. Must be valid UTF-8
   * @param length length in bytes of `text`
   * @param level embedding level, or -1 if unknown
   * @param language language tag
   * @param attrs array with one `PangoLogAttr`   per character in `text,` plus one extra, to be filled in
   */
  function getLogAttrs(
    text: string,
    length: number,
    level: number,
    language: Language,
    attrs: LogAttr[]
  ): void
  /**
   * Returns the mirrored character of a Unicode character.
   *
   * Mirror characters are determined by the Unicode mirrored property.
   * @param ch a Unicode character
   * @param mirroredCh location to store the mirrored character
   * @returns %TRUE if @ch has a mirrored character and @mirrored_ch is filled in, %FALSE otherwise
   */
  function getMirrorChar(ch: string, mirroredCh: string): boolean
  /**
   * Finds the gravity that best matches the rotation component
   * in a `PangoMatrix`.
   * @param matrix a `PangoMatrix`
   * @returns the gravity of @matrix, which will never be %PANGO_GRAVITY_AUTO, or %PANGO_GRAVITY_SOUTH if @matrix is %NULL
   */
  function gravityGetForMatrix(matrix: Matrix | null): Gravity
  /**
   * Returns the gravity to use in laying out a `PangoItem`.
   *
   * The gravity is determined based on the script, base gravity, and hint.
   *
   * If `base_gravity` is %PANGO_GRAVITY_AUTO, it is first replaced with the
   * preferred gravity of `script`.  To get the preferred gravity of a script,
   * pass %PANGO_GRAVITY_AUTO and %PANGO_GRAVITY_HINT_STRONG in.
   * @param script `PangoScript` to query
   * @param baseGravity base gravity of the paragraph
   * @param hint orientation hint
   * @returns resolved gravity suitable to use for a run of text with @script
   */
  function gravityGetForScript(
    script: Script,
    baseGravity: Gravity,
    hint: GravityHint
  ): Gravity
  /**
   * Returns the gravity to use in laying out a single character
   * or `PangoItem`.
   *
   * The gravity is determined based on the script, East Asian width,
   * base gravity, and hint,
   *
   * This function is similar to [func`Pango`.Gravity.get_for_script] except
   * that this function makes a distinction between narrow/half-width and
   * wide/full-width characters also. Wide/full-width characters always
   * stand *upright*, that is, they always take the base gravity,
   * whereas narrow/full-width characters are always rotated in vertical
   * context.
   *
   * If `base_gravity` is %PANGO_GRAVITY_AUTO, it is first replaced with the
   * preferred gravity of `script`.
   * @param script `PangoScript` to query
   * @param wide %TRUE for wide characters as returned by g_unichar_iswide()
   * @param baseGravity base gravity of the paragraph
   * @param hint orientation hint
   * @returns resolved gravity suitable to use for a run of text with @script and @wide.
   */
  function gravityGetForScriptAndWidth(
    script: Script,
    wide: boolean,
    baseGravity: Gravity,
    hint: GravityHint
  ): Gravity
  /**
   * Converts a `PangoGravity` value to its natural rotation in radians.
   *
   * Note that [method`Pango`.Matrix.rotate] takes angle in degrees, not radians.
   * So, to call [method`Pango`.Matrix,rotate] with the output of this function
   * you should multiply it by (180. / G_PI).
   * @param gravity gravity to query, should not be %PANGO_GRAVITY_AUTO
   * @returns the rotation value corresponding to @gravity.
   */
  function gravityToRotation(gravity: Gravity): number
  /**
   * Checks if a character that should not be normally rendered.
   *
   * This includes all Unicode characters with "ZERO WIDTH" in their name,
   * as well as *bidi* formatting characters, and a few other ones.
   *
   * This is totally different from [func`GLib`.unichar_iszerowidth] and is at best misnamed.
   * @param ch a Unicode character
   * @returns %TRUE if @ch is a zero-width character, %FALSE otherwise
   */
  function isZeroWidth(ch: string): boolean
  /**
   * Breaks a piece of text into segments with consistent directional
   * level and font.
   *
   * Each byte of `text` will be contained in exactly one of the items in the
   * returned list; the generated list of items will be in logical order (the
   * start offsets of the items are ascending).
   *
   * `cached_iter` should be an iterator over `attrs` currently positioned
   * at a range before or containing `start_index;` `cached_iter` will be
   * advanced to the range covering the position just after
   * `start_index` + `length`. (i.e. if itemizing in a loop, just keep passing
   * in the same `cached_iter)`.
   * @param context a structure holding information that affects   the itemization process.
   * @param text the text to itemize. Must be valid UTF-8
   * @param startIndex first byte in `text` to process
   * @param length the number of bytes (not characters) to process   after `start_index`. This must be >= 0.
   * @param attrs the set of attributes that apply to `text`.
   * @param cachedIter Cached attribute iterator
   * @returns a `GList` of   [struct@Pango.Item] structures. The items should be freed using   [method@Pango.Item.free] in combination with [func@GLib.List.free_full].
   */
  function itemize(
    context: Context,
    text: string,
    startIndex: number,
    length: number,
    attrs: AttrList,
    cachedIter: AttrIterator | null
  ): Item[]
  /**
   * Like `pango_itemize()`, but with an explicitly specified base direction.
   *
   * The base direction is used when computing bidirectional levels.
   * [func`itemize]` gets the base direction from the `PangoContext`
   * (see [method`Pango`.Context.set_base_dir]).
   * @param context a structure holding information that affects   the itemization process.
   * @param baseDir base direction to use for bidirectional processing
   * @param text the text to itemize.
   * @param startIndex first byte in `text` to process
   * @param length the number of bytes (not characters) to process   after `start_index`. This must be >= 0.
   * @param attrs the set of attributes that apply to `text`.
   * @param cachedIter Cached attribute iterator
   * @returns a `GList` of   [struct@Pango.Item] structures. The items should be freed using   [method@Pango.Item.free] probably in combination with [func@GLib.List.free_full].
   */
  function itemizeWithBaseDir(
    context: Context,
    baseDir: Direction,
    text: string,
    startIndex: number,
    length: number,
    attrs: AttrList,
    cachedIter: AttrIterator | null
  ): Item[]
  /**
   * Convert a language tag to a `PangoLanguage`.
   *
   * The language tag must be in a RFC-3066 format. `PangoLanguage` pointers
   * can be efficiently copied (copy the pointer) and compared with other
   * language tags (compare the pointer.)
   *
   * This function first canonicalizes the string by converting it to
   * lowercase, mapping '_' to '-', and stripping all characters other
   * than letters and '-'.
   *
   * Use [func`Pango`.Language.get_default] if you want to get the
   * `PangoLanguage` for the current locale of the process.
   * @param language a string representing a language tag
   * @returns a `PangoLanguage`
   */
  function languageFromString(language: string | null): Language | null
  /**
   * Returns the `PangoLanguage` for the current locale of the process.
   *
   * On Unix systems, this is the return value is derived from
   * `setlocale (LC_CTYPE, NULL)`, and the user can
   * affect this through the environment variables LC_ALL, LC_CTYPE or
   * LANG (checked in that order). The locale string typically is in
   * the form lang_COUNTRY, where lang is an ISO-639 language code, and
   * COUNTRY is an ISO-3166 country code. For instance, sv_FI for
   * Swedish as written in Finland or pt_BR for Portuguese as written in
   * Brazil.
   *
   * On Windows, the C library does not use any such environment
   * variables, and setting them won't affect the behavior of functions
   * like ctime(). The user sets the locale through the Regional Options
   * in the Control Panel. The C library (in the setlocale() function)
   * does not use country and language codes, but country and language
   * names spelled out in English.
   * However, this function does check the above environment
   * variables, and does return a Unix-style locale string based on
   * either said environment variables or the thread's current locale.
   *
   * Your application should call `setlocale(LC_ALL, "")` for the user
   * settings to take effect. GTK does this in its initialization
   * functions automatically (by calling gtk_set_locale()).
   * See the setlocale() manpage for more details.
   *
   * Note that the default language can change over the life of an application.
   *
   * Also note that this function will not do the right thing if you
   * use per-thread locales with uselocale(). In that case, you should
   * just call pango_language_from_string() yourself.
   * @returns the default language as a `PangoLanguage`
   */
  function languageGetDefault(): Language
  /**
   * Returns the list of languages that the user prefers.
   *
   * The list is specified by the `PANGO_LANGUAGE` or `LANGUAGE`
   * environment variables, in order of preference. Note that this
   * list does not necessarily include the language returned by
   * [func`Pango`.Language.get_default].
   *
   * When choosing language-specific resources, such as the sample
   * text returned by [method`Pango`.Language.get_sample_string],
   * you should first try the default language, followed by the
   * languages returned by this function.
   * @returns a %NULL-terminated array   of `PangoLanguage`*
   */
  function languageGetPreferred(): Language[] | null
  function layoutDeserializeErrorQuark(): GLib.Quark
  /**
   * Return the bidirectional embedding levels of the input paragraph.
   *
   * The bidirectional embedding levels are defined by the [Unicode Bidirectional
   * Algorithm](http://www.unicode.org/reports/tr9/).
   *
   * If the input base direction is a weak direction, the direction of the
   * characters in the text will determine the final resolved direction.
   * @param text the text to itemize.
   * @param length the number of bytes (not characters) to process, or -1   if `text` is nul-terminated and the length should be calculated.
   * @param pbaseDir input base direction, and output resolved direction.
   * @returns a newly allocated array of embedding levels, one item per   character (not byte), that should be freed using [func@GLib.free].
   */
  function log2visGetEmbeddingLevels(
    text: string,
    length: number,
    pbaseDir: Direction
  ): number
  /**
   * Finishes parsing markup.
   *
   * After feeding a Pango markup parser some data with [method`GLib`.MarkupParseContext.parse],
   * use this function to get the list of attributes and text out of the
   * markup. This function will not free `context,` use [method`GLib`.MarkupParseContext.free]
   * to do so.
   * @param context A valid parse context that was returned from [func`markup_parser_new]`
   * @returns %FALSE if @error is set, otherwise %TRUE
   */
  function markupParserFinish(
    context: GLib.MarkupParseContext
  ): [
    /* returnType */ boolean,
    /* attrList */ AttrList,
    /* text */ string,
    /* accelChar */ string,
  ]
  /**
   * Incrementally parses marked-up text to create a plain-text string
   * and an attribute list.
   *
   * See the [Pango Markup](pango_markup.html) docs for details about the
   * supported markup.
   *
   * If `accel_marker` is nonzero, the given character will mark the
   * character following it as an accelerator. For example, `accel_marker`
   * might be an ampersand or underscore. All characters marked
   * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
   * and the first character so marked will be returned in `accel_char,`
   * when calling [func`markup_parser_finish]`. Two `accel_marker` characters
   * following each other produce a single literal `accel_marker` character.
   *
   * To feed markup to the parser, use [method`GLib`.MarkupParseContext.parse]
   * on the returned [struct`GLib`.MarkupParseContext]. When done with feeding markup
   * to the parser, use [func`markup_parser_finish]` to get the data out
   * of it, and then use [method`GLib`.MarkupParseContext.free] to free it.
   *
   * This function is designed for applications that read Pango markup
   * from streams. To simply parse a string containing Pango markup,
   * the [func`Pango`.parse_markup] API is recommended instead.
   * @param accelMarker character that precedes an accelerator, or 0 for none
   * @returns a `GMarkupParseContext` that should be destroyed with [method@GLib.MarkupParseContext.free].
   */
  function markupParserNew(accelMarker: string): GLib.MarkupParseContext
  /**
   * Parses an enum type and stores the result in `value`.
   *
   * If `str` does not match the nick name of any of the possible values
   * for the enum and is not an integer, %FALSE is returned, a warning
   * is issued if `warn` is %TRUE, and a string representing the list of
   * possible values is stored in `possible_values`. The list is
   * slash-separated, eg. "none/start/middle/end".
   *
   * If failed and `possible_values` is not %NULL, returned string should
   * be freed using g_free().
   * @param type enum type to parse, eg. %PANGO_TYPE_ELLIPSIZE_MODE
   * @param str string to parse
   * @param warn if %TRUE, issue a g_warning() on bad input
   * @returns %TRUE if @str was successfully parsed
   */
  function parseEnum(
    type: GObject.GType,
    str: string | null,
    warn: boolean
  ): [/* returnType */ boolean, /* value */ number, /* possibleValues */ string]
  /**
   * Parses marked-up text to create a plain-text string and an attribute list.
   *
   * See the [Pango Markup](pango_markup.html) docs for details about the
   * supported markup.
   *
   * If `accel_marker` is nonzero, the given character will mark the
   * character following it as an accelerator. For example, `accel_marker`
   * might be an ampersand or underscore. All characters marked
   * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
   * and the first character so marked will be returned in `accel_char`.
   * Two `accel_marker` characters following each other produce a single
   * literal `accel_marker` character.
   *
   * To parse a stream of pango markup incrementally, use [func`markup_parser_new]`.
   *
   * If any error happens, none of the output arguments are touched except
   * for `error`.
   * @param markupText markup to parse (see the [Pango Markup](pango_markup.html) docs)
   * @param length length of `markup_text,` or -1 if nul-terminated
   * @param accelMarker character that precedes an accelerator, or 0 for none
   * @returns %FALSE if @error is set, otherwise %TRUE
   */
  function parseMarkup(
    markupText: string,
    length: number,
    accelMarker: string
  ): [
    /* returnType */ boolean,
    /* attrList */ AttrList,
    /* text */ string,
    /* accelChar */ string,
  ]
  /**
   * Parses a font stretch.
   *
   * The allowed values are
   * "ultra_condensed", "extra_condensed", "condensed",
   * "semi_condensed", "normal", "semi_expanded", "expanded",
   * "extra_expanded" and "ultra_expanded". Case variations are
   * ignored and the '_' characters may be omitted.
   * @param str a string to parse.
   * @param warn if %TRUE, issue a g_warning() on bad input.
   * @returns %TRUE if @str was successfully parsed.
   */
  function parseStretch(
    str: string,
    warn: boolean
  ): [/* returnType */ boolean, /* stretch */ Stretch]
  /**
   * Parses a font style.
   *
   * The allowed values are "normal", "italic" and "oblique", case
   * variations being
   * ignored.
   * @param str a string to parse.
   * @param warn if %TRUE, issue a g_warning() on bad input.
   * @returns %TRUE if @str was successfully parsed.
   */
  function parseStyle(
    str: string,
    warn: boolean
  ): [/* returnType */ boolean, /* style */ Style]
  /**
   * Parses a font variant.
   *
   * The allowed values are "normal", "small-caps", "all-small-caps",
   * "petite-caps", "all-petite-caps", "unicase" and "title-caps",
   * case variations being ignored.
   * @param str a string to parse.
   * @param warn if %TRUE, issue a g_warning() on bad input.
   * @returns %TRUE if @str was successfully parsed.
   */
  function parseVariant(
    str: string,
    warn: boolean
  ): [/* returnType */ boolean, /* variant */ Variant]
  /**
   * Parses a font weight.
   *
   * The allowed values are "heavy",
   * "ultrabold", "bold", "normal", "light", "ultraleight"
   * and integers. Case variations are ignored.
   * @param str a string to parse.
   * @param warn if %TRUE, issue a g_warning() on bad input.
   * @returns %TRUE if @str was successfully parsed.
   */
  function parseWeight(
    str: string,
    warn: boolean
  ): [/* returnType */ boolean, /* weight */ Weight]
  /**
   * Quantizes the thickness and position of a line to whole device pixels.
   *
   * This is typically used for underline or strikethrough. The purpose of
   * this function is to avoid such lines looking blurry.
   *
   * Care is taken to make sure `thickness` is at least one pixel when this
   * function returns, but returned `position` may become zero as a result
   * of rounding.
   * @param thickness pointer to the thickness of a line, in Pango units
   * @param position corresponding position
   */
  function quantizeLineGeometry(
    thickness: number,
    position: number
  ): [/* thickness */ number, /* position */ number]
  /**
   * Reads an entire line from a file into a buffer.
   *
   * Lines may be delimited with '\n', '\r', '\n\r', or '\r\n'. The delimiter
   * is not written into the buffer. Text after a '#' character is treated as
   * a comment and skipped. '\' can be used to escape a # character.
   * '\' proceeding a line delimiter combines adjacent lines. A '\' proceeding
   * any other character is ignored and written into the output buffer
   * unmodified.
   * @param stream a stdio stream
   * @param str `GString` buffer into which to write the result
   * @returns 0 if the stream was already at an %EOF character,   otherwise the number of lines read (this is useful for maintaining   a line number counter which doesn't combine lines with '\')
   */
  function readLine(stream: any | null, str: GLib.String): number
  /**
   * Reorder items from logical order to visual order.
   *
   * The visual order is determined from the associated directional
   * levels of the items. The original list is unmodified.
   *
   * (Please open a bug if you use this function.
   *  It is not a particularly convenient interface, and the code
   *  is duplicated elsewhere in Pango for that reason.)
   * @param items a `GList` of `PangoItem`   in logical order.
   * @returns a `GList`   of `PangoItem` structures in visual order.
   */
  function reorderItems(items: Item[]): Item[]
  /**
   * Scans an integer.
   *
   * Leading white space is skipped.
   * @param pos in/out string position
   * @returns %FALSE if a parse error occurred
   */
  function scanInt(
    pos: string
  ): [/* returnType */ boolean, /* pos */ string, /* out */ number]
  /**
   * Scans a string into a `GString` buffer.
   *
   * The string may either be a sequence of non-white-space characters,
   * or a quoted string with '"'. Instead a quoted string, '\"' represents
   * a literal quote. Leading white space outside of quotes is skipped.
   * @param pos in/out string position
   * @param out a `GString` into which to write the result
   * @returns %FALSE if a parse error occurred
   */
  function scanString(
    pos: string,
    out: GLib.String
  ): [/* returnType */ boolean, /* pos */ string]
  /**
   * Scans a word into a `GString` buffer.
   *
   * A word consists of [A-Za-z_] followed by zero or more
   * [A-Za-z_0-9]. Leading white space is skipped.
   * @param pos in/out string position
   * @param out a `GString` into which to write the result
   * @returns %FALSE if a parse error occurred
   */
  function scanWord(
    pos: string,
    out: GLib.String
  ): [/* returnType */ boolean, /* pos */ string]
  /**
   * Looks up the script for a particular character.
   *
   * The script of a character is defined by
   * [Unicode Standard Annex 24: Script names](http://www.unicode.org/reports/tr24/).
   *
   * No check is made for `ch` being a valid Unicode character; if you pass
   * in invalid character, the result is undefined.
   *
   * Note that while the return type of this function is declared
   * as `PangoScript`, as of Pango 1.18, this function simply returns
   * the return value of [func`GLib`.unichar_get_script]. Callers must be
   * prepared to handle unknown values.
   * @param ch a Unicode character
   * @returns the `PangoScript` for the character.
   */
  function scriptForUnichar(ch: string): Script
  /**
   * Finds a language tag that is reasonably representative of `script`.
   *
   * The language will usually be the most widely spoken or used language
   * written in that script: for instance, the sample language for
   * %PANGO_SCRIPT_CYRILLIC is ru (Russian), the sample language for
   * %PANGO_SCRIPT_ARABIC is ar.
   *
   * For some scripts, no sample language will be returned because
   * there is no language that is sufficiently representative. The
   * best example of this is %PANGO_SCRIPT_HAN, where various different
   * variants of written Chinese, Japanese, and Korean all use
   * significantly different sets of Han characters and forms
   * of shared characters. No sample language can be provided
   * for many historical scripts as well.
   *
   * As of 1.18, this function checks the environment variables
   * `PANGO_LANGUAGE` and `LANGUAGE` (checked in that order) first.
   * If one of them is set, it is parsed as a list of language tags
   * separated by colons or other separators. This function
   * will return the first language in the parsed list that Pango
   * believes may use `script` for writing. This last predicate
   * is tested using [method`Pango`.Language.includes_script]. This can
   * be used to control Pango's font selection for non-primary
   * languages. For example, a `PANGO_LANGUAGE` enviroment variable
   * set to "en:fa" makes Pango choose fonts suitable for Persian (fa)
   * instead of Arabic (ar) when a segment of Arabic text is found
   * in an otherwise non-Arabic text. The same trick can be used to
   * choose a default language for %PANGO_SCRIPT_HAN when setting
   * context language is not feasible.
   * @param script a `PangoScript`
   * @returns a `PangoLanguage` that is representative   of the script
   */
  function scriptGetSampleLanguage(script: Script): Language | null
  /**
   * Convert the characters in `text` into glyphs.
   *
   * Given a segment of text and the corresponding `PangoAnalysis` structure
   * returned from [func`Pango`.itemize], convert the characters into glyphs. You
   * may also pass in only a substring of the item from [func`Pango`.itemize].
   *
   * It is recommended that you use [func`Pango`.shape_full] instead, since
   * that API allows for shaping interaction happening across text item
   * boundaries.
   *
   * Some aspects of hyphen insertion and text transformation (in particular,
   * capitalization) require log attrs, and thus can only be handled by
   * [func`Pango`.shape_item].
   *
   * Note that the extra attributes in the `analyis` that is returned from
   * [func`Pango`.itemize] have indices that are relative to the entire paragraph,
   * so you need to subtract the item offset from their indices before
   * calling [func`Pango`.shape].
   * @param text the text to process
   * @param length the length (in bytes) of `text`
   * @param analysis `PangoAnalysis` structure from [func`Pango`.itemize]
   * @param glyphs glyph string in which to store results
   */
  function shape(
    text: string,
    length: number,
    analysis: Analysis,
    glyphs: GlyphString
  ): void
  /**
   * Convert the characters in `text` into glyphs.
   *
   * Given a segment of text and the corresponding `PangoAnalysis` structure
   * returned from [func`Pango`.itemize], convert the characters into glyphs.
   * You may also pass in only a substring of the item from [func`Pango`.itemize].
   *
   * This is similar to [func`Pango`.shape], except it also can optionally take
   * the full paragraph text as input, which will then be used to perform
   * certain cross-item shaping interactions. If you have access to the broader
   * text of which `item_text` is part of, provide the broader text as
   * `paragraph_text`. If `paragraph_text` is %NULL, item text is used instead.
   *
   * Some aspects of hyphen insertion and text transformation (in particular,
   * capitalization) require log attrs, and thus can only be handled by
   * [func`Pango`.shape_item].
   *
   * Note that the extra attributes in the `analyis` that is returned from
   * [func`Pango`.itemize] have indices that are relative to the entire paragraph,
   * so you do not pass the full paragraph text as `paragraph_text,` you need
   * to subtract the item offset from their indices before calling
   * [func`Pango`.shape_full].
   * @param itemText valid UTF-8 text to shape.
   * @param itemLength the length (in bytes) of `item_text`. -1 means nul-terminated text.
   * @param paragraphText text of the paragraph (see details).
   * @param paragraphLength the length (in bytes) of `paragraph_text`. -1 means nul-terminated text.
   * @param analysis `PangoAnalysis` structure from [func`Pango`.itemize].
   * @param glyphs glyph string in which to store results.
   */
  function shapeFull(
    itemText: string,
    itemLength: number,
    paragraphText: string | null,
    paragraphLength: number,
    analysis: Analysis,
    glyphs: GlyphString
  ): void
  /**
   * Convert the characters in `item` into glyphs.
   *
   * This is similar to [func`Pango`.shape_with_flags], except it takes a
   * `PangoItem` instead of separate `item_text` and `analysis` arguments.
   *
   * It also takes `log_attrs,` which are needed for implementing some aspects
   * of hyphen insertion and text transforms (in particular, capitalization).
   *
   * Note that the extra attributes in the `analyis` that is returned from
   * [func`Pango`.itemize] have indices that are relative to the entire paragraph,
   * so you do not pass the full paragraph text as `paragraph_text,` you need
   * to subtract the item offset from their indices before calling
   * [func`Pango`.shape_with_flags].
   * @param item `PangoItem` to shape
   * @param paragraphText text of the paragraph (see details).
   * @param paragraphLength the length (in bytes) of `paragraph_text`.     -1 means nul-terminated text.
   * @param logAttrs array of `PangoLogAttr` for `item`
   * @param glyphs glyph string in which to store results
   * @param flags flags influencing the shaping process
   */
  function shapeItem(
    item: Item,
    paragraphText: string | null,
    paragraphLength: number,
    logAttrs: LogAttr | null,
    glyphs: GlyphString,
    flags: ShapeFlags
  ): void
  /**
   * Convert the characters in `text` into glyphs.
   *
   * Given a segment of text and the corresponding `PangoAnalysis` structure
   * returned from [func`Pango`.itemize], convert the characters into glyphs.
   * You may also pass in only a substring of the item from [func`Pango`.itemize].
   *
   * This is similar to [func`Pango`.shape_full], except it also takes flags
   * that can influence the shaping process.
   *
   * Some aspects of hyphen insertion and text transformation (in particular,
   * capitalization) require log attrs, and thus can only be handled by
   * [func`Pango`.shape_item].
   *
   * Note that the extra attributes in the `analyis` that is returned from
   * [func`Pango`.itemize] have indices that are relative to the entire paragraph,
   * so you do not pass the full paragraph text as `paragraph_text,` you need
   * to subtract the item offset from their indices before calling
   * [func`Pango`.shape_with_flags].
   * @param itemText valid UTF-8 text to shape
   * @param itemLength the length (in bytes) of `item_text`.     -1 means nul-terminated text.
   * @param paragraphText text of the paragraph (see details).
   * @param paragraphLength the length (in bytes) of `paragraph_text`.     -1 means nul-terminated text.
   * @param analysis `PangoAnalysis` structure from [func`Pango`.itemize]
   * @param glyphs glyph string in which to store results
   * @param flags flags influencing the shaping process
   */
  function shapeWithFlags(
    itemText: string,
    itemLength: number,
    paragraphText: string | null,
    paragraphLength: number,
    analysis: Analysis,
    glyphs: GlyphString,
    flags: ShapeFlags
  ): void
  /**
   * Skips 0 or more characters of white space.
   * @param pos in/out string position
   * @returns %FALSE if skipping the white space leaves   the position at a '\0' character.
   */
  function skipSpace(pos: string): [/* returnType */ boolean, /* pos */ string]
  /**
   * Splits a %G_SEARCHPATH_SEPARATOR-separated list of files, stripping
   * white space and substituting ~/ with $HOME/.
   * @param str a %G_SEARCHPATH_SEPARATOR separated list of filenames
   * @returns a list of   strings to be freed with g_strfreev()
   */
  function splitFileList(str: string): string[]
  /**
   * Deserializes a `PangoTabArray` from a string.
   *
   * This is the counterpart to [method`Pango`.TabArray.to_string].
   * See that functions for details about the format.
   * @param text a string
   * @returns a new `PangoTabArray`
   */
  function tabArrayFromString(text: string): TabArray | null
  /**
   * Apply language-specific tailoring to the breaks in `attrs`.
   *
   * The line breaks are assumed to have been produced by [func`Pango`.default_break].
   *
   * If `offset` is not -1, it is used to apply attributes from `analysis` that are
   * relevant to line breaking.
   *
   * Note that it is better to pass -1 for `offset` and use [func`Pango`.attr_break]
   * to apply attributes to the whole paragraph.
   * @param text text to process. Must be valid UTF-8
   * @param length length in bytes of `text`
   * @param analysis `PangoAnalysis` for `text`
   * @param offset Byte offset of `text` from the beginning of the   paragraph, or -1 to ignore attributes from `analysis`
   * @param attrs array with one `PangoLogAttr`   per character in `text,` plus one extra, to be filled in
   */
  function tailorBreak(
    text: string,
    length: number,
    analysis: Analysis,
    offset: number,
    attrs: LogAttr[]
  ): void
  /**
   * Trims leading and trailing whitespace from a string.
   * @param str a string
   * @returns A newly-allocated string that must be freed with g_free()
   */
  function trimString(str: string): string | null
  /**
   * Determines the inherent direction of a character.
   *
   * The inherent direction is either `PANGO_DIRECTION_LTR`, `PANGO_DIRECTION_RTL`,
   * or `PANGO_DIRECTION_NEUTRAL`.
   *
   * This function is useful to categorize characters into left-to-right
   * letters, right-to-left letters, and everything else. If full Unicode
   * bidirectional type of a character is needed, [func`Pango`.BidiType.for_unichar]
   * can be used instead.
   * @param ch a Unicode character
   * @returns the direction of the character.
   */
  function unicharDirection(ch: string): Direction
  /**
   * Converts a floating-point number to Pango units.
   *
   * The conversion is done by multiplying `d` by %PANGO_SCALE and
   * rounding the result to nearest integer.
   * @param d double floating-point value
   * @returns the value in Pango units.
   */
  function unitsFromDouble(d: number): number
  /**
   * Converts a number in Pango units to floating-point.
   *
   * The conversion is done by dividing `i` by %PANGO_SCALE.
   * @param i value in Pango units
   * @returns the double value.
   */
  function unitsToDouble(i: number): number
  /**
   * Returns the encoded version of Pango available at run-time.
   *
   * This is similar to the macro %PANGO_VERSION except that the macro
   * returns the encoded version available at compile-time. A version
   * number can be encoded into an integer using PANGO_VERSION_ENCODE().
   * @returns The encoded version of Pango library available at run time.
   */
  function version(): number
  /**
   * Checks that the Pango library in use is compatible with the
   * given version.
   *
   * Generally you would pass in the constants %PANGO_VERSION_MAJOR,
   * %PANGO_VERSION_MINOR, %PANGO_VERSION_MICRO as the three arguments
   * to this function; that produces a check that the library in use at
   * run-time is compatible with the version of Pango the application or
   * module was compiled against.
   *
   * Compatibility is defined by two things: first the version
   * of the running library is newer than the version
   * `required_major`.required_minor.`required_micro`. Second
   * the running library must be binary compatible with the
   * version `required_major`.required_minor.`required_micro`
   * (same major version.)
   *
   * For compile-time version checking use PANGO_VERSION_CHECK().
   * @param requiredMajor the required major version
   * @param requiredMinor the required minor version
   * @param requiredMicro the required major version
   * @returns %NULL if the Pango library is compatible   with the given version, or a string describing the version   mismatch.  The returned string is owned by Pango and should not   be modified or freed.
   */
  function versionCheck(
    requiredMajor: number,
    requiredMinor: number,
    requiredMicro: number
  ): string | null
  /**
   * Returns the version of Pango available at run-time.
   *
   * This is similar to the macro %PANGO_VERSION_STRING except that the
   * macro returns the version available at compile-time.
   * @returns A string containing the version of Pango library available   at run time. The returned string is owned by Pango and should not   be modified or freed.
   */
  function versionString(): string
  /**
   * Type of a function that can duplicate user data for an attribute.
   * @callback
   * @returns new copy of @user_data.
   */
  interface AttrDataCopyFunc {
    (): any | null
  }
  /**
   * Type of a function filtering a list of attributes.
   * @callback
   * @param attribute a Pango attribute
   * @returns %TRUE if the attribute should be selected for   filtering, %FALSE otherwise.
   */
  interface AttrFilterFunc {
    (attribute: Attribute): boolean
  }
  /**
   * Callback used when enumerating fonts in a fontset.
   *
   * See [method`Pango`.Fontset.foreach].
   * @callback
   * @param fontset a `PangoFontset`
   * @param font a font from `fontset`
   * @returns if %TRUE, stop iteration and return immediately.
   */
  interface FontsetForeachFunc {
    (fontset: Fontset, font: Font): boolean
  }
  module Context {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Context {
    // Own properties of Pango-1.0.Pango.Context

    __gtype__: number

    // Owm methods of Pango-1.0.Pango.Context

    /**
     * Forces a change in the context, which will cause any `PangoLayout`
     * using this context to re-layout.
     *
     * This function is only useful when implementing a new backend
     * for Pango, something applications won't do. Backends should
     * call this function if they have attached extra data to the context
     * and such data is changed.
     */
    changed(): void
    /**
     * Retrieves the base direction for the context.
     *
     * See [method`Pango`.Context.set_base_dir].
     * @returns the base direction for the context.
     */
    getBaseDir(): Direction
    /**
     * Retrieves the base gravity for the context.
     *
     * See [method`Pango`.Context.set_base_gravity].
     * @returns the base gravity for the context.
     */
    getBaseGravity(): Gravity
    /**
     * Retrieve the default font description for the context.
     * @returns a pointer to the context's default font   description. This value must not be modified or freed.
     */
    getFontDescription(): FontDescription | null
    /**
     * Gets the `PangoFontMap` used to look up fonts for this context.
     * @returns the font map for the.   `PangoContext` This value is owned by Pango and should not be   unreferenced.
     */
    getFontMap(): FontMap | null
    /**
     * Retrieves the gravity for the context.
     *
     * This is similar to [method`Pango`.Context.get_base_gravity],
     * except for when the base gravity is %PANGO_GRAVITY_AUTO for
     * which [func`Pango`.Gravity.get_for_matrix] is used to return the
     * gravity from the current context matrix.
     * @returns the resolved gravity for the context.
     */
    getGravity(): Gravity
    /**
     * Retrieves the gravity hint for the context.
     *
     * See [method`Pango`.Context.set_gravity_hint] for details.
     * @returns the gravity hint for the context.
     */
    getGravityHint(): GravityHint
    /**
     * Retrieves the global language tag for the context.
     * @returns the global language tag.
     */
    getLanguage(): Language
    /**
     * Gets the transformation matrix that will be applied when
     * rendering with this context.
     *
     * See [method`Pango`.Context.set_matrix].
     * @returns the matrix, or %NULL if no   matrix has been set (which is the same as the identity matrix).   The returned matrix is owned by Pango and must not be modified   or freed.
     */
    getMatrix(): Matrix | null
    /**
     * Get overall metric information for a particular font description.
     *
     * Since the metrics may be substantially different for different scripts,
     * a language tag can be provided to indicate that the metrics should be
     * retrieved that correspond to the script(s) used by that language.
     *
     * The `PangoFontDescription` is interpreted in the same way as by [func`itemize]`,
     * and the family name may be a comma separated list of names. If characters
     * from multiple of these families would be used to render the string, then
     * the returned fonts would be a composite of the metrics for the fonts loaded
     * for the individual families.
     * @param desc a `PangoFontDescription` structure. %NULL means that the   font description from the context will be used.
     * @param language language tag used to determine which script to get   the metrics for. %NULL means that the language tag from the context   will be used. If no language tag is set on the context, metrics   for the default language (as determined by [func`Pango`.Language.get_default]   will be returned.
     * @returns a `PangoFontMetrics` object. The caller must call   [method@Pango.FontMetrics.unref] when finished using the object.
     */
    getMetrics(
      desc: FontDescription | null,
      language: Language | null
    ): FontMetrics
    /**
     * Returns whether font rendering with this context should
     * round glyph positions and widths.
     */
    getRoundGlyphPositions(): boolean
    /**
     * Returns the current serial number of `context`.
     *
     * The serial number is initialized to an small number larger than zero
     * when a new context is created and is increased whenever the context
     * is changed using any of the setter functions, or the `PangoFontMap` it
     * uses to find fonts has changed. The serial may wrap, but will never
     * have the value 0. Since it can wrap, never compare it with "less than",
     * always use "not equals".
     *
     * This can be used to automatically detect changes to a `PangoContext`,
     * and is only useful when implementing objects that need update when their
     * `PangoContext` changes, like `PangoLayout`.
     * @returns The current serial number of @context.
     */
    getSerial(): number
    /**
     * List all families for a context.
     */
    listFamilies(): /* families */ FontFamily[]
    /**
     * Loads the font in one of the fontmaps in the context
     * that is the closest match for `desc`.
     * @param desc a `PangoFontDescription` describing the font to load
     * @returns the newly allocated `PangoFont`   that was loaded, or %NULL if no font matched.
     */
    loadFont(desc: FontDescription): Font | null
    /**
     * Load a set of fonts in the context that can be used to render
     * a font matching `desc`.
     * @param desc a `PangoFontDescription` describing the fonts to load
     * @param language a `PangoLanguage` the fonts will be used for
     * @returns the newly allocated   `PangoFontset` loaded, or %NULL if no font matched.
     */
    loadFontset(desc: FontDescription, language: Language): Fontset | null
    /**
     * Sets the base direction for the context.
     *
     * The base direction is used in applying the Unicode bidirectional
     * algorithm; if the `direction` is %PANGO_DIRECTION_LTR or
     * %PANGO_DIRECTION_RTL, then the value will be used as the paragraph
     * direction in the Unicode bidirectional algorithm. A value of
     * %PANGO_DIRECTION_WEAK_LTR or %PANGO_DIRECTION_WEAK_RTL is used only
     * for paragraphs that do not contain any strong characters themselves.
     * @param direction the new base direction
     */
    setBaseDir(direction: Direction): void
    /**
     * Sets the base gravity for the context.
     *
     * The base gravity is used in laying vertical text out.
     * @param gravity the new base gravity
     */
    setBaseGravity(gravity: Gravity): void
    /**
     * Set the default font description for the context
     * @param desc the new pango font description
     */
    setFontDescription(desc: FontDescription | null): void
    /**
     * Sets the font map to be searched when fonts are looked-up
     * in this context.
     *
     * This is only for internal use by Pango backends, a `PangoContext`
     * obtained via one of the recommended methods should already have a
     * suitable font map.
     * @param fontMap the `PangoFontMap` to set.
     */
    setFontMap(fontMap: FontMap | null): void
    /**
     * Sets the gravity hint for the context.
     *
     * The gravity hint is used in laying vertical text out, and
     * is only relevant if gravity of the context as returned by
     * [method`Pango`.Context.get_gravity] is set to %PANGO_GRAVITY_EAST
     * or %PANGO_GRAVITY_WEST.
     * @param hint the new gravity hint
     */
    setGravityHint(hint: GravityHint): void
    /**
     * Sets the global language tag for the context.
     *
     * The default language for the locale of the running process
     * can be found using [func`Pango`.Language.get_default].
     * @param language the new language tag.
     */
    setLanguage(language: Language | null): void
    /**
     * Sets the transformation matrix that will be applied when rendering
     * with this context.
     *
     * Note that reported metrics are in the user space coordinates before
     * the application of the matrix, not device-space coordinates after the
     * application of the matrix. So, they don't scale with the matrix, though
     * they may change slightly for different matrices, depending on how the
     * text is fit to the pixel grid.
     * @param matrix a `PangoMatrix`, or %NULL to unset any existing matrix. (No matrix set is the same as setting the identity matrix.)
     */
    setMatrix(matrix: Matrix | null): void
    /**
     * Sets whether font rendering with this context should
     * round glyph positions and widths to integral positions,
     * in device units.
     *
     * This is useful when the renderer can't handle subpixel
     * positioning of glyphs.
     *
     * The default value is to round glyph positions, to remain
     * compatible with previous Pango behavior.
     * @param roundPositions whether to round glyph positions
     */
    setRoundGlyphPositions(roundPositions: boolean): void

    // Class property signals of Pango-1.0.Pango.Context

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `PangoContext` stores global information used to control the
   * itemization process.
   *
   * The information stored by `PangoContext` includes the fontmap used
   * to look up fonts, and default values such as the default language,
   * default gravity, or default font.
   *
   * To obtain a `PangoContext`, use [method`Pango`.FontMap.create_context].
   * @class
   */
  class Context extends GObject.Object {
    // Own properties of Pango-1.0.Pango.Context

    static name: string

    // Constructors of Pango-1.0.Pango.Context

    constructor(config?: Context.ConstructorProperties)
    /**
     * Creates a new `PangoContext` initialized to default values.
     *
     * This function is not particularly useful as it should always
     * be followed by a [method`Pango`.Context.set_font_map] call, and the
     * function [method`Pango`.FontMap.create_context] does these two steps
     * together and hence users are recommended to use that.
     *
     * If you are using Pango as part of a higher-level system,
     * that system may have it's own way of create a `PangoContext`.
     * For instance, the GTK toolkit has, among others,
     * `gtk_widget_get_pango_context()`. Use those instead.
     * @constructor
     * @returns the newly allocated `PangoContext`, which should   be freed with g_object_unref().
     */
    constructor()
    /**
     * Creates a new `PangoContext` initialized to default values.
     *
     * This function is not particularly useful as it should always
     * be followed by a [method`Pango`.Context.set_font_map] call, and the
     * function [method`Pango`.FontMap.create_context] does these two steps
     * together and hence users are recommended to use that.
     *
     * If you are using Pango as part of a higher-level system,
     * that system may have it's own way of create a `PangoContext`.
     * For instance, the GTK toolkit has, among others,
     * `gtk_widget_get_pango_context()`. Use those instead.
     * @constructor
     * @returns the newly allocated `PangoContext`, which should   be freed with g_object_unref().
     */
    static new(): Context
    _init(config?: Context.ConstructorProperties): void
  }

  module Coverage {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Coverage {
    // Own properties of Pango-1.0.Pango.Coverage

    __gtype__: number

    // Owm methods of Pango-1.0.Pango.Coverage

    /**
     * Copy an existing `PangoCoverage`.
     * @returns the newly allocated `PangoCoverage`,   with a reference count of one, which should be freed with   [method@Pango.Coverage.unref].
     */
    copy(): Coverage
    /**
     * Determine whether a particular index is covered by `coverage`.
     * @param index the index to check
     * @returns the coverage level of @coverage for character @index_.
     */
    get(index: number): CoverageLevel
    /**
     * Set the coverage for each index in `coverage` to be the max (better)
     * value of the current coverage for the index and the coverage for
     * the corresponding index in `other`.
     * @param other another `PangoCoverage`
     */
    max(other: Coverage): void
    /**
     * Increase the reference count on the `PangoCoverage` by one.
     * @returns @coverage
     */
    ref(): Coverage

    // Overloads of ref

    /**
     * Increases the reference count of `object`.
     *
     * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
     * of `object` will be propagated to the return type (using the GCC typeof()
     * extension), so any casting the caller needs to do on the return type must be
     * explicit.
     * @returns the same @object
     */
    ref(): GObject.Object
    /**
     * Modify a particular index within `coverage`
     * @param index the index to modify
     * @param level the new level for `index_`
     */
    set(index: number, level: CoverageLevel): void
    /**
     * Convert a `PangoCoverage` structure into a flat binary format.
     */
    toBytes(): /* bytes */ number[]
    /**
     * Decrease the reference count on the `PangoCoverage` by one.
     *
     * If the result is zero, free the coverage and all associated memory.
     */
    unref(): void

    // Class property signals of Pango-1.0.Pango.Coverage

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `PangoCoverage` structure is a map from Unicode characters
   * to [enum`Pango`.CoverageLevel] values.
   *
   * It is often necessary in Pango to determine if a particular
   * font can represent a particular character, and also how well
   * it can represent that character. The `PangoCoverage` is a data
   * structure that is used to represent that information. It is an
   * opaque structure with no public fields.
   * @class
   */
  class Coverage extends GObject.Object {
    // Own properties of Pango-1.0.Pango.Coverage

    static name: string

    // Constructors of Pango-1.0.Pango.Coverage

    constructor(config?: Coverage.ConstructorProperties)
    /**
     * Create a new `PangoCoverage`
     * @constructor
     * @returns the newly allocated `PangoCoverage`, initialized   to %PANGO_COVERAGE_NONE with a reference count of one, which   should be freed with [method@Pango.Coverage.unref].
     */
    constructor()
    /**
     * Create a new `PangoCoverage`
     * @constructor
     * @returns the newly allocated `PangoCoverage`, initialized   to %PANGO_COVERAGE_NONE with a reference count of one, which   should be freed with [method@Pango.Coverage.unref].
     */
    static new(): Coverage
    _init(config?: Coverage.ConstructorProperties): void
    /**
     * Convert data generated from [method`Pango`.Coverage.to_bytes]
     * back to a `PangoCoverage`.
     * @param bytes binary data   representing a `PangoCoverage`
     * @returns a newly allocated `PangoCoverage`
     */
    static fromBytes(bytes: number[]): Coverage | null
  }

  module Font {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Font {
    // Own properties of Pango-1.0.Pango.Font

    __gtype__: number

    // Own fields of Pango-1.0.Pango.Font

    parentInstance: GObject.Object

    // Owm methods of Pango-1.0.Pango.Font

    // Has conflict: describe(): FontDescription
    /**
     * Returns a description of the font, with absolute font size set
     * in device units.
     *
     * Use [method`Pango`.Font.describe] if you want the font size in points.
     * @returns a newly-allocated `PangoFontDescription` object.
     */
    describeWithAbsoluteSize(): FontDescription
    // Has conflict: getCoverage(language: Language): Coverage
    /**
     * Gets the `PangoFontFace` to which `font` belongs.
     * @returns the `PangoFontFace`
     */
    getFace(): FontFace
    // Has conflict: getFeatures(numFeatures: number): [ /* features */ HarfBuzz.feature_t[], /* numFeatures */ number ]
    // Has conflict: getFontMap(): FontMap | null
    // Has conflict: getGlyphExtents(glyph: Glyph): [ /* inkRect */ Rectangle, /* logicalRect */ Rectangle ]
    /**
     * Returns the languages that are supported by `font`.
     *
     * If the font backend does not provide this information,
     * %NULL is returned. For the fontconfig backend, this
     * corresponds to the FC_LANG member of the FcPattern.
     *
     * The returned array is only valid as long as the font
     * and its fontmap are valid.
     * @returns an array of `PangoLanguage`
     */
    getLanguages(): Language[] | null
    // Has conflict: getMetrics(language: Language | null): FontMetrics
    /**
     * Returns whether the font provides a glyph for this character.
     * @param wc a Unicode character
     * @returns `TRUE` if @font can render @wc
     */
    hasChar(wc: string): boolean
    /**
     * Serializes the `font` in a way that can be uniquely identified.
     *
     * There are no guarantees about the format of the output across different
     * versions of Pango.
     *
     * The intended use of this function is testing, benchmarking and debugging.
     * The format is not meant as a permanent storage format.
     *
     * To recreate a font from its serialized form, use [func`Pango`.Font.deserialize].
     * @returns a `GBytes` containing the serialized form of @font
     */
    serialize(): any

    // Own virtual methods of Pango-1.0.Pango.Font

    createHbFont(): HarfBuzz.font_t
    /**
     * Returns a description of the font, with font size set in points.
     *
     * Use [method`Pango`.Font.describe_with_absolute_size] if you want
     * the font size in device units.
     * @virtual
     * @returns a newly-allocated `PangoFontDescription` object.
     */
    describe(): FontDescription
    describeAbsolute(): FontDescription
    /**
     * Computes the coverage map for a given font and language tag.
     * @virtual
     * @param language the language tag
     * @returns a newly-allocated `PangoCoverage`   object.
     */
    getCoverage(language: Language): Coverage
    /**
     * Obtain the OpenType features that are provided by the font.
     *
     * These are passed to the rendering system, together with features
     * that have been explicitly set via attributes.
     *
     * Note that this does not include OpenType features which the
     * rendering system enables by default.
     * @virtual
     * @param numFeatures the number of used items in `features`
     */
    getFeatures(
      numFeatures: number
    ): [/* features */ HarfBuzz.feature_t[], /* numFeatures */ number]
    /**
     * Gets the font map for which the font was created.
     *
     * Note that the font maintains a *weak* reference to
     * the font map, so if all references to font map are
     * dropped, the font map will be finalized even if there
     * are fonts created with the font map that are still alive.
     * In that case this function will return %NULL.
     *
     * It is the responsibility of the user to ensure that the
     * font map is kept alive. In most uses this is not an issue
     * as a `PangoContext` holds a reference to the font map.
     * @virtual
     * @returns the `PangoFontMap`   for the font
     */
    getFontMap(): FontMap | null
    /**
     * Gets the logical and ink extents of a glyph within a font.
     *
     * The coordinate system for each rectangle has its origin at the
     * base line and horizontal origin of the character with increasing
     * coordinates extending to the right and down. The macros PANGO_ASCENT(),
     * PANGO_DESCENT(), PANGO_LBEARING(), and PANGO_RBEARING() can be used to convert
     * from the extents rectangle to more traditional font metrics. The units
     * of the rectangles are in 1/PANGO_SCALE of a device unit.
     *
     * If `font` is %NULL, this function gracefully sets some sane values in the
     * output variables and returns.
     * @virtual
     * @param glyph the glyph index
     */
    getGlyphExtents(
      glyph: Glyph
    ): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Gets overall metric information for a font.
     *
     * Since the metrics may be substantially different for different scripts,
     * a language tag can be provided to indicate that the metrics should be
     * retrieved that correspond to the script(s) used by that language.
     *
     * If `font` is %NULL, this function gracefully sets some sane values in the
     * output variables and returns.
     * @virtual
     * @param language language tag used to determine which script   to get the metrics for, or %NULL to indicate to get the metrics for   the entire font.
     * @returns a `PangoFontMetrics` object. The caller must call   [method@Pango.FontMetrics.unref] when finished using the object.
     */
    getMetrics(language: Language | null): FontMetrics

    // Class property signals of Pango-1.0.Pango.Font

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `PangoFont` is used to represent a font in a
   * rendering-system-independent manner.
   * @interface
   */
  class Font extends GObject.Object {
    // Own properties of Pango-1.0.Pango.Font

    static name: string

    // Constructors of Pango-1.0.Pango.Font

    constructor(config?: Font.ConstructorProperties)
    _init(config?: Font.ConstructorProperties): void
    /**
     * Frees an array of font descriptions.
     * @param descs a pointer   to an array of `PangoFontDescription`, may be %NULL
     */
    static descriptionsFree(descs: FontDescription[] | null): void
    /**
     * Loads data previously created via [method`Pango`.Font.serialize].
     *
     * For a discussion of the supported format, see that function.
     *
     * Note: to verify that the returned font is identical to
     * the one that was serialized, you can compare `bytes` to the
     * result of serializing the font again.
     * @param context a `PangoContext`
     * @param bytes the bytes containing the data
     * @returns a new `PangoFont`
     */
    static deserialize(context: Context, bytes: any): Font | null
  }

  module FontFace {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface FontFace {
    // Own properties of Pango-1.0.Pango.FontFace

    __gtype__: number

    // Own fields of Pango-1.0.Pango.FontFace

    parentInstance: GObject.Object

    // Owm methods of Pango-1.0.Pango.FontFace

    // Has conflict: describe(): FontDescription
    // Has conflict: getFaceName(): string
    // Has conflict: getFamily(): FontFamily
    // Has conflict: isSynthesized(): boolean
    // Has conflict: listSizes(): /* sizes */ number[] | null

    // Own virtual methods of Pango-1.0.Pango.FontFace

    /**
     * Returns a font description that matches the face.
     *
     * The resulting font description will have the family, style,
     * variant, weight and stretch of the face, but its size field
     * will be unset.
     * @virtual
     * @returns a newly-created `PangoFontDescription` structure   holding the description of the face. Use [method@Pango.FontDescription.free]   to free the result.
     */
    describe(): FontDescription
    /**
     * Gets a name representing the style of this face.
     *
     * Note that a font family may contain multiple faces
     * with the same name (e.g. a variable and a non-variable
     * face for the same style).
     * @virtual
     * @returns the face name for the face. This string is   owned by the face object and must not be modified or freed.
     */
    getFaceName(): string
    /**
     * Gets the `PangoFontFamily` that `face` belongs to.
     * @virtual
     * @returns the `PangoFontFamily`
     */
    getFamily(): FontFamily
    /**
     * Returns whether a `PangoFontFace` is synthesized.
     *
     * This will be the case if the underlying font rendering engine
     * creates this face from another face, by shearing, emboldening,
     * lightening or modifying it in some other way.
     * @virtual
     * @returns whether @face is synthesized
     */
    isSynthesized(): boolean
    /**
     * List the available sizes for a font.
     *
     * This is only applicable to bitmap fonts. For scalable fonts, stores
     * %NULL at the location pointed to by `sizes` and 0 at the location pointed
     * to by `n_sizes`. The sizes returned are in Pango units and are sorted
     * in ascending order.
     * @virtual
     */
    listSizes(): /* sizes */ number[] | null

    // Class property signals of Pango-1.0.Pango.FontFace

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `PangoFontFace` is used to represent a group of fonts with
   * the same family, slant, weight, and width, but varying sizes.
   * @class
   */
  class FontFace extends GObject.Object {
    // Own properties of Pango-1.0.Pango.FontFace

    static name: string

    // Constructors of Pango-1.0.Pango.FontFace

    constructor(config?: FontFace.ConstructorProperties)
    _init(config?: FontFace.ConstructorProperties): void
  }

  module FontFamily {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface FontFamily extends Gio.ListModel {
    // Own properties of Pango-1.0.Pango.FontFamily

    // Has conflict: readonly isMonospace: boolean
    // Has conflict: readonly isVariable: boolean
    /**
     * The type of items contained in this list.
     */
    readonly itemType: GObject.GType
    /**
     * The number of items contained in this list.
     */
    readonly nItems: number
    /**
     * The name of the family
     */
    readonly name: string | null
    __gtype__: number

    // Own fields of Pango-1.0.Pango.FontFamily

    parentInstance: GObject.Object

    // Owm methods of Pango-1.0.Pango.FontFamily

    // Has conflict: getFace(name: string | null): FontFace | null
    // Has conflict: getName(): string
    // Has conflict: listFaces(): /* faces */ FontFace[]

    // Own virtual methods of Pango-1.0.Pango.FontFamily

    /**
     * Gets the `PangoFontFace` of `family` with the given name.
     * @virtual
     * @param name the name of a face. If the name is %NULL,   the family's default face (fontconfig calls it "Regular")   will be returned.
     * @returns the `PangoFontFace`,   or %NULL if no face with the given name exists.
     */
    getFace(name: string | null): FontFace | null
    /**
     * Gets the name of the family.
     *
     * The name is unique among all fonts for the font backend and can
     * be used in a `PangoFontDescription` to specify that a face from
     * this family is desired.
     * @virtual
     * @returns the name of the family. This string is owned   by the family object and must not be modified or freed.
     */
    getName(): string
    /**
     * A monospace font is a font designed for text display where the the
     * characters form a regular grid.
     *
     * For Western languages this would
     * mean that the advance width of all characters are the same, but
     * this categorization also includes Asian fonts which include
     * double-width characters: characters that occupy two grid cells.
     * g_unichar_iswide() returns a result that indicates whether a
     * character is typically double-width in a monospace font.
     *
     * The best way to find out the grid-cell size is to call
     * [method`Pango`.FontMetrics.get_approximate_digit_width], since the
     * results of [method`Pango`.FontMetrics.get_approximate_char_width] may
     * be affected by double-width characters.
     * @virtual
     * @returns %TRUE if the family is monospace.
     */
    isMonospace(): boolean
    /**
     * A variable font is a font which has axes that can be modified to
     * produce different faces.
     *
     * Such axes are also known as _variations_; see
     * [method`Pango`.FontDescription.set_variations] for more information.
     * @virtual
     * @returns %TRUE if the family is variable
     */
    isVariable(): boolean
    /**
     * Lists the different font faces that make up `family`.
     *
     * The faces in a family share a common design, but differ in slant, weight,
     * width and other aspects.
     *
     * Note that the returned faces are not in any particular order, and
     * multiple faces may have the same name or characteristics.
     *
     * `PangoFontFamily` also implemented the [iface`Gio`.ListModel] interface
     * for enumerating faces.
     * @virtual
     */
    listFaces(): /* faces */ FontFace[]

    // Class property signals of Pango-1.0.Pango.FontFamily

    connect(
      sigName: "notify::is-monospace",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-monospace",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-monospace",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-monospace",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-monospace", ...args: any[]): void
    connect(
      sigName: "notify::is-variable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-variable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-variable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-variable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-variable", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `PangoFontFamily` is used to represent a family of related
   * font faces.
   *
   * The font faces in a family share a common design, but differ in
   * slant, weight, width or other aspects.
   * @class
   */
  class FontFamily extends GObject.Object {
    // Own properties of Pango-1.0.Pango.FontFamily

    static name: string

    // Constructors of Pango-1.0.Pango.FontFamily

    constructor(config?: FontFamily.ConstructorProperties)
    _init(config?: FontFamily.ConstructorProperties): void
  }

  module FontMap {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface FontMap extends Gio.ListModel {
    // Own properties of Pango-1.0.Pango.FontMap

    /**
     * The type of items contained in this list.
     */
    readonly itemType: GObject.GType
    /**
     * The number of items contained in this list.
     */
    readonly nItems: number
    __gtype__: number

    // Own fields of Pango-1.0.Pango.FontMap

    parentInstance: GObject.Object

    // Owm methods of Pango-1.0.Pango.FontMap

    // Has conflict: changed(): void
    /**
     * Creates a `PangoContext` connected to `fontmap`.
     *
     * This is equivalent to [ctor`Pango`.Context.new] followed by
     * [method`Pango`.Context.set_font_map].
     *
     * If you are using Pango as part of a higher-level system,
     * that system may have it's own way of create a `PangoContext`.
     * For instance, the GTK toolkit has, among others,
     * gtk_widget_get_pango_context(). Use those instead.
     * @returns the newly allocated `PangoContext`,   which should be freed with g_object_unref().
     */
    createContext(): Context
    // Has conflict: getFamily(name: string): FontFamily
    // Has conflict: getSerial(): number
    // Has conflict: listFamilies(): /* families */ FontFamily[]
    // Has conflict: loadFont(context: Context, desc: FontDescription): Font | null
    // Has conflict: loadFontset(context: Context, desc: FontDescription, language: Language): Fontset | null
    /**
     * Returns a new font that is like `font,` except that its size
     * is multiplied by `scale,` its backend-dependent configuration
     * (e.g. cairo font options) is replaced by the one in `context,`
     * and its variations are replaced by `variations`.
     * @param font a font in `fontmap`
     * @param scale the scale factor to apply
     * @param context a `PangoContext`
     * @param variations font variations to use
     * @returns the modified font
     */
    reloadFont(
      font: Font,
      scale: number,
      context: Context | null,
      variations: string | null
    ): Font

    // Own virtual methods of Pango-1.0.Pango.FontMap

    /**
     * Forces a change in the context, which will cause any `PangoContext`
     * using this fontmap to change.
     *
     * This function is only useful when implementing a new backend
     * for Pango, something applications won't do. Backends should
     * call this function if they have attached extra data to the
     * context and such data is changed.
     * @virtual
     */
    changed(): void
    /**
     * Gets a font family by name.
     * @virtual
     * @param name a family name
     * @returns the `PangoFontFamily`
     */
    getFamily(name: string): FontFamily
    /**
     * Returns the current serial number of `fontmap`.
     *
     * The serial number is initialized to an small number larger than zero
     * when a new fontmap is created and is increased whenever the fontmap
     * is changed. It may wrap, but will never have the value 0. Since it can
     * wrap, never compare it with "less than", always use "not equals".
     *
     * The fontmap can only be changed using backend-specific API, like changing
     * fontmap resolution.
     *
     * This can be used to automatically detect changes to a `PangoFontMap`,
     * like in `PangoContext`.
     * @virtual
     * @returns The current serial number of @fontmap.
     */
    getSerial(): number
    /**
     * List all families for a fontmap.
     *
     * Note that the returned families are not in any particular order.
     *
     * `PangoFontMap` also implemented the [iface`Gio`.ListModel] interface
     * for enumerating families.
     * @virtual
     */
    listFamilies(): /* families */ FontFamily[]
    /**
     * Load the font in the fontmap that is the closest match for `desc`.
     * @virtual
     * @param context the `PangoContext` the font will be used with
     * @param desc a `PangoFontDescription` describing the font to load
     * @returns the newly allocated `PangoFont`   loaded, or %NULL if no font matched.
     */
    loadFont(context: Context, desc: FontDescription): Font | null
    /**
     * Load a set of fonts in the fontmap that can be used to render
     * a font matching `desc`.
     * @virtual
     * @param context the `PangoContext` the font will be used with
     * @param desc a `PangoFontDescription` describing the font to load
     * @param language a `PangoLanguage` the fonts will be used for
     * @returns the newly allocated   `PangoFontset` loaded, or %NULL if no font matched.
     */
    loadFontset(
      context: Context,
      desc: FontDescription,
      language: Language
    ): Fontset | null

    // Class property signals of Pango-1.0.Pango.FontMap

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `PangoFontMap` represents the set of fonts available for a
   * particular rendering system.
   *
   * This is a virtual object with implementations being specific to
   * particular rendering systems.
   * @interface
   */
  class FontMap extends GObject.Object {
    // Own properties of Pango-1.0.Pango.FontMap

    static name: string

    // Constructors of Pango-1.0.Pango.FontMap

    constructor(config?: FontMap.ConstructorProperties)
    _init(config?: FontMap.ConstructorProperties): void
  }

  module Fontset {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Fontset {
    // Own properties of Pango-1.0.Pango.Fontset

    __gtype__: number

    // Own fields of Pango-1.0.Pango.Fontset

    parentInstance: GObject.Object

    // Owm methods of Pango-1.0.Pango.Fontset

    // Has conflict: foreach(func: FontsetForeachFunc): void
    // Has conflict: getFont(wc: number): Font
    // Has conflict: getMetrics(): FontMetrics

    // Own virtual methods of Pango-1.0.Pango.Fontset

    /**
     * Iterates through all the fonts in a fontset, calling `func` for
     * each one.
     *
     * If `func` returns %TRUE, that stops the iteration.
     * @virtual
     * @param func Callback function
     */
    foreach(func: FontsetForeachFunc): void
    /**
     * Returns the font in the fontset that contains the best
     * glyph for a Unicode character.
     * @virtual
     * @param wc a Unicode character
     * @returns a `PangoFont`
     */
    getFont(wc: number): Font
    /**
     * a function to get the language of the fontset.
     * @virtual
     */
    getLanguage(): Language
    /**
     * Get overall metric information for the fonts in the fontset.
     * @virtual
     * @returns a `PangoFontMetrics` object
     */
    getMetrics(): FontMetrics

    // Class property signals of Pango-1.0.Pango.Fontset

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `PangoFontset` represents a set of `PangoFont` to use when rendering text.
   *
   * A `PangoFontset` is the result of resolving a `PangoFontDescription`
   * against a particular `PangoContext`. It has operations for finding the
   * component font for a particular Unicode character, and for finding a
   * composite set of metrics for the entire fontset.
   * @class
   */
  class Fontset extends GObject.Object {
    // Own properties of Pango-1.0.Pango.Fontset

    static name: string

    // Constructors of Pango-1.0.Pango.Fontset

    constructor(config?: Fontset.ConstructorProperties)
    _init(config?: Fontset.ConstructorProperties): void
  }

  module FontsetSimple {
    // Constructor properties interface

    interface ConstructorProperties extends Fontset.ConstructorProperties {}
  }

  interface FontsetSimple {
    // Own properties of Pango-1.0.Pango.FontsetSimple

    __gtype__: number

    // Owm methods of Pango-1.0.Pango.FontsetSimple

    /**
     * Adds a font to the fontset.
     *
     * The fontset takes ownership of `font`.
     * @param font a `PangoFont`.
     */
    append(font: Font): void
    /**
     * Returns the number of fonts in the fontset.
     * @returns the size of @fontset
     */
    size(): number

    // Class property signals of Pango-1.0.Pango.FontsetSimple

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `PangoFontsetSimple` is a implementation of the abstract
   * `PangoFontset` base class as an array of fonts.
   *
   * When creating a `PangoFontsetSimple`, you have to provide
   * the array of fonts that make up the fontset.
   * @class
   */
  class FontsetSimple extends Fontset {
    // Own properties of Pango-1.0.Pango.FontsetSimple

    static name: string

    // Constructors of Pango-1.0.Pango.FontsetSimple

    constructor(config?: FontsetSimple.ConstructorProperties)
    /**
     * Creates a new `PangoFontsetSimple` for the given language.
     * @constructor
     * @param language a `PangoLanguage` tag
     * @returns the newly allocated `PangoFontsetSimple`
     */
    constructor(language: Language)
    /**
     * Creates a new `PangoFontsetSimple` for the given language.
     * @constructor
     * @param language a `PangoLanguage` tag
     * @returns the newly allocated `PangoFontsetSimple`
     */
    static new(language: Language): FontsetSimple
    _init(config?: FontsetSimple.ConstructorProperties): void
  }

  module Layout {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Layout {
    // Own properties of Pango-1.0.Pango.Layout

    __gtype__: number

    // Owm methods of Pango-1.0.Pango.Layout

    /**
     * Forces recomputation of any state in the `PangoLayout` that
     * might depend on the layout's context.
     *
     * This function should be called if you make changes to the context
     * subsequent to creating the layout.
     */
    contextChanged(): void
    /**
     * Creates a deep copy-by-value of the layout.
     *
     * The attribute list, tab array, and text from the original layout
     * are all copied by value.
     * @returns the newly allocated `PangoLayout`
     */
    copy(): Layout
    /**
     * Gets the alignment for the layout: how partial lines are
     * positioned within the horizontal space available.
     * @returns the alignment
     */
    getAlignment(): Alignment
    /**
     * Gets the attribute list for the layout, if any.
     * @returns a `PangoAttrList`
     */
    getAttributes(): AttrList | null
    /**
     * Gets whether to calculate the base direction for the layout
     * according to its contents.
     *
     * See [method`Pango`.Layout.set_auto_dir].
     * @returns %TRUE if the bidirectional base direction   is computed from the layout's contents, %FALSE otherwise
     */
    getAutoDir(): boolean
    /**
     * Gets the Y position of baseline of the first line in `layout`.
     * @returns baseline of first line, from top of @layout
     */
    getBaseline(): number
    /**
     * Given an index within a layout, determines the positions that of the
     * strong and weak cursors if the insertion point is at that index.
     *
     * This is a variant of [method`Pango`.Layout.get_cursor_pos] that applies
     * font metric information about caret slope and offset to the positions
     * it returns.
     *
     * <picture>
     *   <source srcset="caret-metrics-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Caret metrics" src="caret-metrics-light.png">
     * </picture>
     * @param index the byte index of the cursor
     */
    getCaretPos(
      index: number
    ): [/* strongPos */ Rectangle, /* weakPos */ Rectangle]
    /**
     * Returns the number of Unicode characters in the
     * the text of `layout`.
     * @returns the number of Unicode characters   in the text of @layout
     */
    getCharacterCount(): number
    /**
     * Retrieves the `PangoContext` used for this layout.
     * @returns the `PangoContext` for the layout
     */
    getContext(): Context
    /**
     * Given an index within a layout, determines the positions that of the
     * strong and weak cursors if the insertion point is at that index.
     *
     * The position of each cursor is stored as a zero-width rectangle
     * with the height of the run extents.
     *
     * <picture>
     *   <source srcset="cursor-positions-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Cursor positions" src="cursor-positions-light.png">
     * </picture>
     *
     * The strong cursor location is the location where characters of the
     * directionality equal to the base direction of the layout are inserted.
     * The weak cursor location is the location where characters of the
     * directionality opposite to the base direction of the layout are inserted.
     *
     * The following example shows text with both a strong and a weak cursor.
     *
     * <picture>
     *   <source srcset="split-cursor-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Strong and weak cursors" src="split-cursor-light.png">
     * </picture>
     *
     * The strong cursor has a little arrow pointing to the right, the weak
     * cursor to the left. Typing a 'c' in this situation will insert the
     * character after the 'b', and typing another Hebrew character, like 'ג',
     * will insert it at the end.
     * @param index the byte index of the cursor
     */
    getCursorPos(
      index: number
    ): [/* strongPos */ Rectangle, /* weakPos */ Rectangle]
    /**
     * Gets the text direction at the given character position in `layout`.
     * @param index the byte index of the char
     * @returns the text direction at @index
     */
    getDirection(index: number): Direction
    /**
     * Gets the type of ellipsization being performed for `layout`.
     *
     * See [method`Pango`.Layout.set_ellipsize].
     *
     * Use [method`Pango`.Layout.is_ellipsized] to query whether any
     * paragraphs were actually ellipsized.
     * @returns the current ellipsization mode for @layout
     */
    getEllipsize(): EllipsizeMode
    /**
     * Computes the logical and ink extents of `layout`.
     *
     * Logical extents are usually what you want for positioning things. Note
     * that both extents may have non-zero x and y. You may want to use those
     * to offset where you render the layout. Not doing that is a very typical
     * bug that shows up as right-to-left layouts not being correctly positioned
     * in a layout with a set width.
     *
     * The extents are given in layout coordinates and in Pango units; layout
     * coordinates begin at the top left corner of the layout.
     */
    getExtents(): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Gets the font description for the layout, if any.
     * @returns a pointer to the   layout's font description, or %NULL if the font description   from the layout's context is inherited.
     */
    getFontDescription(): FontDescription | null
    /**
     * Gets the height of layout used for ellipsization.
     *
     * See [method`Pango`.Layout.set_height] for details.
     * @returns the height, in Pango units if positive,   or number of lines if negative.
     */
    getHeight(): number
    /**
     * Gets the paragraph indent width in Pango units.
     *
     * A negative value indicates a hanging indentation.
     * @returns the indent in Pango units
     */
    getIndent(): number
    /**
     * Returns an iterator to iterate over the visual extents of the layout.
     * @returns the new `PangoLayoutIter`
     */
    getIter(): LayoutIter
    /**
     * Gets whether each complete line should be stretched to fill the entire
     * width of the layout.
     * @returns the justify value
     */
    getJustify(): boolean
    /**
     * Gets whether the last line should be stretched
     * to fill the entire width of the layout.
     * @returns the justify value
     */
    getJustifyLastLine(): boolean
    /**
     * Retrieves a particular line from a `PangoLayout`.
     *
     * Use the faster [method`Pango`.Layout.get_line_readonly] if you do not
     * plan to modify the contents of the line (glyphs, glyph widths, etc.).
     * @param line the index of a line, which must be between 0 and   `pango_layout_get_line_count(layout) - 1`, inclusive.
     * @returns the requested `PangoLayoutLine`,   or %NULL if the index is out of range. This layout line can be ref'ed   and retained, but will become invalid if changes are made to the   `PangoLayout`.
     */
    getLine(line: number): LayoutLine | null
    /**
     * Retrieves the count of lines for the `layout`.
     * @returns the line count
     */
    getLineCount(): number
    /**
     * Retrieves a particular line from a `PangoLayout`.
     *
     * This is a faster alternative to [method`Pango`.Layout.get_line],
     * but the user is not expected to modify the contents of the line
     * (glyphs, glyph widths, etc.).
     * @param line the index of a line, which must be between 0 and   `pango_layout_get_line_count(layout) - 1`, inclusive.
     * @returns the requested `PangoLayoutLine`,   or %NULL if the index is out of range. This layout line can be ref'ed   and retained, but will become invalid if changes are made to the   `PangoLayout`. No changes should be made to the line.
     */
    getLineReadonly(line: number): LayoutLine | null
    /**
     * Gets the line spacing factor of `layout`.
     *
     * See [method`Pango`.Layout.set_line_spacing].
     */
    getLineSpacing(): number
    /**
     * Returns the lines of the `layout` as a list.
     *
     * Use the faster [method`Pango`.Layout.get_lines_readonly] if you do not
     * plan to modify the contents of the lines (glyphs, glyph widths, etc.).
     * @returns a `GSList`   containing the lines in the layout. This points to internal data of the   `PangoLayout` and must be used with care. It will become invalid on any   change to the layout's text or properties.
     */
    getLines(): LayoutLine[]
    /**
     * Returns the lines of the `layout` as a list.
     *
     * This is a faster alternative to [method`Pango`.Layout.get_lines],
     * but the user is not expected to modify the contents of the lines
     * (glyphs, glyph widths, etc.).
     * @returns a `GSList`   containing the lines in the layout. This points to internal data of the   `PangoLayout` and must be used with care. It will become invalid on any   change to the layout's text or properties. No changes should be made to   the lines.
     */
    getLinesReadonly(): LayoutLine[]
    /**
     * Retrieves an array of logical attributes for each character in
     * the `layout`.
     */
    getLogAttrs(): /* attrs */ LogAttr[]
    /**
     * Retrieves an array of logical attributes for each character in
     * the `layout`.
     *
     * This is a faster alternative to [method`Pango`.Layout.get_log_attrs].
     * The returned array is part of `layout` and must not be modified.
     * Modifying the layout will invalidate the returned array.
     *
     * The number of attributes returned in `n_attrs` will be one more
     * than the total number of characters in the layout, since there
     * need to be attributes corresponding to both the position before
     * the first character and the position after the last character.
     * @returns an array of logical attributes
     */
    getLogAttrsReadonly(): LogAttr[]
    /**
     * Computes the logical and ink extents of `layout` in device units.
     *
     * This function just calls [method`Pango`.Layout.get_extents] followed by
     * two [func`extents_to_pixels]` calls, rounding `ink_rect` and `logical_rect`
     * such that the rounded rectangles fully contain the unrounded one (that is,
     * passes them as first argument to [func`Pango`.extents_to_pixels]).
     */
    getPixelExtents(): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Determines the logical width and height of a `PangoLayout` in device
     * units.
     *
     * [method`Pango`.Layout.get_size] returns the width and height
     * scaled by %PANGO_SCALE. This is simply a convenience function
     * around [method`Pango`.Layout.get_pixel_extents].
     */
    getPixelSize(): [/* width */ number, /* height */ number]
    /**
     * Returns the current serial number of `layout`.
     *
     * The serial number is initialized to an small number larger than zero
     * when a new layout is created and is increased whenever the layout is
     * changed using any of the setter functions, or the `PangoContext` it
     * uses has changed. The serial may wrap, but will never have the value 0.
     * Since it can wrap, never compare it with "less than", always use "not equals".
     *
     * This can be used to automatically detect changes to a `PangoLayout`,
     * and is useful for example to decide whether a layout needs redrawing.
     * To force the serial to be increased, use
     * [method`Pango`.Layout.context_changed].
     * @returns The current serial number of @layout.
     */
    getSerial(): number
    /**
     * Obtains whether `layout` is in single paragraph mode.
     *
     * See [method`Pango`.Layout.set_single_paragraph_mode].
     * @returns %TRUE if the layout does not break paragraphs   at paragraph separator characters, %FALSE otherwise
     */
    getSingleParagraphMode(): boolean
    /**
     * Determines the logical width and height of a `PangoLayout` in Pango
     * units.
     *
     * This is simply a convenience function around [method`Pango`.Layout.get_extents].
     */
    getSize(): [/* width */ number, /* height */ number]
    /**
     * Gets the amount of spacing between the lines of the layout.
     * @returns the spacing in Pango units
     */
    getSpacing(): number
    /**
     * Gets the current `PangoTabArray` used by this layout.
     *
     * If no `PangoTabArray` has been set, then the default tabs are
     * in use and %NULL is returned. Default tabs are every 8 spaces.
     *
     * The return value should be freed with [method`Pango`.TabArray.free].
     * @returns a copy of the tabs for this layout
     */
    getTabs(): TabArray | null
    /**
     * Gets the text in the layout.
     *
     * The returned text should not be freed or modified.
     * @returns the text in the @layout
     */
    getText(): string
    /**
     * Counts the number of unknown glyphs in `layout`.
     *
     * This function can be used to determine if there are any fonts
     * available to render all characters in a certain string, or when
     * used in combination with %PANGO_ATTR_FALLBACK, to check if a
     * certain font supports all the characters in the string.
     * @returns The number of unknown glyphs in @layout
     */
    getUnknownGlyphsCount(): number
    /**
     * Gets the width to which the lines of the `PangoLayout` should wrap.
     * @returns the width in Pango units, or -1 if no width set.
     */
    getWidth(): number
    /**
     * Gets the wrap mode for the layout.
     *
     * Use [method`Pango`.Layout.is_wrapped] to query whether
     * any paragraphs were actually wrapped.
     * @returns active wrap mode.
     */
    getWrap(): WrapMode
    /**
     * Converts from byte `index_` within the `layout` to line and X position.
     *
     * The X position is measured from the left edge of the line.
     * @param index the byte index of a grapheme within the layout
     * @param trailing an integer indicating the edge of the grapheme to retrieve the   position of. If > 0, the trailing edge of the grapheme, if 0,   the leading of the grapheme
     */
    indexToLineX(
      index: number,
      trailing: boolean
    ): [/* line */ number, /* xPos */ number]
    /**
     * Converts from an index within a `PangoLayout` to the onscreen position
     * corresponding to the grapheme at that index.
     *
     * The returns is represented as rectangle. Note that `pos->x` is
     * always the leading edge of the grapheme and `pos->x + pos->width` the
     * trailing edge of the grapheme. If the directionality of the grapheme
     * is right-to-left, then `pos->width` will be negative.
     * @param index byte index within `layout`
     */
    indexToPos(index: number): /* pos */ Rectangle
    /**
     * Queries whether the layout had to ellipsize any paragraphs.
     *
     * This returns %TRUE if the ellipsization mode for `layout`
     * is not %PANGO_ELLIPSIZE_NONE, a positive width is set on `layout,`
     * and there are paragraphs exceeding that width that have to be
     * ellipsized.
     * @returns %TRUE if any paragraphs had to be ellipsized,   %FALSE otherwise
     */
    isEllipsized(): boolean
    /**
     * Queries whether the layout had to wrap any paragraphs.
     *
     * This returns %TRUE if a positive width is set on `layout,`
     * ellipsization mode of `layout` is set to %PANGO_ELLIPSIZE_NONE,
     * and there are paragraphs exceeding the layout width that have
     * to be wrapped.
     * @returns %TRUE if any paragraphs had to be wrapped, %FALSE   otherwise
     */
    isWrapped(): boolean
    /**
     * Computes a new cursor position from an old position and a direction.
     *
     * If `direction` is positive, then the new position will cause the strong
     * or weak cursor to be displayed one position to right of where it was
     * with the old cursor position. If `direction` is negative, it will be
     * moved to the left.
     *
     * In the presence of bidirectional text, the correspondence between
     * logical and visual order will depend on the direction of the current
     * run, and there may be jumps when the cursor is moved off of the end
     * of a run.
     *
     * Motion here is in cursor positions, not in characters, so a single
     * call to this function may move the cursor over multiple characters
     * when multiple characters combine to form a single grapheme.
     * @param strong whether the moving cursor is the strong cursor or the   weak cursor. The strong cursor is the cursor corresponding   to text insertion in the base direction for the layout.
     * @param oldIndex the byte index of the current cursor position
     * @param oldTrailing if 0, the cursor was at the leading edge of the   grapheme indicated by `old_index,` if > 0, the cursor   was at the trailing edge.
     * @param direction direction to move cursor. A negative   value indicates motion to the left
     */
    moveCursorVisually(
      strong: boolean,
      oldIndex: number,
      oldTrailing: number,
      direction: number
    ): [/* newIndex */ number, /* newTrailing */ number]
    /**
     * Serializes the `layout` for later deserialization via [func`Pango`.Layout.deserialize].
     *
     * There are no guarantees about the format of the output across different
     * versions of Pango and [func`Pango`.Layout.deserialize] will reject data
     * that it cannot parse.
     *
     * The intended use of this function is testing, benchmarking and debugging.
     * The format is not meant as a permanent storage format.
     * @param flags `PangoLayoutSerializeFlags`
     * @returns a `GBytes` containing the serialized form of @layout
     */
    serialize(flags: LayoutSerializeFlags): any
    /**
     * Sets the alignment for the layout: how partial lines are
     * positioned within the horizontal space available.
     *
     * The default alignment is %PANGO_ALIGN_LEFT.
     * @param alignment the alignment
     */
    setAlignment(alignment: Alignment): void
    /**
     * Sets the text attributes for a layout object.
     *
     * References `attrs,` so the caller can unref its reference.
     * @param attrs a `PangoAttrList`
     */
    setAttributes(attrs: AttrList | null): void
    /**
     * Sets whether to calculate the base direction
     * for the layout according to its contents.
     *
     * When this flag is on (the default), then paragraphs in `layout` that
     * begin with strong right-to-left characters (Arabic and Hebrew principally),
     * will have right-to-left layout, paragraphs with letters from other scripts
     * will have left-to-right layout. Paragraphs with only neutral characters
     * get their direction from the surrounding paragraphs.
     *
     * When %FALSE, the choice between left-to-right and right-to-left
     * layout is done according to the base direction of the layout's
     * `PangoContext`. (See [method`Pango`.Context.set_base_dir]).
     *
     * When the auto-computed direction of a paragraph differs from the
     * base direction of the context, the interpretation of
     * %PANGO_ALIGN_LEFT and %PANGO_ALIGN_RIGHT are swapped.
     * @param autoDir if %TRUE, compute the bidirectional base direction   from the layout's contents
     */
    setAutoDir(autoDir: boolean): void
    /**
     * Sets the type of ellipsization being performed for `layout`.
     *
     * Depending on the ellipsization mode `ellipsize` text is
     * removed from the start, middle, or end of text so they
     * fit within the width and height of layout set with
     * [method`Pango`.Layout.set_width] and [method`Pango`.Layout.set_height].
     *
     * If the layout contains characters such as newlines that
     * force it to be layed out in multiple paragraphs, then whether
     * each paragraph is ellipsized separately or the entire layout
     * is ellipsized as a whole depends on the set height of the layout.
     *
     * The default value is %PANGO_ELLIPSIZE_NONE.
     *
     * See [method`Pango`.Layout.set_height] for details.
     * @param ellipsize the new ellipsization mode for `layout`
     */
    setEllipsize(ellipsize: EllipsizeMode): void
    /**
     * Sets the default font description for the layout.
     *
     * If no font description is set on the layout, the
     * font description from the layout's context is used.
     * @param desc the new `PangoFontDescription`   to unset the current font description
     */
    setFontDescription(desc: FontDescription | null): void
    /**
     * Sets the height to which the `PangoLayout` should be ellipsized at.
     *
     * There are two different behaviors, based on whether `height` is positive
     * or negative.
     *
     * If `height` is positive, it will be the maximum height of the layout. Only
     * lines would be shown that would fit, and if there is any text omitted,
     * an ellipsis added. At least one line is included in each paragraph regardless
     * of how small the height value is. A value of zero will render exactly one
     * line for the entire layout.
     *
     * If `height` is negative, it will be the (negative of) maximum number of lines
     * per paragraph. That is, the total number of lines shown may well be more than
     * this value if the layout contains multiple paragraphs of text.
     * The default value of -1 means that the first line of each paragraph is ellipsized.
     * This behavior may be changed in the future to act per layout instead of per
     * paragraph. File a bug against pango at
     * [https://gitlab.gnome.org/gnome/pango](https://gitlab.gnome.org/gnome/pango)
     * if your code relies on this behavior.
     *
     * Height setting only has effect if a positive width is set on
     * `layout` and ellipsization mode of `layout` is not %PANGO_ELLIPSIZE_NONE.
     * The behavior is undefined if a height other than -1 is set and
     * ellipsization mode is set to %PANGO_ELLIPSIZE_NONE, and may change in the
     * future.
     * @param height the desired height of the layout in Pango units if positive,   or desired number of lines if negative.
     */
    setHeight(height: number): void
    /**
     * Sets the width in Pango units to indent each paragraph.
     *
     * A negative value of `indent` will produce a hanging indentation.
     * That is, the first line will have the full width, and subsequent
     * lines will be indented by the absolute value of `indent`.
     *
     * The indent setting is ignored if layout alignment is set to
     * %PANGO_ALIGN_CENTER.
     *
     * The default value is 0.
     * @param indent the amount by which to indent
     */
    setIndent(indent: number): void
    /**
     * Sets whether each complete line should be stretched to fill the
     * entire width of the layout.
     *
     * Stretching is typically done by adding whitespace, but for some scripts
     * (such as Arabic), the justification may be done in more complex ways,
     * like extending the characters.
     *
     * Note that this setting is not implemented and so is ignored in
     * Pango older than 1.18.
     *
     * Note that tabs and justification conflict with each other:
     * Justification will move content away from its tab-aligned
     * positions.
     *
     * The default value is %FALSE.
     *
     * Also see [method`Pango`.Layout.set_justify_last_line].
     * @param justify whether the lines in the layout should be justified
     */
    setJustify(justify: boolean): void
    /**
     * Sets whether the last line should be stretched to fill the
     * entire width of the layout.
     *
     * This only has an effect if [method`Pango`.Layout.set_justify] has
     * been called as well.
     *
     * The default value is %FALSE.
     * @param justify whether the last line in the layout should be justified
     */
    setJustifyLastLine(justify: boolean): void
    /**
     * Sets a factor for line spacing.
     *
     * Typical values are: 0, 1, 1.5, 2. The default values is 0.
     *
     * If `factor` is non-zero, lines are placed so that
     *
     *     baseline2 = baseline1 + factor * height2
     *
     * where height2 is the line height of the second line
     * (as determined by the font(s)). In this case, the spacing
     * set with [method`Pango`.Layout.set_spacing] is ignored.
     *
     * If `factor` is zero (the default), spacing is applied as before.
     *
     * Note: for semantics that are closer to the CSS line-height
     * property, see [func`Pango`.attr_line_height_new].
     * @param factor the new line spacing factor
     */
    setLineSpacing(factor: number): void
    // Has conflict: setMarkup(markup: string, length: number): void
    /**
     * Sets the layout text and attribute list from marked-up text.
     *
     * See [Pango Markup](pango_markup.html)).
     *
     * Replaces the current text and attribute list.
     *
     * If `accel_marker` is nonzero, the given character will mark the
     * character following it as an accelerator. For example, `accel_marker`
     * might be an ampersand or underscore. All characters marked
     * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
     * and the first character so marked will be returned in `accel_char`.
     * Two `accel_marker` characters following each other produce a single
     * literal `accel_marker` character.
     * @param markup marked-up text (see [Pango Markup](pango_markup.html))
     * @param length length of marked-up text in bytes, or -1 if `markup` is   `NUL`-terminated
     * @param accelMarker marker for accelerators in the text
     */
    setMarkupWithAccel(
      markup: string,
      length: number,
      accelMarker: string
    ): /* accelChar */ string
    /**
     * Sets the single paragraph mode of `layout`.
     *
     * If `setting` is %TRUE, do not treat newlines and similar characters
     * as paragraph separators; instead, keep all text in a single paragraph,
     * and display a glyph for paragraph separator characters. Used when
     * you want to allow editing of newlines on a single text line.
     *
     * The default value is %FALSE.
     * @param setting new setting
     */
    setSingleParagraphMode(setting: boolean): void
    /**
     * Sets the amount of spacing in Pango units between
     * the lines of the layout.
     *
     * When placing lines with spacing, Pango arranges things so that
     *
     *     line2.top = line1.bottom + spacing
     *
     * The default value is 0.
     *
     * Note: Since 1.44, Pango is using the line height (as determined
     * by the font) for placing lines when the line spacing factor is set
     * to a non-zero value with [method`Pango`.Layout.set_line_spacing].
     * In that case, the `spacing` set with this function is ignored.
     *
     * Note: for semantics that are closer to the CSS line-height
     * property, see [func`Pango`.attr_line_height_new].
     * @param spacing the amount of spacing
     */
    setSpacing(spacing: number): void
    /**
     * Sets the tabs to use for `layout,` overriding the default tabs.
     *
     * `PangoLayout` will place content at the next tab position
     * whenever it meets a Tab character (U+0009).
     *
     * By default, tabs are every 8 spaces. If `tabs` is %NULL, the
     * default tabs are reinstated. `tabs` is copied into the layout;
     * you must free your copy of `tabs` yourself.
     *
     * Note that tabs and justification conflict with each other:
     * Justification will move content away from its tab-aligned
     * positions. The same is true for alignments other than
     * %PANGO_ALIGN_LEFT.
     * @param tabs a `PangoTabArray`
     */
    setTabs(tabs: TabArray | null): void
    // Has conflict: setText(text: string, length: number): void
    /**
     * Sets the width to which the lines of the `PangoLayout` should wrap or
     * ellipsized.
     *
     * The default value is -1: no width set.
     * @param width the desired width in Pango units, or -1 to indicate that no   wrapping or ellipsization should be performed.
     */
    setWidth(width: number): void
    /**
     * Sets the wrap mode.
     *
     * The wrap mode only has effect if a width is set on the layout
     * with [method`Pango`.Layout.set_width]. To turn off wrapping,
     * set the width to -1.
     *
     * The default value is %PANGO_WRAP_WORD.
     * @param wrap the wrap mode
     */
    setWrap(wrap: WrapMode): void
    /**
     * A convenience method to serialize a layout to a file.
     *
     * It is equivalent to calling [method`Pango`.Layout.serialize]
     * followed by [func`GLib`.file_set_contents].
     *
     * See those two functions for details on the arguments.
     *
     * It is mostly intended for use inside a debugger to quickly dump
     * a layout to a file for later inspection.
     * @param flags `PangoLayoutSerializeFlags`
     * @param filename the file to save it to
     * @returns %TRUE if saving was successful
     */
    writeToFile(flags: LayoutSerializeFlags, filename: string): boolean
    /**
     * Converts from X and Y position within a layout to the byte index to the
     * character at that logical position.
     *
     * If the Y position is not inside the layout, the closest position is
     * chosen (the position will be clamped inside the layout). If the X position
     * is not within the layout, then the start or the end of the line is
     * chosen as described for [method`Pango`.LayoutLine.x_to_index]. If either
     * the X or Y positions were not inside the layout, then the function returns
     * %FALSE; on an exact hit, it returns %TRUE.
     * @param x the X offset (in Pango units) from the left edge of the layout
     * @param y the Y offset (in Pango units) from the top edge of the layout
     * @returns %TRUE if the coordinates were inside text, %FALSE otherwise
     */
    xyToIndex(
      x: number,
      y: number
    ): [/* returnType */ boolean, /* index */ number, /* trailing */ number]
    /**
     * Sets the layout text and attribute list from marked-up text.
     *
     * See [Pango Markup](pango_markup.html)).
     *
     * Replaces the current text and attribute list.
     *
     * This is the same as [method`Pango`.Layout.set_markup_with_accel],
     * but the markup text isn't scanned for accelerators.
     * @param markup marked-up text
     * @param length length of marked-up text in bytes, or -1 if `markup` is   `NUL`-terminated
     */
    setMarkup(markup: string): void
    /**
     * Sets the text of the layout.
     *
     * This function validates `text` and renders invalid UTF-8
     * with a placeholder glyph.
     *
     * Note that if you have used [method`Pango`.Layout.set_markup] or
     * [method`Pango`.Layout.set_markup_with_accel] on `layout` before, you
     * may want to call [method`Pango`.Layout.set_attributes] to clear the
     * attributes set on the layout from the markup as this function does
     * not clear attributes.
     * @param text the text
     * @param length maximum length of `text,` in bytes. -1 indicates that   the string is nul-terminated and the length should be calculated.   The text will also be truncated on encountering a nul-termination   even when `length` is positive.
     */
    setText(text: string): void

    // Class property signals of Pango-1.0.Pango.Layout

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `PangoLayout` structure represents an entire paragraph of text.
   *
   * While complete access to the layout capabilities of Pango is provided
   * using the detailed interfaces for itemization and shaping, using
   * that functionality directly involves writing a fairly large amount
   * of code. `PangoLayout` provides a high-level driver for formatting
   * entire paragraphs of text at once. This includes paragraph-level
   * functionality such as line breaking, justification, alignment and
   * ellipsization.
   *
   * A `PangoLayout` is initialized with a `PangoContext`, UTF-8 string
   * and set of attributes for that string. Once that is done, the set of
   * formatted lines can be extracted from the object, the layout can be
   * rendered, and conversion between logical character positions within
   * the layout's text, and the physical position of the resulting glyphs
   * can be made.
   *
   * There are a number of parameters to adjust the formatting of a
   * `PangoLayout`. The following image shows adjustable parameters
   * (on the left) and font metrics (on the right):
   *
   * <picture>
   *   <source srcset="layout-dark.png" media="(prefers-color-scheme: dark)">
   *   <img alt="Pango Layout Parameters" src="layout-light.png">
   * </picture>
   *
   * The following images demonstrate the effect of alignment and
   * justification on the layout of text:
   *
   * | | |
   * | --- | --- |
   * | ![align=left](align-left.png) | ![align=left, justify](align-left-justify.png) |
   * | ![align=center](align-center.png) | ![align=center, justify](align-center-justify.png) |
   * | ![align=right](align-right.png) | ![align=right, justify](align-right-justify.png) |
   *
   *
   * It is possible, as well, to ignore the 2-D setup,
   * and simply treat the results of a `PangoLayout` as a list of lines.
   * @class
   */
  class Layout extends GObject.Object {
    // Own properties of Pango-1.0.Pango.Layout

    static name: string

    // Constructors of Pango-1.0.Pango.Layout

    constructor(config?: Layout.ConstructorProperties)
    /**
     * Create a new `PangoLayout` object with attributes initialized to
     * default values for a particular `PangoContext`.
     * @constructor
     * @param context a `PangoContext`
     * @returns the newly allocated `PangoLayout`
     */
    constructor(context: Context)
    /**
     * Create a new `PangoLayout` object with attributes initialized to
     * default values for a particular `PangoContext`.
     * @constructor
     * @param context a `PangoContext`
     * @returns the newly allocated `PangoLayout`
     */
    static new(context: Context): Layout
    _init(config?: Layout.ConstructorProperties): void
    /**
     * Loads data previously created via [method`Pango`.Layout.serialize].
     *
     * For a discussion of the supported format, see that function.
     *
     * Note: to verify that the returned layout is identical to
     * the one that was serialized, you can compare `bytes` to the
     * result of serializing the layout again.
     * @param context a `PangoContext`
     * @param bytes the bytes containing the data
     * @param flags `PangoLayoutDeserializeFlags`
     * @returns a new `PangoLayout`
     */
    static deserialize(
      context: Context,
      bytes: any,
      flags: LayoutDeserializeFlags
    ): Layout | null
  }

  module Renderer {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Renderer {
    // Own properties of Pango-1.0.Pango.Renderer

    __gtype__: number

    // Own fields of Pango-1.0.Pango.Renderer

    /**
     * the current transformation matrix for
     *   the Renderer; may be %NULL, which should be treated the
     *   same as the identity matrix.
     * @field
     */
    matrix: Matrix

    // Owm methods of Pango-1.0.Pango.Renderer

    /**
     * Does initial setup before rendering operations on `renderer`.
     *
     * [method`Pango`.Renderer.deactivate] should be called when done drawing.
     * Calls such as [method`Pango`.Renderer.draw_layout] automatically
     * activate the layout before drawing on it.
     *
     * Calls to [method`Pango`.Renderer.activate] and
     * [method`Pango`.Renderer.deactivate] can be nested and the
     * renderer will only be initialized and deinitialized once.
     */
    activate(): void
    /**
     * Cleans up after rendering operations on `renderer`.
     *
     * See docs for [method`Pango`.Renderer.activate].
     */
    deactivate(): void
    // Has conflict: drawErrorUnderline(x: number, y: number, width: number, height: number): void
    // Has conflict: drawGlyph(font: Font, glyph: Glyph, x: number, y: number): void
    // Has conflict: drawGlyphItem(text: string | null, glyphItem: GlyphItem, x: number, y: number): void
    // Has conflict: drawGlyphs(font: Font, glyphs: GlyphString, x: number, y: number): void
    /**
     * Draws `layout` with the specified `PangoRenderer`.
     *
     * This is equivalent to drawing the lines of the layout, at their
     * respective positions relative to `x,` `y`.
     * @param layout a `PangoLayout`
     * @param x X position of left edge of baseline, in user space coordinates   in Pango units.
     * @param y Y position of left edge of baseline, in user space coordinates   in Pango units.
     */
    drawLayout(layout: Layout, x: number, y: number): void
    /**
     * Draws `line` with the specified `PangoRenderer`.
     *
     * This draws the glyph items that make up the line, as well as
     * shapes, backgrounds and lines that are specified by the attributes
     * of those items.
     * @param line a `PangoLayoutLine`
     * @param x X position of left edge of baseline, in user space coordinates   in Pango units.
     * @param y Y position of left edge of baseline, in user space coordinates   in Pango units.
     */
    drawLayoutLine(line: LayoutLine, x: number, y: number): void
    // Has conflict: drawRectangle(part: RenderPart, x: number, y: number, width: number, height: number): void
    // Has conflict: drawTrapezoid(part: RenderPart, y1: number, x11: number, x21: number, y2: number, x12: number, x22: number): void
    /**
     * Gets the current alpha for the specified part.
     * @param part the part to get the alpha for
     * @returns the alpha for the specified part,   or 0 if it hasn't been set and should be   inherited from the environment.
     */
    getAlpha(part: RenderPart): number
    /**
     * Gets the current rendering color for the specified part.
     * @param part the part to get the color for
     * @returns the color for the   specified part, or %NULL if it hasn't been set and should be   inherited from the environment.
     */
    getColor(part: RenderPart): Color | null
    /**
     * Gets the layout currently being rendered using `renderer`.
     *
     * Calling this function only makes sense from inside a subclass's
     * methods, like in its draw_shape vfunc, for example.
     *
     * The returned layout should not be modified while still being
     * rendered.
     * @returns the layout, or %NULL if   no layout is being rendered using @renderer at this time.
     */
    getLayout(): Layout | null
    /**
     * Gets the layout line currently being rendered using `renderer`.
     *
     * Calling this function only makes sense from inside a subclass's
     * methods, like in its draw_shape vfunc, for example.
     *
     * The returned layout line should not be modified while still being
     * rendered.
     * @returns the layout line, or %NULL   if no layout line is being rendered using @renderer at this time.
     */
    getLayoutLine(): LayoutLine | null
    /**
     * Gets the transformation matrix that will be applied when
     * rendering.
     *
     * See [method`Pango`.Renderer.set_matrix].
     * @returns the matrix, or %NULL if no matrix has   been set (which is the same as the identity matrix). The returned   matrix is owned by Pango and must not be modified or freed.
     */
    getMatrix(): Matrix | null
    // Has conflict: partChanged(part: RenderPart): void
    /**
     * Sets the alpha for part of the rendering.
     *
     * Note that the alpha may only be used if a color is
     * specified for `part` as well.
     * @param part the part to set the alpha for
     * @param alpha an alpha value between 1 and 65536, or 0 to unset the alpha
     */
    setAlpha(part: RenderPart, alpha: number): void
    /**
     * Sets the color for part of the rendering.
     *
     * Also see [method`Pango`.Renderer.set_alpha].
     * @param part the part to change the color of
     * @param color the new color or %NULL to unset the current color
     */
    setColor(part: RenderPart, color: Color | null): void
    /**
     * Sets the transformation matrix that will be applied when rendering.
     * @param matrix a `PangoMatrix`, or %NULL to unset any existing matrix  (No matrix set is the same as setting the identity matrix.)
     */
    setMatrix(matrix: Matrix | null): void

    // Own virtual methods of Pango-1.0.Pango.Renderer

    /**
     * Do renderer-specific initialization before drawing
     * @virtual
     */
    begin(): void
    /**
     * Draw a squiggly line that approximately covers the given rectangle
     * in the style of an underline used to indicate a spelling error.
     *
     * The width of the underline is rounded to an integer number
     * of up/down segments and the resulting rectangle is centered
     * in the original rectangle.
     *
     * This should be called while `renderer` is already active.
     * Use [method`Pango`.Renderer.activate] to activate a renderer.
     * @virtual
     * @param x X coordinate of underline, in Pango units in user coordinate system
     * @param y Y coordinate of underline, in Pango units in user coordinate system
     * @param width width of underline, in Pango units in user coordinate system
     * @param height height of underline, in Pango units in user coordinate system
     */
    drawErrorUnderline(
      x: number,
      y: number,
      width: number,
      height: number
    ): void
    /**
     * Draws a single glyph with coordinates in device space.
     * @virtual
     * @param font a `PangoFont`
     * @param glyph the glyph index of a single glyph
     * @param x X coordinate of left edge of baseline of glyph
     * @param y Y coordinate of left edge of baseline of glyph
     */
    drawGlyph(font: Font, glyph: Glyph, x: number, y: number): void
    /**
     * Draws the glyphs in `glyph_item` with the specified `PangoRenderer`,
     * embedding the text associated with the glyphs in the output if the
     * output format supports it.
     *
     * This is useful for rendering text in PDF.
     *
     * Note that this method does not handle attributes in `glyph_item`.
     * If you want colors, shapes and lines handled automatically according
     * to those attributes, you need to use pango_renderer_draw_layout_line()
     * or pango_renderer_draw_layout().
     *
     * Note that `text` is the start of the text for layout, which is then
     * indexed by `glyph_item->item->offset`.
     *
     * If `text` is %NULL, this simply calls [method`Pango`.Renderer.draw_glyphs].
     *
     * The default implementation of this method simply falls back to
     * [method`Pango`.Renderer.draw_glyphs].
     * @virtual
     * @param text the UTF-8 text that `glyph_item` refers to
     * @param glyphItem a `PangoGlyphItem`
     * @param x X position of left edge of baseline, in user space coordinates   in Pango units
     * @param y Y position of left edge of baseline, in user space coordinates   in Pango units
     */
    drawGlyphItem(
      text: string | null,
      glyphItem: GlyphItem,
      x: number,
      y: number
    ): void
    /**
     * Draws the glyphs in `glyphs` with the specified `PangoRenderer`.
     * @virtual
     * @param font a `PangoFont`
     * @param glyphs a `PangoGlyphString`
     * @param x X position of left edge of baseline, in user space coordinates   in Pango units.
     * @param y Y position of left edge of baseline, in user space coordinates   in Pango units.
     */
    drawGlyphs(font: Font, glyphs: GlyphString, x: number, y: number): void
    /**
     * Draws an axis-aligned rectangle in user space coordinates with the
     * specified `PangoRenderer`.
     *
     * This should be called while `renderer` is already active.
     * Use [method`Pango`.Renderer.activate] to activate a renderer.
     * @virtual
     * @param part type of object this rectangle is part of
     * @param x X position at which to draw rectangle, in user space coordinates   in Pango units
     * @param y Y position at which to draw rectangle, in user space coordinates   in Pango units
     * @param width width of rectangle in Pango units
     * @param height height of rectangle in Pango units
     */
    drawRectangle(
      part: RenderPart,
      x: number,
      y: number,
      width: number,
      height: number
    ): void
    /**
     * draw content for a glyph shaped with `PangoAttrShape`
     *   `x,` `y` are the coordinates of the left edge of the baseline,
     *   in user coordinates.
     * @virtual
     * @param attr
     * @param x
     * @param y
     */
    drawShape(attr: AttrShape, x: number, y: number): void
    /**
     * Draws a trapezoid with the parallel sides aligned with the X axis
     * using the given `PangoRenderer`; coordinates are in device space.
     * @virtual
     * @param part type of object this trapezoid is part of
     * @param y1 Y coordinate of top of trapezoid
     * @param x11 X coordinate of left end of top of trapezoid
     * @param x21 X coordinate of right end of top of trapezoid
     * @param y2 Y coordinate of bottom of trapezoid
     * @param x12 X coordinate of left end of bottom of trapezoid
     * @param x22 X coordinate of right end of bottom of trapezoid
     */
    drawTrapezoid(
      part: RenderPart,
      y1: number,
      x11: number,
      x21: number,
      y2: number,
      x12: number,
      x22: number
    ): void
    /**
     * Do renderer-specific cleanup after drawing
     * @virtual
     */
    end(): void
    /**
     * Informs Pango that the way that the rendering is done
     * for `part` has changed.
     *
     * This should be called if the rendering changes in a way that would
     * prevent multiple pieces being joined together into one drawing call.
     * For instance, if a subclass of `PangoRenderer` was to add a stipple
     * option for drawing underlines, it needs to call
     *
     * ```
     * pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
     * ```
     *
     * When the stipple changes or underlines with different stipples
     * might be joined together. Pango automatically calls this for
     * changes to colors. (See [method`Pango`.Renderer.set_color])
     * @virtual
     * @param part the part for which rendering has changed.
     */
    partChanged(part: RenderPart): void
    /**
     * updates the renderer for a new run
     * @virtual
     * @param run
     */
    prepareRun(run: LayoutRun): void

    // Class property signals of Pango-1.0.Pango.Renderer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `PangoRenderer` is a base class for objects that can render text
   * provided as `PangoGlyphString` or `PangoLayout`.
   *
   * By subclassing `PangoRenderer` and overriding operations such as
   * `draw_glyphs` and `draw_rectangle,` renderers for particular font
   * backends and destinations can be created.
   * @class
   */
  class Renderer extends GObject.Object {
    // Own properties of Pango-1.0.Pango.Renderer

    static name: string

    // Constructors of Pango-1.0.Pango.Renderer

    constructor(config?: Renderer.ConstructorProperties)
    _init(config?: Renderer.ConstructorProperties): void
  }

  interface Analysis {
    // Own fields of Pango-1.0.Pango.Analysis

    /**
     * unused, reserved
     * @field
     */
    shapeEngine: any
    /**
     * unused, reserved
     * @field
     */
    langEngine: any
    /**
     * the font for this segment.
     * @field
     */
    font: Font
    /**
     * the bidirectional level for this segment.
     * @field
     */
    level: number
    /**
     * the glyph orientation for this segment (A `PangoGravity`).
     * @field
     */
    gravity: number
    /**
     * boolean flags for this segment (Since: 1.16).
     * @field
     */
    flags: number
    /**
     * the detected script for this segment (A `PangoScript`) (Since: 1.18).
     * @field
     */
    script: number
    /**
     * the detected language for this segment.
     * @field
     */
    language: Language
    /**
     * extra attributes for this segment.
     * @field
     */
    extraAttrs: any[]
  }

  /**
   * The `PangoAnalysis` structure stores information about
   * the properties of a segment of text.
   * @record
   */
  class Analysis {
    // Own properties of Pango-1.0.Pango.Analysis

    static name: string
  }

  interface AttrClass {
    // Own fields of Pango-1.0.Pango.AttrClass

    /**
     * the type ID for this attribute
     * @field
     */
    type: AttrType
    /**
     * function to duplicate an attribute of this type
     *   (see [method`Pango`.Attribute.copy])
     * @field
     */
    copy: (attr: Attribute) => Attribute
    /**
     * function to free an attribute of this type
     *   (see [method`Pango`.Attribute.destroy])
     * @field
     */
    destroy: (attr: Attribute) => void
    /**
     * function to check two attributes of this type for equality
     *   (see [method`Pango`.Attribute.equal])
     * @field
     */
    equal: (attr1: Attribute, attr2: Attribute) => boolean
  }

  /**
   * The `PangoAttrClass` structure stores the type and operations for
   * a particular type of attribute.
   *
   * The functions in this structure should not be called directly. Instead,
   * one should use the wrapper functions provided for `PangoAttribute`.
   * @record
   */
  class AttrClass {
    // Own properties of Pango-1.0.Pango.AttrClass

    static name: string
  }

  interface AttrColor {
    // Own fields of Pango-1.0.Pango.AttrColor

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * the `PangoColor` which is the value of the attribute
     * @field
     */
    color: Color
  }

  /**
   * The `PangoAttrColor` structure is used to represent attributes that
   * are colors.
   * @record
   */
  class AttrColor {
    // Own properties of Pango-1.0.Pango.AttrColor

    static name: string
  }

  interface AttrFloat {
    // Own fields of Pango-1.0.Pango.AttrFloat

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * the value of the attribute
     * @field
     */
    value: number
  }

  /**
   * The `PangoAttrFloat` structure is used to represent attributes with
   * a float or double value.
   * @record
   */
  class AttrFloat {
    // Own properties of Pango-1.0.Pango.AttrFloat

    static name: string
  }

  interface AttrFontDesc {
    // Own fields of Pango-1.0.Pango.AttrFontDesc

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * the font description which is the value of this attribute
     * @field
     */
    desc: FontDescription
  }

  /**
   * The `PangoAttrFontDesc` structure is used to store an attribute that
   * sets all aspects of the font description at once.
   * @record
   */
  class AttrFontDesc {
    // Own properties of Pango-1.0.Pango.AttrFontDesc

    static name: string

    // Constructors of Pango-1.0.Pango.AttrFontDesc

    /**
     * Create a new font description attribute.
     *
     * This attribute allows setting family, style, weight, variant,
     * stretch, and size simultaneously.
     * @param desc the font description
     * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
     */
    static new(desc: FontDescription): Attribute
  }

  interface AttrFontFeatures {
    // Own fields of Pango-1.0.Pango.AttrFontFeatures

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * the features, as a string in CSS syntax
     * @field
     */
    features: string | null
  }

  /**
   * The `PangoAttrFontFeatures` structure is used to represent OpenType
   * font features as an attribute.
   * @record
   */
  class AttrFontFeatures {
    // Own properties of Pango-1.0.Pango.AttrFontFeatures

    static name: string

    // Constructors of Pango-1.0.Pango.AttrFontFeatures

    /**
     * Create a new font features tag attribute.
     *
     * You can use this attribute to select OpenType font features like small-caps,
     * alternative glyphs, ligatures, etc. for fonts that support them.
     * @param features a string with OpenType font features, with the syntax of the [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc)
     * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
     */
    static new(features: string): Attribute
  }

  interface AttrInt {
    // Own fields of Pango-1.0.Pango.AttrInt

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * the value of the attribute
     * @field
     */
    value: number
  }

  /**
   * The `PangoAttrInt` structure is used to represent attributes with
   * an integer or enumeration value.
   * @record
   */
  class AttrInt {
    // Own properties of Pango-1.0.Pango.AttrInt

    static name: string
  }

  interface AttrIterator {
    // Owm methods of Pango-1.0.Pango.AttrIterator

    /**
     * Copy a `PangoAttrIterator`.
     * @returns the newly allocated   `PangoAttrIterator`, which should be freed with   [method@Pango.AttrIterator.destroy]
     */
    copy(): AttrIterator
    /**
     * Destroy a `PangoAttrIterator` and free all associated memory.
     */
    destroy(): void
    /**
     * Find the current attribute of a particular type
     * at the iterator location.
     *
     * When multiple attributes of the same type overlap,
     * the attribute whose range starts closest to the
     * current location is used.
     * @param type the type of attribute to find
     * @returns the current   attribute of the given type, or %NULL if no attribute   of that type applies to the current location.
     */
    get(type: AttrType): Attribute | null
    /**
     * Gets a list of all attributes at the current position of the
     * iterator.
     * @returns a list of all attributes for the current range. To free   this value, call [method@Pango.Attribute.destroy] on each   value and g_slist_free() on the list.
     */
    getAttrs(): Attribute[]
    /**
     * Get the font and other attributes at the current
     * iterator position.
     * @param desc a `PangoFontDescription` to fill in with the current   values. The family name in this structure will be set using   [method`Pango`.FontDescription.set_family_static] using   values from an attribute in the `PangoAttrList` associated   with the iterator, so if you plan to keep it around, you   must call:   `pango_font_description_set_family (desc, pango_font_description_get_family (desc))`.
     */
    getFont(
      desc: FontDescription
    ): [/* language */ Language, /* extraAttrs */ Attribute[]]
    /**
     * Advance the iterator until the next change of style.
     * @returns %FALSE if the iterator is at the end   of the list, otherwise %TRUE
     */
    next(): boolean
    /**
     * Get the range of the current segment.
     *
     * Note that the stored return values are signed, not unsigned
     * like the values in `PangoAttribute`. To deal with this API
     * oversight, stored return values that wouldn't fit into
     * a signed integer are clamped to %G_MAXINT.
     */
    range(): [/* start */ number, /* end */ number]
  }

  /**
   * A `PangoAttrIterator` is used to iterate through a `PangoAttrList`.
   *
   * A new iterator is created with [method`Pango`.AttrList.get_iterator].
   * Once the iterator is created, it can be advanced through the style
   * changes in the text using [method`Pango`.AttrIterator.next]. At each
   * style change, the range of the current style segment and the attributes
   * currently in effect can be queried.
   * @record
   */
  class AttrIterator {
    // Own properties of Pango-1.0.Pango.AttrIterator

    static name: string
  }

  interface AttrLanguage {
    // Own fields of Pango-1.0.Pango.AttrLanguage

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * the `PangoLanguage` which is the value of the attribute
     * @field
     */
    value: Language
  }

  /**
   * The `PangoAttrLanguage` structure is used to represent attributes that
   * are languages.
   * @record
   */
  class AttrLanguage {
    // Own properties of Pango-1.0.Pango.AttrLanguage

    static name: string

    // Constructors of Pango-1.0.Pango.AttrLanguage

    /**
     * Create a new language tag attribute.
     * @param language language tag
     * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
     */
    static new(language: Language): Attribute
  }

  interface AttrList {
    // Owm methods of Pango-1.0.Pango.AttrList

    /**
     * Insert the given attribute into the `PangoAttrList`.
     *
     * It will replace any attributes of the same type
     * on that segment and be merged with any adjoining
     * attributes that are identical.
     *
     * This function is slower than [method`Pango`.AttrList.insert]
     * for creating an attribute list in order (potentially
     * much slower for large lists). However,
     * [method`Pango`.AttrList.insert] is not suitable for
     * continually changing a set of attributes since it
     * never removes or combines existing attributes.
     * @param attr the attribute to insert
     */
    change(attr: Attribute): void
    /**
     * Copy `list` and return an identical new list.
     * @returns the newly allocated   `PangoAttrList`, with a reference count of one,   which should be freed with [method@Pango.AttrList.unref].   Returns %NULL if @list was %NULL.
     */
    copy(): AttrList | null
    /**
     * Checks whether `list` and `other_list` contain the same
     * attributes and whether those attributes apply to the
     * same ranges.
     *
     * Beware that this will return wrong values if any list
     * contains duplicates.
     * @param otherList the other `PangoAttrList`
     * @returns %TRUE if the lists are equal, %FALSE if   they aren't
     */
    equal(otherList: AttrList): boolean
    /**
     * Given a `PangoAttrList` and callback function, removes
     * any elements of `list` for which `func` returns %TRUE and
     * inserts them into a new list.
     * @param func callback function;   returns %TRUE if an attribute should be filtered out
     * @returns the new   `PangoAttrList` or %NULL if no attributes of the   given types were found
     */
    filter(func: AttrFilterFunc): AttrList | null
    /**
     * Gets a list of all attributes in `list`.
     * @returns a list of all attributes in @list. To free this value,   call [method@Pango.Attribute.destroy] on each value and   g_slist_free() on the list.
     */
    getAttributes(): Attribute[]
    /**
     * Create a iterator initialized to the beginning of the list.
     *
     * `list` must not be modified until this iterator is freed.
     * @returns the newly allocated   `PangoAttrIterator`, which should be freed with   [method@Pango.AttrIterator.destroy]
     */
    getIterator(): AttrIterator
    /**
     * Insert the given attribute into the `PangoAttrList`.
     *
     * It will be inserted after all other attributes with a
     * matching `start_index`.
     * @param attr the attribute to insert
     */
    insert(attr: Attribute): void
    /**
     * Insert the given attribute into the `PangoAttrList`.
     *
     * It will be inserted before all other attributes with a
     * matching `start_index`.
     * @param attr the attribute to insert
     */
    insertBefore(attr: Attribute): void
    /**
     * Increase the reference count of the given attribute
     * list by one.
     * @returns The attribute list passed in
     */
    ref(): AttrList
    /**
     * This function opens up a hole in `list,` fills it
     * in with attributes from the left, and then merges
     * `other` on top of the hole.
     *
     * This operation is equivalent to stretching every attribute
     * that applies at position `pos` in `list` by an amount `len,`
     * and then calling [method`Pango`.AttrList.change] with a copy
     * of each attribute in `other` in sequence (offset in position
     * by `pos,` and limited in length to `len)`.
     *
     * This operation proves useful for, for instance, inserting
     * a pre-edit string in the middle of an edit buffer.
     *
     * For backwards compatibility, the function behaves differently
     * when `len` is 0. In this case, the attributes from `other` are
     * not imited to `len,` and are just overlayed on top of `list`.
     *
     * This mode is useful for merging two lists of attributes together.
     * @param other another `PangoAttrList`
     * @param pos the position in `list` at which to insert `other`
     * @param len the length of the spliced segment. (Note that this   must be specified since the attributes in `other` may only   be present at some subsection of this range)
     */
    splice(other: AttrList, pos: number, len: number): void
    /**
     * Serializes a `PangoAttrList` to a string.
     *
     * In the resulting string, serialized attributes are separated by newlines or commas.
     * Individual attributes are serialized to a string of the form
     *
     *   START END TYPE VALUE
     *
     * Where START and END are the indices (with -1 being accepted in place
     * of MAXUINT), TYPE is the nickname of the attribute value type, e.g.
     * _weight_ or _stretch_, and the value is serialized according to its type:
     *
     * - enum values as nick or numeric value
     * - boolean values as _true_ or _false_
     * - integers and floats as numbers
     * - strings as string, optionally quoted
     * - font features as quoted string
     * - PangoLanguage as string
     * - PangoFontDescription as serialized by [method`Pango`.FontDescription.to_string], quoted
     * - PangoColor as serialized by [method`Pango`.Color.to_string]
     *
     * Examples:
     *
     * ```
     * 0 10 foreground red, 5 15 weight bold, 0 200 font-desc "Sans 10"
     * ```
     *
     * ```
     * 0 -1 weight 700
     * 0 100 family Times
     * ```
     *
     * To parse the returned value, use [func`Pango`.AttrList.from_string].
     *
     * Note that shape attributes can not be serialized.
     * @returns a newly allocated string
     */
    toString(): string | null
    /**
     * Decrease the reference count of the given attribute
     * list by one.
     *
     * If the result is zero, free the attribute list
     * and the attributes it contains.
     */
    unref(): void
    /**
     * Update indices of attributes in `list` for a change in the
     * text they refer to.
     *
     * The change that this function applies is removing `remove`
     * bytes at position `pos` and inserting `add` bytes instead.
     *
     * Attributes that fall entirely in the (`pos,` `pos` + `remove)`
     * range are removed.
     *
     * Attributes that start or end inside the (`pos,` `pos` + `remove)`
     * range are shortened to reflect the removal.
     *
     * Attributes start and end positions are updated if they are
     * behind `pos` + `remove`.
     * @param pos the position of the change
     * @param remove the number of removed bytes
     * @param add the number of added bytes
     */
    update(pos: number, remove: number, add: number): void
  }

  /**
   * A `PangoAttrList` represents a list of attributes that apply to a section
   * of text.
   *
   * The attributes in a `PangoAttrList` are, in general, allowed to overlap in
   * an arbitrary fashion. However, if the attributes are manipulated only through
   * [method`Pango`.AttrList.change], the overlap between properties will meet
   * stricter criteria.
   *
   * Since the `PangoAttrList` structure is stored as a linear list, it is not
   * suitable for storing attributes for large amounts of text. In general, you
   * should not use a single `PangoAttrList` for more than one paragraph of text.
   * @record
   */
  class AttrList {
    // Own properties of Pango-1.0.Pango.AttrList

    static name: string

    // Constructors of Pango-1.0.Pango.AttrList

    /**
     * Create a new empty attribute list with a reference
     * count of one.
     * @constructor
     * @returns the newly allocated   `PangoAttrList`, which should be freed with   [method@Pango.AttrList.unref]
     */
    constructor()
    /**
     * Create a new empty attribute list with a reference
     * count of one.
     * @constructor
     * @returns the newly allocated   `PangoAttrList`, which should be freed with   [method@Pango.AttrList.unref]
     */
    static new(): AttrList
    /**
     * Deserializes a `PangoAttrList` from a string.
     *
     * This is the counterpart to [method`Pango`.AttrList.to_string].
     * See that functions for details about the format.
     * @param text a string
     * @returns a new `PangoAttrList`
     */
    static fromString(text: string): AttrList | null
  }

  interface AttrShape {
    // Own fields of Pango-1.0.Pango.AttrShape

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * the ink rectangle to restrict to
     * @field
     */
    inkRect: Rectangle
    /**
     * the logical rectangle to restrict to
     * @field
     */
    logicalRect: Rectangle
    /**
     * user data set (see [func`Pango`.AttrShape.new_with_data])
     * @field
     */
    data: any
    /**
     * copy function for the user data
     * @field
     */
    copyFunc: AttrDataCopyFunc
    /**
     * destroy function for the user data
     * @field
     */
    destroyFunc: GLib.DestroyNotify
  }

  /**
   * The `PangoAttrShape` structure is used to represent attributes which
   * impose shape restrictions.
   * @record
   */
  class AttrShape {
    // Own properties of Pango-1.0.Pango.AttrShape

    static name: string

    // Constructors of Pango-1.0.Pango.AttrShape

    /**
     * Create a new shape attribute.
     *
     * A shape is used to impose a particular ink and logical
     * rectangle on the result of shaping a particular glyph.
     * This might be used, for instance, for embedding a picture
     * or a widget inside a `PangoLayout`.
     * @param inkRect ink rectangle to assign to each character
     * @param logicalRect logical rectangle to assign to each character
     * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
     */
    static new(inkRect: Rectangle, logicalRect: Rectangle): Attribute
    /**
     * Creates a new shape attribute.
     *
     * Like [func`Pango`.AttrShape.new], but a user data pointer
     * is also provided; this pointer can be accessed when later
     * rendering the glyph.
     * @param inkRect ink rectangle to assign to each character
     * @param logicalRect logical rectangle to assign to each character
     * @param data user data pointer
     * @param copyFunc function to copy `data` when the   attribute is copied. If %NULL, `data` is simply copied   as a pointer
     * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
     */
    static newWithData(
      inkRect: Rectangle,
      logicalRect: Rectangle,
      data: any | null,
      copyFunc: AttrDataCopyFunc | null
    ): Attribute
  }

  interface AttrSize {
    // Own fields of Pango-1.0.Pango.AttrSize

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * size of font, in units of 1/%PANGO_SCALE of a point (for
     *   %PANGO_ATTR_SIZE) or of a device unit (for %PANGO_ATTR_ABSOLUTE_SIZE)
     * @field
     */
    size: number
    /**
     * whether the font size is in device units or points.
     *   This field is only present for compatibility with Pango-1.8.0
     *   (%PANGO_ATTR_ABSOLUTE_SIZE was added in 1.8.1); and always will
     *   be %FALSE for %PANGO_ATTR_SIZE and %TRUE for %PANGO_ATTR_ABSOLUTE_SIZE.
     * @field
     */
    absolute: number
  }

  /**
   * The `PangoAttrSize` structure is used to represent attributes which
   * set font size.
   * @record
   */
  class AttrSize {
    // Own properties of Pango-1.0.Pango.AttrSize

    static name: string

    // Constructors of Pango-1.0.Pango.AttrSize

    /**
     * Create a new font-size attribute in fractional points.
     * @param size the font size, in %PANGO_SCALE-ths of a point
     * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
     */
    static new(size: number): Attribute
    /**
     * Create a new font-size attribute in device units.
     * @param size the font size, in %PANGO_SCALE-ths of a device unit
     * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
     */
    static newAbsolute(size: number): Attribute
  }

  interface AttrString {
    // Own fields of Pango-1.0.Pango.AttrString

    /**
     * the common portion of the attribute
     * @field
     */
    attr: Attribute
    /**
     * the string which is the value of the attribute
     * @field
     */
    value: string | null
  }

  /**
   * The `PangoAttrString` structure is used to represent attributes with
   * a string value.
   * @record
   */
  class AttrString {
    // Own properties of Pango-1.0.Pango.AttrString

    static name: string
  }

  interface Attribute {
    // Own fields of Pango-1.0.Pango.Attribute

    /**
     * the class structure holding information about the type of the attribute
     * @field
     */
    klass: AttrClass
    /**
     * the start index of the range (in bytes).
     * @field
     */
    startIndex: number
    /**
     * end index of the range (in bytes). The character at this index
     *   is not included in the range.
     * @field
     */
    endIndex: number

    // Owm methods of Pango-1.0.Pango.Attribute

    /**
     * Returns the attribute cast to `PangoAttrColor`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrColor`,   or %NULL if it's not a color attribute
     */
    asColor(): AttrColor | null
    /**
     * Returns the attribute cast to `PangoAttrFloat`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrFloat`,   or %NULL if it's not a floating point attribute
     */
    asFloat(): AttrFloat | null
    /**
     * Returns the attribute cast to `PangoAttrFontDesc`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrFontDesc`,   or %NULL if it's not a font description attribute
     */
    asFontDesc(): AttrFontDesc | null
    /**
     * Returns the attribute cast to `PangoAttrFontFeatures`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrFontFeatures`,   or %NULL if it's not a font features attribute
     */
    asFontFeatures(): AttrFontFeatures | null
    /**
     * Returns the attribute cast to `PangoAttrInt`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrInt`,   or %NULL if it's not an integer attribute
     */
    asInt(): AttrInt | null
    /**
     * Returns the attribute cast to `PangoAttrLanguage`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrLanguage`,   or %NULL if it's not a language attribute
     */
    asLanguage(): AttrLanguage | null
    /**
     * Returns the attribute cast to `PangoAttrShape`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrShape`,   or %NULL if it's not a shape attribute
     */
    asShape(): AttrShape | null
    /**
     * Returns the attribute cast to `PangoAttrSize`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrSize`,   or NULL if it's not a size attribute
     */
    asSize(): AttrSize | null
    /**
     * Returns the attribute cast to `PangoAttrString`.
     *
     * This is mainly useful for language bindings.
     * @returns The attribute as `PangoAttrString`,   or %NULL if it's not a string attribute
     */
    asString(): AttrString | null
    /**
     * Make a copy of an attribute.
     * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy].
     */
    copy(): Attribute
    /**
     * Destroy a `PangoAttribute` and free all associated memory.
     */
    destroy(): void
    /**
     * Compare two attributes for equality.
     *
     * This compares only the actual value of the two
     * attributes and not the ranges that the attributes
     * apply to.
     * @param attr2 another `PangoAttribute`
     * @returns %TRUE if the two attributes have the same value
     */
    equal(attr2: Attribute): boolean
    /**
     * Initializes `attr'`s klass to `klass,` it's start_index to
     * %PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING and end_index to
     * %PANGO_ATTR_INDEX_TO_TEXT_END such that the attribute applies
     * to the entire text by default.
     * @param klass a `PangoAttrClass`
     */
    init(klass: AttrClass): void
  }

  /**
   * The `PangoAttribute` structure represents the common portions of all
   * attributes.
   *
   * Particular types of attributes include this structure as their initial
   * portion. The common portion of the attribute holds the range to which
   * the value in the type-specific part of the attribute applies and should
   * be initialized using [method`Pango`.Attribute.init]. By default, an attribute
   * will have an all-inclusive range of [0,%G_MAXUINT].
   * @record
   */
  class Attribute {
    // Own properties of Pango-1.0.Pango.Attribute

    static name: string
  }

  interface Color {
    // Own fields of Pango-1.0.Pango.Color

    /**
     * value of red component
     * @field
     */
    red: number
    /**
     * value of green component
     * @field
     */
    green: number
    /**
     * value of blue component
     * @field
     */
    blue: number

    // Owm methods of Pango-1.0.Pango.Color

    /**
     * Creates a copy of `src`.
     *
     * The copy should be freed with [method`Pango`.Color.free].
     * Primarily used by language bindings, not that useful
     * otherwise (since colors can just be copied by assignment
     * in C).
     * @returns the newly allocated `PangoColor`,   which should be freed with [method@Pango.Color.free]
     */
    copy(): Color | null
    /**
     * Frees a color allocated by [method`Pango`.Color.copy].
     */
    free(): void
    /**
     * Fill in the fields of a color from a string specification.
     *
     * The string can either one of a large set of standard names.
     * (Taken from the CSS Color [specification](https://www.w3.org/TR/css-color-4/#named-colors),
     * or it can be a value in the form `#rgb`, `#rrggbb`,
     * `#rrrgggbbb` or `#rrrrggggbbbb`, where `r`, `g` and `b`
     * are hex digits of the red, green, and blue components
     * of the color, respectively. (White in the four forms is
     * `#fff`, `#ffffff`, `#fffffffff` and `#ffffffffffff`.)
     * @param spec a string specifying the new color
     * @returns %TRUE if parsing of the specifier succeeded,   otherwise %FALSE
     */
    parse(spec: string): boolean
    /**
     * Fill in the fields of a color from a string specification.
     *
     * The string can either one of a large set of standard names.
     * (Taken from the CSS Color [specification](https://www.w3.org/TR/css-color-4/#named-colors),
     * or it can be a hexadecimal value in the form `#rgb`,
     * `#rrggbb`, `#rrrgggbbb` or `#rrrrggggbbbb` where `r`, `g`
     * and `b` are hex digits of the red, green, and blue components
     * of the color, respectively. (White in the four forms is
     * `#fff`, `#ffffff`, `#fffffffff` and `#ffffffffffff`.)
     *
     * Additionally, parse strings of the form `#rgba`, `#rrggbbaa`,
     * `#rrrrggggbbbbaaaa`, if `alpha` is not %NULL, and set `alpha`
     * to the value specified by the hex digits for `a`. If no alpha
     * component is found in `spec,` `alpha` is set to 0xffff (for a
     * solid color).
     * @param spec a string specifying the new color
     * @returns %TRUE if parsing of the specifier succeeded,   otherwise %FALSE
     */
    parseWithAlpha(spec: string): [/* returnType */ boolean, /* alpha */ number]
    /**
     * Returns a textual specification of `color`.
     *
     * The string is in the hexadecimal form `#rrrrggggbbbb`,
     * where `r`, `g` and `b` are hex digits representing the
     * red, green, and blue components respectively.
     * @returns a newly-allocated text string that must   be freed with g_free().
     */
    toString(): string | null
  }

  /**
   * The `PangoColor` structure is used to
   * represent a color in an uncalibrated RGB color-space.
   * @record
   */
  class Color {
    // Own properties of Pango-1.0.Pango.Color

    static name: string
  }

  interface ContextClass {}

  abstract class ContextClass {
    // Own properties of Pango-1.0.Pango.ContextClass

    static name: string
  }

  interface FontClass {
    // Own fields of Pango-1.0.Pango.FontClass

    parentClass: GObject.ObjectClass
    describe: (font: Font) => FontDescription
    getCoverage: (font: Font, language: Language) => Coverage
    getGlyphExtents: (
      font: Font | null,
      glyph: Glyph
    ) => [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    getMetrics: (font: Font | null, language: Language | null) => FontMetrics
    getFontMap: (font: Font | null) => FontMap | null
    describeAbsolute: (font: Font) => FontDescription
    getFeatures: (
      font: Font,
      numFeatures: number
    ) => [/* features */ HarfBuzz.feature_t[], /* numFeatures */ number]
    createHbFont: (font: Font) => HarfBuzz.font_t
  }

  abstract class FontClass {
    // Own properties of Pango-1.0.Pango.FontClass

    static name: string
  }

  interface FontDescription {
    // Owm methods of Pango-1.0.Pango.FontDescription

    /**
     * Determines if the style attributes of `new_match` are a closer match
     * for `desc` than those of `old_match` are, or if `old_match` is %NULL,
     * determines if `new_match` is a match at all.
     *
     * Approximate matching is done for weight and style; other style attributes
     * must match exactly. Style attributes are all attributes other than family
     * and size-related attributes. Approximate matching for style considers
     * %PANGO_STYLE_OBLIQUE and %PANGO_STYLE_ITALIC as matches, but not as good
     * a match as when the styles are equal.
     *
     * Note that `old_match` must match `desc`.
     * @param oldMatch a `PangoFontDescription`, or %NULL
     * @param newMatch a `PangoFontDescription`
     * @returns %TRUE if @new_match is a better match
     */
    betterMatch(
      oldMatch: FontDescription | null,
      newMatch: FontDescription
    ): boolean
    /**
     * Make a copy of a `PangoFontDescription`.
     * @returns the newly allocated `PangoFontDescription`,   which should be freed with [method@Pango.FontDescription.free],   or %NULL if @desc was %NULL.
     */
    copy(): FontDescription | null
    /**
     * Make a copy of a `PangoFontDescription`, but don't duplicate
     * allocated fields.
     *
     * This is like [method`Pango`.FontDescription.copy], but only a shallow
     * copy is made of the family name and other allocated fields. The result
     * can only be used until `desc` is modified or freed. This is meant
     * to be used when the copy is only needed temporarily.
     * @returns the newly allocated `PangoFontDescription`,   which should be freed with [method@Pango.FontDescription.free],   or %NULL if @desc was %NULL.
     */
    copyStatic(): FontDescription | null
    /**
     * Compares two font descriptions for equality.
     *
     * Two font descriptions are considered equal if the fonts they describe
     * are provably identical. This means that their masks do not have to match,
     * as long as other fields are all the same. (Two font descriptions may
     * result in identical fonts being loaded, but still compare %FALSE.)
     * @param desc2 another `PangoFontDescription`
     * @returns %TRUE if the two font descriptions are identical,   %FALSE otherwise.
     */
    equal(desc2: FontDescription): boolean
    /**
     * Frees a font description.
     */
    free(): void
    /**
     * Gets the family name field of a font description.
     *
     * See [method`Pango`.FontDescription.set_family].
     * @returns the family name field for the   font description, or %NULL if not previously set. This has the same   life-time as the font description itself and should not be freed.
     */
    getFamily(): string | null
    /**
     * Gets the gravity field of a font description.
     *
     * See [method`Pango`.FontDescription.set_gravity].
     * @returns the gravity field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to find out   if the field was explicitly set or not.
     */
    getGravity(): Gravity
    /**
     * Determines which fields in a font description have been set.
     * @returns a bitmask with bits set corresponding to the   fields in @desc that have been set.
     */
    getSetFields(): FontMask
    /**
     * Gets the size field of a font description.
     *
     * See [method`Pango`.FontDescription.set_size].
     * @returns the size field for the font description in points   or device units. You must call   [method@Pango.FontDescription.get_size_is_absolute] to find out   which is the case. Returns 0 if the size field has not previously   been set or it has been set to 0 explicitly.   Use [method@Pango.FontDescription.get_set_fields] to find out   if the field was explicitly set or not.
     */
    getSize(): number
    /**
     * Determines whether the size of the font is in points (not absolute)
     * or device units (absolute).
     *
     * See [method`Pango`.FontDescription.set_size]
     * and [method`Pango`.FontDescription.set_absolute_size].
     * @returns whether the size for the font description is in   points or device units. Use [method@Pango.FontDescription.get_set_fields]   to find out if the size field of the font description was explicitly   set or not.
     */
    getSizeIsAbsolute(): boolean
    /**
     * Gets the stretch field of a font description.
     *
     * See [method`Pango`.FontDescription.set_stretch].
     * @returns the stretch field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to find   out if the field was explicitly set or not.
     */
    getStretch(): Stretch
    /**
     * Gets the style field of a `PangoFontDescription`.
     *
     * See [method`Pango`.FontDescription.set_style].
     * @returns the style field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to   find out if the field was explicitly set or not.
     */
    getStyle(): Style
    /**
     * Gets the variant field of a `PangoFontDescription`.
     *
     * See [method`Pango`.FontDescription.set_variant].
     * @returns the variant field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to find   out if the field was explicitly set or not.
     */
    getVariant(): Variant
    /**
     * Gets the variations field of a font description.
     *
     * See [method`Pango`.FontDescription.set_variations].
     * @returns the variations field for the font   description, or %NULL if not previously set. This has the same   life-time as the font description itself and should not be freed.
     */
    getVariations(): string | null
    /**
     * Gets the weight field of a font description.
     *
     * See [method`Pango`.FontDescription.set_weight].
     * @returns the weight field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to find   out if the field was explicitly set or not.
     */
    getWeight(): Weight
    /**
     * Computes a hash of a `PangoFontDescription` structure.
     *
     * This is suitable to be used, for example, as an argument
     * to g_hash_table_new(). The hash value is independent of `desc->`mask.
     * @returns the hash value.
     */
    hash(): number
    /**
     * Merges the fields that are set in `desc_to_merge` into the fields in
     * `desc`.
     *
     * If `replace_existing` is %FALSE, only fields in `desc` that
     * are not already set are affected. If %TRUE, then fields that are
     * already set will be replaced as well.
     *
     * If `desc_to_merge` is %NULL, this function performs nothing.
     * @param descToMerge the `PangoFontDescription` to merge from,   or %NULL
     * @param replaceExisting if %TRUE, replace fields in `desc` with the   corresponding values from `desc_to_merge,` even if they   are already exist.
     */
    merge(descToMerge: FontDescription | null, replaceExisting: boolean): void
    /**
     * Merges the fields that are set in `desc_to_merge` into the fields in
     * `desc,` without copying allocated fields.
     *
     * This is like [method`Pango`.FontDescription.merge], but only a shallow copy
     * is made of the family name and other allocated fields. `desc` can only
     * be used until `desc_to_merge` is modified or freed. This is meant to
     * be used when the merged font description is only needed temporarily.
     * @param descToMerge the `PangoFontDescription` to merge from
     * @param replaceExisting if %TRUE, replace fields in `desc` with the   corresponding values from `desc_to_merge,` even if they   are already exist.
     */
    mergeStatic(descToMerge: FontDescription, replaceExisting: boolean): void
    /**
     * Sets the size field of a font description, in device units.
     *
     * This is mutually exclusive with [method`Pango`.FontDescription.set_size]
     * which sets the font size in points.
     * @param size the new size, in Pango units. There are %PANGO_SCALE Pango units   in one device unit. For an output backend where a device unit is a pixel,   a `size` value of 10 * PANGO_SCALE gives a 10 pixel font.
     */
    setAbsoluteSize(size: number): void
    /**
     * Sets the family name field of a font description.
     *
     * The family
     * name represents a family of related font styles, and will
     * resolve to a particular `PangoFontFamily`. In some uses of
     * `PangoFontDescription`, it is also possible to use a comma
     * separated list of family names for this field.
     * @param family a string representing the family name.
     */
    setFamily(family: string): void
    /**
     * Sets the family name field of a font description, without copying the string.
     *
     * This is like [method`Pango`.FontDescription.set_family], except that no
     * copy of `family` is made. The caller must make sure that the
     * string passed in stays around until `desc` has been freed or the
     * name is set again. This function can be used if `family` is a static
     * string such as a C string literal, or if `desc` is only needed temporarily.
     * @param family a string representing the family name
     */
    setFamilyStatic(family: string): void
    /**
     * Sets the gravity field of a font description.
     *
     * The gravity field
     * specifies how the glyphs should be rotated. If `gravity` is
     * %PANGO_GRAVITY_AUTO, this actually unsets the gravity mask on
     * the font description.
     *
     * This function is seldom useful to the user. Gravity should normally
     * be set on a `PangoContext`.
     * @param gravity the gravity for the font description.
     */
    setGravity(gravity: Gravity): void
    /**
     * Sets the size field of a font description in fractional points.
     *
     * This is mutually exclusive with
     * [method`Pango`.FontDescription.set_absolute_size].
     * @param size the size of the font in points, scaled by %PANGO_SCALE.   (That is, a `size` value of 10 * PANGO_SCALE is a 10 point font.   The conversion factor between points and device units depends on   system configuration and the output device. For screen display, a   logical DPI of 96 is common, in which case a 10 point font corresponds   to a 10 * (96 / 72) = 13.3 pixel font.   Use [method`Pango`.FontDescription.set_absolute_size] if you need   a particular size in device units.
     */
    setSize(size: number): void
    /**
     * Sets the stretch field of a font description.
     *
     * The [enum`Pango`.Stretch] field specifies how narrow or
     * wide the font should be.
     * @param stretch the stretch for the font description
     */
    setStretch(stretch: Stretch): void
    /**
     * Sets the style field of a `PangoFontDescription`.
     *
     * The [enum`Pango`.Style] enumeration describes whether the font is
     * slanted and the manner in which it is slanted; it can be either
     * %PANGO_STYLE_NORMAL, %PANGO_STYLE_ITALIC, or %PANGO_STYLE_OBLIQUE.
     *
     * Most fonts will either have a italic style or an oblique style,
     * but not both, and font matching in Pango will match italic
     * specifications with oblique fonts and vice-versa if an exact
     * match is not found.
     * @param style the style for the font description
     */
    setStyle(style: Style): void
    /**
     * Sets the variant field of a font description.
     *
     * The [enum`Pango`.Variant] can either be %PANGO_VARIANT_NORMAL
     * or %PANGO_VARIANT_SMALL_CAPS.
     * @param variant the variant type for the font description.
     */
    setVariant(variant: Variant): void
    /**
     * Sets the variations field of a font description.
     *
     * OpenType font variations allow to select a font instance by
     * specifying values for a number of axes, such as width or weight.
     *
     * The format of the variations string is
     *
     *     AXIS1=VALUE,AXIS2=VALUE...
     *
     * with each AXIS a 4 character tag that identifies a font axis,
     * and each VALUE a floating point number. Unknown axes are ignored,
     * and values are clamped to their allowed range.
     *
     * Pango does not currently have a way to find supported axes of
     * a font. Both harfbuzz and freetype have API for this. See
     * for example [hb_ot_var_get_axis_infos](https://harfbuzz.github.io/harfbuzz-hb-ot-var.html#hb-ot-var-get-axis-infos).
     * @param variations a string representing the variations
     */
    setVariations(variations: string | null): void
    /**
     * Sets the variations field of a font description.
     *
     * This is like [method`Pango`.FontDescription.set_variations], except
     * that no copy of `variations` is made. The caller must make sure that
     * the string passed in stays around until `desc` has been freed
     * or the name is set again. This function can be used if
     * `variations` is a static string such as a C string literal,
     * or if `desc` is only needed temporarily.
     * @param variations a string representing the variations
     */
    setVariationsStatic(variations: string): void
    /**
     * Sets the weight field of a font description.
     *
     * The weight field
     * specifies how bold or light the font should be. In addition
     * to the values of the [enum`Pango`.Weight] enumeration, other
     * intermediate numeric values are possible.
     * @param weight the weight for the font description.
     */
    setWeight(weight: Weight): void
    /**
     * Creates a filename representation of a font description.
     *
     * The filename is identical to the result from calling
     * [method`Pango`.FontDescription.to_string], but with underscores
     * instead of characters that are untypical in filenames, and in
     * lower case only.
     * @returns a new string that must be freed with g_free().
     */
    toFilename(): string | null
    /**
     * Creates a string representation of a font description.
     *
     * See [func`Pango`.FontDescription.from_string] for a description
     * of the format of the string representation. The family list in
     * the string description will only have a terminating comma if
     * the last word of the list is a valid style option.
     * @returns a new string that must be freed with g_free().
     */
    toString(): string | null
    /**
     * Unsets some of the fields in a `PangoFontDescription`.
     *
     * The unset fields will get back to their default values.
     * @param toUnset bitmask of fields in the `desc` to unset.
     */
    unsetFields(toUnset: FontMask): void
  }

  /**
   * A `PangoFontDescription` describes a font in an implementation-independent
   * manner.
   *
   * `PangoFontDescription` structures are used both to list what fonts are
   * available on the system and also for specifying the characteristics of
   * a font to load.
   * @record
   */
  class FontDescription {
    // Own properties of Pango-1.0.Pango.FontDescription

    static name: string

    // Constructors of Pango-1.0.Pango.FontDescription

    /**
     * Creates a new font description structure with all fields unset.
     * @constructor
     * @returns the newly allocated `PangoFontDescription`,   which should be freed using [method@Pango.FontDescription.free].
     */
    constructor()
    /**
     * Creates a new font description structure with all fields unset.
     * @constructor
     * @returns the newly allocated `PangoFontDescription`,   which should be freed using [method@Pango.FontDescription.free].
     */
    static new(): FontDescription
    /**
     * Creates a new font description from a string representation.
     *
     * The string must have the form
     *
     *     "\[FAMILY-LIST] \[STYLE-OPTIONS] \[SIZE] \[VARIATIONS]",
     *
     * where FAMILY-LIST is a comma-separated list of families optionally
     * terminated by a comma, STYLE_OPTIONS is a whitespace-separated list
     * of words where each word describes one of style, variant, weight,
     * stretch, or gravity, and SIZE is a decimal number (size in points)
     * or optionally followed by the unit modifier "px" for absolute size.
     * VARIATIONS is a comma-separated list of font variation
     * specifications of the form "\`axis=`value" (the = sign is optional).
     *
     * The following words are understood as styles:
     * "Normal", "Roman", "Oblique", "Italic".
     *
     * The following words are understood as variants:
     * "Small-Caps", "All-Small-Caps", "Petite-Caps", "All-Petite-Caps",
     * "Unicase", "Title-Caps".
     *
     * The following words are understood as weights:
     * "Thin", "Ultra-Light", "Extra-Light", "Light", "Semi-Light",
     * "Demi-Light", "Book", "Regular", "Medium", "Semi-Bold", "Demi-Bold",
     * "Bold", "Ultra-Bold", "Extra-Bold", "Heavy", "Black", "Ultra-Black",
     * "Extra-Black".
     *
     * The following words are understood as stretch values:
     * "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed",
     * "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded".
     *
     * The following words are understood as gravity values:
     * "Not-Rotated", "South", "Upside-Down", "North", "Rotated-Left",
     * "East", "Rotated-Right", "West".
     *
     * Any one of the options may be absent. If FAMILY-LIST is absent, then
     * the family_name field of the resulting font description will be
     * initialized to %NULL. If STYLE-OPTIONS is missing, then all style
     * options will be set to the default values. If SIZE is missing, the
     * size in the resulting font description will be set to 0.
     *
     * A typical example:
     *
     *     "Cantarell Italic Light 15 \`wght=`200"
     * @param str string representation of a font description.
     * @returns a new `PangoFontDescription`.
     */
    static fromString(str: string): FontDescription
  }

  interface FontFaceClass {
    // Own fields of Pango-1.0.Pango.FontFaceClass

    parentClass: GObject.ObjectClass
    getFaceName: (face: FontFace) => string
    describe: (face: FontFace) => FontDescription
    listSizes: (face: FontFace) => /* sizes */ number[] | null
    isSynthesized: (face: FontFace) => boolean
    getFamily: (face: FontFace) => FontFamily
  }

  abstract class FontFaceClass {
    // Own properties of Pango-1.0.Pango.FontFaceClass

    static name: string
  }

  interface FontFamilyClass {
    // Own fields of Pango-1.0.Pango.FontFamilyClass

    parentClass: GObject.ObjectClass
    listFaces: (family: FontFamily) => /* faces */ FontFace[]
    getName: (family: FontFamily) => string
    isMonospace: (family: FontFamily) => boolean
    isVariable: (family: FontFamily) => boolean
    getFace: (family: FontFamily, name: string | null) => FontFace | null
  }

  abstract class FontFamilyClass {
    // Own properties of Pango-1.0.Pango.FontFamilyClass

    static name: string
  }

  interface FontMapClass {
    // Own fields of Pango-1.0.Pango.FontMapClass

    /**
     * parent `GObjectClass`
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * a function to load a font with a given description. See
     * pango_font_map_load_font().
     * @field
     */
    loadFont: (
      fontmap: FontMap,
      context: Context,
      desc: FontDescription
    ) => Font | null
    /**
     * A function to list available font families. See
     * pango_font_map_list_families().
     * @field
     */
    listFamilies: (fontmap: FontMap) => /* families */ FontFamily[]
    /**
     * a function to load a fontset with a given given description
     * suitable for a particular language. See pango_font_map_load_fontset().
     * @field
     */
    loadFontset: (
      fontmap: FontMap,
      context: Context,
      desc: FontDescription,
      language: Language
    ) => Fontset | null
    /**
     * the type of rendering-system-dependent engines that
     * can handle fonts of this fonts loaded with this fontmap.
     * @field
     */
    shapeEngineType: string
    /**
     * a function to get the serial number of the fontmap.
     * See pango_font_map_get_serial().
     * @field
     */
    getSerial: (fontmap: FontMap) => number
    /**
     * See pango_font_map_changed()
     * @field
     */
    changed: (fontmap: FontMap) => void
    getFamily: (fontmap: FontMap, name: string) => FontFamily
  }

  /**
   * The `PangoFontMapClass` structure holds the virtual functions for
   * a particular `PangoFontMap` implementation.
   * @record
   */
  abstract class FontMapClass {
    // Own properties of Pango-1.0.Pango.FontMapClass

    static name: string
  }

  interface FontMetrics {
    // Owm methods of Pango-1.0.Pango.FontMetrics

    /**
     * Gets the approximate character width for a font metrics structure.
     *
     * This is merely a representative value useful, for example, for
     * determining the initial size for a window. Actual characters in
     * text will be wider and narrower than this.
     * @returns the character width, in Pango units.
     */
    getApproximateCharWidth(): number
    /**
     * Gets the approximate digit width for a font metrics structure.
     *
     * This is merely a representative value useful, for example, for
     * determining the initial size for a window. Actual digits in
     * text can be wider or narrower than this, though this value
     * is generally somewhat more accurate than the result of
     * pango_font_metrics_get_approximate_char_width() for digits.
     * @returns the digit width, in Pango units.
     */
    getApproximateDigitWidth(): number
    /**
     * Gets the ascent from a font metrics structure.
     *
     * The ascent is the distance from the baseline to the logical top
     * of a line of text. (The logical top may be above or below the top
     * of the actual drawn ink. It is necessary to lay out the text to
     * figure where the ink will be.)
     * @returns the ascent, in Pango units.
     */
    getAscent(): number
    /**
     * Gets the descent from a font metrics structure.
     *
     * The descent is the distance from the baseline to the logical bottom
     * of a line of text. (The logical bottom may be above or below the
     * bottom of the actual drawn ink. It is necessary to lay out the text
     * to figure where the ink will be.)
     * @returns the descent, in Pango units.
     */
    getDescent(): number
    /**
     * Gets the line height from a font metrics structure.
     *
     * The line height is the recommended distance between successive
     * baselines in wrapped text using this font.
     *
     * If the line height is not available, 0 is returned.
     * @returns the height, in Pango units
     */
    getHeight(): number
    /**
     * Gets the suggested position to draw the strikethrough.
     *
     * The value returned is the distance *above* the
     * baseline of the top of the strikethrough.
     * @returns the suggested strikethrough position, in Pango units.
     */
    getStrikethroughPosition(): number
    /**
     * Gets the suggested thickness to draw for the strikethrough.
     * @returns the suggested strikethrough thickness, in Pango units.
     */
    getStrikethroughThickness(): number
    /**
     * Gets the suggested position to draw the underline.
     *
     * The value returned is the distance *above* the baseline of the top
     * of the underline. Since most fonts have underline positions beneath
     * the baseline, this value is typically negative.
     * @returns the suggested underline position, in Pango units.
     */
    getUnderlinePosition(): number
    /**
     * Gets the suggested thickness to draw for the underline.
     * @returns the suggested underline thickness, in Pango units.
     */
    getUnderlineThickness(): number
    /**
     * Increase the reference count of a font metrics structure by one.
     * @returns @metrics
     */
    ref(): FontMetrics | null
    /**
     * Decrease the reference count of a font metrics structure by one.
     *
     * If the result is zero, frees the structure and any associated memory.
     */
    unref(): void
  }

  /**
   * A `PangoFontMetrics` structure holds the overall metric information
   * for a font.
   *
   * The information in a `PangoFontMetrics` structure may be restricted
   * to a script. The fields of this structure are private to implementations
   * of a font backend. See the documentation of the corresponding getters
   * for documentation of their meaning.
   *
   * For an overview of the most important metrics, see:
   *
   * <picture>
   *   <source srcset="fontmetrics-dark.png" media="(prefers-color-scheme: dark)">
   *   <img alt="Font metrics" src="fontmetrics-light.png">
   * </picture>
   * @record
   */
  class FontMetrics {
    // Own properties of Pango-1.0.Pango.FontMetrics

    static name: string
  }

  interface FontsetClass {
    // Own fields of Pango-1.0.Pango.FontsetClass

    /**
     * parent `GObjectClass`
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * a function to get the font in the fontset that contains the
     *   best glyph for the given Unicode character; see [method`Pango`.Fontset.get_font]
     * @field
     */
    getFont: (fontset: Fontset, wc: number) => Font
    /**
     * a function to get overall metric information for the fonts
     *   in the fontset; see [method`Pango`.Fontset.get_metrics]
     * @field
     */
    getMetrics: (fontset: Fontset) => FontMetrics
    /**
     * a function to get the language of the fontset.
     * @field
     */
    getLanguage: (fontset: Fontset) => Language
    /**
     * a function to loop over the fonts in the fontset. See
     *   [method`Pango`.Fontset.foreach]
     * @field
     */
    foreach: (fontset: Fontset, func: FontsetForeachFunc) => void
  }

  /**
   * The `PangoFontsetClass` structure holds the virtual functions for
   * a particular `PangoFontset` implementation.
   * @record
   */
  abstract class FontsetClass {
    // Own properties of Pango-1.0.Pango.FontsetClass

    static name: string
  }

  interface FontsetSimpleClass {}

  abstract class FontsetSimpleClass {
    // Own properties of Pango-1.0.Pango.FontsetSimpleClass

    static name: string
  }

  interface GlyphGeometry {
    // Own fields of Pango-1.0.Pango.GlyphGeometry

    /**
     * the logical width to use for the the character.
     * @field
     */
    width: GlyphUnit
    /**
     * horizontal offset from nominal character position.
     * @field
     */
    xOffset: GlyphUnit
    /**
     * vertical offset from nominal character position.
     * @field
     */
    yOffset: GlyphUnit
  }

  /**
   * The `PangoGlyphGeometry` structure contains width and positioning
   * information for a single glyph.
   *
   * Note that `width` is not guaranteed to be the same as the glyph
   * extents. Kerning and other positioning applied during shaping will
   * affect both the `width` and the `x_offset` for the glyphs in the
   * glyph string that results from shaping.
   *
   * The information in this struct is intended for rendering the glyphs,
   * as follows:
   *
   * 1. Assume the current point is (x, y)
   * 2. Render the current glyph at (x + x_offset, y + y_offset),
   * 3. Advance the current point to (x + width, y)
   * 4. Render the next glyph
   * @record
   */
  class GlyphGeometry {
    // Own properties of Pango-1.0.Pango.GlyphGeometry

    static name: string
  }

  interface GlyphInfo {
    // Own fields of Pango-1.0.Pango.GlyphInfo

    /**
     * the glyph itself.
     * @field
     */
    glyph: Glyph
    /**
     * the positional information about the glyph.
     * @field
     */
    geometry: GlyphGeometry
    /**
     * the visual attributes of the glyph.
     * @field
     */
    attr: GlyphVisAttr
  }

  /**
   * A `PangoGlyphInfo` structure represents a single glyph with
   * positioning information and visual attributes.
   * @record
   */
  class GlyphInfo {
    // Own properties of Pango-1.0.Pango.GlyphInfo

    static name: string
  }

  interface GlyphItem {
    // Own fields of Pango-1.0.Pango.GlyphItem

    /**
     * corresponding `PangoItem`
     * @field
     */
    item: Item
    /**
     * corresponding `PangoGlyphString`
     * @field
     */
    glyphs: GlyphString
    /**
     * shift of the baseline, relative to the baseline
     *   of the containing line. Positive values shift upwards
     * @field
     */
    yOffset: number
    /**
     * horizontal displacement to apply before the
     *   glyph item. Positive values shift right
     * @field
     */
    startXOffset: number
    /**
     * horizontal displacement to apply after th
     *   glyph item. Positive values shift right
     * @field
     */
    endXOffset: number

    // Owm methods of Pango-1.0.Pango.GlyphItem

    /**
     * Splits a shaped item (`PangoGlyphItem`) into multiple items based
     * on an attribute list.
     *
     * The idea is that if you have attributes that don't affect shaping,
     * such as color or underline, to avoid affecting shaping, you filter
     * them out ([method`Pango`.AttrList.filter]), apply the shaping process
     * and then reapply them to the result using this function.
     *
     * All attributes that start or end inside a cluster are applied
     * to that cluster; for instance, if half of a cluster is underlined
     * and the other-half strikethrough, then the cluster will end
     * up with both underline and strikethrough attributes. In these
     * cases, it may happen that `item->`extra_attrs for some of the
     * result items can have multiple attributes of the same type.
     *
     * This function takes ownership of `glyph_item;` it will be reused
     * as one of the elements in the list.
     * @param text text that `list` applies to
     * @param list a `PangoAttrList`
     * @returns a   list of glyph items resulting from splitting @glyph_item. Free   the elements using [method@Pango.GlyphItem.free], the list using   g_slist_free().
     */
    applyAttrs(text: string, list: AttrList): GlyphItem[]
    /**
     * Make a deep copy of an existing `PangoGlyphItem` structure.
     * @returns the newly allocated `PangoGlyphItem`
     */
    copy(): GlyphItem | null
    /**
     * Frees a `PangoGlyphItem` and resources to which it points.
     */
    free(): void
    /**
     * Given a `PangoGlyphItem` and the corresponding text, determine the
     * width corresponding to each character.
     *
     * When multiple characters compose a single cluster, the width of the
     * entire cluster is divided equally among the characters.
     *
     * See also [method`Pango`.GlyphString.get_logical_widths].
     * @param text text that `glyph_item` corresponds to   (glyph_item->item->offset is an offset from the   start of `text)`
     * @param logicalWidths an array whose length is the number of   characters in glyph_item (equal to glyph_item->item->num_chars)   to be filled in with the resulting character widths.
     */
    getLogicalWidths(text: string, logicalWidths: number[]): void
    /**
     * Adds spacing between the graphemes of `glyph_item` to
     * give the effect of typographic letter spacing.
     * @param text text that `glyph_item` corresponds to   (glyph_item->item->offset is an offset from the   start of `text)`
     * @param logAttrs logical attributes for the item   (the first logical attribute refers to the position   before the first character in the item)
     * @param letterSpacing amount of letter spacing to add   in Pango units. May be negative, though too large   negative values will give ugly results.
     */
    letterSpace(text: string, logAttrs: LogAttr[], letterSpacing: number): void
    /**
     * Modifies `orig` to cover only the text after `split_index,` and
     * returns a new item that covers the text before `split_index` that
     * used to be in `orig`.
     *
     * You can think of `split_index` as the length of the returned item.
     * `split_index` may not be 0, and it may not be greater than or equal
     * to the length of `orig` (that is, there must be at least one byte
     * assigned to each item, you can't create a zero-length item).
     *
     * This function is similar in function to pango_item_split() (and uses
     * it internally.)
     * @param text text to which positions in `orig` apply
     * @param splitIndex byte index of position to split item, relative to the   start of the item
     * @returns the newly allocated item   representing text before @split_index, which should be freed   with pango_glyph_item_free().
     */
    split(text: string, splitIndex: number): GlyphItem | null
  }

  /**
   * A `PangoGlyphItem` is a pair of a `PangoItem` and the glyphs
   * resulting from shaping the items text.
   *
   * As an example of the usage of `PangoGlyphItem`, the results
   * of shaping text with `PangoLayout` is a list of `PangoLayoutLine`,
   * each of which contains a list of `PangoGlyphItem`.
   * @record
   */
  class GlyphItem {
    // Own properties of Pango-1.0.Pango.GlyphItem

    static name: string
  }

  interface GlyphItemIter {
    // Own fields of Pango-1.0.Pango.GlyphItemIter

    glyphItem: GlyphItem
    text: string
    startGlyph: number
    startIndex: number
    startChar: number
    endGlyph: number
    endIndex: number
    endChar: number

    // Owm methods of Pango-1.0.Pango.GlyphItemIter

    /**
     * Make a shallow copy of an existing `PangoGlyphItemIter` structure.
     * @returns the newly allocated `PangoGlyphItemIter`
     */
    copy(): GlyphItemIter | null
    /**
     * Frees a `PangoGlyphItem`Iter.
     */
    free(): void
    /**
     * Initializes a `PangoGlyphItemIter` structure to point to the
     * last cluster in a glyph item.
     *
     * See `PangoGlyphItemIter` for details of cluster orders.
     * @param glyphItem the glyph item to iterate over
     * @param text text corresponding to the glyph item
     * @returns %FALSE if there are no clusters in the glyph item
     */
    initEnd(glyphItem: GlyphItem, text: string): boolean
    /**
     * Initializes a `PangoGlyphItemIter` structure to point to the
     * first cluster in a glyph item.
     *
     * See `PangoGlyphItemIter` for details of cluster orders.
     * @param glyphItem the glyph item to iterate over
     * @param text text corresponding to the glyph item
     * @returns %FALSE if there are no clusters in the glyph item
     */
    initStart(glyphItem: GlyphItem, text: string): boolean
    /**
     * Advances the iterator to the next cluster in the glyph item.
     *
     * See `PangoGlyphItemIter` for details of cluster orders.
     * @returns %TRUE if the iterator was advanced,   %FALSE if we were already on the  last cluster.
     */
    nextCluster(): boolean
    /**
     * Moves the iterator to the preceding cluster in the glyph item.
     * See `PangoGlyphItemIter` for details of cluster orders.
     * @returns %TRUE if the iterator was moved,   %FALSE if we were already on the first cluster.
     */
    prevCluster(): boolean
  }

  /**
   * A `PangoGlyphItemIter` is an iterator over the clusters in a
   * `PangoGlyphItem`.
   *
   * The *forward direction* of the iterator is the logical direction of text.
   * That is, with increasing `start_index` and `start_char` values. If `glyph_item`
   * is right-to-left (that is, if `glyph_item->item->analysis.level` is odd),
   * then `start_glyph` decreases as the iterator moves forward.  Moreover,
   * in right-to-left cases, `start_glyph` is greater than `end_glyph`.
   *
   * An iterator should be initialized using either
   * pango_glyph_item_iter_init_start() or
   * pango_glyph_item_iter_init_end(), for forward and backward iteration
   * respectively, and walked over using any desired mixture of
   * pango_glyph_item_iter_next_cluster() and
   * pango_glyph_item_iter_prev_cluster().
   *
   * A common idiom for doing a forward iteration over the clusters is:
   *
   * ```
   * PangoGlyphItemIter cluster_iter;
   * gboolean have_cluster;
   *
   * for (have_cluster = pango_glyph_item_iter_init_start (&cluster_iter,
   *                                                       glyph_item, text);
   *      have_cluster;
   *      have_cluster = pango_glyph_item_iter_next_cluster (&cluster_iter))
   * {
   *   ...
   * }
   * ```
   *
   * Note that `text` is the start of the text for layout, which is then
   * indexed by `glyph_item->item->offset` to get to the text of `glyph_item`.
   * The `start_index` and `end_index` values can directly index into `text`. The
   * `start_glyph,` `end_glyph,` `start_char,` and `end_char` values however are
   * zero-based for the `glyph_item`.  For each cluster, the item pointed at by
   * the start variables is included in the cluster while the one pointed at by
   * end variables is not.
   *
   * None of the members of a `PangoGlyphItemIter` should be modified manually.
   * @record
   */
  class GlyphItemIter {
    // Own properties of Pango-1.0.Pango.GlyphItemIter

    static name: string
  }

  interface GlyphString {
    // Own fields of Pango-1.0.Pango.GlyphString

    /**
     * number of glyphs in this glyph string
     * @field
     */
    numGlyphs: number
    /**
     * array of glyph information
     * @field
     */
    glyphs: GlyphInfo[]
    /**
     * logical cluster info, indexed by the byte index
     *   within the text corresponding to the glyph string
     * @field
     */
    logClusters: number

    // Owm methods of Pango-1.0.Pango.GlyphString

    /**
     * Copy a glyph string and associated storage.
     * @returns the newly allocated `PangoGlyphString`
     */
    copy(): GlyphString | null
    /**
     * Compute the logical and ink extents of a glyph string.
     *
     * See the documentation for [method`Pango`.Font.get_glyph_extents] for details
     * about the interpretation of the rectangles.
     *
     * Examples of logical (red) and ink (green) rects:
     *
     * ![](rects1.png) ![](rects2.png)
     * @param font a `PangoFont`
     */
    extents(font: Font): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Computes the extents of a sub-portion of a glyph string.
     *
     * The extents are relative to the start of the glyph string range
     * (the origin of their coordinate system is at the start of the range,
     * not at the start of the entire glyph string).
     * @param start start index
     * @param end end index (the range is the set of bytes with   indices such that start <= index < end)
     * @param font a `PangoFont`
     */
    extentsRange(
      start: number,
      end: number,
      font: Font
    ): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Free a glyph string and associated storage.
     */
    free(): void
    /**
     * Given a `PangoGlyphString` and corresponding text, determine the width
     * corresponding to each character.
     *
     * When multiple characters compose a single cluster, the width of the
     * entire cluster is divided equally among the characters.
     *
     * See also [method`Pango`.GlyphItem.get_logical_widths].
     * @param text the text corresponding to the glyphs
     * @param length the length of `text,` in bytes
     * @param embeddingLevel the embedding level of the string
     * @param logicalWidths an array whose length is the number of   characters in text (equal to `g_utf8_strlen (text, length)` unless   text has `NUL` bytes) to be filled in with the resulting character widths.
     */
    getLogicalWidths(
      text: string,
      length: number,
      embeddingLevel: number,
      logicalWidths: number[]
    ): void
    /**
     * Computes the logical width of the glyph string.
     *
     * This can also be computed using [method`Pango`.GlyphString.extents].
     * However, since this only computes the width, it's much faster. This
     * is in fact only a convenience function that computes the sum of
     * `geometry`.width for each glyph in the `glyphs`.
     * @returns the logical width of the glyph string.
     */
    getWidth(): number
    /**
     * Converts from character position to x position.
     *
     * The X position is measured from the left edge of the run.
     * Character positions are obtained using font metrics for ligatures
     * where available, and computed by dividing up each cluster
     * into equal portions, otherwise.
     *
     * <picture>
     *   <source srcset="glyphstring-positions-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Glyph positions" src="glyphstring-positions-light.png">
     * </picture>
     * @param text the text for the run
     * @param length the number of bytes (not characters) in `text`.
     * @param analysis the analysis information return from [func`itemize]`
     * @param index the byte index within `text`
     * @param trailing whether we should compute the result for the beginning (%FALSE)   or end (%TRUE) of the character.
     */
    indexToX(
      text: string,
      length: number,
      analysis: Analysis,
      index: number,
      trailing: boolean
    ): /* xPos */ number
    /**
     * Converts from character position to x position.
     *
     * This variant of [method`Pango`.GlyphString.index_to_x] additionally
     * accepts a `PangoLogAttr` array. The grapheme boundary information
     * in it can be used to disambiguate positioning inside some complex
     * clusters.
     * @param text the text for the run
     * @param length the number of bytes (not characters) in `text`.
     * @param analysis the analysis information return from [func`itemize]`
     * @param attrs `PangoLogAttr` array for `text`
     * @param index the byte index within `text`
     * @param trailing whether we should compute the result for the beginning (%FALSE)   or end (%TRUE) of the character.
     */
    indexToXFull(
      text: string,
      length: number,
      analysis: Analysis,
      attrs: LogAttr | null,
      index: number,
      trailing: boolean
    ): /* xPos */ number
    /**
     * Resize a glyph string to the given length.
     * @param newLen the new length of the string
     */
    setSize(newLen: number): void
    /**
     * Convert from x offset to character position.
     *
     * Character positions are computed by dividing up each cluster into
     * equal portions. In scripts where positioning within a cluster is
     * not allowed (such as Thai), the returned value may not be a valid
     * cursor position; the caller must combine the result with the logical
     * attributes for the text to compute the valid cursor position.
     * @param text the text for the run
     * @param length the number of bytes (not characters) in text.
     * @param analysis the analysis information return from [func`itemize]`
     * @param xPos the x offset (in Pango units)
     */
    xToIndex(
      text: string,
      length: number,
      analysis: Analysis,
      xPos: number
    ): [/* index */ number, /* trailing */ number]
  }

  /**
   * A `PangoGlyphString` is used to store strings of glyphs with geometry
   * and visual attribute information.
   *
   * The storage for the glyph information is owned by the structure
   * which simplifies memory management.
   * @record
   */
  class GlyphString {
    // Own properties of Pango-1.0.Pango.GlyphString

    static name: string

    // Constructors of Pango-1.0.Pango.GlyphString

    /**
     * Create a new `PangoGlyphString`.
     * @constructor
     * @returns the newly allocated `PangoGlyphString`, which   should be freed with [method@Pango.GlyphString.free].
     */
    constructor()
    /**
     * Create a new `PangoGlyphString`.
     * @constructor
     * @returns the newly allocated `PangoGlyphString`, which   should be freed with [method@Pango.GlyphString.free].
     */
    static new(): GlyphString
  }

  interface GlyphVisAttr {
    // Own fields of Pango-1.0.Pango.GlyphVisAttr

    /**
     * set for the first logical glyph in each cluster.
     * @field
     */
    isClusterStart: number
    /**
     * set if the the font will render this glyph with color. Since 1.50
     * @field
     */
    isColor: number
  }

  /**
   * A `PangoGlyphVisAttr` structure communicates information between
   * the shaping and rendering phases.
   *
   * Currently, it contains cluster start and color information.
   * More attributes may be added in the future.
   *
   * Clusters are stored in visual order, within the cluster, glyphs
   * are always ordered in logical order, since visual order is meaningless;
   * that is, in Arabic text, accent glyphs follow the glyphs for the
   * base character.
   * @record
   */
  class GlyphVisAttr {
    // Own properties of Pango-1.0.Pango.GlyphVisAttr

    static name: string
  }

  interface Item {
    // Own fields of Pango-1.0.Pango.Item

    /**
     * byte offset of the start of this item in text.
     * @field
     */
    offset: number
    /**
     * length of this item in bytes.
     * @field
     */
    length: number
    /**
     * number of Unicode characters in the item.
     * @field
     */
    numChars: number
    /**
     * analysis results for the item.
     * @field
     */
    analysis: Analysis

    // Owm methods of Pango-1.0.Pango.Item

    /**
     * Add attributes to a `PangoItem`.
     *
     * The idea is that you have attributes that don't affect itemization,
     * such as font features, so you filter them out using
     * [method`Pango`.AttrList.filter], itemize your text, then reapply the
     * attributes to the resulting items using this function.
     *
     * The `iter` should be positioned before the range of the item,
     * and will be advanced past it. This function is meant to be called
     * in a loop over the items resulting from itemization, while passing
     * the iter to each call.
     * @param iter a `PangoAttrIterator`
     */
    applyAttrs(iter: AttrIterator): void
    /**
     * Copy an existing `PangoItem` structure.
     * @returns the newly allocated `PangoItem`
     */
    copy(): Item | null
    /**
     * Free a `PangoItem` and all associated memory.
     */
    free(): void
    /**
     * Modifies `orig` to cover only the text after `split_index,` and
     * returns a new item that covers the text before `split_index` that
     * used to be in `orig`.
     *
     * You can think of `split_index` as the length of the returned item.
     * `split_index` may not be 0, and it may not be greater than or equal
     * to the length of `orig` (that is, there must be at least one byte
     * assigned to each item, you can't create a zero-length item).
     * `split_offset` is the length of the first item in chars, and must be
     * provided because the text used to generate the item isn't available,
     * so `pango_item_split()` can't count the char length of the split items
     * itself.
     * @param splitIndex byte index of position to split item, relative to the   start of the item
     * @param splitOffset number of chars between start of `orig` and `split_index`
     * @returns new item representing text before @split_index, which   should be freed with [method@Pango.Item.free].
     */
    split(splitIndex: number, splitOffset: number): Item
  }

  /**
   * The `PangoItem` structure stores information about a segment of text.
   *
   * You typically obtain `PangoItems` by itemizing a piece of text
   * with [func`itemize]`.
   * @record
   */
  class Item {
    // Own properties of Pango-1.0.Pango.Item

    static name: string

    // Constructors of Pango-1.0.Pango.Item

    /**
     * Creates a new `PangoItem` structure initialized to default values.
     * @constructor
     * @returns the newly allocated `PangoItem`, which should   be freed with [method@Pango.Item.free].
     */
    constructor()
    /**
     * Creates a new `PangoItem` structure initialized to default values.
     * @constructor
     * @returns the newly allocated `PangoItem`, which should   be freed with [method@Pango.Item.free].
     */
    static new(): Item
  }

  interface Language {
    // Owm methods of Pango-1.0.Pango.Language

    /**
     * Get a string that is representative of the characters needed to
     * render a particular language.
     *
     * The sample text may be a pangram, but is not necessarily. It is chosen
     * to be demonstrative of normal text in the language, as well as exposing
     * font feature requirements unique to the language. It is suitable for use
     * as sample text in a font selection dialog.
     *
     * If `language` is %NULL, the default language as found by
     * [func`Pango`.Language.get_default] is used.
     *
     * If Pango does not have a sample string for `language,` the classic
     * "The quick brown fox..." is returned.  This can be detected by
     * comparing the returned pointer value to that returned for (non-existent)
     * language code "xx".  That is, compare to:
     *
     * ```
     * pango_language_get_sample_string (pango_language_from_string ("xx"))
     * ```
     * @returns the sample string
     */
    getSampleString(): string
    /**
     * Determines the scripts used to to write `language`.
     *
     * If nothing is known about the language tag `language,`
     * or if `language` is %NULL, then %NULL is returned.
     * The list of scripts returned starts with the script that the
     * language uses most and continues to the one it uses least.
     *
     * The value `num_script` points at will be set to the number
     * of scripts in the returned array (or zero if %NULL is returned).
     *
     * Most languages use only one script for writing, but there are
     * some that use two (Latin and Cyrillic for example), and a few
     * use three (Japanese for example). Applications should not make
     * any assumptions on the maximum number of scripts returned
     * though, except that it is positive if the return value is not
     * %NULL, and it is a small number.
     *
     * The [method`Pango`.Language.includes_script] function uses this
     * function internally.
     *
     * Note: while the return value is declared as `PangoScript`, the
     * returned values are from the `GUnicodeScript` enumeration, which
     * may have more values. Callers need to handle unknown values.
     * @returns An array of `PangoScript` values, with the number of entries in   the array stored in @num_scripts, or %NULL if Pango does not have   any information about this particular language tag (also the case   if @language is %NULL).
     */
    getScripts(): Script[] | null
    /**
     * Determines if `script` is one of the scripts used to
     * write `language`.
     *
     * The returned value is conservative; if nothing is known about
     * the language tag `language,` %TRUE will be returned, since, as
     * far as Pango knows, `script` might be used to write `language`.
     *
     * This routine is used in Pango's itemization process when
     * determining if a supplied language tag is relevant to
     * a particular section of text. It probably is not useful
     * for applications in most circumstances.
     *
     * This function uses [method`Pango`.Language.get_scripts] internally.
     * @param script a `PangoScript`
     * @returns %TRUE if @script is one of the scripts used   to write @language or if nothing is known about @language   (including the case that @language is %NULL), %FALSE otherwise.
     */
    includesScript(script: Script): boolean
    /**
     * Checks if a language tag matches one of the elements in a list of
     * language ranges.
     *
     * A language tag is considered to match a range in the list if the
     * range is '*', the range is exactly the tag, or the range is a prefix
     * of the tag, and the character after it in the tag is '-'.
     * @param rangeList a list of language ranges, separated by ';', ':',   ',', or space characters.   Each element must either be '*', or a RFC 3066 language range   canonicalized as by [func`Pango`.Language.from_string]
     * @returns %TRUE if a match was found
     */
    matches(rangeList: string): boolean
    /**
     * Gets the RFC-3066 format string representing the given language tag.
     *
     * Returns (transfer none): a string representing the language tag
     */
    toString(): string
  }

  /**
   * The `PangoLanguage` structure is used to
   * represent a language.
   *
   * `PangoLanguage` pointers can be efficiently
   * copied and compared with each other.
   * @record
   */
  class Language {
    // Own properties of Pango-1.0.Pango.Language

    static name: string

    // Constructors of Pango-1.0.Pango.Language

    /**
     * Convert a language tag to a `PangoLanguage`.
     *
     * The language tag must be in a RFC-3066 format. `PangoLanguage` pointers
     * can be efficiently copied (copy the pointer) and compared with other
     * language tags (compare the pointer.)
     *
     * This function first canonicalizes the string by converting it to
     * lowercase, mapping '_' to '-', and stripping all characters other
     * than letters and '-'.
     *
     * Use [func`Pango`.Language.get_default] if you want to get the
     * `PangoLanguage` for the current locale of the process.
     * @param language a string representing a language tag
     * @returns a `PangoLanguage`
     */
    static fromString(language: string | null): Language | null
    /**
     * Returns the `PangoLanguage` for the current locale of the process.
     *
     * On Unix systems, this is the return value is derived from
     * `setlocale (LC_CTYPE, NULL)`, and the user can
     * affect this through the environment variables LC_ALL, LC_CTYPE or
     * LANG (checked in that order). The locale string typically is in
     * the form lang_COUNTRY, where lang is an ISO-639 language code, and
     * COUNTRY is an ISO-3166 country code. For instance, sv_FI for
     * Swedish as written in Finland or pt_BR for Portuguese as written in
     * Brazil.
     *
     * On Windows, the C library does not use any such environment
     * variables, and setting them won't affect the behavior of functions
     * like ctime(). The user sets the locale through the Regional Options
     * in the Control Panel. The C library (in the setlocale() function)
     * does not use country and language codes, but country and language
     * names spelled out in English.
     * However, this function does check the above environment
     * variables, and does return a Unix-style locale string based on
     * either said environment variables or the thread's current locale.
     *
     * Your application should call `setlocale(LC_ALL, "")` for the user
     * settings to take effect. GTK does this in its initialization
     * functions automatically (by calling gtk_set_locale()).
     * See the setlocale() manpage for more details.
     *
     * Note that the default language can change over the life of an application.
     *
     * Also note that this function will not do the right thing if you
     * use per-thread locales with uselocale(). In that case, you should
     * just call pango_language_from_string() yourself.
     * @returns the default language as a `PangoLanguage`
     */
    static getDefault(): Language
    /**
     * Returns the list of languages that the user prefers.
     *
     * The list is specified by the `PANGO_LANGUAGE` or `LANGUAGE`
     * environment variables, in order of preference. Note that this
     * list does not necessarily include the language returned by
     * [func`Pango`.Language.get_default].
     *
     * When choosing language-specific resources, such as the sample
     * text returned by [method`Pango`.Language.get_sample_string],
     * you should first try the default language, followed by the
     * languages returned by this function.
     * @returns a %NULL-terminated array   of `PangoLanguage`*
     */
    static getPreferred(): Language[] | null
  }

  interface LayoutClass {}

  abstract class LayoutClass {
    // Own properties of Pango-1.0.Pango.LayoutClass

    static name: string
  }

  interface LayoutIter {
    // Owm methods of Pango-1.0.Pango.LayoutIter

    /**
     * Determines whether `iter` is on the last line of the layout.
     * @returns %TRUE if @iter is on the last line
     */
    atLastLine(): boolean
    /**
     * Copies a `PangoLayoutIter`.
     * @returns the newly allocated `PangoLayoutIter`
     */
    copy(): LayoutIter | null
    /**
     * Frees an iterator that's no longer in use.
     */
    free(): void
    /**
     * Gets the Y position of the current line's baseline, in layout
     * coordinates.
     *
     * Layout coordinates have the origin at the top left of the entire layout.
     * @returns baseline of current line
     */
    getBaseline(): number
    /**
     * Gets the extents of the current character, in layout coordinates.
     *
     * Layout coordinates have the origin at the top left of the entire layout.
     *
     * Only logical extents can sensibly be obtained for characters;
     * ink extents make sense only down to the level of clusters.
     */
    getCharExtents(): /* logicalRect */ Rectangle
    /**
     * Gets the extents of the current cluster, in layout coordinates.
     *
     * Layout coordinates have the origin at the top left of the entire layout.
     */
    getClusterExtents(): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Gets the current byte index.
     *
     * Note that iterating forward by char moves in visual order,
     * not logical order, so indexes may not be sequential. Also,
     * the index may be equal to the length of the text in the
     * layout, if on the %NULL run (see [method`Pango`.LayoutIter.get_run]).
     * @returns current byte index
     */
    getIndex(): number
    /**
     * Gets the layout associated with a `PangoLayoutIter`.
     * @returns the layout associated with @iter
     */
    getLayout(): Layout | null
    /**
     * Obtains the extents of the `PangoLayout` being iterated over.
     */
    getLayoutExtents(): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Gets the current line.
     *
     * Use the faster [method`Pango`.LayoutIter.get_line_readonly] if
     * you do not plan to modify the contents of the line (glyphs,
     * glyph widths, etc.).
     * @returns the current line
     */
    getLine(): LayoutLine | null
    /**
     * Obtains the extents of the current line.
     *
     * Extents are in layout coordinates (origin is the top-left corner
     * of the entire `PangoLayout`). Thus the extents returned by this
     * function will be the same width/height but not at the same x/y
     * as the extents returned from [method`Pango`.LayoutLine.get_extents].
     */
    getLineExtents(): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Gets the current line for read-only access.
     *
     * This is a faster alternative to [method`Pango`.LayoutIter.get_line],
     * but the user is not expected to modify the contents of the line
     * (glyphs, glyph widths, etc.).
     * @returns the current line, that should not be   modified
     */
    getLineReadonly(): LayoutLine | null
    /**
     * Divides the vertical space in the `PangoLayout` being iterated over
     * between the lines in the layout, and returns the space belonging to
     * the current line.
     *
     * A line's range includes the line's logical extents. plus half of the
     * spacing above and below the line, if [method`Pango`.Layout.set_spacing]
     * has been called to set layout spacing. The Y positions are in layout
     * coordinates (origin at top left of the entire layout).
     *
     * Note: Since 1.44, Pango uses line heights for placing lines, and there
     * may be gaps between the ranges returned by this function.
     */
    getLineYrange(): [/* y0 */ number, /* y1 */ number]
    /**
     * Gets the current run.
     *
     * When iterating by run, at the end of each line, there's a position
     * with a %NULL run, so this function can return %NULL. The %NULL run
     * at the end of each line ensures that all lines have at least one run,
     * even lines consisting of only a newline.
     *
     * Use the faster [method`Pango`.LayoutIter.get_run_readonly] if you do not
     * plan to modify the contents of the run (glyphs, glyph widths, etc.).
     * @returns the current run
     */
    getRun(): LayoutRun | null
    /**
     * Gets the Y position of the current run's baseline, in layout
     * coordinates.
     *
     * Layout coordinates have the origin at the top left of the entire layout.
     *
     * The run baseline can be different from the line baseline, for
     * example due to superscript or subscript positioning.
     */
    getRunBaseline(): number
    /**
     * Gets the extents of the current run in layout coordinates.
     *
     * Layout coordinates have the origin at the top left of the entire layout.
     */
    getRunExtents(): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Gets the current run for read-only access.
     *
     * When iterating by run, at the end of each line, there's a position
     * with a %NULL run, so this function can return %NULL. The %NULL run
     * at the end of each line ensures that all lines have at least one run,
     * even lines consisting of only a newline.
     *
     * This is a faster alternative to [method`Pango`.LayoutIter.get_run],
     * but the user is not expected to modify the contents of the run (glyphs,
     * glyph widths, etc.).
     * @returns the current run, that   should not be modified
     */
    getRunReadonly(): LayoutRun | null
    /**
     * Moves `iter` forward to the next character in visual order.
     *
     * If `iter` was already at the end of the layout, returns %FALSE.
     * @returns whether motion was possible
     */
    nextChar(): boolean
    /**
     * Moves `iter` forward to the next cluster in visual order.
     *
     * If `iter` was already at the end of the layout, returns %FALSE.
     * @returns whether motion was possible
     */
    nextCluster(): boolean
    /**
     * Moves `iter` forward to the start of the next line.
     *
     * If `iter` is already on the last line, returns %FALSE.
     * @returns whether motion was possible
     */
    nextLine(): boolean
    /**
     * Moves `iter` forward to the next run in visual order.
     *
     * If `iter` was already at the end of the layout, returns %FALSE.
     * @returns whether motion was possible
     */
    nextRun(): boolean
  }

  /**
   * A `PangoLayoutIter` can be used to iterate over the visual
   * extents of a `PangoLayout`.
   *
   * To obtain a `PangoLayoutIter`, use [method`Pango`.Layout.get_iter].
   *
   * The `PangoLayoutIter` structure is opaque, and has no user-visible fields.
   * @record
   */
  class LayoutIter {
    // Own properties of Pango-1.0.Pango.LayoutIter

    static name: string
  }

  interface LayoutLine {
    // Own fields of Pango-1.0.Pango.LayoutLine

    /**
     * the layout this line belongs to, might be %NULL
     * @field
     */
    layout: Layout
    /**
     * start of line as byte index into layout->text
     * @field
     */
    startIndex: number
    /**
     * length of line in bytes
     * @field
     */
    length: number
    /**
     * list of runs in the
     *   line, from left to right
     * @field
     */
    runs: LayoutRun[]
    /**
     * #TRUE if this is the first line of the paragraph
     * @field
     */
    isParagraphStart: number
    /**
     * #Resolved PangoDirection of line
     * @field
     */
    resolvedDir: number

    // Owm methods of Pango-1.0.Pango.LayoutLine

    /**
     * Computes the logical and ink extents of a layout line.
     *
     * See [method`Pango`.Font.get_glyph_extents] for details
     * about the interpretation of the rectangles.
     */
    getExtents(): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Computes the height of the line, as the maximum of the heights
     * of fonts used in this line.
     *
     * Note that the actual baseline-to-baseline distance between lines
     * of text is influenced by other factors, such as
     * [method`Pango`.Layout.set_spacing] and
     * [method`Pango`.Layout.set_line_spacing].
     */
    getHeight(): /* height */ number
    /**
     * Returns the length of the line, in bytes.
     * @returns the length of the line
     */
    getLength(): number
    /**
     * Computes the logical and ink extents of `layout_line` in device units.
     *
     * This function just calls [method`Pango`.LayoutLine.get_extents] followed by
     * two [func`extents_to_pixels]` calls, rounding `ink_rect` and `logical_rect`
     * such that the rounded rectangles fully contain the unrounded one (that is,
     * passes them as first argument to [func`extents_to_pixels]`).
     */
    getPixelExtents(): [/* inkRect */ Rectangle, /* logicalRect */ Rectangle]
    /**
     * Returns the resolved direction of the line.
     * @returns the resolved direction of the line
     */
    getResolvedDirection(): Direction
    /**
     * Returns the start index of the line, as byte index
     * into the text of the layout.
     * @returns the start index of the line
     */
    getStartIndex(): number
    /**
     * Gets a list of visual ranges corresponding to a given logical range.
     *
     * This list is not necessarily minimal - there may be consecutive
     * ranges which are adjacent. The ranges will be sorted from left to
     * right. The ranges are with respect to the left edge of the entire
     * layout, not with respect to the line.
     * @param startIndex Start byte index of the logical range. If this value   is less than the start index for the line, then the first range   will extend all the way to the leading edge of the layout. Otherwise,   it will start at the leading edge of the first character.
     * @param endIndex Ending byte index of the logical range. If this value is   greater than the end index for the line, then the last range will   extend all the way to the trailing edge of the layout. Otherwise,   it will end at the trailing edge of the last character.
     */
    getXRanges(startIndex: number, endIndex: number): /* ranges */ number[]
    /**
     * Converts an index within a line to a X position.
     * @param index byte offset of a grapheme within the layout
     * @param trailing an integer indicating the edge of the grapheme to retrieve   the position of. If > 0, the trailing edge of the grapheme,   if 0, the leading of the grapheme
     */
    indexToX(index: number, trailing: boolean): /* xPos */ number
    /**
     * Increase the reference count of a `PangoLayoutLine` by one.
     * @returns the line passed in.
     */
    ref(): LayoutLine | null
    /**
     * Decrease the reference count of a `PangoLayoutLine` by one.
     *
     * If the result is zero, the line and all associated memory
     * will be freed.
     */
    unref(): void
    /**
     * Converts from x offset to the byte index of the corresponding character
     * within the text of the layout.
     *
     * If `x_pos` is outside the line, `index_` and `trailing` will point to the very
     * first or very last position in the line. This determination is based on the
     * resolved direction of the paragraph; for example, if the resolved direction
     * is right-to-left, then an X position to the right of the line (after it)
     * results in 0 being stored in `index_` and `trailing`. An X position to the
     * left of the line results in `index_` pointing to the (logical) last grapheme
     * in the line and `trailing` being set to the number of characters in that
     * grapheme. The reverse is true for a left-to-right line.
     * @param xPos the X offset (in Pango units) from the left edge of the line.
     * @returns %FALSE if @x_pos was outside the line, %TRUE if inside
     */
    xToIndex(
      xPos: number
    ): [/* returnType */ boolean, /* index */ number, /* trailing */ number]
  }

  /**
   * A `PangoLayoutLine` represents one of the lines resulting from laying
   * out a paragraph via `PangoLayout`.
   *
   * `PangoLayoutLine` structures are obtained by calling
   * [method`Pango`.Layout.get_line] and are only valid until the text,
   * attributes, or settings of the parent `PangoLayout` are modified.
   * @record
   */
  class LayoutLine {
    // Own properties of Pango-1.0.Pango.LayoutLine

    static name: string
  }

  interface LogAttr {
    // Own fields of Pango-1.0.Pango.LogAttr

    /**
     * if set, can break line in front of character
     * @field
     */
    isLineBreak: number
    /**
     * if set, must break line in front of character
     * @field
     */
    isMandatoryBreak: number
    /**
     * if set, can break here when doing character wrapping
     * @field
     */
    isCharBreak: number
    /**
     * is whitespace character
     * @field
     */
    isWhite: number
    /**
     * if set, cursor can appear in front of character.
     *   i.e. this is a grapheme boundary, or the first character in the text.
     *   This flag implements Unicode's
     *   [Grapheme Cluster Boundaries](http://www.unicode.org/reports/tr29/)
     *   semantics.
     * @field
     */
    isCursorPosition: number
    /**
     * is first character in a word
     * @field
     */
    isWordStart: number
    /**
     * is first non-word char after a word
     *   Note that in degenerate cases, you could have both `is_word_start`
     *   and `is_word_end` set for some character.
     * @field
     */
    isWordEnd: number
    /**
     * is a sentence boundary.
     *   There are two ways to divide sentences. The first assigns all
     *   inter-sentence whitespace/control/format chars to some sentence,
     *   so all chars are in some sentence; `is_sentence_boundary` denotes
     *   the boundaries there. The second way doesn't assign
     *   between-sentence spaces, etc. to any sentence, so
     *   `is_sentence_start/``is_sentence_end` mark the boundaries of those sentences.
     * @field
     */
    isSentenceBoundary: number
    /**
     * is first character in a sentence
     * @field
     */
    isSentenceStart: number
    /**
     * is first char after a sentence.
     *   Note that in degenerate cases, you could have both `is_sentence_start`
     *   and `is_sentence_end` set for some character. (e.g. no space after a
     *   period, so the next sentence starts right away)
     * @field
     */
    isSentenceEnd: number
    /**
     * if set, backspace deletes one character
     *   rather than the entire grapheme cluster. This field is only meaningful
     *   on grapheme boundaries (where `is_cursor_position` is set). In some languages,
     *   the full grapheme (e.g. letter + diacritics) is considered a unit, while in
     *   others, each decomposed character in the grapheme is a unit. In the default
     *   implementation of [func`break]`, this bit is set on all grapheme boundaries
     *   except those following Latin, Cyrillic or Greek base characters.
     * @field
     */
    backspaceDeletesCharacter: number
    /**
     * is a whitespace character that can possibly be
     *   expanded for justification purposes. (Since: 1.18)
     * @field
     */
    isExpandableSpace: number
    /**
     * is a word boundary, as defined by UAX#29.
     *   More specifically, means that this is not a position in the middle of a word.
     *   For example, both sides of a punctuation mark are considered word boundaries.
     *   This flag is particularly useful when selecting text word-by-word. This flag
     *   implements Unicode's [Word Boundaries](http://www.unicode.org/reports/tr29/)
     *   semantics. (Since: 1.22)
     * @field
     */
    isWordBoundary: number
    /**
     * when breaking lines before this char, insert a hyphen.
     *   Since: 1.50
     * @field
     */
    breakInsertsHyphen: number
    /**
     * when breaking lines before this char, remove the
     *   preceding char. Since 1.50
     * @field
     */
    breakRemovesPreceding: number
    reserved: number
  }

  /**
   * The `PangoLogAttr` structure stores information about the attributes of a
   * single character.
   * @record
   */
  class LogAttr {
    // Own properties of Pango-1.0.Pango.LogAttr

    static name: string
  }

  interface Matrix {
    // Own fields of Pango-1.0.Pango.Matrix

    /**
     * 1st component of the transformation matrix
     * @field
     */
    xx: number
    /**
     * 2nd component of the transformation matrix
     * @field
     */
    xy: number
    /**
     * 3rd component of the transformation matrix
     * @field
     */
    yx: number
    /**
     * 4th component of the transformation matrix
     * @field
     */
    yy: number
    /**
     * x translation
     * @field
     */
    x0: number
    /**
     * y translation
     * @field
     */
    y0: number

    // Owm methods of Pango-1.0.Pango.Matrix

    /**
     * Changes the transformation represented by `matrix` to be the
     * transformation given by first applying transformation
     * given by `new_matrix` then applying the original transformation.
     * @param newMatrix a `PangoMatrix`
     */
    concat(newMatrix: Matrix): void
    /**
     * Copies a `PangoMatrix`.
     * @returns the newly allocated `PangoMatrix`
     */
    copy(): Matrix | null
    /**
     * Free a `PangoMatrix`.
     */
    free(): void
    /**
     * Returns the scale factor of a matrix on the height of the font.
     *
     * That is, the scale factor in the direction perpendicular to the
     * vector that the X coordinate is mapped to.  If the scale in the X
     * coordinate is needed as well, use [method`Pango`.Matrix.get_font_scale_factors].
     * @returns the scale factor of @matrix on the height of the font,   or 1.0 if @matrix is %NULL.
     */
    getFontScaleFactor(): number
    /**
     * Calculates the scale factor of a matrix on the width and height of the font.
     *
     * That is, `xscale` is the scale factor in the direction of the X coordinate,
     * and `yscale` is the scale factor in the direction perpendicular to the
     * vector that the X coordinate is mapped to.
     *
     * Note that output numbers will always be non-negative.
     */
    getFontScaleFactors(): [/* xscale */ number, /* yscale */ number]
    /**
     * Gets the slant ratio of a matrix.
     *
     * For a simple shear matrix in the form:
     *
     *     1 λ
     *     0 1
     *
     * this is simply λ.
     * @returns the slant ratio of @matrix
     */
    getSlantRatio(): number
    /**
     * Changes the transformation represented by `matrix` to be the
     * transformation given by first rotating by `degrees` degrees
     * counter-clockwise then applying the original transformation.
     * @param degrees degrees to rotate counter-clockwise
     */
    rotate(degrees: number): void
    /**
     * Changes the transformation represented by `matrix` to be the
     * transformation given by first scaling by `sx` in the X direction
     * and `sy` in the Y direction then applying the original
     * transformation.
     * @param scaleX amount to scale by in X direction
     * @param scaleY amount to scale by in Y direction
     */
    scale(scaleX: number, scaleY: number): void
    /**
     * Transforms the distance vector (`dx,``dy)` by `matrix`.
     *
     * This is similar to [method`Pango`.Matrix.transform_point],
     * except that the translation components of the transformation
     * are ignored. The calculation of the returned vector is as follows:
     *
     * ```
     * dx2 = dx1 * xx + dy1 * xy;
     * dy2 = dx1 * yx + dy1 * yy;
     * ```
     *
     * Affine transformations are position invariant, so the same vector
     * always transforms to the same vector. If (`x1`,`y1`) transforms
     * to (`x2`,`y2`) then (`x1`+`dx1`,`y1`+`dy1`) will transform to
     * (`x1`+`dx2`,`y1`+`dy2`) for all values of `x1` and `x2`.
     * @param dx in/out X component of a distance vector
     * @param dy in/out Y component of a distance vector
     */
    transformDistance(
      dx: number,
      dy: number
    ): [/* dx */ number, /* dy */ number]
    /**
     * First transforms the `rect` using `matrix,` then calculates the bounding box
     * of the transformed rectangle.
     *
     * This function is useful for example when you want to draw a rotated
     * `PangoLayout` to an image buffer, and want to know how large the image
     * should be and how much you should shift the layout when rendering.
     *
     * For better accuracy, you should use [method`Pango`.Matrix.transform_rectangle]
     * on original rectangle in Pango units and convert to pixels afterward
     * using [func`extents_to_pixels]`'s first argument.
     * @param rect in/out bounding box in device units
     */
    transformPixelRectangle(rect?: Rectangle): /* rect */ Rectangle
    /**
     * Transforms the point (`x,` `y)` by `matrix`.
     * @param x in/out X position
     * @param y in/out Y position
     */
    transformPoint(x: number, y: number): [/* x */ number, /* y */ number]
    /**
     * First transforms `rect` using `matrix,` then calculates the bounding box
     * of the transformed rectangle.
     *
     * This function is useful for example when you want to draw a rotated
     * `PangoLayout` to an image buffer, and want to know how large the image
     * should be and how much you should shift the layout when rendering.
     *
     * If you have a rectangle in device units (pixels), use
     * [method`Pango`.Matrix.transform_pixel_rectangle].
     *
     * If you have the rectangle in Pango units and want to convert to
     * transformed pixel bounding box, it is more accurate to transform it first
     * (using this function) and pass the result to pango_extents_to_pixels(),
     * first argument, for an inclusive rounded rectangle.
     * However, there are valid reasons that you may want to convert
     * to pixels first and then transform, for example when the transformed
     * coordinates may overflow in Pango units (large matrix translation for
     * example).
     * @param rect in/out bounding box in Pango units
     */
    transformRectangle(rect?: Rectangle): /* rect */ Rectangle
    /**
     * Changes the transformation represented by `matrix` to be the
     * transformation given by first translating by (`tx,` `ty)`
     * then applying the original transformation.
     * @param tx amount to translate in the X direction
     * @param ty amount to translate in the Y direction
     */
    translate(tx: number, ty: number): void
  }

  /**
   * A `PangoMatrix` specifies a transformation between user-space
   * and device coordinates.
   *
   * The transformation is given by
   *
   * ```
   * x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
   * y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
   * ```
   * @record
   */
  class Matrix {
    // Own properties of Pango-1.0.Pango.Matrix

    static name: string
  }

  interface Rectangle {
    // Own fields of Pango-1.0.Pango.Rectangle

    /**
     * X coordinate of the left side of the rectangle.
     * @field
     */
    x: number
    /**
     * Y coordinate of the the top side of the rectangle.
     * @field
     */
    y: number
    /**
     * width of the rectangle.
     * @field
     */
    width: number
    /**
     * height of the rectangle.
     * @field
     */
    height: number
  }

  /**
   * The `PangoRectangle` structure represents a rectangle.
   *
   * `PangoRectangle` is frequently used to represent the logical or ink
   * extents of a single glyph or section of text. (See, for instance,
   * [method`Pango`.Font.get_glyph_extents].)
   * @record
   */
  class Rectangle {
    // Own properties of Pango-1.0.Pango.Rectangle

    static name: string
  }

  interface RendererClass {
    // Own fields of Pango-1.0.Pango.RendererClass

    /**
     * draws a `PangoGlyphString`
     * @field
     */
    drawGlyphs: (
      renderer: Renderer,
      font: Font,
      glyphs: GlyphString,
      x: number,
      y: number
    ) => void
    /**
     * draws a rectangle
     * @field
     */
    drawRectangle: (
      renderer: Renderer,
      part: RenderPart,
      x: number,
      y: number,
      width: number,
      height: number
    ) => void
    /**
     * draws a squiggly line that approximately
     * covers the given rectangle in the style of an underline used to
     * indicate a spelling error.
     * @field
     */
    drawErrorUnderline: (
      renderer: Renderer,
      x: number,
      y: number,
      width: number,
      height: number
    ) => void
    /**
     * draw content for a glyph shaped with `PangoAttrShape`
     *   `x,` `y` are the coordinates of the left edge of the baseline,
     *   in user coordinates.
     * @field
     */
    drawShape: (
      renderer: Renderer,
      attr: AttrShape,
      x: number,
      y: number
    ) => void
    /**
     * draws a trapezoidal filled area
     * @field
     */
    drawTrapezoid: (
      renderer: Renderer,
      part: RenderPart,
      y1: number,
      x11: number,
      x21: number,
      y2: number,
      x12: number,
      x22: number
    ) => void
    /**
     * draws a single glyph
     * @field
     */
    drawGlyph: (
      renderer: Renderer,
      font: Font,
      glyph: Glyph,
      x: number,
      y: number
    ) => void
    /**
     * do renderer specific processing when rendering
     *  attributes change
     * @field
     */
    partChanged: (renderer: Renderer, part: RenderPart) => void
    /**
     * Do renderer-specific initialization before drawing
     * @field
     */
    begin: (renderer: Renderer) => void
    /**
     * Do renderer-specific cleanup after drawing
     * @field
     */
    end: (renderer: Renderer) => void
    /**
     * updates the renderer for a new run
     * @field
     */
    prepareRun: (renderer: Renderer, run: LayoutRun) => void
    /**
     * draws a `PangoGlyphItem`
     * @field
     */
    drawGlyphItem: (
      renderer: Renderer,
      text: string | null,
      glyphItem: GlyphItem,
      x: number,
      y: number
    ) => void
  }

  /**
   * Class structure for `PangoRenderer`.
   *
   * The following vfuncs take user space coordinates in Pango units
   * and have default implementations:
   * - draw_glyphs
   * - draw_rectangle
   * - draw_error_underline
   * - draw_shape
   * - draw_glyph_item
   *
   * The default draw_shape implementation draws nothing.
   *
   * The following vfuncs take device space coordinates as doubles
   * and must be implemented:
   * - draw_trapezoid
   * - draw_glyph
   * @record
   */
  abstract class RendererClass {
    // Own properties of Pango-1.0.Pango.RendererClass

    static name: string
  }

  interface RendererPrivate {}

  class RendererPrivate {
    // Own properties of Pango-1.0.Pango.RendererPrivate

    static name: string
  }

  interface ScriptIter {
    // Owm methods of Pango-1.0.Pango.ScriptIter

    /**
     * Frees a `PangoScriptIter`.
     */
    free(): void
    /**
     * Gets information about the range to which `iter` currently points.
     *
     * The range is the set of locations p where *start <= p < *end.
     * (That is, it doesn't include the character stored at *end)
     *
     * Note that while the type of the `script` argument is declared
     * as `PangoScript`, as of Pango 1.18, this function simply returns
     * `GUnicodeScript` values. Callers must be prepared to handle unknown
     * values.
     */
    getRange(): [/* start */ string, /* end */ string, /* script */ Script]
    /**
     * Advances a `PangoScriptIter` to the next range.
     *
     * If `iter` is already at the end, it is left unchanged
     * and %FALSE is returned.
     * @returns %TRUE if @iter was successfully advanced
     */
    next(): boolean
  }

  /**
   * A `PangoScriptIter` is used to iterate through a string
   * and identify ranges in different scripts.
   * @record
   */
  class ScriptIter {
    // Own properties of Pango-1.0.Pango.ScriptIter

    static name: string

    // Constructors of Pango-1.0.Pango.ScriptIter

    /**
     * Create a new `PangoScriptIter`, used to break a string of
     * Unicode text into runs by Unicode script.
     *
     * No copy is made of `text,` so the caller needs to make
     * sure it remains valid until the iterator is freed with
     * [method`Pango`.ScriptIter.free].
     * @constructor
     * @param text a UTF-8 string
     * @param length length of `text,` or -1 if `text` is nul-terminated
     * @returns the new script iterator, initialized  to point at the first range in the text, which should be  freed with [method@Pango.ScriptIter.free]. If the string is  empty, it will point at an empty range.
     */
    constructor(text: string, length: number)
    /**
     * Create a new `PangoScriptIter`, used to break a string of
     * Unicode text into runs by Unicode script.
     *
     * No copy is made of `text,` so the caller needs to make
     * sure it remains valid until the iterator is freed with
     * [method`Pango`.ScriptIter.free].
     * @constructor
     * @param text a UTF-8 string
     * @param length length of `text,` or -1 if `text` is nul-terminated
     * @returns the new script iterator, initialized  to point at the first range in the text, which should be  freed with [method@Pango.ScriptIter.free]. If the string is  empty, it will point at an empty range.
     */
    static new(text: string, length: number): ScriptIter
  }

  interface TabArray {
    // Owm methods of Pango-1.0.Pango.TabArray

    /**
     * Copies a `PangoTabArray`.
     * @returns the newly allocated `PangoTabArray`, which should   be freed with [method@Pango.TabArray.free].
     */
    copy(): TabArray
    /**
     * Frees a tab array and associated resources.
     */
    free(): void
    /**
     * Gets the Unicode character to use as decimal point.
     *
     * This is only relevant for tabs with %PANGO_TAB_DECIMAL alignment,
     * which align content at the first occurrence of the decimal point
     * character.
     *
     * The default value of 0 means that Pango will use the
     * decimal point according to the current locale.
     * @param tabIndex the index of a tab stop
     */
    getDecimalPoint(tabIndex: number): string
    /**
     * Returns %TRUE if the tab positions are in pixels,
     * %FALSE if they are in Pango units.
     * @returns whether positions are in pixels.
     */
    getPositionsInPixels(): boolean
    /**
     * Gets the number of tab stops in `tab_array`.
     * @returns the number of tab stops in the array.
     */
    getSize(): number
    /**
     * Gets the alignment and position of a tab stop.
     * @param tabIndex tab stop index
     */
    getTab(tabIndex: number): [/* alignment */ TabAlign, /* location */ number]
    /**
     * If non-%NULL, `alignments` and `locations` are filled with allocated
     * arrays.
     *
     * The arrays are of length [method`Pango`.TabArray.get_size].
     * You must free the returned array.
     */
    getTabs(): [/* alignments */ TabAlign, /* locations */ number[]]
    /**
     * Resizes a tab array.
     *
     * You must subsequently initialize any tabs
     * that were added as a result of growing the array.
     * @param newSize new size of the array
     */
    resize(newSize: number): void
    /**
     * Sets the Unicode character to use as decimal point.
     *
     * This is only relevant for tabs with %PANGO_TAB_DECIMAL alignment,
     * which align content at the first occurrence of the decimal point
     * character.
     *
     * By default, Pango uses the decimal point according
     * to the current locale.
     * @param tabIndex the index of a tab stop
     * @param decimalPoint the decimal point to use
     */
    setDecimalPoint(tabIndex: number, decimalPoint: string): void
    /**
     * Sets whether positions in this array are specified in
     * pixels.
     * @param positionsInPixels whether positions are in pixels
     */
    setPositionsInPixels(positionsInPixels: boolean): void
    /**
     * Sets the alignment and location of a tab stop.
     * @param tabIndex the index of a tab stop
     * @param alignment tab alignment
     * @param location tab location in Pango units
     */
    setTab(tabIndex: number, alignment: TabAlign, location: number): void
    /**
     * Utility function to ensure that the tab stops are in increasing order.
     */
    sort(): void
    /**
     * Serializes a `PangoTabArray` to a string.
     *
     * No guarantees are made about the format of the string,
     * it may change between Pango versions.
     *
     * The intended use of this function is testing and
     * debugging. The format is not meant as a permanent
     * storage format.
     * @returns a newly allocated string
     */
    toString(): string | null
  }

  /**
   * A `PangoTabArray` contains an array of tab stops.
   *
   * `PangoTabArray` can be used to set tab stops in a `PangoLayout`.
   * Each tab stop has an alignment, a position, and optionally
   * a character to use as decimal point.
   * @record
   */
  class TabArray {
    // Own properties of Pango-1.0.Pango.TabArray

    static name: string

    // Constructors of Pango-1.0.Pango.TabArray

    /**
     * Creates an array of `initial_size` tab stops.
     *
     * Tab stops are specified in pixel units if `positions_in_pixels` is %TRUE,
     * otherwise in Pango units. All stops are initially at position 0.
     * @constructor
     * @param initialSize Initial number of tab stops to allocate, can be 0
     * @param positionsInPixels whether positions are in pixel units
     * @returns the newly allocated `PangoTabArray`, which should   be freed with [method@Pango.TabArray.free].
     */
    constructor(initialSize: number, positionsInPixels: boolean)
    /**
     * Creates an array of `initial_size` tab stops.
     *
     * Tab stops are specified in pixel units if `positions_in_pixels` is %TRUE,
     * otherwise in Pango units. All stops are initially at position 0.
     * @constructor
     * @param initialSize Initial number of tab stops to allocate, can be 0
     * @param positionsInPixels whether positions are in pixel units
     * @returns the newly allocated `PangoTabArray`, which should   be freed with [method@Pango.TabArray.free].
     */
    static new(initialSize: number, positionsInPixels: boolean): TabArray
    /**
     * Deserializes a `PangoTabArray` from a string.
     *
     * This is the counterpart to [method`Pango`.TabArray.to_string].
     * See that functions for details about the format.
     * @param text a string
     * @returns a new `PangoTabArray`
     */
    static fromString(text: string): TabArray | null
  }

  type Glyph = number
  type GlyphUnit = number
  type LayoutRun = GlyphItem
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace PangoCairo {
  /**
   * Retrieves any font rendering options previously set with
   * [func`PangoCairo`.context_set_font_options].
   *
   * This function does not report options that are derived from
   * the target surface by [func`update_context]`.
   * @param context a `PangoContext`, from a pangocairo font map
   * @returns the font options previously set on the   context, or %NULL if no options have been set. This value is   owned by the context and must not be modified or freed.
   */
  function contextGetFontOptions(
    context: Pango.Context
  ): cairo.FontOptions | null
  /**
   * Gets the resolution for the context.
   *
   * See [func`PangoCairo`.context_set_resolution]
   * @param context a `PangoContext`, from a pangocairo font map
   * @returns the resolution in "dots per inch". A negative value will   be returned if no resolution has previously been set.
   */
  function contextGetResolution(context: Pango.Context): number
  /**
   * Sets the font options used when rendering text with this context.
   *
   * These options override any options that [func`update_context]`
   * derives from the target surface.
   * @param context a `PangoContext`, from a pangocairo font map
   * @param options a `cairo_font_options_t`, or %NULL to unset   any previously set options. A copy is made.
   */
  function contextSetFontOptions(
    context: Pango.Context,
    options: cairo.FontOptions | null
  ): void
  /**
   * Sets the resolution for the context.
   *
   * This is a scale factor between points specified in a `PangoFontDescription`
   * and Cairo units. The default value is 96, meaning that a 10 point font will
   * be 13 units high. (10 * 96. / 72. = 13.3).
   * @param context a `PangoContext`, from a pangocairo font map
   * @param dpi the resolution in "dots per inch". (Physical inches aren't actually   involved; the terminology is conventional.) A 0 or negative value   means to use the resolution from the font map.
   */
  function contextSetResolution(context: Pango.Context, dpi: number): void
  /**
   * Sets callback function for context to use for rendering attributes
   * of type %PANGO_ATTR_SHAPE.
   *
   * See `PangoCairoShapeRendererFunc` for details.
   * @param context a `PangoContext`, from a pangocairo font map
   * @param func Callback function for rendering attributes of   type %PANGO_ATTR_SHAPE, or %NULL to disable shape rendering.
   */
  function contextSetShapeRenderer(
    context: Pango.Context,
    func: ShapeRendererFunc | null
  ): void
  /**
   * Creates a context object set up to match the current transformation
   * and target surface of the Cairo context.
   *
   * This context can then be
   * used to create a layout using [ctor`Pango`.Layout.new].
   *
   * This function is a convenience function that creates a context using
   * the default font map, then updates it to `cr`. If you just need to
   * create a layout for use with `cr` and do not need to access `PangoContext`
   * directly, you can use [func`create_layout]` instead.
   * @param cr a Cairo context
   * @returns the newly created `PangoContext`
   */
  function createContext(cr: cairo.Context): Pango.Context
  /**
   * Creates a layout object set up to match the current transformation
   * and target surface of the Cairo context.
   *
   * This layout can then be used for text measurement with functions
   * like [method`Pango`.Layout.get_size] or drawing with functions like
   * [func`show_layout]`. If you change the transformation or target
   * surface for `cr,` you need to call [func`update_layout]`.
   *
   * This function is the most convenient way to use Cairo with Pango,
   * however it is slightly inefficient since it creates a separate
   * `PangoContext` object for each layout. This might matter in an
   * application that was laying out large amounts of text.
   * @param cr a Cairo context
   * @returns the newly created `PangoLayout`
   */
  function createLayout(cr: cairo.Context): Pango.Layout
  /**
   * Add a squiggly line to the current path in the specified cairo context that
   * approximately covers the given rectangle in the style of an underline used
   * to indicate a spelling error.
   *
   * The width of the underline is rounded to an integer number of up/down
   * segments and the resulting rectangle is centered in the original rectangle.
   * @param cr a Cairo context
   * @param x The X coordinate of one corner of the rectangle
   * @param y The Y coordinate of one corner of the rectangle
   * @param width Non-negative width of the rectangle
   * @param height Non-negative height of the rectangle
   */
  function errorUnderlinePath(
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Gets a default `PangoCairoFontMap` to use with Cairo.
   *
   * Note that the type of the returned object will depend on the
   * particular font backend Cairo was compiled to use; you generally
   * should only use the `PangoFontMap` and `PangoCairoFontMap`
   * interfaces on the returned object.
   *
   * The default Cairo fontmap can be changed by using
   * [method`PangoCairo`.FontMap.set_default]. This can be used to
   * change the Cairo font backend that the default fontmap uses
   * for example.
   *
   * Note that since Pango 1.32.6, the default fontmap is per-thread.
   * Each thread gets its own default fontmap. In this way, PangoCairo
   * can be used safely from multiple threads.
   * @returns the default PangoCairo fontmap  for the current thread. This object is owned by Pango and must  not be freed.
   */
  function fontMapGetDefault(): Pango.FontMap
  /**
   * Creates a new `PangoCairoFontMap` object.
   *
   * A fontmap is used to cache information about available fonts,
   * and holds certain global parameters such as the resolution.
   * In most cases, you can use `func`PangoCairo`.font_map_get_default]
   * instead.
   *
   * Note that the type of the returned object will depend
   * on the particular font backend Cairo was compiled to use;
   * You generally should only use the `PangoFontMap` and
   * `PangoCairoFontMap` interfaces on the returned object.
   *
   * You can override the type of backend returned by using an
   * environment variable %PANGOCAIRO_BACKEND. Supported types,
   * based on your build, are fc (fontconfig), win32, and coretext.
   * If requested type is not available, NULL is returned. Ie.
   * this is only useful for testing, when at least two backends
   * are compiled in.
   * @returns the newly allocated `PangoFontMap`,   which should be freed with g_object_unref().
   */
  function fontMapNew(): Pango.FontMap
  /**
   * Creates a new `PangoCairoFontMap` object of the type suitable
   * to be used with cairo font backend of type `fonttype`.
   *
   * In most cases one should simply use [func`PangoCairo`.FontMap.new], or
   * in fact in most of those cases, just use [func`PangoCairo`.FontMap.get_default].
   * @param fonttype desired #cairo_font_type_t
   * @returns the newly allocated   `PangoFontMap` of suitable type which should be freed with   g_object_unref(), or %NULL if the requested cairo font backend   is not supported / compiled in.
   */
  function fontMapNewForFontType(fonttype: cairo.FontType): Pango.FontMap | null
  /**
   * Adds the glyphs in `glyphs` to the current path in the specified
   * cairo context.
   *
   * The origin of the glyphs (the left edge of the baseline)
   * will be at the current point of the cairo context.
   * @param cr a Cairo context
   * @param font a `PangoFont` from a `PangoCairoFontMap`
   * @param glyphs a `PangoGlyphString`
   */
  function glyphStringPath(
    cr: cairo.Context,
    font: Pango.Font,
    glyphs: Pango.GlyphString
  ): void
  /**
   * Adds the text in `PangoLayoutLine` to the current path in the
   * specified cairo context.
   *
   * The origin of the glyphs (the left edge of the line) will be
   * at the current point of the cairo context.
   * @param cr a Cairo context
   * @param line a `PangoLayoutLine`
   */
  function layoutLinePath(cr: cairo.Context, line: Pango.LayoutLine): void
  /**
   * Adds the text in a `PangoLayout` to the current path in the
   * specified cairo context.
   *
   * The top-left corner of the `PangoLayout` will be at the
   * current point of the cairo context.
   * @param cr a Cairo context
   * @param layout a Pango layout
   */
  function layoutPath(cr: cairo.Context, layout: Pango.Layout): void
  /**
   * Draw a squiggly line in the specified cairo context that approximately
   * covers the given rectangle in the style of an underline used to indicate a
   * spelling error.
   *
   * The width of the underline is rounded to an integer
   * number of up/down segments and the resulting rectangle is centered in the
   * original rectangle.
   * @param cr a Cairo context
   * @param x The X coordinate of one corner of the rectangle
   * @param y The Y coordinate of one corner of the rectangle
   * @param width Non-negative width of the rectangle
   * @param height Non-negative height of the rectangle
   */
  function showErrorUnderline(
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Draws the glyphs in `glyph_item` in the specified cairo context,
   *
   * embedding the text associated with the glyphs in the output if the
   * output format supports it (PDF for example), otherwise it acts
   * similar to [func`show_glyph_string]`.
   *
   * The origin of the glyphs (the left edge of the baseline) will
   * be drawn at the current point of the cairo context.
   *
   * Note that `text` is the start of the text for layout, which is then
   * indexed by `glyph_item->item->offset`.
   * @param cr a Cairo context
   * @param text the UTF-8 text that `glyph_item` refers to
   * @param glyphItem a `PangoGlyphItem`
   */
  function showGlyphItem(
    cr: cairo.Context,
    text: string,
    glyphItem: Pango.GlyphItem
  ): void
  /**
   * Draws the glyphs in `glyphs` in the specified cairo context.
   *
   * The origin of the glyphs (the left edge of the baseline) will
   * be drawn at the current point of the cairo context.
   * @param cr a Cairo context
   * @param font a `PangoFont` from a `PangoCairoFontMap`
   * @param glyphs a `PangoGlyphString`
   */
  function showGlyphString(
    cr: cairo.Context,
    font: Pango.Font,
    glyphs: Pango.GlyphString
  ): void
  /**
   * Draws a `PangoLayout` in the specified cairo context.
   *
   * The top-left corner of the `PangoLayout` will be drawn
   * at the current point of the cairo context.
   * @param cr a Cairo context
   * @param layout a Pango layout
   */
  function showLayout(cr: cairo.Context, layout: Pango.Layout): void
  /**
   * Draws a `PangoLayoutLine` in the specified cairo context.
   *
   * The origin of the glyphs (the left edge of the line) will
   * be drawn at the current point of the cairo context.
   * @param cr a Cairo context
   * @param line a `PangoLayoutLine`
   */
  function showLayoutLine(cr: cairo.Context, line: Pango.LayoutLine): void
  /**
   * Updates a `PangoContext` previously created for use with Cairo to
   * match the current transformation and target surface of a Cairo
   * context.
   *
   * If any layouts have been created for the context, it's necessary
   * to call [method`Pango`.Layout.context_changed] on those layouts.
   * @param cr a Cairo context
   * @param context a `PangoContext`, from a pangocairo font map
   */
  function updateContext(cr: cairo.Context, context: Pango.Context): void
  /**
   * Updates the private `PangoContext` of a `PangoLayout` created with
   * [func`create_layout]` to match the current transformation and target
   * surface of a Cairo context.
   * @param cr a Cairo context
   * @param layout a `PangoLayout`, from [func`create_layout]`
   */
  function updateLayout(cr: cairo.Context, layout: Pango.Layout): void
  /**
   * Function type for rendering attributes of type %PANGO_ATTR_SHAPE
   * with Pango's Cairo renderer.
   * @callback
   * @param cr a Cairo context with current point set to where the shape should be rendered
   * @param attr the %PANGO_ATTR_SHAPE to render
   * @param doPath whether only the shape path should be appended to current path of `cr` and no filling/stroking done.  This will be set to %TRUE when called from pango_cairo_layout_path() and pango_cairo_layout_line_path() rendering functions.
   */
  interface ShapeRendererFunc {
    (cr: cairo.Context, attr: Pango.AttrShape, doPath: boolean): void
  }
  module Font {
    // Constructor properties interface

    interface ConstructorProperties
      extends Pango.Font.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface Font extends Pango.Font {
    // Own properties of PangoCairo-1.0.PangoCairo.Font

    __gtype__: number

    // Owm methods of PangoCairo-1.0.PangoCairo.Font

    /**
     * Gets the `cairo_scaled_font_t` used by `font`.
     * The scaled font can be referenced and kept using
     * cairo_scaled_font_reference().
     * @returns the `cairo_scaled_font_t`   used by @font
     */
    getScaledFont(): cairo.ScaledFont | null

    // Class property signals of PangoCairo-1.0.PangoCairo.Font

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `PangoCairoFont` is an interface exported by fonts for
   * use with Cairo.
   *
   * The actual type of the font will depend on the particular
   * font technology Cairo was compiled to use.
   * @interface
   */
  class Font extends GObject.Object {
    // Own properties of PangoCairo-1.0.PangoCairo.Font

    static name: string

    // Constructors of PangoCairo-1.0.PangoCairo.Font

    constructor(config?: Font.ConstructorProperties)
    _init(config?: Font.ConstructorProperties): void
  }

  module FontMap {
    // Constructor properties interface

    interface ConstructorProperties
      extends Pango.FontMap.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface FontMap extends Pango.FontMap {
    // Own properties of PangoCairo-1.0.PangoCairo.FontMap

    __gtype__: number

    // Owm methods of PangoCairo-1.0.PangoCairo.FontMap

    /**
     * Gets the type of Cairo font backend that `fontmap` uses.
     * @returns the `cairo_font_type_t` cairo font backend type
     */
    getFontType(): cairo.FontType
    /**
     * Gets the resolution for the fontmap.
     *
     * See [method`PangoCairo`.FontMap.set_resolution].
     * @returns the resolution in "dots per inch"
     */
    getResolution(): number
    /**
     * Sets a default `PangoCairoFontMap` to use with Cairo.
     *
     * This can be used to change the Cairo font backend that the
     * default fontmap uses for example. The old default font map
     * is unreffed and the new font map referenced.
     *
     * Note that since Pango 1.32.6, the default fontmap is per-thread.
     * This function only changes the default fontmap for
     * the current thread. Default fontmaps of existing threads
     * are not changed. Default fontmaps of any new threads will
     * still be created using [func`PangoCairo`.FontMap.new].
     *
     * A value of %NULL for `fontmap` will cause the current default
     * font map to be released and a new default font map to be created
     * on demand, using [func`PangoCairo`.FontMap.new].
     */
    setDefault(): void
    /**
     * Sets the resolution for the fontmap.
     *
     * This is a scale factor between
     * points specified in a `PangoFontDescription` and Cairo units. The
     * default value is 96, meaning that a 10 point font will be 13
     * units high. (10 * 96. / 72. = 13.3).
     * @param dpi the resolution in "dots per inch". (Physical inches aren't actually   involved; the terminology is conventional.)
     */
    setResolution(dpi: number): void

    // Class property signals of PangoCairo-1.0.PangoCairo.FontMap

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `PangoCairoFontMap` is an interface exported by font maps for
   * use with Cairo.
   *
   * The actual type of the font map will depend on the particular
   * font technology Cairo was compiled to use.
   * @interface
   */
  class FontMap extends GObject.Object {
    // Own properties of PangoCairo-1.0.PangoCairo.FontMap

    static name: string

    // Constructors of PangoCairo-1.0.PangoCairo.FontMap

    constructor(config?: FontMap.ConstructorProperties)
    _init(config?: FontMap.ConstructorProperties): void
    /**
     * Creates a new `PangoCairoFontMap` object.
     *
     * A fontmap is used to cache information about available fonts,
     * and holds certain global parameters such as the resolution.
     * In most cases, you can use `func`PangoCairo`.font_map_get_default]
     * instead.
     *
     * Note that the type of the returned object will depend
     * on the particular font backend Cairo was compiled to use;
     * You generally should only use the `PangoFontMap` and
     * `PangoCairoFontMap` interfaces on the returned object.
     *
     * You can override the type of backend returned by using an
     * environment variable %PANGOCAIRO_BACKEND. Supported types,
     * based on your build, are fc (fontconfig), win32, and coretext.
     * If requested type is not available, NULL is returned. Ie.
     * this is only useful for testing, when at least two backends
     * are compiled in.
     * @returns the newly allocated `PangoFontMap`,   which should be freed with g_object_unref().
     */
    static new(): Pango.FontMap
    /**
     * Creates a new `PangoCairoFontMap` object of the type suitable
     * to be used with cairo font backend of type `fonttype`.
     *
     * In most cases one should simply use [func`PangoCairo`.FontMap.new], or
     * in fact in most of those cases, just use [func`PangoCairo`.FontMap.get_default].
     * @param fonttype desired #cairo_font_type_t
     * @returns the newly allocated   `PangoFontMap` of suitable type which should be freed with   g_object_unref(), or %NULL if the requested cairo font backend   is not supported / compiled in.
     */
    static newForFontType(fonttype: cairo.FontType): Pango.FontMap | null
    /**
     * Gets a default `PangoCairoFontMap` to use with Cairo.
     *
     * Note that the type of the returned object will depend on the
     * particular font backend Cairo was compiled to use; you generally
     * should only use the `PangoFontMap` and `PangoCairoFontMap`
     * interfaces on the returned object.
     *
     * The default Cairo fontmap can be changed by using
     * [method`PangoCairo`.FontMap.set_default]. This can be used to
     * change the Cairo font backend that the default fontmap uses
     * for example.
     *
     * Note that since Pango 1.32.6, the default fontmap is per-thread.
     * Each thread gets its own default fontmap. In this way, PangoCairo
     * can be used safely from multiple threads.
     * @returns the default PangoCairo fontmap  for the current thread. This object is owned by Pango and must  not be freed.
     */
    static getDefault(): Pango.FontMap
  }
}

type GdkPixbuf20 = typeof GdkPixbuf

declare global {
  interface NodeGtkGi {
    require(ns: "GdkPixbuf", ver?: "2.0"): GdkPixbuf20
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace GdkPixbuf {
  /**
   * This enumeration defines the color spaces that are supported by
   * the gdk-pixbuf library.
   *
   * Currently only RGB is supported.
   */
  enum Colorspace {
    /**
     * Indicates a red/green/blue additive color space.
     */
    RGB,
  }
  /**
   * Interpolation modes for scaling functions.
   *
   * The `GDK_INTERP_NEAREST` mode is the fastest scaling method, but has
   * horrible quality when scaling down; `GDK_INTERP_BILINEAR` is the best
   * choice if you aren't sure what to choose, it has a good speed/quality
   * balance.
   *
   * **Note**: Cubic filtering is missing from the list; hyperbolic
   * interpolation is just as fast and results in higher quality.
   */
  enum InterpType {
    /**
     * Nearest neighbor sampling; this is the fastest
     *  and lowest quality mode. Quality is normally unacceptable when scaling
     *  down, but may be OK when scaling up.
     */
    NEAREST,
    /**
     * This is an accurate simulation of the PostScript
     *  image operator without any interpolation enabled.  Each pixel is
     *  rendered as a tiny parallelogram of solid color, the edges of which
     *  are implemented with antialiasing.  It resembles nearest neighbor for
     *  enlargement, and bilinear for reduction.
     */
    TILES,
    /**
     * Best quality/speed balance; use this mode by
     *  default. Bilinear interpolation.  For enlargement, it is
     *  equivalent to point-sampling the ideal bilinear-interpolated image.
     *  For reduction, it is equivalent to laying down small tiles and
     *  integrating over the coverage area.
     */
    BILINEAR,
    /**
     * This is the slowest and highest quality
     *  reconstruction function. It is derived from the hyperbolic filters in
     *  Wolberg's "Digital Image Warping", and is formally defined as the
     *  hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
     *  image (the filter is designed to be idempotent for 1:1 pixel mapping).
     *  **Deprecated**: this interpolation filter is deprecated, as in reality
     *  it has a lower quality than the `GDK_INTERP_BILINEAR` filter
     *  (Since: 2.38)
     */
    HYPER,
  }
  /**
   * Control the alpha channel for drawables.
   *
   * These values can be passed to gdk_pixbuf_xlib_render_to_drawable_alpha()
   * in gdk-pixbuf-xlib to control how the alpha channel of an image should
   * be handled.
   *
   * This function can create a bilevel clipping mask (black and white) and use
   * it while painting the image.
   *
   * In the future, when the X Window System gets an alpha channel extension,
   * it will be possible to do full alpha compositing onto arbitrary drawables.
   * For now both cases fall back to a bilevel clipping mask.
   */
  enum PixbufAlphaMode {
    /**
     * A bilevel clipping mask (black and white)
     *  will be created and used to draw the image.  Pixels below 0.5 opacity
     *  will be considered fully transparent, and all others will be
     *  considered fully opaque.
     */
    BILEVEL,
    /**
     * For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL.
     *  In the future it will do full alpha compositing.
     */
    FULL,
  }
  /**
   * An error code in the `GDK_PIXBUF_ERROR` domain.
   *
   * Many gdk-pixbuf operations can cause errors in this domain, or in
   * the `G_FILE_ERROR` domain.
   */
  enum PixbufError {
    /**
     * An image file was broken somehow.
     */
    CORRUPT_IMAGE,
    /**
     * Not enough memory.
     */
    INSUFFICIENT_MEMORY,
    /**
     * A bad option was passed to a pixbuf save module.
     */
    BAD_OPTION,
    /**
     * Unknown image type.
     */
    UNKNOWN_TYPE,
    /**
     * Don't know how to perform the
     *  given operation on the type of image at hand.
     */
    UNSUPPORTED_OPERATION,
    /**
     * Generic failure code, something went wrong.
     */
    FAILED,
    /**
     * Only part of the animation was loaded.
     */
    INCOMPLETE_ANIMATION,
  }
  /**
   * The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
   *
   * To make them easier to use, their numerical values are the actual degrees.
   */
  enum PixbufRotation {
    /**
     * No rotation.
     */
    NONE,
    /**
     * Rotate by 90 degrees.
     */
    COUNTERCLOCKWISE,
    /**
     * Rotate by 180 degrees.
     */
    UPSIDEDOWN,
    /**
     * Rotate by 270 degrees.
     */
    CLOCKWISE,
  }
  /**
   * Flags which allow a module to specify further details about the supported
   * operations.
   * @bitfield
   */
  enum PixbufFormatFlags {
    /**
     * the module can write out images in the format.
     */
    WRITABLE,
    /**
     * the image format is scalable
     */
    SCALABLE,
    /**
     * the module is threadsafe. gdk-pixbuf
     *     ignores modules that are not marked as threadsafe. (Since 2.28).
     */
    THREADSAFE,
  }
  /**
   * Major version of gdk-pixbuf library, that is the "0" in
   * "0.8.2" for example.
   */
  const PIXBUF_MAJOR: number
  /**
   * Micro version of gdk-pixbuf library, that is the "2" in
   * "0.8.2" for example.
   */
  const PIXBUF_MICRO: number
  /**
   * Minor version of gdk-pixbuf library, that is the "8" in
   * "0.8.2" for example.
   */
  const PIXBUF_MINOR: number
  /**
   * Contains the full version of GdkPixbuf as a string.
   *
   * This is the version being compiled against; contrast with
   * `gdk_pixbuf_version`.
   */
  const PIXBUF_VERSION: string
  function pixbufErrorQuark(): GLib.Quark
  /**
   * A function of this type is responsible for freeing the pixel array
   * of a pixbuf.
   *
   * The gdk_pixbuf_new_from_data() function lets you pass in a pre-allocated
   * pixel array so that a pixbuf can be created from it; in this case you
   * will need to pass in a function of type `GdkPixbufDestroyNotify` so that
   * the pixel data can be freed when the pixbuf is finalized.
   * @callback
   * @param pixels The pixel array of the pixbuf   that is being finalized.
   */
  interface PixbufDestroyNotify {
    (pixels: number[]): void
  }
  /**
   * Defines the type of the function used to fill a
   * #GdkPixbufFormat structure with information about a module.
   * @callback
   * @param info a #GdkPixbufFormat.
   */
  interface PixbufModuleFillInfoFunc {
    (info: PixbufFormat): void
  }
  /**
   * Defines the type of the function used to set the vtable of a
   * #GdkPixbufModule when it is loaded.
   * @callback
   * @param module a #GdkPixbufModule.
   */
  interface PixbufModuleFillVtableFunc {
    (module: PixbufModule): void
  }
  /**
   * Incrementally loads a buffer into the image data.
   * @callback
   * @param context the state object created by [callback`GdkPixbuf`.PixbufModuleBeginLoadFunc]
   * @param buf the data to load
   * @returns `TRUE` if the incremental load was successful
   */
  interface PixbufModuleIncrementLoadFunc {
    (context: any | null, buf: number[]): boolean
  }
  /**
   * Loads a file from a standard C file stream into a new `GdkPixbufAnimation`.
   *
   * In case of error, this function should return `NULL` and set the `error` argument.
   * @callback
   * @param f the file stream from which the image should be loaded
   * @returns a newly created `GdkPixbufAnimation` for the contents of the file
   */
  interface PixbufModuleLoadAnimationFunc {
    (f: any | null): PixbufAnimation
  }
  /**
   * Loads a file from a standard C file stream into a new `GdkPixbuf`.
   *
   * In case of error, this function should return `NULL` and set the `error` argument.
   * @callback
   * @param f the file stream from which the image should be loaded
   * @returns a newly created `GdkPixbuf` for the contents of the file
   */
  interface PixbufModuleLoadFunc {
    (f: any | null): Pixbuf
  }
  /**
   * Loads XPM data into a new `GdkPixbuf`.
   * @callback
   * @param data the XPM data
   * @returns a newly created `GdkPixbuf` for the XPM data
   */
  interface PixbufModuleLoadXpmDataFunc {
    (data: string[]): Pixbuf
  }
  /**
   * Defines the type of the function that gets called once the initial
   * setup of `pixbuf` is done.
   *
   * #GdkPixbufLoader uses a function of this type to emit the
   * "<link linkend="GdkPixbufLoader-area-prepared">area_prepared</link>"
   * signal.
   * @callback
   * @param pixbuf the #GdkPixbuf that is currently being loaded.
   * @param anim if an animation is being loaded, the #GdkPixbufAnimation, else %NULL.
   */
  interface PixbufModulePreparedFunc {
    (pixbuf: Pixbuf, anim: PixbufAnimation): void
  }
  /**
   * Saves a `GdkPixbuf` into a standard C file stream.
   *
   * The optional `param_keys` and `param_values` arrays contain the keys and
   * values (in the same order) for attributes to be saved alongside the image
   * data.
   * @callback
   * @param f the file stream into which the image should be saved
   * @param pixbuf the image to save
   * @param paramKeys parameter keys to save
   * @param paramValues parameter values to save
   * @returns `TRUE` on success; in case of failure, `FALSE` is returned and   the `error` is set
   */
  interface PixbufModuleSaveFunc {
    (
      f: any | null,
      pixbuf: Pixbuf,
      paramKeys: string[] | null,
      paramValues: string[] | null
    ): boolean
  }
  /**
   * Checks whether the given `option_key` is supported when saving.
   * @callback
   * @param optionKey the option key to check
   * @returns `TRUE` if the option is supported
   */
  interface PixbufModuleSaveOptionSupportedFunc {
    (optionKey: string): boolean
  }
  /**
   * Defines the type of the function that gets called once the size
   * of the loaded image is known.
   *
   * The function is expected to set `width` and `height` to the desired
   * size to which the image should be scaled. If a module has no efficient
   * way to achieve the desired scaling during the loading of the image, it may
   * either ignore the size request, or only approximate it - gdk-pixbuf will
   * then perform the required scaling on the completely loaded image.
   *
   * If the function sets `width` or `height` to zero, the module should interpret
   * this as a hint that it will be closed soon and shouldn't allocate further
   * resources. This convention is used to implement gdk_pixbuf_get_file_info()
   * efficiently.
   * @callback
   * @param width pointer to a location containing the current image width
   * @param height pointer to a location containing the current image height
   */
  interface PixbufModuleSizeFunc {
    (width: number, height: number): void
  }
  /**
   * Finalizes the image loading state.
   *
   * This function is called on success and error states.
   * @callback
   * @param context the state object created by [callback`GdkPixbuf`.PixbufModuleBeginLoadFunc]
   * @returns `TRUE` if the loading operation was successful
   */
  interface PixbufModuleStopLoadFunc {
    (context: any | null): boolean
  }
  /**
   * Defines the type of the function that gets called every time a region
   * of `pixbuf` is updated.
   *
   * #GdkPixbufLoader uses a function of this type to emit the
   * "<link linkend="GdkPixbufLoader-area-updated">area_updated</link>"
   * signal.
   * @callback
   * @param pixbuf the #GdkPixbuf that is currently being loaded.
   * @param x the X origin of the updated area.
   * @param y the Y origin of the updated area.
   * @param width the width of the updated area.
   * @param height the height of the updated area.
   */
  interface PixbufModuleUpdatedFunc {
    (pixbuf: Pixbuf, x: number, y: number, width: number, height: number): void
  }
  /**
   * Save functions used by [method`GdkPixbuf`.Pixbuf.save_to_callback].
   *
   * This function is called once for each block of bytes that is "written"
   * by `gdk_pixbuf_save_to_callback()`.
   *
   * If successful it should return `TRUE`; if an error occurs it should set
   * `error` and return `FALSE`, in which case `gdk_pixbuf_save_to_callback()`
   * will fail with the same error.
   * @callback
   * @param buf bytes to be written.
   * @returns `TRUE` if successful, `FALSE` otherwise
   */
  interface PixbufSaveFunc {
    (buf: number[]): boolean
  }
  module Pixbuf {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.Icon.ConstructorProperties,
        Gio.LoadableIcon.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf

      /**
       * The number of bits per sample.
       *
       * Currently only 8 bit per sample are supported.
       */
      bits_per_sample?: number | null
      /**
       * The color space of the pixbuf.
       *
       * Currently, only `GDK_COLORSPACE_RGB` is supported.
       */
      colorspace?: Colorspace | null
      /**
       * Whether the pixbuf has an alpha channel.
       */
      has_alpha?: boolean | null
      /**
       * The number of rows of the pixbuf.
       */
      height?: number | null
      /**
       * The number of samples per pixel.
       *
       * Currently, only 3 or 4 samples per pixel are supported.
       */
      n_channels?: number | null
      pixel_bytes?: any | null
      /**
       * A pointer to the pixel data of the pixbuf.
       */
      pixels?: any | null
      /**
       * The number of bytes between the start of a row and
       * the start of the next row.
       *
       * This number must (obviously) be at least as large as the
       * width of the pixbuf.
       */
      rowstride?: number | null
      /**
       * The number of columns of the pixbuf.
       */
      width?: number | null
    }
  }

  interface Pixbuf extends Gio.Icon, Gio.LoadableIcon {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf

    /**
     * The number of bits per sample.
     *
     * Currently only 8 bit per sample are supported.
     */
    readonly bitsPerSample: number
    /**
     * The color space of the pixbuf.
     *
     * Currently, only `GDK_COLORSPACE_RGB` is supported.
     */
    readonly colorspace: Colorspace
    /**
     * Whether the pixbuf has an alpha channel.
     */
    readonly hasAlpha: boolean
    /**
     * The number of rows of the pixbuf.
     */
    readonly height: number
    /**
     * The number of samples per pixel.
     *
     * Currently, only 3 or 4 samples per pixel are supported.
     */
    readonly nChannels: number
    readonly pixelBytes: any
    /**
     * A pointer to the pixel data of the pixbuf.
     */
    readonly pixels: any
    /**
     * The number of bytes between the start of a row and
     * the start of the next row.
     *
     * This number must (obviously) be at least as large as the
     * width of the pixbuf.
     */
    readonly rowstride: number
    /**
     * The number of columns of the pixbuf.
     */
    readonly width: number
    __gtype__: number

    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.Pixbuf

    /**
     * Takes an existing pixbuf and adds an alpha channel to it.
     *
     * If the existing pixbuf already had an alpha channel, the channel
     * values are copied from the original; otherwise, the alpha channel
     * is initialized to 255 (full opacity).
     *
     * If `substitute_color` is `TRUE`, then the color specified by the
     * (`r`, `g`, `b`) arguments will be assigned zero opacity. That is,
     * if you pass `(255, 255, 255)` for the substitute color, all white
     * pixels will become fully transparent.
     *
     * If `substitute_color` is `FALSE`, then the (`r`, `g`, `b`) arguments
     * will be ignored.
     * @param substituteColor Whether to set a color to zero opacity.
     * @param r Red value to substitute.
     * @param g Green value to substitute.
     * @param b Blue value to substitute.
     * @returns A newly-created pixbuf
     */
    addAlpha(substituteColor: boolean, r: number, g: number, b: number): Pixbuf
    /**
     * Takes an existing pixbuf and checks for the presence of an
     * associated "orientation" option.
     *
     * The orientation option may be provided by the JPEG loader (which
     * reads the exif orientation tag) or the TIFF loader (which reads
     * the TIFF orientation tag, and compensates it for the partial
     * transforms performed by libtiff).
     *
     * If an orientation option/tag is present, the appropriate transform
     * will be performed so that the pixbuf is oriented correctly.
     * @returns A newly-created pixbuf
     */
    applyEmbeddedOrientation(): Pixbuf | null
    /**
     * Creates a transformation of the source image `src` by scaling by
     * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y`.
     *
     * This gives an image in the coordinates of the destination pixbuf.
     * The rectangle (`dest_x,` `dest_y,` `dest_width,` `dest_height)`
     * is then alpha blended onto the corresponding rectangle of the
     * original destination image.
     *
     * When the destination rectangle contains parts not in the source
     * image, the data at the edges of the source image is replicated
     * to infinity.
     *
     * ![](composite.png)
     * @param dest the #GdkPixbuf into which to render the results
     * @param destX the left coordinate for region to render
     * @param destY the top coordinate for region to render
     * @param destWidth the width of the region to render
     * @param destHeight the height of the region to render
     * @param offsetX the offset in the X direction (currently rounded to an integer)
     * @param offsetY the offset in the Y direction (currently rounded to an integer)
     * @param scaleX the scale factor in the X direction
     * @param scaleY the scale factor in the Y direction
     * @param interpType the interpolation type for the transformation.
     * @param overallAlpha overall alpha for source image (0..255)
     */
    composite(
      dest: Pixbuf,
      destX: number,
      destY: number,
      destWidth: number,
      destHeight: number,
      offsetX: number,
      offsetY: number,
      scaleX: number,
      scaleY: number,
      interpType: InterpType,
      overallAlpha: number
    ): void
    /**
     * Creates a transformation of the source image `src` by scaling by
     * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y,`
     * then alpha blends the rectangle (`dest_x` ,`dest_y,` `dest_width,`
     * `dest_height)` of the resulting image with a checkboard of the
     * colors `color1` and `color2` and renders it onto the destination
     * image.
     *
     * If the source image has no alpha channel, and `overall_alpha` is 255, a fast
     * path is used which omits the alpha blending and just performs the scaling.
     *
     * See gdk_pixbuf_composite_color_simple() for a simpler variant of this
     * function suitable for many tasks.
     * @param dest the #GdkPixbuf into which to render the results
     * @param destX the left coordinate for region to render
     * @param destY the top coordinate for region to render
     * @param destWidth the width of the region to render
     * @param destHeight the height of the region to render
     * @param offsetX the offset in the X direction (currently rounded to an integer)
     * @param offsetY the offset in the Y direction (currently rounded to an integer)
     * @param scaleX the scale factor in the X direction
     * @param scaleY the scale factor in the Y direction
     * @param interpType the interpolation type for the transformation.
     * @param overallAlpha overall alpha for source image (0..255)
     * @param checkX the X offset for the checkboard (origin of checkboard is at -`check_x,` -`check_y)`
     * @param checkY the Y offset for the checkboard
     * @param checkSize the size of checks in the checkboard (must be a power of two)
     * @param color1 the color of check at upper left
     * @param color2 the color of the other check
     */
    compositeColor(
      dest: Pixbuf,
      destX: number,
      destY: number,
      destWidth: number,
      destHeight: number,
      offsetX: number,
      offsetY: number,
      scaleX: number,
      scaleY: number,
      interpType: InterpType,
      overallAlpha: number,
      checkX: number,
      checkY: number,
      checkSize: number,
      color1: number,
      color2: number
    ): void
    /**
     * Creates a new pixbuf by scaling `src` to `dest_width` x `dest_height`
     * and alpha blending the result with a checkboard of colors `color1`
     * and `color2`.
     * @param destWidth the width of destination image
     * @param destHeight the height of destination image
     * @param interpType the interpolation type for the transformation.
     * @param overallAlpha overall alpha for source image (0..255)
     * @param checkSize the size of checks in the checkboard (must be a power of two)
     * @param color1 the color of check at upper left
     * @param color2 the color of the other check
     * @returns the new pixbuf
     */
    compositeColorSimple(
      destWidth: number,
      destHeight: number,
      interpType: InterpType,
      overallAlpha: number,
      checkSize: number,
      color1: number,
      color2: number
    ): Pixbuf | null
    /**
     * Creates a new `GdkPixbuf` with a copy of the information in the specified
     * `pixbuf`.
     *
     * Note that this does not copy the options set on the original `GdkPixbuf`,
     * use gdk_pixbuf_copy_options() for this.
     * @returns A newly-created pixbuf
     */
    copy(): Pixbuf | null
    /**
     * Copies a rectangular area from `src_pixbuf` to `dest_pixbuf`.
     *
     * Conversion of pixbuf formats is done automatically.
     *
     * If the source rectangle overlaps the destination rectangle on the
     * same pixbuf, it will be overwritten during the copy operation.
     * Therefore, you can not use this function to scroll a pixbuf.
     * @param srcX Source X coordinate within `src_pixbuf`.
     * @param srcY Source Y coordinate within `src_pixbuf`.
     * @param width Width of the area to copy.
     * @param height Height of the area to copy.
     * @param destPixbuf Destination pixbuf.
     * @param destX X coordinate within `dest_pixbuf`.
     * @param destY Y coordinate within `dest_pixbuf`.
     */
    copyArea(
      srcX: number,
      srcY: number,
      width: number,
      height: number,
      destPixbuf: Pixbuf,
      destX: number,
      destY: number
    ): void
    /**
     * Copies the key/value pair options attached to a `GdkPixbuf` to another
     * `GdkPixbuf`.
     *
     * This is useful to keep original metadata after having manipulated
     * a file. However be careful to remove metadata which you've already
     * applied, such as the "orientation" option after rotating the image.
     * @param destPixbuf the destination pixbuf
     * @returns `TRUE` on success.
     */
    copyOptions(destPixbuf: Pixbuf): boolean
    /**
     * Clears a pixbuf to the given RGBA value, converting the RGBA value into
     * the pixbuf's pixel format.
     *
     * The alpha component will be ignored if the pixbuf doesn't have an alpha
     * channel.
     * @param pixel RGBA pixel to used to clear (`0xffffffff` is opaque white,   `0x00000000` transparent black)
     */
    fill(pixel: number): void
    /**
     * Flips a pixbuf horizontally or vertically and returns the
     * result in a new pixbuf.
     * @param horizontal `TRUE` to flip horizontally, `FALSE` to flip vertically
     * @returns the new pixbuf
     */
    flip(horizontal: boolean): Pixbuf | null
    /**
     * Queries the number of bits per color sample in a pixbuf.
     * @returns Number of bits per color sample.
     */
    getBitsPerSample(): number
    /**
     * Returns the length of the pixel data, in bytes.
     * @returns The length of the pixel data.
     */
    getByteLength(): number
    /**
     * Queries the color space of a pixbuf.
     * @returns Color space.
     */
    getColorspace(): Colorspace
    /**
     * Queries whether a pixbuf has an alpha channel (opacity information).
     * @returns `TRUE` if it has an alpha channel, `FALSE` otherwise.
     */
    getHasAlpha(): boolean
    /**
     * Queries the height of a pixbuf.
     * @returns Height in pixels.
     */
    getHeight(): number
    /**
     * Queries the number of channels of a pixbuf.
     * @returns Number of channels.
     */
    getNChannels(): number
    /**
     * Looks up `key` in the list of options that may have been attached to the
     * `pixbuf` when it was loaded, or that may have been attached by another
     * function using gdk_pixbuf_set_option().
     *
     * For instance, the ANI loader provides "Title" and "Artist" options.
     * The ICO, XBM, and XPM loaders provide "x_hot" and "y_hot" hot-spot
     * options for cursor definitions. The PNG loader provides the tEXt ancillary
     * chunk key/value pairs as options. Since 2.12, the TIFF and JPEG loaders
     * return an "orientation" option string that corresponds to the embedded
     * TIFF/Exif orientation tag (if present). Since 2.32, the TIFF loader sets
     * the "multipage" option string to "yes" when a multi-page TIFF is loaded.
     * Since 2.32 the JPEG and PNG loaders set "x-dpi" and "y-dpi" if the file
     * contains image density information in dots per inch.
     * Since 2.36.6, the JPEG loader sets the "comment" option with the comment
     * EXIF tag.
     * @param key a nul-terminated string.
     * @returns the value associated with `key`
     */
    getOption(key: string): string | null
    /**
     * Returns a `GHashTable` with a list of all the options that may have been
     * attached to the `pixbuf` when it was loaded, or that may have been
     * attached by another function using [method`GdkPixbuf`.Pixbuf.set_option].
     * @returns a #GHashTable   of key/values pairs
     */
    getOptions(): GLib.HashTable
    /**
     * Queries a pointer to the pixel data of a pixbuf.
     *
     * This function will cause an implicit copy of the pixbuf data if the
     * pixbuf was created from read-only data.
     *
     * Please see the section on [image data](class.Pixbuf.html#image-data) for information
     * about how the pixel data is stored in memory.
     * @returns A pointer to the pixbuf's pixel data.
     */
    getPixels(): number[]
    /**
     * Queries the rowstride of a pixbuf, which is the number of bytes between
     * the start of a row and the start of the next row.
     * @returns Distance between row starts.
     */
    getRowstride(): number
    /**
     * Queries the width of a pixbuf.
     * @returns Width in pixels.
     */
    getWidth(): number
    /**
     * Creates a new pixbuf which represents a sub-region of `src_pixbuf`.
     *
     * The new pixbuf shares its pixels with the original pixbuf, so
     * writing to one affects both.  The new pixbuf holds a reference to
     * `src_pixbuf`, so `src_pixbuf` will not be finalized until the new
     * pixbuf is finalized.
     *
     * Note that if `src_pixbuf` is read-only, this function will force it
     * to be mutable.
     * @param srcX X coord in `src_pixbuf`
     * @param srcY Y coord in `src_pixbuf`
     * @param width width of region in `src_pixbuf`
     * @param height height of region in `src_pixbuf`
     * @returns a new pixbuf
     */
    newSubpixbuf(
      srcX: number,
      srcY: number,
      width: number,
      height: number
    ): Pixbuf
    /**
     * Provides a #GBytes buffer containing the raw pixel data; the data
     * must not be modified.
     *
     * This function allows skipping the implicit copy that must be made
     * if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
     * @returns A new reference to a read-only copy of   the pixel data.  Note that for mutable pixbufs, this function will   incur a one-time copy of the pixel data for conversion into the   returned #GBytes.
     */
    readPixelBytes(): any
    /**
     * Provides a read-only pointer to the raw pixel data.
     *
     * This function allows skipping the implicit copy that must be made
     * if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
     * @returns a read-only pointer to the raw pixel data
     */
    readPixels(): number
    /**
     * Removes the key/value pair option attached to a `GdkPixbuf`.
     * @param key a nul-terminated string representing the key to remove.
     * @returns `TRUE` if an option was removed, `FALSE` if not.
     */
    removeOption(key: string): boolean
    /**
     * Rotates a pixbuf by a multiple of 90 degrees, and returns the
     * result in a new pixbuf.
     *
     * If `angle` is 0, this function will return a copy of `src`.
     * @param angle the angle to rotate by
     * @returns the new pixbuf
     */
    rotateSimple(angle: PixbufRotation): Pixbuf | null
    /**
     * Modifies saturation and optionally pixelates `src`, placing the result in
     * `dest`.
     *
     * The `src` and `dest` pixbufs must have the same image format, size, and
     * rowstride.
     *
     * The `src` and `dest` arguments may be the same pixbuf with no ill effects.
     *
     * If `saturation` is 1.0 then saturation is not changed. If it's less than 1.0,
     * saturation is reduced (the image turns toward grayscale); if greater than
     * 1.0, saturation is increased (the image gets more vivid colors).
     *
     * If `pixelate` is `TRUE`, then pixels are faded in a checkerboard pattern to
     * create a pixelated image.
     * @param dest place to write modified version of `src`
     * @param saturation saturation factor
     * @param pixelate whether to pixelate
     */
    saturateAndPixelate(
      dest: Pixbuf,
      saturation: number,
      pixelate: boolean
    ): void
    /**
     * Vector version of `gdk_pixbuf_save_to_buffer()`.
     *
     * Saves pixbuf to a new buffer in format `type,` which is currently "jpeg",
     * "tiff", "png", "ico" or "bmp".
     *
     * See [method`GdkPixbuf`.Pixbuf.save_to_buffer] for more details.
     * @param type name of file format.
     * @param optionKeys name of options to set
     * @param optionValues values for named options
     * @returns whether an error was set
     */
    saveToBufferv(
      type: string,
      optionKeys: string[] | null,
      optionValues: string[] | null
    ): [/* returnType */ boolean, /* buffer */ number[]]
    /**
     * Vector version of `gdk_pixbuf_save_to_callback()`.
     *
     * Saves pixbuf to a callback in format `type,` which is currently "jpeg",
     * "png", "tiff", "ico" or "bmp".
     *
     * If `error` is set, `FALSE` will be returned.
     *
     * See [method`GdkPixbuf`.Pixbuf.save_to_callback] for more details.
     * @param saveFunc a function that is called to save each block of data that   the save routine generates.
     * @param type name of file format.
     * @param optionKeys name of options to set
     * @param optionValues values for named options
     * @returns whether an error was set
     */
    saveToCallbackv(
      saveFunc: PixbufSaveFunc,
      type: string,
      optionKeys: string[] | null,
      optionValues: string[] | null
    ): boolean
    /**
     * Saves `pixbuf` to an output stream.
     *
     * Supported file formats are currently "jpeg", "tiff", "png", "ico" or
     * "bmp".
     *
     * See [method`GdkPixbuf`.Pixbuf.save_to_stream] for more details.
     * @param stream a `GOutputStream` to save the pixbuf to
     * @param type name of file format
     * @param optionKeys name of options to set
     * @param optionValues values for named options
     * @param cancellable optional `GCancellable` object, `NULL` to ignore
     * @returns `TRUE` if the pixbuf was saved successfully, `FALSE` if an   error was set.
     */
    saveToStreamv(
      stream: Gio.OutputStream,
      type: string,
      optionKeys: string[] | null,
      optionValues: string[] | null,
      cancellable: Gio.Cancellable | null
    ): boolean
    /**
     * Saves `pixbuf` to an output stream asynchronously.
     *
     * For more details see gdk_pixbuf_save_to_streamv(), which is the synchronous
     * version of this function.
     *
     * When the operation is finished, `callback` will be called in the main thread.
     *
     * You can then call gdk_pixbuf_save_to_stream_finish() to get the result of
     * the operation.
     * @param stream a `GOutputStream` to which to save the pixbuf
     * @param type name of file format
     * @param optionKeys name of options to set
     * @param optionValues values for named options
     * @param cancellable optional `GCancellable` object, `NULL` to ignore
     * @param callback a `GAsyncReadyCallback` to call when the pixbuf is saved
     */
    saveToStreamvAsync(
      stream: Gio.OutputStream,
      type: string,
      optionKeys: string[] | null,
      optionValues: string[] | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Vector version of `gdk_pixbuf_save()`.
     *
     * Saves pixbuf to a file in `type`, which is currently "jpeg", "png", "tiff", "ico" or "bmp".
     *
     * If `error` is set, `FALSE` will be returned.
     *
     * See [method`GdkPixbuf`.Pixbuf.save] for more details.
     * @param filename name of file to save.
     * @param type name of file format.
     * @param optionKeys name of options to set
     * @param optionValues values for named options
     * @returns whether an error was set
     */
    savev(
      filename: string,
      type: string,
      optionKeys: string[] | null,
      optionValues: string[] | null
    ): boolean
    /**
     * Creates a transformation of the source image `src` by scaling by
     * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y,`
     * then renders the rectangle (`dest_x,` `dest_y,` `dest_width,`
     * `dest_height)` of the resulting image onto the destination image
     * replacing the previous contents.
     *
     * Try to use gdk_pixbuf_scale_simple() first; this function is
     * the industrial-strength power tool you can fall back to, if
     * gdk_pixbuf_scale_simple() isn't powerful enough.
     *
     * If the source rectangle overlaps the destination rectangle on the
     * same pixbuf, it will be overwritten during the scaling which
     * results in rendering artifacts.
     * @param dest the #GdkPixbuf into which to render the results
     * @param destX the left coordinate for region to render
     * @param destY the top coordinate for region to render
     * @param destWidth the width of the region to render
     * @param destHeight the height of the region to render
     * @param offsetX the offset in the X direction (currently rounded to an integer)
     * @param offsetY the offset in the Y direction (currently rounded to an integer)
     * @param scaleX the scale factor in the X direction
     * @param scaleY the scale factor in the Y direction
     * @param interpType the interpolation type for the transformation.
     */
    scale(
      dest: Pixbuf,
      destX: number,
      destY: number,
      destWidth: number,
      destHeight: number,
      offsetX: number,
      offsetY: number,
      scaleX: number,
      scaleY: number,
      interpType: InterpType
    ): void
    /**
     * Create a new pixbuf containing a copy of `src` scaled to
     * `dest_width` x `dest_height`.
     *
     * This function leaves `src` unaffected.
     *
     * The `interp_type` should be `GDK_INTERP_NEAREST` if you want maximum
     * speed (but when scaling down `GDK_INTERP_NEAREST` is usually unusably
     * ugly). The default `interp_type` should be `GDK_INTERP_BILINEAR` which
     * offers reasonable quality and speed.
     *
     * You can scale a sub-portion of `src` by creating a sub-pixbuf
     * pointing into `src`; see [method`GdkPixbuf`.Pixbuf.new_subpixbuf].
     *
     * If `dest_width` and `dest_height` are equal to the width and height of
     * `src`, this function will return an unscaled copy of `src`.
     *
     * For more complicated scaling/alpha blending see [method`GdkPixbuf`.Pixbuf.scale]
     * and [method`GdkPixbuf`.Pixbuf.composite].
     * @param destWidth the width of destination image
     * @param destHeight the height of destination image
     * @param interpType the interpolation type for the transformation.
     * @returns the new pixbuf
     */
    scaleSimple(
      destWidth: number,
      destHeight: number,
      interpType: InterpType
    ): Pixbuf | null
    /**
     * Attaches a key/value pair as an option to a `GdkPixbuf`.
     *
     * If `key` already exists in the list of options attached to the `pixbuf`,
     * the new value is ignored and `FALSE` is returned.
     * @param key a nul-terminated string.
     * @param value a nul-terminated string.
     * @returns `TRUE` on success
     */
    setOption(key: string, value: string): boolean

    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.Pixbuf

    connect(
      sigName: "notify::bits-per-sample",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::bits-per-sample",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::bits-per-sample",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::bits-per-sample",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::bits-per-sample", ...args: any[]): void
    connect(
      sigName: "notify::colorspace",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::colorspace",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::colorspace",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::colorspace",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::colorspace", ...args: any[]): void
    connect(
      sigName: "notify::has-alpha",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-alpha",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-alpha", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::n-channels",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-channels",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-channels",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-channels",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-channels", ...args: any[]): void
    connect(
      sigName: "notify::pixel-bytes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixel-bytes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixel-bytes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixel-bytes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixel-bytes", ...args: any[]): void
    connect(
      sigName: "notify::pixels",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels", ...args: any[]): void
    connect(
      sigName: "notify::rowstride",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rowstride",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rowstride",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rowstride",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rowstride", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A pixel buffer.
   *
   * `GdkPixbuf` contains information about an image's pixel data,
   * its color space, bits per sample, width and height, and the
   * rowstride (the number of bytes between the start of one row
   * and the start of the next).
   *
   * ## Creating new `GdkPixbuf`
   *
   * The most basic way to create a pixbuf is to wrap an existing pixel
   * buffer with a [class`GdkPixbuf`.Pixbuf] instance. You can use the
   * [`ctor`GdkPixbuf`.Pixbuf.new_from_data`] function to do this.
   *
   * Every time you create a new `GdkPixbuf` instance for some data, you
   * will need to specify the destroy notification function that will be
   * called when the data buffer needs to be freed; this will happen when
   * a `GdkPixbuf` is finalized by the reference counting functions. If
   * you have a chunk of static data compiled into your application, you
   * can pass in `NULL` as the destroy notification function so that the
   * data will not be freed.
   *
   * The [`ctor`GdkPixbuf`.Pixbuf.new`] constructor function can be used
   * as a convenience to create a pixbuf with an empty buffer; this is
   * equivalent to allocating a data buffer using `malloc()` and then
   * wrapping it with `gdk_pixbuf_new_from_data()`. The `gdk_pixbuf_new()`
   * function will compute an optimal rowstride so that rendering can be
   * performed with an efficient algorithm.
   *
   * As a special case, you can use the [`ctor`GdkPixbuf`.Pixbuf.new_from_xpm_data`]
   * function to create a pixbuf from inline XPM image data.
   *
   * You can also copy an existing pixbuf with the [method`Pixbuf`.copy]
   * function. This is not the same as just acquiring a reference to
   * the old pixbuf instance: the copy function will actually duplicate
   * the pixel data in memory and create a new [class`Pixbuf]` instance
   * for it.
   *
   * ## Reference counting
   *
   * `GdkPixbuf` structures are reference counted. This means that an
   * application can share a single pixbuf among many parts of the
   * code. When a piece of the program needs to use a pixbuf, it should
   * acquire a reference to it by calling `g_object_ref()`; when it no
   * longer needs the pixbuf, it should release the reference it acquired
   * by calling `g_object_unref()`. The resources associated with a
   * `GdkPixbuf` will be freed when its reference count drops to zero.
   * Newly-created `GdkPixbuf` instances start with a reference count
   * of one.
   *
   * ## Image Data
   *
   * Image data in a pixbuf is stored in memory in an uncompressed,
   * packed format. Rows in the image are stored top to bottom, and
   * in each row pixels are stored from left to right.
   *
   * There may be padding at the end of a row.
   *
   * The "rowstride" value of a pixbuf, as returned by [`method`GdkPixbuf`.Pixbuf.get_rowstride`],
   * indicates the number of bytes between rows.
   *
   * **NOTE**: If you are copying raw pixbuf data with `memcpy()` note that the
   * last row in the pixbuf may not be as wide as the full rowstride, but rather
   * just as wide as the pixel data needs to be; that is: it is unsafe to do
   * `memcpy (dest, pixels, rowstride * height)` to copy a whole pixbuf. Use
   * [method`GdkPixbuf`.Pixbuf.copy] instead, or compute the width in bytes of the
   * last row as:
   *
   * ```c
   * last_row = width * ((n_channels * bits_per_sample + 7) / 8);
   * ```
   *
   * The same rule applies when iterating over each row of a `GdkPixbuf` pixels
   * array.
   *
   * The following code illustrates a simple `put_pixel()`
   * function for RGB pixbufs with 8 bits per channel with an alpha
   * channel.
   *
   * ```c
   * static void
   * put_pixel (GdkPixbuf *pixbuf,
   *            int x,
   * 	   int y,
   * 	   guchar red,
   * 	   guchar green,
   * 	   guchar blue,
   * 	   guchar alpha)
   * {
   *   int n_channels = gdk_pixbuf_get_n_channels (pixbuf);
   *
   *   // Ensure that the pixbuf is valid
   *   g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
   *   g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
   *   g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
   *   g_assert (n_channels == 4);
   *
   *   int width = gdk_pixbuf_get_width (pixbuf);
   *   int height = gdk_pixbuf_get_height (pixbuf);
   *
   *   // Ensure that the coordinates are in a valid range
   *   g_assert (x >= 0 && x < width);
   *   g_assert (y >= 0 && y < height);
   *
   *   int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
   *
   *   // The pixel buffer in the GdkPixbuf instance
   *   guchar *pixels = gdk_pixbuf_get_pixels (pixbuf);
   *
   *   // The pixel we wish to modify
   *   guchar *p = pixels + y * rowstride + x * n_channels;
   *   p[0] = red;
   *   p[1] = green;
   *   p[2] = blue;
   *   p[3] = alpha;
   * }
   * ```
   *
   * ## Loading images
   *
   * The `GdkPixBuf` class provides a simple mechanism for loading
   * an image from a file in synchronous and asynchronous fashion.
   *
   * For GUI applications, it is recommended to use the asynchronous
   * stream API to avoid blocking the control flow of the application.
   *
   * Additionally, `GdkPixbuf` provides the [class`GdkPixbuf`.PixbufLoader`]
   * API for progressive image loading.
   *
   * ## Saving images
   *
   * The `GdkPixbuf` class provides methods for saving image data in
   * a number of file formats. The formatted data can be written to a
   * file or to a memory buffer. `GdkPixbuf` can also call a user-defined
   * callback on the data, which allows to e.g. write the image
   * to a socket or store it in a database.
   * @class
   */
  class Pixbuf extends GObject.Object {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.Pixbuf

    static name: string

    // Constructors of GdkPixbuf-2.0.GdkPixbuf.Pixbuf

    constructor(config?: Pixbuf.ConstructorProperties)
    /**
     * Creates a new `GdkPixbuf` structure and allocates a buffer for it.
     *
     * If the allocation of the buffer failed, this function will return `NULL`.
     *
     * The buffer has an optimal rowstride. Note that the buffer is not cleared;
     * you will have to fill it completely yourself.
     * @constructor
     * @param colorspace Color space for image
     * @param hasAlpha Whether the image should have transparency information
     * @param bitsPerSample Number of bits per color sample
     * @param width Width of image in pixels, must be > 0
     * @param height Height of image in pixels, must be > 0
     * @returns A newly-created pixel buffer
     */
    constructor(
      colorspace: Colorspace,
      hasAlpha: boolean,
      bitsPerSample: number,
      width: number,
      height: number
    )
    /**
     * Creates a new `GdkPixbuf` structure and allocates a buffer for it.
     *
     * If the allocation of the buffer failed, this function will return `NULL`.
     *
     * The buffer has an optimal rowstride. Note that the buffer is not cleared;
     * you will have to fill it completely yourself.
     * @constructor
     * @param colorspace Color space for image
     * @param hasAlpha Whether the image should have transparency information
     * @param bitsPerSample Number of bits per color sample
     * @param width Width of image in pixels, must be > 0
     * @param height Height of image in pixels, must be > 0
     * @returns A newly-created pixel buffer
     */
    static new(
      colorspace: Colorspace,
      hasAlpha: boolean,
      bitsPerSample: number,
      width: number,
      height: number
    ): Pixbuf
    /**
     * Creates a new #GdkPixbuf out of in-memory readonly image data.
     *
     * Currently only RGB images with 8 bits per sample are supported.
     *
     * This is the `GBytes` variant of gdk_pixbuf_new_from_data(), useful
     * for language bindings.
     * @constructor
     * @param data Image data in 8-bit/sample packed format inside a #GBytes
     * @param colorspace Colorspace for the image data
     * @param hasAlpha Whether the data has an opacity channel
     * @param bitsPerSample Number of bits per sample
     * @param width Width of the image in pixels, must be > 0
     * @param height Height of the image in pixels, must be > 0
     * @param rowstride Distance in bytes between row starts
     * @returns A newly-created pixbuf
     */
    static newFromBytes(
      data: any,
      colorspace: Colorspace,
      hasAlpha: boolean,
      bitsPerSample: number,
      width: number,
      height: number,
      rowstride: number
    ): Pixbuf
    /**
     * Creates a new #GdkPixbuf out of in-memory image data.
     *
     * Currently only RGB images with 8 bits per sample are supported.
     *
     * Since you are providing a pre-allocated pixel buffer, you must also
     * specify a way to free that data.  This is done with a function of
     * type `GdkPixbufDestroyNotify`.  When a pixbuf created with is
     * finalized, your destroy notification function will be called, and
     * it is its responsibility to free the pixel array.
     *
     * See also: [ctor`GdkPixbuf`.Pixbuf.new_from_bytes]
     * @constructor
     * @param data Image data in 8-bit/sample packed format
     * @param colorspace Colorspace for the image data
     * @param hasAlpha Whether the data has an opacity channel
     * @param bitsPerSample Number of bits per sample
     * @param width Width of the image in pixels, must be > 0
     * @param height Height of the image in pixels, must be > 0
     * @param rowstride Distance in bytes between row starts
     * @param destroyFn Function used to free the data when the pixbuf's reference count drops to zero, or %NULL if the data should not be freed
     * @returns A newly-created pixbuf
     */
    static newFromData(
      data: number[],
      colorspace: Colorspace,
      hasAlpha: boolean,
      bitsPerSample: number,
      width: number,
      height: number,
      rowstride: number,
      destroyFn: PixbufDestroyNotify | null
    ): Pixbuf
    /**
     * Creates a new pixbuf by loading an image from a file.
     *
     * The file format is detected automatically.
     *
     * If `NULL` is returned, then `error` will be set. Possible errors are:
     *
     *  - the file could not be opened
     *  - there is no loader for the file's format
     *  - there is not enough memory to allocate the image buffer
     *  - the image buffer contains invalid data
     *
     * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
     * @constructor
     * @param filename Name of file to load, in the GLib file   name encoding
     * @returns A newly-created pixbuf
     */
    static newFromFile(filename: string): Pixbuf
    /**
     * Creates a new pixbuf by loading an image from a file.
     *
     * The file format is detected automatically.
     *
     * If `NULL` is returned, then `error` will be set. Possible errors are:
     *
     *  - the file could not be opened
     *  - there is no loader for the file's format
     *  - there is not enough memory to allocate the image buffer
     *  - the image buffer contains invalid data
     *
     * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
     *
     * The image will be scaled to fit in the requested size, optionally preserving
     * the image's aspect ratio.
     *
     * When preserving the aspect ratio, a `width` of -1 will cause the image
     * to be scaled to the exact given height, and a `height` of -1 will cause
     * the image to be scaled to the exact given width. When not preserving
     * aspect ratio, a `width` or `height` of -1 means to not scale the image
     * at all in that dimension. Negative values for `width` and `height` are
     * allowed since 2.8.
     * @constructor
     * @param filename Name of file to load, in the GLib file     name encoding
     * @param width The width the image should have or -1 to not constrain the width
     * @param height The height the image should have or -1 to not constrain the height
     * @param preserveAspectRatio `TRUE` to preserve the image's aspect ratio
     * @returns A newly-created pixbuf
     */
    static newFromFileAtScale(
      filename: string,
      width: number,
      height: number,
      preserveAspectRatio: boolean
    ): Pixbuf
    /**
     * Creates a new pixbuf by loading an image from a file.
     *
     * The file format is detected automatically.
     *
     * If `NULL` is returned, then `error` will be set. Possible errors are:
     *
     *  - the file could not be opened
     *  - there is no loader for the file's format
     *  - there is not enough memory to allocate the image buffer
     *  - the image buffer contains invalid data
     *
     * The error domains are `GDK_PIXBUF_ERROR` and `G_FILE_ERROR`.
     *
     * The image will be scaled to fit in the requested size, preserving
     * the image's aspect ratio. Note that the returned pixbuf may be smaller
     * than `width` x `height`, if the aspect ratio requires it. To load
     * and image at the requested size, regardless of aspect ratio, use
     * [ctor`GdkPixbuf`.Pixbuf.new_from_file_at_scale].
     * @constructor
     * @param filename Name of file to load, in the GLib file     name encoding
     * @param width The width the image should have or -1 to not constrain the width
     * @param height The height the image should have or -1 to not constrain the height
     * @returns A newly-created pixbuf
     */
    static newFromFileAtSize(
      filename: string,
      width: number,
      height: number
    ): Pixbuf
    /**
     * Creates a `GdkPixbuf` from a flat representation that is suitable for
     * storing as inline data in a program.
     *
     * This is useful if you want to ship a program with images, but don't want
     * to depend on any external files.
     *
     * GdkPixbuf ships with a program called `gdk-pixbuf-csource`, which allows
     * for conversion of `GdkPixbuf`s into such a inline representation.
     *
     * In almost all cases, you should pass the `--raw` option to
     * `gdk-pixbuf-csource`. A sample invocation would be:
     *
     * ```
     * gdk-pixbuf-csource --raw --name=myimage_inline myimage.png
     * ```
     *
     * For the typical case where the inline pixbuf is read-only static data,
     * you don't need to copy the pixel data unless you intend to write to
     * it, so you can pass `FALSE` for `copy_pixels`. If you pass `--rle` to
     * `gdk-pixbuf-csource`, a copy will be made even if `copy_pixels` is `FALSE`,
     * so using this option is generally a bad idea.
     *
     * If you create a pixbuf from const inline data compiled into your
     * program, it's probably safe to ignore errors and disable length checks,
     * since things will always succeed:
     *
     * ```c
     * pixbuf = gdk_pixbuf_new_from_inline (-1, myimage_inline, FALSE, NULL);
     * ```
     *
     * For non-const inline data, you could get out of memory. For untrusted
     * inline data located at runtime, you could have corrupt inline data in
     * addition.
     * @constructor
     * @param data Byte data containing a   serialized `GdkPixdata` structure
     * @param copyPixels Whether to copy the pixel data, or use direct pointers   `data` for the resulting pixbuf
     * @returns A newly-created pixbuf
     */
    static newFromInline(data: number[], copyPixels: boolean): Pixbuf
    /**
     * Creates a new pixbuf by loading an image from an resource.
     *
     * The file format is detected automatically. If `NULL` is returned, then
     * `error` will be set.
     * @constructor
     * @param resourcePath the path of the resource file
     * @returns A newly-created pixbuf
     */
    static newFromResource(resourcePath: string): Pixbuf
    /**
     * Creates a new pixbuf by loading an image from an resource.
     *
     * The file format is detected automatically. If `NULL` is returned, then
     * `error` will be set.
     *
     * The image will be scaled to fit in the requested size, optionally
     * preserving the image's aspect ratio. When preserving the aspect ratio,
     * a `width` of -1 will cause the image to be scaled to the exact given
     * height, and a `height` of -1 will cause the image to be scaled to the
     * exact given width. When not preserving aspect ratio, a `width` or
     * `height` of -1 means to not scale the image at all in that dimension.
     *
     * The stream is not closed.
     * @constructor
     * @param resourcePath the path of the resource file
     * @param width The width the image should have or -1 to not constrain the width
     * @param height The height the image should have or -1 to not constrain the height
     * @param preserveAspectRatio `TRUE` to preserve the image's aspect ratio
     * @returns A newly-created pixbuf
     */
    static newFromResourceAtScale(
      resourcePath: string,
      width: number,
      height: number,
      preserveAspectRatio: boolean
    ): Pixbuf
    /**
     * Creates a new pixbuf by loading an image from an input stream.
     *
     * The file format is detected automatically.
     *
     * If `NULL` is returned, then `error` will be set.
     *
     * The `cancellable` can be used to abort the operation from another thread.
     * If the operation was cancelled, the error `G_IO_ERROR_CANCELLED` will be
     * returned. Other possible errors are in the `GDK_PIXBUF_ERROR` and
     * `G_IO_ERROR` domains.
     *
     * The stream is not closed.
     * @constructor
     * @param stream a `GInputStream` to load the pixbuf from
     * @param cancellable optional `GCancellable` object, `NULL` to ignore
     * @returns A newly-created pixbuf
     */
    static newFromStream(
      stream: Gio.InputStream,
      cancellable: Gio.Cancellable | null
    ): Pixbuf
    /**
     * Creates a new pixbuf by loading an image from an input stream.
     *
     * The file format is detected automatically. If `NULL` is returned, then
     * `error` will be set. The `cancellable` can be used to abort the operation
     * from another thread. If the operation was cancelled, the error
     * `G_IO_ERROR_CANCELLED` will be returned. Other possible errors are in
     * the `GDK_PIXBUF_ERROR` and `G_IO_ERROR` domains.
     *
     * The image will be scaled to fit in the requested size, optionally
     * preserving the image's aspect ratio.
     *
     * When preserving the aspect ratio, a `width` of -1 will cause the image to be
     * scaled to the exact given height, and a `height` of -1 will cause the image
     * to be scaled to the exact given width. If both `width` and `height` are
     * given, this function will behave as if the smaller of the two values
     * is passed as -1.
     *
     * When not preserving aspect ratio, a `width` or `height` of -1 means to not
     * scale the image at all in that dimension.
     *
     * The stream is not closed.
     * @constructor
     * @param stream a `GInputStream` to load the pixbuf from
     * @param width The width the image should have or -1 to not constrain the width
     * @param height The height the image should have or -1 to not constrain the height
     * @param preserveAspectRatio `TRUE` to preserve the image's aspect ratio
     * @param cancellable optional `GCancellable` object, `NULL` to ignore
     * @returns A newly-created pixbuf
     */
    static newFromStreamAtScale(
      stream: Gio.InputStream,
      width: number,
      height: number,
      preserveAspectRatio: boolean,
      cancellable: Gio.Cancellable | null
    ): Pixbuf
    /**
     * Finishes an asynchronous pixbuf creation operation started with
     * gdk_pixbuf_new_from_stream_async().
     * @constructor
     * @param asyncResult a `GAsyncResult`
     * @returns the newly created pixbuf
     */
    static newFromStreamFinish(asyncResult: Gio.AsyncResult): Pixbuf
    /**
     * Creates a new pixbuf by parsing XPM data in memory.
     *
     * This data is commonly the result of including an XPM file into a
     * program's C source.
     * @constructor
     * @param data Pointer to inline XPM data.
     * @returns A newly-created pixbuf
     */
    static newFromXpmData(data: string[]): Pixbuf
    _init(config?: Pixbuf.ConstructorProperties): void
    /**
     * Creates a new pixbuf by asynchronously loading an image from an input stream.
     *
     * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
     * version of this function.
     *
     * When the operation is finished, `callback` will be called in the main thread.
     * You can then call gdk_pixbuf_new_from_stream_finish() to get the result of
     * the operation.
     * @param stream a `GInputStream` from which to load the pixbuf
     * @param cancellable optional `GCancellable` object, `NULL` to ignore
     * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded
     */
    static newFromStreamAsync(
      stream: Gio.InputStream,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Creates a new pixbuf by asynchronously loading an image from an input stream.
     *
     * For more details see gdk_pixbuf_new_from_stream_at_scale(), which is the synchronous
     * version of this function.
     *
     * When the operation is finished, `callback` will be called in the main thread.
     * You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
     * @param stream a `GInputStream` from which to load the pixbuf
     * @param width the width the image should have or -1 to not constrain the width
     * @param height the height the image should have or -1 to not constrain the height
     * @param preserveAspectRatio `TRUE` to preserve the image's aspect ratio
     * @param cancellable optional `GCancellable` object, `NULL` to ignore
     * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded
     */
    static newFromStreamAtScaleAsync(
      stream: Gio.InputStream,
      width: number,
      height: number,
      preserveAspectRatio: boolean,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Calculates the rowstride that an image created with those values would
     * have.
     *
     * This function is useful for front-ends and backends that want to check
     * image values without needing to create a `GdkPixbuf`.
     * @param colorspace Color space for image
     * @param hasAlpha Whether the image should have transparency information
     * @param bitsPerSample Number of bits per color sample
     * @param width Width of image in pixels, must be > 0
     * @param height Height of image in pixels, must be > 0
     * @returns the rowstride for the given values, or -1 in case of error.
     */
    static calculateRowstride(
      colorspace: Colorspace,
      hasAlpha: boolean,
      bitsPerSample: number,
      width: number,
      height: number
    ): number
    /**
     * Parses an image file far enough to determine its format and size.
     * @param filename The name of the file to identify.
     * @returns A `GdkPixbufFormat` describing   the image format of the file
     */
    static getFileInfo(
      filename: string
    ): [
      /* returnType */ PixbufFormat | null,
      /* width */ number,
      /* height */ number,
    ]
    /**
     * Asynchronously parses an image file far enough to determine its
     * format and size.
     *
     * For more details see gdk_pixbuf_get_file_info(), which is the synchronous
     * version of this function.
     *
     * When the operation is finished, `callback` will be called in the
     * main thread. You can then call gdk_pixbuf_get_file_info_finish() to
     * get the result of the operation.
     * @param filename The name of the file to identify
     * @param cancellable optional `GCancellable` object, `NULL` to ignore
     * @param callback a `GAsyncReadyCallback` to call when the file info is available
     */
    static getFileInfoAsync(
      filename: string,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous pixbuf parsing operation started with
     * gdk_pixbuf_get_file_info_async().
     * @param asyncResult a `GAsyncResult`
     * @returns A `GdkPixbufFormat` describing the   image format of the file
     */
    static getFileInfoFinish(
      asyncResult: Gio.AsyncResult
    ): [
      /* returnType */ PixbufFormat | null,
      /* width */ number,
      /* height */ number,
    ]
    /**
     * Obtains the available information about the image formats supported
     * by GdkPixbuf.
     * @returns A list of   support image formats.
     */
    static getFormats(): PixbufFormat[]
    /**
     * Initalizes the gdk-pixbuf loader modules referenced by the `loaders.cache`
     * file present inside that directory.
     *
     * This is to be used by applications that want to ship certain loaders
     * in a different location from the system ones.
     *
     * This is needed when the OS or runtime ships a minimal number of loaders
     * so as to reduce the potential attack surface of carefully crafted image
     * files, especially for uncommon file types. Applications that require
     * broader image file types coverage, such as image viewers, would be
     * expected to ship the gdk-pixbuf modules in a separate location, bundled
     * with the application in a separate directory from the OS or runtime-
     * provided modules.
     * @param path Path to directory where the `loaders.cache` is installed
     */
    static initModules(path: string): boolean
    /**
     * Finishes an asynchronous pixbuf save operation started with
     * gdk_pixbuf_save_to_stream_async().
     * @param asyncResult a `GAsyncResult`
     * @returns `TRUE` if the pixbuf was saved successfully, `FALSE` if an error was set.
     */
    static saveToStreamFinish(asyncResult: Gio.AsyncResult): boolean
  }

  module PixbufAnimation {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface PixbufAnimation {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation

    __gtype__: number

    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation

    parentInstance: GObject.Object

    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation

    /**
     * Queries the height of the bounding box of a pixbuf animation.
     * @returns Height of the bounding box of the animation.
     */
    getHeight(): number
    // Has conflict: getIter(startTime: GLib.TimeVal | null): PixbufAnimationIter
    // Has conflict: getStaticImage(): Pixbuf
    /**
     * Queries the width of the bounding box of a pixbuf animation.
     * @returns Width of the bounding box of the animation.
     */
    getWidth(): number
    // Has conflict: isStaticImage(): boolean

    // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation

    /**
     * Get an iterator for displaying an animation.
     *
     * The iterator provides the frames that should be displayed at a
     * given time.
     *
     * `start_time` would normally come from g_get_current_time(), and marks
     * the beginning of animation playback. After creating an iterator, you
     * should immediately display the pixbuf returned by
     * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install
     * a timeout (with g_timeout_add()) or by some other mechanism ensure
     * that you'll update the image after
     * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
     * the image is updated, you should reinstall the timeout with the new,
     * possibly-changed delay time.
     *
     * As a shortcut, if `start_time` is `NULL`, the result of
     * g_get_current_time() will be used automatically.
     *
     * To update the image (i.e. possibly change the result of
     * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
     * call gdk_pixbuf_animation_iter_advance().
     *
     * If you're using #GdkPixbufLoader, in addition to updating the image
     * after the delay time, you should also update it whenever you
     * receive the area_updated signal and
     * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
     * `TRUE`. In this case, the frame currently being fed into the loader
     * has received new data, so needs to be refreshed. The delay time for
     * a frame may also be modified after an area_updated signal, for
     * example if the delay time for a frame is encoded in the data after
     * the frame itself. So your timeout should be reinstalled after any
     * area_updated signal.
     *
     * A delay time of -1 is possible, indicating "infinite".
     * @virtual
     * @param startTime time when the animation starts playing
     * @returns an iterator to move over the animation
     */
    getIter(startTime: GLib.TimeVal | null): PixbufAnimationIter
    /**
     * fills `width` and `height` with the frame size of the animation.
     * @virtual
     * @param width
     * @param height
     */
    getSize(width: number, height: number): void
    /**
     * Retrieves a static image for the animation.
     *
     * If an animation is really just a plain image (has only one frame),
     * this function returns that image.
     *
     * If the animation is an animation, this function returns a reasonable
     * image to use as a static unanimated image, which might be the first
     * frame, or something more sophisticated depending on the file format.
     *
     * If an animation hasn't loaded any frames yet, this function will
     * return `NULL`.
     * @virtual
     * @returns unanimated image representing the animation
     */
    getStaticImage(): Pixbuf
    /**
     * Checks whether the animation is a static image.
     *
     * If you load a file with gdk_pixbuf_animation_new_from_file() and it
     * turns out to be a plain, unanimated image, then this function will
     * return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve
     * the image.
     * @virtual
     * @returns `TRUE` if the "animation" was really just an image
     */
    isStaticImage(): boolean

    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An opaque object representing an animation.
   *
   * The GdkPixBuf library provides a simple mechanism to load and
   * represent animations. An animation is conceptually a series of
   * frames to be displayed over time.
   *
   * The animation may not be represented as a series of frames
   * internally; for example, it may be stored as a sprite and
   * instructions for moving the sprite around a background.
   *
   * To display an animation you don't need to understand its
   * representation, however; you just ask `GdkPixbuf` what should
   * be displayed at a given point in time.
   * @class
   */
  class PixbufAnimation extends GObject.Object {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation

    static name: string

    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimation

    constructor(config?: PixbufAnimation.ConstructorProperties)
    /**
     * Creates a new animation by loading it from a file.
     *
     * The file format is detected automatically.
     *
     * If the file's format does not support multi-frame images, then an animation
     * with a single frame will be created.
     *
     * Possible errors are in the `GDK_PIXBUF_ERROR` and `G_FILE_ERROR` domains.
     * @constructor
     * @param filename Name of file to load, in the GLib file   name encoding
     * @returns A newly-created animation
     */
    static newFromFile(filename: string): PixbufAnimation
    /**
     * Creates a new pixbuf animation by loading an image from an resource.
     *
     * The file format is detected automatically. If `NULL` is returned, then
     * `error` will be set.
     * @constructor
     * @param resourcePath the path of the resource file
     * @returns A newly-created animation
     */
    static newFromResource(resourcePath: string): PixbufAnimation
    /**
     * Creates a new animation by loading it from an input stream.
     *
     * The file format is detected automatically.
     *
     * If `NULL` is returned, then `error` will be set.
     *
     * The `cancellable` can be used to abort the operation from another thread.
     * If the operation was cancelled, the error `G_IO_ERROR_CANCELLED` will be
     * returned. Other possible errors are in the `GDK_PIXBUF_ERROR` and
     * `G_IO_ERROR` domains.
     *
     * The stream is not closed.
     * @constructor
     * @param stream a `GInputStream` to load the pixbuf from
     * @param cancellable optional `GCancellable` object
     * @returns A newly-created animation
     */
    static newFromStream(
      stream: Gio.InputStream,
      cancellable: Gio.Cancellable | null
    ): PixbufAnimation
    /**
     * Finishes an asynchronous pixbuf animation creation operation started with
     * [func`GdkPixbuf`.PixbufAnimation.new_from_stream_async].
     * @constructor
     * @param asyncResult a #GAsyncResult
     * @returns the newly created animation
     */
    static newFromStreamFinish(asyncResult: Gio.AsyncResult): PixbufAnimation
    _init(config?: PixbufAnimation.ConstructorProperties): void
    /**
     * Creates a new animation by asynchronously loading an image from an input stream.
     *
     * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
     * version of this function.
     *
     * When the operation is finished, `callback` will be called in the main thread.
     * You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the
     * result of the operation.
     * @param stream a #GInputStream from which to load the animation
     * @param cancellable optional #GCancellable object
     * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded
     */
    static newFromStreamAsync(
      stream: Gio.InputStream,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
  }

  module PixbufAnimationIter {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface PixbufAnimationIter {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter

    __gtype__: number

    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter

    parentInstance: GObject.Object

    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter

    // Has conflict: advance(currentTime: GLib.TimeVal | null): boolean
    // Has conflict: getDelayTime(): number
    // Has conflict: getPixbuf(): Pixbuf
    // Has conflict: onCurrentlyLoadingFrame(): boolean

    // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter

    /**
     * Possibly advances an animation to a new frame.
     *
     * Chooses the frame based on the start time passed to
     * gdk_pixbuf_animation_get_iter().
     *
     * `current_time` would normally come from g_get_current_time(), and
     * must be greater than or equal to the time passed to
     * gdk_pixbuf_animation_get_iter(), and must increase or remain
     * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
     * called. That is, you can't go backward in time; animations only
     * play forward.
     *
     * As a shortcut, pass `NULL` for the current time and g_get_current_time()
     * will be invoked on your behalf. So you only need to explicitly pass
     * `current_time` if you're doing something odd like playing the animation
     * at double speed.
     *
     * If this function returns `FALSE`, there's no need to update the animation
     * display, assuming the display had been rendered prior to advancing;
     * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf()
     * and update the display with the new pixbuf.
     * @virtual
     * @param currentTime current time
     * @returns `TRUE` if the image may need updating
     */
    advance(currentTime: GLib.TimeVal | null): boolean
    /**
     * Gets the number of milliseconds the current pixbuf should be displayed,
     * or -1 if the current pixbuf should be displayed forever.
     *
     * The `g_timeout_add()` function conveniently takes a timeout in milliseconds,
     * so you can use a timeout to schedule the next update.
     *
     * Note that some formats, like GIF, might clamp the timeout values in the
     * image file to avoid updates that are just too quick. The minimum timeout
     * for GIF images is currently 20 milliseconds.
     * @virtual
     * @returns delay time in milliseconds (thousandths of a second)
     */
    getDelayTime(): number
    /**
     * Gets the current pixbuf which should be displayed.
     *
     * The pixbuf might not be the same size as the animation itself
     * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
     *
     * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time()
     * milliseconds.
     *
     * The caller of this function does not own a reference to the returned
     * pixbuf; the returned pixbuf will become invalid when the iterator
     * advances to the next frame, which may happen anytime you call
     * gdk_pixbuf_animation_iter_advance().
     *
     * Copy the pixbuf to keep it (don't just add a reference), as it may get
     * recycled as you advance the iterator.
     * @virtual
     * @returns the pixbuf to be displayed
     */
    getPixbuf(): Pixbuf
    /**
     * Used to determine how to respond to the area_updated signal on
     * #GdkPixbufLoader when loading an animation.
     *
     * The `::area_updated` signal is emitted for an area of the frame currently
     * streaming in to the loader. So if you're on the currently loading frame,
     * you will need to redraw the screen for the updated area.
     * @virtual
     * @returns `TRUE` if the frame we're on is partially loaded, or the last frame
     */
    onCurrentlyLoadingFrame(): boolean

    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An opaque object representing an iterator which points to a
   * certain position in an animation.
   * @class
   */
  class PixbufAnimationIter extends GObject.Object {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter

    static name: string

    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIter

    constructor(config?: PixbufAnimationIter.ConstructorProperties)
    _init(config?: PixbufAnimationIter.ConstructorProperties): void
  }

  module PixbufLoader {
    // Signal callback interfaces

    /**
     * Signal callback interface for `area-prepared`
     */
    interface AreaPreparedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `area-updated`
     */
    interface AreaUpdatedSignalCallback {
      (x: number, y: number, width: number, height: number): void
    }

    /**
     * Signal callback interface for `closed`
     */
    interface ClosedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `size-prepared`
     */
    interface SizePreparedSignalCallback {
      (width: number, height: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface PixbufLoader {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader

    __gtype__: number

    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader

    /**
     * Informs a pixbuf loader that no further writes with
     * gdk_pixbuf_loader_write() will occur, so that it can free its
     * internal loading structures.
     *
     * This function also tries to parse any data that hasn't yet been parsed;
     * if the remaining data is partial or corrupt, an error will be returned.
     *
     * If `FALSE` is returned, `error` will be set to an error from the
     * `GDK_PIXBUF_ERROR` or `G_FILE_ERROR` domains.
     *
     * If you're just cancelling a load rather than expecting it to be finished,
     * passing `NULL` for `error` to ignore it is reasonable.
     *
     * Remember that this function does not release a reference on the loader, so
     * you will need to explicitly release any reference you hold.
     * @returns `TRUE` if all image data written so far was successfully   passed out via the update_area signal
     */
    close(): boolean
    /**
     * Queries the #GdkPixbufAnimation that a pixbuf loader is currently creating.
     *
     * In general it only makes sense to call this function after the
     * [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been emitted by
     * the loader.
     *
     * If the loader doesn't have enough bytes yet, and hasn't emitted the `area-prepared`
     * signal, this function will return `NULL`.
     * @returns The animation that the loader is   currently loading
     */
    getAnimation(): PixbufAnimation | null
    /**
     * Obtains the available information about the format of the
     * currently loading image file.
     * @returns A #GdkPixbufFormat
     */
    getFormat(): PixbufFormat | null
    /**
     * Queries the #GdkPixbuf that a pixbuf loader is currently creating.
     *
     * In general it only makes sense to call this function after the
     * [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been
     * emitted by the loader; this means that enough data has been read
     * to know the size of the image that will be allocated.
     *
     * If the loader has not received enough data via gdk_pixbuf_loader_write(),
     * then this function returns `NULL`.
     *
     * The returned pixbuf will be the same in all future calls to the loader,
     * so if you want to keep using it, you should acquire a reference to it.
     *
     * Additionally, if the loader is an animation, it will return the "static
     * image" of the animation (see gdk_pixbuf_animation_get_static_image()).
     * @returns The pixbuf that the loader is   creating
     */
    getPixbuf(): Pixbuf | null
    /**
     * Causes the image to be scaled while it is loaded.
     *
     * The desired image size can be determined relative to the original
     * size of the image by calling gdk_pixbuf_loader_set_size() from a
     * signal handler for the ::size-prepared signal.
     *
     * Attempts to set the desired image size  are ignored after the
     * emission of the ::size-prepared signal.
     * @param width The desired width of the image being loaded.
     * @param height The desired height of the image being loaded.
     */
    setSize(width: number, height: number): void
    /**
     * Parses the next `count` bytes in the given image buffer.
     * @param buf Pointer to image data.
     * @returns `TRUE` if the write was successful, or   `FALSE` if the loader cannot parse the buffer
     */
    write(buf: number[]): boolean
    /**
     * Parses the next contents of the given image buffer.
     * @param buffer The image data as a `GBytes` buffer.
     * @returns `TRUE` if the write was successful, or `FALSE` if   the loader cannot parse the buffer
     */
    writeBytes(buffer: any): boolean

    // Own virtual methods of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader

    areaPrepared(): void
    areaUpdated(x: number, y: number, width: number, height: number): void
    closed(): void
    sizePrepared(width: number, height: number): void

    // Own signals of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader

    connect(
      sigName: "area-prepared",
      callback: PixbufLoader.AreaPreparedSignalCallback
    ): number
    on(
      sigName: "area-prepared",
      callback: PixbufLoader.AreaPreparedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "area-prepared",
      callback: PixbufLoader.AreaPreparedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "area-prepared",
      callback: PixbufLoader.AreaPreparedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "area-prepared", ...args: any[]): void
    connect(
      sigName: "area-updated",
      callback: PixbufLoader.AreaUpdatedSignalCallback
    ): number
    on(
      sigName: "area-updated",
      callback: PixbufLoader.AreaUpdatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "area-updated",
      callback: PixbufLoader.AreaUpdatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "area-updated",
      callback: PixbufLoader.AreaUpdatedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "area-updated",
      y: number,
      width: number,
      height: number,
      ...args: any[]
    ): void
    connect(
      sigName: "closed",
      callback: PixbufLoader.ClosedSignalCallback
    ): number
    on(
      sigName: "closed",
      callback: PixbufLoader.ClosedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "closed",
      callback: PixbufLoader.ClosedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "closed",
      callback: PixbufLoader.ClosedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "closed", ...args: any[]): void
    connect(
      sigName: "size-prepared",
      callback: PixbufLoader.SizePreparedSignalCallback
    ): number
    on(
      sigName: "size-prepared",
      callback: PixbufLoader.SizePreparedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "size-prepared",
      callback: PixbufLoader.SizePreparedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "size-prepared",
      callback: PixbufLoader.SizePreparedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "size-prepared", height: number, ...args: any[]): void

    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Incremental image loader.
   *
   * `GdkPixbufLoader` provides a way for applications to drive the
   * process of loading an image, by letting them send the image data
   * directly to the loader instead of having the loader read the data
   * from a file. Applications can use this functionality instead of
   * `gdk_pixbuf_new_from_file()` or `gdk_pixbuf_animation_new_from_file()`
   * when they need to parse image data in small chunks. For example,
   * it should be used when reading an image from a (potentially) slow
   * network connection, or when loading an extremely large file.
   *
   * To use `GdkPixbufLoader` to load an image, create a new instance,
   * and call [method`GdkPixbuf`.PixbufLoader.write] to send the data
   * to it. When done, [method`GdkPixbuf`.PixbufLoader.close] should be
   * called to end the stream and finalize everything.
   *
   * The loader will emit three important signals throughout the process:
   *
   *  - [signal`GdkPixbuf`.PixbufLoader::size-prepared] will be emitted as
   *    soon as the image has enough information to determine the size of
   *    the image to be used. If you want to scale the image while loading
   *    it, you can call [method`GdkPixbuf`.PixbufLoader.set_size] in
   *    response to this signal.
   *  - [signal`GdkPixbuf`.PixbufLoader::area-prepared] will be emitted as
   *    soon as the pixbuf of the desired has been allocated. You can obtain
   *    the `GdkPixbuf` instance by calling [method`GdkPixbuf`.PixbufLoader.get_pixbuf].
   *    If you want to use it, simply acquire a reference to it. You can
   *    also call `gdk_pixbuf_loader_get_pixbuf()` later to get the same
   *    pixbuf.
   *  - [signal`GdkPixbuf`.PixbufLoader::area-updated] will be emitted every
   *    time a region is updated. This way you can update a partially
   *    completed image. Note that you do not know anything about the
   *    completeness of an image from the updated area. For example, in an
   *    interlaced image you will need to make several passes before the
   *    image is done loading.
   *
   * ## Loading an animation
   *
   * Loading an animation is almost as easy as loading an image. Once the
   * first [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been
   * emitted, you can call [method`GdkPixbuf`.PixbufLoader.get_animation] to
   * get the [class`GdkPixbuf`.PixbufAnimation] instance, and then call
   * and [method`GdkPixbuf`.PixbufAnimation.get_iter] to get a
   * [class`GdkPixbuf`.PixbufAnimationIter] to retrieve the pixbuf for the
   * desired time stamp.
   * @class
   */
  class PixbufLoader extends GObject.Object {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader

    static name: string

    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufLoader

    constructor(config?: PixbufLoader.ConstructorProperties)
    /**
     * Creates a new pixbuf loader object.
     * @constructor
     * @returns A newly-created pixbuf loader.
     */
    constructor()
    /**
     * Creates a new pixbuf loader object.
     * @constructor
     * @returns A newly-created pixbuf loader.
     */
    static new(): PixbufLoader
    /**
     * Creates a new pixbuf loader object that always attempts to parse
     * image data as if it were an image of MIME type `mime_type,` instead of
     * identifying the type automatically.
     *
     * This function is useful if you want an error if the image isn't the
     * expected MIME type; for loading image formats that can't be reliably
     * identified by looking at the data; or if the user manually forces a
     * specific MIME type.
     *
     * The list of supported mime types depends on what image loaders
     * are installed, but typically "image/png", "image/jpeg", "image/gif",
     * "image/tiff" and "image/x-xpixmap" are among the supported mime types.
     * To obtain the full list of supported mime types, call
     * gdk_pixbuf_format_get_mime_types() on each of the #GdkPixbufFormat
     * structs returned by gdk_pixbuf_get_formats().
     * @constructor
     * @param mimeType the mime type to be loaded
     * @returns A newly-created pixbuf loader.
     */
    static newWithMimeType(mimeType: string): PixbufLoader
    /**
     * Creates a new pixbuf loader object that always attempts to parse
     * image data as if it were an image of type `image_type,` instead of
     * identifying the type automatically.
     *
     * This function is useful if you want an error if the image isn't the
     * expected type; for loading image formats that can't be reliably
     * identified by looking at the data; or if the user manually forces
     * a specific type.
     *
     * The list of supported image formats depends on what image loaders
     * are installed, but typically "png", "jpeg", "gif", "tiff" and
     * "xpm" are among the supported formats. To obtain the full list of
     * supported image formats, call gdk_pixbuf_format_get_name() on each
     * of the #GdkPixbufFormat structs returned by gdk_pixbuf_get_formats().
     * @constructor
     * @param imageType name of the image format to be loaded with the image
     * @returns A newly-created pixbuf loader.
     */
    static newWithType(imageType: string): PixbufLoader
    _init(config?: PixbufLoader.ConstructorProperties): void
  }

  module PixbufNonAnim {
    // Constructor properties interface

    interface ConstructorProperties
      extends PixbufAnimation.ConstructorProperties {}
  }

  interface PixbufNonAnim {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim

    __gtype__: number

    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  class PixbufNonAnim extends PixbufAnimation {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim

    static name: string

    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufNonAnim

    constructor(config?: PixbufNonAnim.ConstructorProperties)
    constructor(pixbuf: Pixbuf)
    static new(pixbuf: Pixbuf): PixbufNonAnim
    _init(config?: PixbufNonAnim.ConstructorProperties): void
  }

  module PixbufSimpleAnim {
    // Constructor properties interface

    interface ConstructorProperties
      extends PixbufAnimation.ConstructorProperties {
      // Own constructor properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim

      /**
       * Whether the animation should loop when it reaches the end.
       */
      loop?: boolean | null
    }
  }

  interface PixbufSimpleAnim {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim

    /**
     * Whether the animation should loop when it reaches the end.
     */
    loop: boolean
    __gtype__: number

    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim

    /**
     * Adds a new frame to `animation`. The `pixbuf` must
     * have the dimensions specified when the animation
     * was constructed.
     * @param pixbuf the pixbuf to add
     */
    addFrame(pixbuf: Pixbuf): void
    /**
     * Gets whether `animation` should loop indefinitely when it reaches the end.
     * @returns %TRUE if the animation loops forever, %FALSE otherwise
     */
    getLoop(): boolean
    /**
     * Sets whether `animation` should loop indefinitely when it reaches the end.
     * @param loop whether to loop the animation
     */
    setLoop(loop: boolean): void

    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim

    connect(sigName: "notify::loop", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::loop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::loop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::loop",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::loop", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An opaque struct representing a simple animation.
   * @class
   */
  class PixbufSimpleAnim extends PixbufAnimation {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim

    static name: string

    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnim

    constructor(config?: PixbufSimpleAnim.ConstructorProperties)
    /**
     * Creates a new, empty animation.
     * @constructor
     * @param width the width of the animation
     * @param height the height of the animation
     * @param rate the speed of the animation, in frames per second
     * @returns a newly allocated #GdkPixbufSimpleAnim
     */
    constructor(width: number, height: number, rate: number)
    /**
     * Creates a new, empty animation.
     * @constructor
     * @param width the width of the animation
     * @param height the height of the animation
     * @param rate the speed of the animation, in frames per second
     * @returns a newly allocated #GdkPixbufSimpleAnim
     */
    static new(width: number, height: number, rate: number): PixbufSimpleAnim
    _init(config?: PixbufSimpleAnim.ConstructorProperties): void
  }

  module PixbufSimpleAnimIter {
    // Constructor properties interface

    interface ConstructorProperties
      extends PixbufAnimationIter.ConstructorProperties {}
  }

  interface PixbufSimpleAnimIter {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter

    __gtype__: number

    // Class property signals of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  class PixbufSimpleAnimIter extends PixbufAnimationIter {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter

    static name: string

    // Constructors of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimIter

    constructor(config?: PixbufSimpleAnimIter.ConstructorProperties)
    _init(config?: PixbufSimpleAnimIter.ConstructorProperties): void
  }

  interface PixbufAnimationClass {
    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationClass

    /**
     * the parent class
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * returns whether the given animation is just a static image.
     * @field
     */
    isStaticImage: (animation: PixbufAnimation) => boolean
    /**
     * returns a static image representing the given animation.
     * @field
     */
    getStaticImage: (animation: PixbufAnimation) => Pixbuf
    /**
     * fills `width` and `height` with the frame size of the animation.
     * @field
     */
    getSize: (animation: PixbufAnimation, width: number, height: number) => void
    /**
     * returns an iterator for the given animation.
     * @field
     */
    getIter: (
      animation: PixbufAnimation,
      startTime: GLib.TimeVal | null
    ) => PixbufAnimationIter
  }

  /**
   * Modules supporting animations must derive a type from
   * #GdkPixbufAnimation, providing suitable implementations of the
   * virtual functions.
   * @record
   */
  abstract class PixbufAnimationClass {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationClass

    static name: string
  }

  interface PixbufAnimationIterClass {
    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIterClass

    /**
     * the parent class
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * returns the time in milliseconds that the current frame
     *  should be shown.
     * @field
     */
    getDelayTime: (iter: PixbufAnimationIter) => number
    /**
     * returns the current frame.
     * @field
     */
    getPixbuf: (iter: PixbufAnimationIter) => Pixbuf
    /**
     * returns whether the current frame of `iter` is
     *  being loaded.
     * @field
     */
    onCurrentlyLoadingFrame: (iter: PixbufAnimationIter) => boolean
    /**
     * advances the iterator to `current_time,` possibly changing the
     *  current frame.
     * @field
     */
    advance: (
      iter: PixbufAnimationIter,
      currentTime: GLib.TimeVal | null
    ) => boolean
  }

  /**
   * Modules supporting animations must derive a type from
   * #GdkPixbufAnimationIter, providing suitable implementations of the
   * virtual functions.
   * @record
   */
  abstract class PixbufAnimationIterClass {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufAnimationIterClass

    static name: string
  }

  interface PixbufFormat {
    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat

    /**
     * the name of the image format
     * @field
     */
    name: string | null
    /**
     * the signature of the module
     * @field
     */
    signature: PixbufModulePattern
    /**
     * the message domain for the `description`
     * @field
     */
    domain: string | null
    /**
     * a description of the image format
     * @field
     */
    description: string | null
    /**
     * the MIME types for the image format
     * @field
     */
    mimeTypes: string[]
    /**
     * typical filename extensions for the
     *   image format
     * @field
     */
    extensions: string[]
    /**
     * a combination of `GdkPixbufFormatFlags`
     * @field
     */
    flags: number
    /**
     * a boolean determining whether the loader is disabled`
     * @field
     */
    disabled: boolean
    /**
     * a string containing license information, typically set to
     *   shorthands like "GPL", "LGPL", etc.
     * @field
     */
    license: string | null

    // Owm methods of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat

    /**
     * Creates a copy of `format`.
     * @returns the newly allocated copy of a `GdkPixbufFormat`. Use   gdk_pixbuf_format_free() to free the resources when done
     */
    copy(): PixbufFormat
    /**
     * Frees the resources allocated when copying a `GdkPixbufFormat`
     * using gdk_pixbuf_format_copy()
     */
    free(): void
    /**
     * Returns a description of the format.
     * @returns a description of the format.
     */
    getDescription(): string | null
    /**
     * Returns the filename extensions typically used for files in the
     * given format.
     * @returns an array of   filename extensions
     */
    getExtensions(): string[]
    /**
     * Returns information about the license of the image loader for the format.
     *
     * The returned string should be a shorthand for a well known license, e.g.
     * "LGPL", "GPL", "QPL", "GPL/QPL", or "other" to indicate some other license.
     * @returns a string describing the license of the pixbuf format
     */
    getLicense(): string | null
    /**
     * Returns the mime types supported by the format.
     * @returns an array of mime types
     */
    getMimeTypes(): string[]
    /**
     * Returns the name of the format.
     * @returns the name of the format.
     */
    getName(): string | null
    /**
     * Returns whether this image format is disabled.
     *
     * See gdk_pixbuf_format_set_disabled().
     * @returns whether this image format is disabled.
     */
    isDisabled(): boolean
    /**
     * Returns `TRUE` if the save option specified by `option_key` is supported when
     * saving a pixbuf using the module implementing `format`.
     *
     * See gdk_pixbuf_save() for more information about option keys.
     * @param optionKey the name of an option
     * @returns `TRUE` if the specified option is supported
     */
    isSaveOptionSupported(optionKey: string): boolean
    /**
     * Returns whether this image format is scalable.
     *
     * If a file is in a scalable format, it is preferable to load it at
     * the desired size, rather than loading it at the default size and
     * scaling the resulting pixbuf to the desired size.
     * @returns whether this image format is scalable.
     */
    isScalable(): boolean
    /**
     * Returns whether pixbufs can be saved in the given format.
     * @returns whether pixbufs can be saved in the given format.
     */
    isWritable(): boolean
    /**
     * Disables or enables an image format.
     *
     * If a format is disabled, GdkPixbuf won't use the image loader for
     * this format to load images.
     *
     * Applications can use this to avoid using image loaders with an
     * inappropriate license, see gdk_pixbuf_format_get_license().
     * @param disabled `TRUE` to disable the format `format`
     */
    setDisabled(disabled: boolean): void
  }

  /**
   * A `GdkPixbufFormat` contains information about the image format accepted
   * by a module.
   *
   * Only modules should access the fields directly, applications should
   * use the `gdk_pixbuf_format_*` family of functions.
   * @record
   */
  class PixbufFormat {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufFormat

    static name: string
  }

  interface PixbufLoaderClass {
    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufLoaderClass

    parentClass: GObject.ObjectClass
    sizePrepared: (loader: PixbufLoader, width: number, height: number) => void
    areaPrepared: (loader: PixbufLoader) => void
    areaUpdated: (
      loader: PixbufLoader,
      x: number,
      y: number,
      width: number,
      height: number
    ) => void
    closed: (loader: PixbufLoader) => void
  }

  abstract class PixbufLoaderClass {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufLoaderClass

    static name: string
  }

  interface PixbufModule {
    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufModule

    /**
     * the name of the module, usually the same as the
     *  usual file extension for images of this type, eg. "xpm", "jpeg" or "png".
     * @field
     */
    moduleName: string | null
    /**
     * the path from which the module is loaded.
     * @field
     */
    modulePath: string | null
    /**
     * the loaded `GModule`.
     * @field
     */
    module: GModule.Module
    /**
     * a `GdkPixbufFormat` holding information about the module.
     * @field
     */
    info: PixbufFormat
    /**
     * loads an image from a file.
     * @field
     */
    load: PixbufModuleLoadFunc
    /**
     * loads an image from data in memory.
     * @field
     */
    loadXpmData: PixbufModuleLoadXpmDataFunc
    /**
     * stops an incremental load.
     * @field
     */
    stopLoad: PixbufModuleStopLoadFunc
    /**
     * continues an incremental load.
     * @field
     */
    loadIncrement: PixbufModuleIncrementLoadFunc
    /**
     * loads an animation from a file.
     * @field
     */
    loadAnimation: PixbufModuleLoadAnimationFunc
    /**
     * saves a `GdkPixbuf` to a file.
     * @field
     */
    save: PixbufModuleSaveFunc
    /**
     * returns whether a save option key is supported by the module
     * @field
     */
    isSaveOptionSupported: PixbufModuleSaveOptionSupportedFunc
  }

  /**
   * A `GdkPixbufModule` contains the necessary functions to load and save
   * images in a certain file format.
   *
   * If `GdkPixbuf` has been compiled with `GModule` support, it can be extended
   * by modules which can load (and perhaps also save) new image and animation
   * formats.
   *
   * ## Implementing modules
   *
   * The `GdkPixbuf` interfaces needed for implementing modules are contained in
   * `gdk-pixbuf-io.h` (and `gdk-pixbuf-animation.h` if the module supports
   * animations). They are not covered by the same stability guarantees as the
   * regular GdkPixbuf API. To underline this fact, they are protected by the
   * `GDK_PIXBUF_ENABLE_BACKEND` pre-processor symbol.
   *
   * Each loadable module must contain a `GdkPixbufModuleFillVtableFunc` function
   * named `fill_vtable`, which will get called when the module
   * is loaded and must set the function pointers of the `GdkPixbufModule`.
   *
   * In order to make format-checking work before actually loading the modules
   * (which may require calling `dlopen` to load image libraries), modules export
   * their signatures (and other information) via the `fill_info` function. An
   * external utility, `gdk-pixbuf-query-loaders`, uses this to create a text
   * file containing a list of all available loaders and  their signatures.
   * This file is then read at runtime by `GdkPixbuf` to obtain the list of
   * available loaders and their signatures.
   *
   * Modules may only implement a subset of the functionality available via
   * `GdkPixbufModule`. If a particular functionality is not implemented, the
   * `fill_vtable` function will simply not set the corresponding
   * function pointers of the `GdkPixbufModule` structure. If a module supports
   * incremental loading (i.e. provides `begin_load`, `stop_load` and
   * `load_increment`), it doesn't have to implement `load`, since `GdkPixbuf`
   * can supply a generic `load` implementation wrapping the incremental loading.
   *
   * ## Installing modules
   *
   * Installing a module is a two-step process:
   *
   *  - copy the module file(s) to the loader directory (normally
   *    `$libdir/gdk-pixbuf-2.0/$version/loaders`, unless overridden by the
   *    environment variable `GDK_PIXBUF_MODULEDIR`)
   *  - call `gdk-pixbuf-query-loaders` to update the module file (normally
   *    `$libdir/gdk-pixbuf-2.0/$version/loaders.cache`, unless overridden
   *    by the environment variable `GDK_PIXBUF_MODULE_FILE`)
   * @record
   */
  class PixbufModule {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufModule

    static name: string
  }

  interface PixbufModulePattern {
    // Own fields of GdkPixbuf-2.0.GdkPixbuf.PixbufModulePattern

    /**
     * the prefix for this pattern
     * @field
     */
    prefix: string | null
    /**
     * mask containing bytes which modify how the prefix is matched against
     *  test data
     * @field
     */
    mask: string | null
    /**
     * relevance of this pattern
     * @field
     */
    relevance: number
  }

  /**
   * The signature prefix for a module.
   *
   * The signature of a module is a set of prefixes. Prefixes are encoded as
   * pairs of ordinary strings, where the second string, called the mask, if
   * not `NULL`, must be of the same length as the first one and may contain
   * ' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched,
   * not matched, "don't-care"-bytes, zeros and non-zeros, respectively.
   *
   * Each prefix has an associated integer that describes the relevance of
   * the prefix, with 0 meaning a mismatch and 100 a "perfect match".
   *
   * Starting with gdk-pixbuf 2.8, the first byte of the mask may be '*',
   * indicating an unanchored pattern that matches not only at the beginning,
   * but also in the middle. Versions prior to 2.8 will interpret the '*'
   * like an 'x'.
   *
   * The signature of a module is stored as an array of
   * `GdkPixbufModulePatterns`. The array is terminated by a pattern
   * where the `prefix` is `NULL`.
   *
   * ```c
   * GdkPixbufModulePattern *signature[] = {
   *   { "abcdx", " !x z", 100 },
   *   { "bla", NULL,  90 },
   *   { NULL, NULL, 0 }
   * };
   * ```
   *
   * In the example above, the signature matches e.g. "auud\0" with
   * relevance 100, and "blau" with relevance 90.
   * @record
   */
  class PixbufModulePattern {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufModulePattern

    static name: string
  }

  interface PixbufSimpleAnimClass {}

  abstract class PixbufSimpleAnimClass {
    // Own properties of GdkPixbuf-2.0.GdkPixbuf.PixbufSimpleAnimClass

    static name: string
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace Gdk {
  /**
   * Defines how device axes are interpreted by GTK.
   *
   * Note that the X and Y axes are not really needed; pointer devices
   * report their location via the x/y members of events regardless. Whether
   * X and Y are present as axes depends on the GDK backend.
   */
  enum AxisUse {
    /**
     * the axis is ignored.
     */
    IGNORE,
    /**
     * the axis is used as the x axis.
     */
    X,
    /**
     * the axis is used as the y axis.
     */
    Y,
    /**
     * the axis is used as the scroll x delta
     */
    DELTA_X,
    /**
     * the axis is used as the scroll y delta
     */
    DELTA_Y,
    /**
     * the axis is used for pressure information.
     */
    PRESSURE,
    /**
     * the axis is used for x tilt information.
     */
    XTILT,
    /**
     * the axis is used for y tilt information.
     */
    YTILT,
    /**
     * the axis is used for wheel information.
     */
    WHEEL,
    /**
     * the axis is used for pen/tablet distance information
     */
    DISTANCE,
    /**
     * the axis is used for pen rotation information
     */
    ROTATION,
    /**
     * the axis is used for pen slider information
     */
    SLIDER,
    /**
     * a constant equal to the numerically highest axis value.
     */
    LAST,
  }
  /**
   * Specifies the crossing mode for enter and leave events.
   */
  enum CrossingMode {
    /**
     * crossing because of pointer motion.
     */
    NORMAL,
    /**
     * crossing because a grab is activated.
     */
    GRAB,
    /**
     * crossing because a grab is deactivated.
     */
    UNGRAB,
    /**
     * crossing because a GTK grab is activated.
     */
    GTK_GRAB,
    /**
     * crossing because a GTK grab is deactivated.
     */
    GTK_UNGRAB,
    /**
     * crossing because a GTK widget changed
     *   state (e.g. sensitivity).
     */
    STATE_CHANGED,
    /**
     * crossing because a touch sequence has begun,
     *   this event is synthetic as the pointer might have not left the surface.
     */
    TOUCH_BEGIN,
    /**
     * crossing because a touch sequence has ended,
     *   this event is synthetic as the pointer might have not left the surface.
     */
    TOUCH_END,
    /**
     * crossing because of a device switch (i.e.
     *   a mouse taking control of the pointer after a touch device), this event
     *   is synthetic as the pointer didn’t leave the surface.
     */
    DEVICE_SWITCH,
  }
  /**
   * A pad feature.
   */
  enum DevicePadFeature {
    /**
     * a button
     */
    BUTTON,
    /**
     * a ring-shaped interactive area
     */
    RING,
    /**
     * a straight interactive area
     */
    STRIP,
  }
  /**
   * Indicates the specific type of tool being used being a tablet. Such as an
   * airbrush, pencil, etc.
   */
  enum DeviceToolType {
    /**
     * Tool is of an unknown type.
     */
    UNKNOWN,
    /**
     * Tool is a standard tablet stylus.
     */
    PEN,
    /**
     * Tool is standard tablet eraser.
     */
    ERASER,
    /**
     * Tool is a brush stylus.
     */
    BRUSH,
    /**
     * Tool is a pencil stylus.
     */
    PENCIL,
    /**
     * Tool is an airbrush stylus.
     */
    AIRBRUSH,
    /**
     * Tool is a mouse.
     */
    MOUSE,
    /**
     * Tool is a lens cursor.
     */
    LENS,
  }
  /**
   * Error enumeration for `GdkDmabufTexture`.
   */
  enum DmabufError {
    /**
     * Dmabuf support is not available, because the OS
     *   is not Linux, or it was explicitly disabled at compile- or runtime
     */
    NOT_AVAILABLE,
    /**
     * The requested format is not supported
     */
    UNSUPPORTED_FORMAT,
    /**
     * GTK failed to create the resource for other
     *   reasons
     */
    CREATION_FAILED,
  }
  /**
   * Used in `GdkDrag` to the reason of a cancelled DND operation.
   */
  enum DragCancelReason {
    /**
     * There is no suitable drop target.
     */
    NO_TARGET,
    /**
     * Drag cancelled by the user
     */
    USER_CANCELLED,
    /**
     * Unspecified error.
     */
    ERROR,
  }
  /**
   * Specifies the type of the event.
   */
  enum EventType {
    /**
     * the window manager has requested that the toplevel surface be
     *   hidden or destroyed, usually when the user clicks on a special icon in the
     *   title bar.
     */
    DELETE,
    /**
     * the pointer (usually a mouse) has moved.
     */
    MOTION_NOTIFY,
    /**
     * a mouse button has been pressed.
     */
    BUTTON_PRESS,
    /**
     * a mouse button has been released.
     */
    BUTTON_RELEASE,
    /**
     * a key has been pressed.
     */
    KEY_PRESS,
    /**
     * a key has been released.
     */
    KEY_RELEASE,
    /**
     * the pointer has entered the surface.
     */
    ENTER_NOTIFY,
    /**
     * the pointer has left the surface.
     */
    LEAVE_NOTIFY,
    /**
     * the keyboard focus has entered or left the surface.
     */
    FOCUS_CHANGE,
    /**
     * an input device has moved into contact with a sensing
     *   surface (e.g. a touchscreen or graphics tablet).
     */
    PROXIMITY_IN,
    /**
     * an input device has moved out of contact with a sensing
     *   surface.
     */
    PROXIMITY_OUT,
    /**
     * the mouse has entered the surface while a drag is in progress.
     */
    DRAG_ENTER,
    /**
     * the mouse has left the surface while a drag is in progress.
     */
    DRAG_LEAVE,
    /**
     * the mouse has moved in the surface while a drag is in
     *   progress.
     */
    DRAG_MOTION,
    /**
     * a drop operation onto the surface has started.
     */
    DROP_START,
    /**
     * the scroll wheel was turned
     */
    SCROLL,
    /**
     * a pointer or keyboard grab was broken.
     */
    GRAB_BROKEN,
    /**
     * A new touch event sequence has just started.
     */
    TOUCH_BEGIN,
    /**
     * A touch event sequence has been updated.
     */
    TOUCH_UPDATE,
    /**
     * A touch event sequence has finished.
     */
    TOUCH_END,
    /**
     * A touch event sequence has been canceled.
     */
    TOUCH_CANCEL,
    /**
     * A touchpad swipe gesture event, the current state
     *   is determined by its phase field.
     */
    TOUCHPAD_SWIPE,
    /**
     * A touchpad pinch gesture event, the current state
     *   is determined by its phase field.
     */
    TOUCHPAD_PINCH,
    /**
     * A tablet pad button press event.
     */
    PAD_BUTTON_PRESS,
    /**
     * A tablet pad button release event.
     */
    PAD_BUTTON_RELEASE,
    /**
     * A tablet pad axis event from a "ring".
     */
    PAD_RING,
    /**
     * A tablet pad axis event from a "strip".
     */
    PAD_STRIP,
    /**
     * A tablet pad group mode change.
     */
    PAD_GROUP_MODE,
    /**
     * A touchpad hold gesture event, the current state is determined by its phase
     * field.
     */
    TOUCHPAD_HOLD,
    /**
     * marks the end of the GdkEventType enumeration.
     */
    EVENT_LAST,
  }
  /**
   * Indicates which monitor a surface should span over when in fullscreen mode.
   */
  enum FullscreenMode {
    /**
     * Fullscreen on current monitor only.
     */
    CURRENT_MONITOR,
    /**
     * Span across all monitors when fullscreen.
     */
    ALL_MONITORS,
  }
  /**
   * Error enumeration for `GdkGLContext`.
   */
  enum GLError {
    /**
     * OpenGL support is not available
     */
    NOT_AVAILABLE,
    /**
     * The requested visual format is not supported
     */
    UNSUPPORTED_FORMAT,
    /**
     * The requested profile is not supported
     */
    UNSUPPORTED_PROFILE,
    /**
     * The shader compilation failed
     */
    COMPILATION_FAILED,
    /**
     * The shader linking failed
     */
    LINK_FAILED,
  }
  /**
   * Defines the reference point of a surface and is used in `GdkPopupLayout`.
   */
  enum Gravity {
    /**
     * the reference point is at the top left corner.
     */
    NORTH_WEST,
    /**
     * the reference point is in the middle of the top edge.
     */
    NORTH,
    /**
     * the reference point is at the top right corner.
     */
    NORTH_EAST,
    /**
     * the reference point is at the middle of the left edge.
     */
    WEST,
    /**
     * the reference point is at the center of the surface.
     */
    CENTER,
    /**
     * the reference point is at the middle of the right edge.
     */
    EAST,
    /**
     * the reference point is at the lower left corner.
     */
    SOUTH_WEST,
    /**
     * the reference point is at the middle of the lower edge.
     */
    SOUTH,
    /**
     * the reference point is at the lower right corner.
     */
    SOUTH_EAST,
    /**
     * the reference point is at the top left corner of the
     *  surface itself, ignoring window manager decorations.
     */
    STATIC,
  }
  /**
   * An enumeration describing the type of an input device in general terms.
   */
  enum InputSource {
    /**
     * the device is a mouse. (This will be reported for the core
     *   pointer, even if it is something else, such as a trackball.)
     */
    MOUSE,
    /**
     * the device is a stylus of a graphics tablet or similar device.
     */
    PEN,
    /**
     * the device is a keyboard.
     */
    KEYBOARD,
    /**
     * the device is a direct-input touch device, such
     *   as a touchscreen or tablet
     */
    TOUCHSCREEN,
    /**
     * the device is an indirect touch device, such
     *   as a touchpad
     */
    TOUCHPAD,
    /**
     * the device is a trackpoint
     */
    TRACKPOINT,
    /**
     * the device is a "pad", a collection of buttons,
     *   rings and strips found in drawing tablets
     */
    TABLET_PAD,
  }
  /**
   * Describes how well an event matches a given keyval and modifiers.
   *
   * `GdkKeyMatch` values are returned by [method`Gdk`.KeyEvent.matches].
   */
  enum KeyMatch {
    /**
     * The key event does not match
     */
    NONE,
    /**
     * The key event matches if keyboard state
     *   (specifically, the currently active group) is ignored
     */
    PARTIAL,
    /**
     * The key event matches
     */
    EXACT,
  }
  /**
   * `GdkMemoryFormat` describes formats that image data can have in memory.
   *
   * It describes formats by listing the contents of the memory passed to it.
   * So `GDK_MEMORY_A8R8G8B8` will be 1 byte (8 bits) of alpha, followed by a
   * byte each of red, green and blue. It is not endian-dependent, so
   * `CAIRO_FORMAT_ARGB32` is represented by different `GdkMemoryFormats`
   * on architectures with different endiannesses.
   *
   * Its naming is modelled after
   * [VkFormat](https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VkFormat)
   * for details).
   */
  enum MemoryFormat {
    /**
     * 4 bytes; for blue, green, red, alpha.
     *   The color values are premultiplied with the alpha value.
     */
    B8G8R8A8_PREMULTIPLIED,
    /**
     * 4 bytes; for alpha, red, green, blue.
     *   The color values are premultiplied with the alpha value.
     */
    A8R8G8B8_PREMULTIPLIED,
    /**
     * 4 bytes; for red, green, blue, alpha
     *   The color values are premultiplied with the alpha value.
     */
    R8G8B8A8_PREMULTIPLIED,
    /**
     * 4 bytes; for blue, green, red, alpha.
     */
    B8G8R8A8,
    /**
     * 4 bytes; for alpha, red, green, blue.
     */
    A8R8G8B8,
    /**
     * 4 bytes; for red, green, blue, alpha.
     */
    R8G8B8A8,
    /**
     * 4 bytes; for alpha, blue, green, red.
     */
    A8B8G8R8,
    /**
     * 3 bytes; for red, green, blue. The data is opaque.
     */
    R8G8B8,
    /**
     * 3 bytes; for blue, green, red. The data is opaque.
     */
    B8G8R8,
    /**
     * 3 guint16 values; for red, green, blue.
     */
    R16G16B16,
    /**
     * 4 guint16 values; for red, green, blue, alpha. The color values are
     * premultiplied with the alpha value.
     */
    R16G16B16A16_PREMULTIPLIED,
    /**
     * 4 guint16 values; for red, green, blue, alpha.
     */
    R16G16B16A16,
    /**
     * 3 half-float values; for red, green, blue. The data is opaque.
     */
    R16G16B16_FLOAT,
    /**
     * 4 half-float values; for red, green, blue and alpha. The color values are
     * premultiplied with the alpha value.
     */
    R16G16B16A16_FLOAT_PREMULTIPLIED,
    /**
     * 4 half-float values; for red, green, blue and alpha.
     */
    R16G16B16A16_FLOAT,
    /**
     * 3 float values; for red, green, blue.
     */
    R32G32B32_FLOAT,
    /**
     * 4 float values; for red, green, blue and alpha. The color values are
     * premultiplied with the alpha value.
     */
    R32G32B32A32_FLOAT_PREMULTIPLIED,
    /**
     * 4 float values; for red, green, blue and alpha.
     */
    R32G32B32A32_FLOAT,
    /**
     * 2 bytes; for grayscale, alpha. The color values are premultiplied with the
     * alpha value.
     */
    G8A8_PREMULTIPLIED,
    /**
     * 2 bytes; for grayscale, alpha.
     */
    G8A8,
    /**
     * One byte; for grayscale. The data is opaque.
     */
    G8,
    /**
     * 2 guint16 values; for grayscale, alpha. The color values are premultiplied
     * with the alpha value.
     */
    G16A16_PREMULTIPLIED,
    /**
     * 2 guint16 values; for grayscale, alpha.
     */
    G16A16,
    /**
     * One guint16 value; for grayscale. The data is opaque.
     */
    G16,
    /**
     * One byte; for alpha.
     */
    A8,
    /**
     * One guint16 value; for alpha.
     */
    A16,
    /**
     * One half-float value; for alpha.
     */
    A16_FLOAT,
    /**
     * One float value; for alpha.
     */
    A32_FLOAT,
    /**
     * 4 bytes; for alpha, blue, green, red, The color values are premultiplied with
     * the alpha value.
     */
    A8B8G8R8_PREMULTIPLIED,
    /**
     * 4 bytes; for blue, green, red, unused.
     */
    B8G8R8X8,
    /**
     * 4 bytes; for unused, red, green, blue.
     */
    X8R8G8B8,
    /**
     * 4 bytes; for red, green, blue, unused.
     */
    R8G8B8X8,
    /**
     * 4 bytes; for unused, blue, green, red.
     */
    X8B8G8R8,
    /**
     * The number of formats. This value will change as
     *   more formats get added, so do not rely on its concrete integer.
     */
    N_FORMATS,
  }
  /**
   * Specifies the kind of crossing for enter and leave events.
   *
   * See the X11 protocol specification of LeaveNotify for
   * full details of crossing event generation.
   */
  enum NotifyType {
    /**
     * the surface is entered from an ancestor or
     *   left towards an ancestor.
     */
    ANCESTOR,
    /**
     * the pointer moves between an ancestor and an
     *   inferior of the surface.
     */
    VIRTUAL,
    /**
     * the surface is entered from an inferior or
     *   left towards an inferior.
     */
    INFERIOR,
    /**
     * the surface is entered from or left towards
     *   a surface which is neither an ancestor nor an inferior.
     */
    NONLINEAR,
    /**
     * the pointer moves between two surfaces
     *   which are not ancestors of each other and the surface is part of
     *   the ancestor chain between one of these surfaces and their least
     *   common ancestor.
     */
    NONLINEAR_VIRTUAL,
    /**
     * an unknown type of enter/leave event occurred.
     */
    UNKNOWN,
  }
  /**
   * Specifies the direction for scroll events.
   */
  enum ScrollDirection {
    /**
     * the surface is scrolled up.
     */
    UP,
    /**
     * the surface is scrolled down.
     */
    DOWN,
    /**
     * the surface is scrolled to the left.
     */
    LEFT,
    /**
     * the surface is scrolled to the right.
     */
    RIGHT,
    /**
     * the scrolling is determined by the delta values
     *   in scroll events. See gdk_scroll_event_get_deltas()
     */
    SMOOTH,
  }
  /**
   * Specifies the unit of scroll deltas.
   *
   * When you get %GDK_SCROLL_UNIT_WHEEL, a delta of 1.0 means 1 wheel detent
   * click in the south direction, 2.0 means 2 wheel detent clicks in the south
   * direction... This is the same logic for negative values but in the north
   * direction.
   *
   * If you get %GDK_SCROLL_UNIT_SURFACE, are managing a scrollable view and get a
   * value of 123, you have to scroll 123 surface logical pixels right if it's
   * `delta_x` or down if it's `delta_y`. This is the same logic for negative values
   * but you have to scroll left instead of right if it's `delta_x` and up instead
   * of down if it's `delta_y`.
   *
   * 1 surface logical pixel is equal to 1 real screen pixel multiplied by the
   * final scale factor of your graphical interface (the product of the desktop
   * scale factor and eventually a custom scale factor in your app).
   */
  enum ScrollUnit {
    /**
     * The delta is in number of wheel clicks.
     */
    WHEEL,
    /**
     * The delta is in surface pixels to scroll directly
     *   on screen.
     */
    SURFACE,
  }
  /**
   * This enumeration describes how the red, green and blue components
   * of physical pixels on an output device are laid out.
   */
  enum SubpixelLayout {
    /**
     * The layout is not known
     */
    UNKNOWN,
    /**
     * Not organized in this way
     */
    NONE,
    /**
     * The layout is horizontal, the order is RGB
     */
    HORIZONTAL_RGB,
    /**
     * The layout is horizontal, the order is BGR
     */
    HORIZONTAL_BGR,
    /**
     * The layout is vertical, the order is RGB
     */
    VERTICAL_RGB,
    /**
     * The layout is vertical, the order is BGR
     */
    VERTICAL_BGR,
  }
  /**
   * Determines a surface edge or corner.
   */
  enum SurfaceEdge {
    /**
     * the top left corner.
     */
    NORTH_WEST,
    /**
     * the top edge.
     */
    NORTH,
    /**
     * the top right corner.
     */
    NORTH_EAST,
    /**
     * the left edge.
     */
    WEST,
    /**
     * the right edge.
     */
    EAST,
    /**
     * the lower left corner.
     */
    SOUTH_WEST,
    /**
     * the lower edge.
     */
    SOUTH,
    /**
     * the lower right corner.
     */
    SOUTH_EAST,
  }
  /**
   * Possible errors that can be returned by `GdkTexture` constructors.
   */
  enum TextureError {
    /**
     * Not enough memory to handle this image
     */
    TOO_LARGE,
    /**
     * The image data appears corrupted
     */
    CORRUPT_IMAGE,
    /**
     * The image contains features
     *   that cannot be loaded
     */
    UNSUPPORTED_CONTENT,
    /**
     * The image format is not supported
     */
    UNSUPPORTED_FORMAT,
  }
  enum TitlebarGesture {
    DOUBLE_CLICK,
    RIGHT_CLICK,
    MIDDLE_CLICK,
  }
  /**
   * Specifies the current state of a touchpad gesture.
   *
   * All gestures are guaranteed to begin with an event with phase
   * %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN, followed by 0 or several events
   * with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.
   *
   * A finished gesture may have 2 possible outcomes, an event with phase
   * %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
   * considered successful, this should be used as the hint to perform any
   * permanent changes.
   *
   * Cancelled gestures may be so for a variety of reasons, due to hardware
   * or the compositor, or due to the gesture recognition layers hinting the
   * gesture did not finish resolutely (eg. a 3rd finger being added during
   * a pinch gesture). In these cases, the last event will report the phase
   * %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
   * to undo any visible/permanent changes that were done throughout the
   * progress of the gesture.
   */
  enum TouchpadGesturePhase {
    /**
     * The gesture has begun.
     */
    BEGIN,
    /**
     * The gesture has been updated.
     */
    UPDATE,
    /**
     * The gesture was finished, changes
     *   should be permanently applied.
     */
    END,
    /**
     * The gesture was cancelled, all
     *   changes should be undone.
     */
    CANCEL,
  }
  /**
   * Error enumeration for `GdkVulkanContext`.
   */
  enum VulkanError {
    /**
     * Vulkan is not supported on this backend or has not been
     *   compiled in.
     */
    UNSUPPORTED,
    /**
     * Vulkan support is not available on this Surface
     */
    NOT_AVAILABLE,
  }
  /**
   * Positioning hints for aligning a surface relative to a rectangle.
   *
   * These hints determine how the surface should be positioned in the case that
   * the surface would fall off-screen if placed in its ideal position.
   *
   * For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
   * %GDK_GRAVITY_NORTH_EAST and vice versa if the surface extends beyond the left
   * or right edges of the monitor.
   *
   * If %GDK_ANCHOR_SLIDE_X is set, the surface can be shifted horizontally to fit
   * on-screen. If %GDK_ANCHOR_RESIZE_X is set, the surface can be shrunken
   * horizontally to fit.
   *
   * In general, when multiple flags are set, flipping should take precedence over
   * sliding, which should take precedence over resizing.
   * @bitfield
   */
  enum AnchorHints {
    /**
     * allow flipping anchors horizontally
     */
    FLIP_X,
    /**
     * allow flipping anchors vertically
     */
    FLIP_Y,
    /**
     * allow sliding surface horizontally
     */
    SLIDE_X,
    /**
     * allow sliding surface vertically
     */
    SLIDE_Y,
    /**
     * allow resizing surface horizontally
     */
    RESIZE_X,
    /**
     * allow resizing surface vertically
     */
    RESIZE_Y,
    /**
     * allow flipping anchors on both axes
     */
    FLIP,
    /**
     * allow sliding surface on both axes
     */
    SLIDE,
    /**
     * allow resizing surface on both axes
     */
    RESIZE,
  }
  /**
   * Flags describing the current capabilities of a device/tool.
   * @bitfield
   */
  enum AxisFlags {
    /**
     * X axis is present
     */
    X,
    /**
     * Y axis is present
     */
    Y,
    /**
     * Scroll X delta axis is present
     */
    DELTA_X,
    /**
     * Scroll Y delta axis is present
     */
    DELTA_Y,
    /**
     * Pressure axis is present
     */
    PRESSURE,
    /**
     * X tilt axis is present
     */
    XTILT,
    /**
     * Y tilt axis is present
     */
    YTILT,
    /**
     * Wheel axis is present
     */
    WHEEL,
    /**
     * Distance axis is present
     */
    DISTANCE,
    /**
     * Z-axis rotation is present
     */
    ROTATION,
    /**
     * Slider axis is present
     */
    SLIDER,
  }
  /**
   * Used in `GdkDrop` and `GdkDrag` to indicate the actions that the
   * destination can and should do with the dropped data.
   * @bitfield
   */
  enum DragAction {
    /**
     * Copy the data.
     */
    COPY,
    /**
     * Move the data, i.e. first copy it, then delete
     *   it from the source using the DELETE target of the X selection protocol.
     */
    MOVE,
    /**
     * Add a link to the data. Note that this is only
     *   useful if source and destination agree on what it means, and is not
     *   supported on all platforms.
     */
    LINK,
    /**
     * Ask the user what to do with the data.
     */
    ASK,
  }
  /**
   * Used to represent the different paint clock phases that can be requested.
   *
   * The elements of the enumeration correspond to the signals of `GdkFrameClock`.
   * @bitfield
   */
  enum FrameClockPhase {
    /**
     * no phase
     */
    NONE,
    /**
     * corresponds to GdkFrameClock::flush-events. Should not be handled by applications.
     */
    FLUSH_EVENTS,
    /**
     * corresponds to GdkFrameClock::before-paint. Should not be handled by applications.
     */
    BEFORE_PAINT,
    /**
     * corresponds to GdkFrameClock::update.
     */
    UPDATE,
    /**
     * corresponds to GdkFrameClock::layout. Should not be handled by applications.
     */
    LAYOUT,
    /**
     * corresponds to GdkFrameClock::paint.
     */
    PAINT,
    /**
     * corresponds to GdkFrameClock::resume-events. Should not be handled by applications.
     */
    RESUME_EVENTS,
    /**
     * corresponds to GdkFrameClock::after-paint. Should not be handled by applications.
     */
    AFTER_PAINT,
  }
  /**
   * The list of the different APIs that GdkGLContext can potentially support.
   * @bitfield
   */
  enum GLAPI {
    /**
     * The OpenGL API
     */
    GL,
    /**
     * The OpenGL ES API
     */
    GLES,
  }
  /**
   * Flags to indicate the state of modifier keys and mouse buttons
   * in events.
   *
   * Typical modifier keys are Shift, Control, Meta, Super, Hyper, Alt, Compose,
   * Apple, CapsLock or ShiftLock.
   *
   * Note that GDK may add internal values to events which include values outside
   * of this enumeration. Your code should preserve and ignore them.  You can use
   * %GDK_MODIFIER_MASK to remove all private values.
   * @bitfield
   */
  enum ModifierType {
    /**
     * No modifier.
     */
    NO_MODIFIER_MASK,
    /**
     * the Shift key.
     */
    SHIFT_MASK,
    /**
     * a Lock key (depending on the modifier mapping of the
     *  X server this may either be CapsLock or ShiftLock).
     */
    LOCK_MASK,
    /**
     * the Control key.
     */
    CONTROL_MASK,
    /**
     * the fourth modifier key (it depends on the modifier
     *  mapping of the X server which key is interpreted as this modifier, but
     *  normally it is the Alt key).
     */
    ALT_MASK,
    /**
     * the first mouse button.
     */
    BUTTON1_MASK,
    /**
     * the second mouse button.
     */
    BUTTON2_MASK,
    /**
     * the third mouse button.
     */
    BUTTON3_MASK,
    /**
     * the fourth mouse button.
     */
    BUTTON4_MASK,
    /**
     * the fifth mouse button.
     */
    BUTTON5_MASK,
    /**
     * the Super modifier
     */
    SUPER_MASK,
    /**
     * the Hyper modifier
     */
    HYPER_MASK,
    /**
     * the Meta modifier
     */
    META_MASK,
  }
  /**
   * Flags about a paintable object.
   *
   * Implementations use these for optimizations such as caching.
   * @bitfield
   */
  enum PaintableFlags {
    /**
     * The size is immutable.
     *   The [signal`Gdk`.Paintable::invalidate-size] signal will never be
     *   emitted.
     */
    SIZE,
    /**
     * The content is immutable.
     *   The [signal`Gdk`.Paintable::invalidate-contents] signal will never be
     *   emitted.
     */
    CONTENTS,
  }
  /**
   * Flags describing the seat capabilities.
   * @bitfield
   */
  enum SeatCapabilities {
    /**
     * No input capabilities
     */
    NONE,
    /**
     * The seat has a pointer (e.g. mouse)
     */
    POINTER,
    /**
     * The seat has touchscreen(s) attached
     */
    TOUCH,
    /**
     * The seat has drawing tablet(s) attached
     */
    TABLET_STYLUS,
    /**
     * The seat has keyboard(s) attached
     */
    KEYBOARD,
    /**
     * The seat has drawing tablet pad(s) attached
     */
    TABLET_PAD,
    /**
     * The union of all pointing capabilities
     */
    ALL_POINTING,
    /**
     * The union of all capabilities
     */
    ALL,
  }
  /**
   * Specifies the state of a toplevel surface.
   *
   * On platforms that support information about individual edges, the
   * %GDK_TOPLEVEL_STATE_TILED state will be set whenever any of the individual
   * tiled states is set. On platforms that lack that support, the tiled state
   * will give an indication of tiledness without any of the per-edge states
   * being set.
   * @bitfield
   */
  enum ToplevelState {
    /**
     * the surface is minimized
     */
    MINIMIZED,
    /**
     * the surface is maximized
     */
    MAXIMIZED,
    /**
     * the surface is sticky
     */
    STICKY,
    /**
     * the surface is maximized without decorations
     */
    FULLSCREEN,
    /**
     * the surface is kept above other surfaces
     */
    ABOVE,
    /**
     * the surface is kept below other surfaces
     */
    BELOW,
    /**
     * the surface is presented as focused (with active decorations)
     */
    FOCUSED,
    /**
     * the surface is in a tiled state
     */
    TILED,
    /**
     * whether the top edge is tiled
     */
    TOP_TILED,
    /**
     * whether the top edge is resizable
     */
    TOP_RESIZABLE,
    /**
     * whether the right edge is tiled
     */
    RIGHT_TILED,
    /**
     * whether the right edge is resizable
     */
    RIGHT_RESIZABLE,
    /**
     * whether the bottom edge is tiled
     */
    BOTTOM_TILED,
    /**
     * whether the bottom edge is resizable
     */
    BOTTOM_RESIZABLE,
    /**
     * whether the left edge is tiled
     */
    LEFT_TILED,
    /**
     * whether the left edge is resizable
     */
    LEFT_RESIZABLE,
    /**
     * the surface is not visible to the user
     */
    SUSPENDED,
  }
  /**
   * Defines all possible DND actions.
   *
   * This can be used in [method`Gdk`.Drop.status] messages when any drop
   * can be accepted or a more specific drop method is not yet known.
   */
  const ACTION_ALL: number
  /**
   * The middle button.
   */
  const BUTTON_MIDDLE: number
  /**
   * The primary button. This is typically the left mouse button, or the
   * right button in a left-handed setup.
   */
  const BUTTON_PRIMARY: number
  /**
   * The secondary button. This is typically the right mouse button, or the
   * left button in a left-handed setup.
   */
  const BUTTON_SECONDARY: number
  /**
   * Represents the current time, and can be used anywhere a time is expected.
   */
  const CURRENT_TIME: number
  /**
   * Use this macro as the return value for continuing the propagation of
   * an event handler.
   */
  const EVENT_PROPAGATE: boolean
  /**
   * Use this macro as the return value for stopping the propagation of
   * an event handler.
   */
  const EVENT_STOP: boolean
  const KEY_0: number
  const KEY_1: number
  const KEY_2: number
  const KEY_3: number
  const KEY_3270_AltCursor: number
  const KEY_3270_Attn: number
  const KEY_3270_BackTab: number
  const KEY_3270_ChangeScreen: number
  const KEY_3270_Copy: number
  const KEY_3270_CursorBlink: number
  const KEY_3270_CursorSelect: number
  const KEY_3270_DeleteWord: number
  const KEY_3270_Duplicate: number
  const KEY_3270_Enter: number
  const KEY_3270_EraseEOF: number
  const KEY_3270_EraseInput: number
  const KEY_3270_ExSelect: number
  const KEY_3270_FieldMark: number
  const KEY_3270_Ident: number
  const KEY_3270_Jump: number
  const KEY_3270_KeyClick: number
  const KEY_3270_Left2: number
  const KEY_3270_PA1: number
  const KEY_3270_PA2: number
  const KEY_3270_PA3: number
  const KEY_3270_Play: number
  const KEY_3270_PrintScreen: number
  const KEY_3270_Quit: number
  const KEY_3270_Record: number
  const KEY_3270_Reset: number
  const KEY_3270_Right2: number
  const KEY_3270_Rule: number
  const KEY_3270_Setup: number
  const KEY_3270_Test: number
  const KEY_4: number
  const KEY_5: number
  const KEY_6: number
  const KEY_7: number
  const KEY_8: number
  const KEY_9: number
  const KEY_A: number
  const KEY_AE: number
  const KEY_Aacute: number
  const KEY_Abelowdot: number
  const KEY_Abreve: number
  const KEY_Abreveacute: number
  const KEY_Abrevebelowdot: number
  const KEY_Abrevegrave: number
  const KEY_Abrevehook: number
  const KEY_Abrevetilde: number
  const KEY_AccessX_Enable: number
  const KEY_AccessX_Feedback_Enable: number
  const KEY_Acircumflex: number
  const KEY_Acircumflexacute: number
  const KEY_Acircumflexbelowdot: number
  const KEY_Acircumflexgrave: number
  const KEY_Acircumflexhook: number
  const KEY_Acircumflextilde: number
  const KEY_AddFavorite: number
  const KEY_Adiaeresis: number
  const KEY_Agrave: number
  const KEY_Ahook: number
  const KEY_Alt_L: number
  const KEY_Alt_R: number
  const KEY_Amacron: number
  const KEY_Aogonek: number
  const KEY_ApplicationLeft: number
  const KEY_ApplicationRight: number
  const KEY_Arabic_0: number
  const KEY_Arabic_1: number
  const KEY_Arabic_2: number
  const KEY_Arabic_3: number
  const KEY_Arabic_4: number
  const KEY_Arabic_5: number
  const KEY_Arabic_6: number
  const KEY_Arabic_7: number
  const KEY_Arabic_8: number
  const KEY_Arabic_9: number
  const KEY_Arabic_ain: number
  const KEY_Arabic_alef: number
  const KEY_Arabic_alefmaksura: number
  const KEY_Arabic_beh: number
  const KEY_Arabic_comma: number
  const KEY_Arabic_dad: number
  const KEY_Arabic_dal: number
  const KEY_Arabic_damma: number
  const KEY_Arabic_dammatan: number
  const KEY_Arabic_ddal: number
  const KEY_Arabic_farsi_yeh: number
  const KEY_Arabic_fatha: number
  const KEY_Arabic_fathatan: number
  const KEY_Arabic_feh: number
  const KEY_Arabic_fullstop: number
  const KEY_Arabic_gaf: number
  const KEY_Arabic_ghain: number
  const KEY_Arabic_ha: number
  const KEY_Arabic_hah: number
  const KEY_Arabic_hamza: number
  const KEY_Arabic_hamza_above: number
  const KEY_Arabic_hamza_below: number
  const KEY_Arabic_hamzaonalef: number
  const KEY_Arabic_hamzaonwaw: number
  const KEY_Arabic_hamzaonyeh: number
  const KEY_Arabic_hamzaunderalef: number
  const KEY_Arabic_heh: number
  const KEY_Arabic_heh_doachashmee: number
  const KEY_Arabic_heh_goal: number
  const KEY_Arabic_jeem: number
  const KEY_Arabic_jeh: number
  const KEY_Arabic_kaf: number
  const KEY_Arabic_kasra: number
  const KEY_Arabic_kasratan: number
  const KEY_Arabic_keheh: number
  const KEY_Arabic_khah: number
  const KEY_Arabic_lam: number
  const KEY_Arabic_madda_above: number
  const KEY_Arabic_maddaonalef: number
  const KEY_Arabic_meem: number
  const KEY_Arabic_noon: number
  const KEY_Arabic_noon_ghunna: number
  const KEY_Arabic_peh: number
  const KEY_Arabic_percent: number
  const KEY_Arabic_qaf: number
  const KEY_Arabic_question_mark: number
  const KEY_Arabic_ra: number
  const KEY_Arabic_rreh: number
  const KEY_Arabic_sad: number
  const KEY_Arabic_seen: number
  const KEY_Arabic_semicolon: number
  const KEY_Arabic_shadda: number
  const KEY_Arabic_sheen: number
  const KEY_Arabic_sukun: number
  const KEY_Arabic_superscript_alef: number
  const KEY_Arabic_switch: number
  const KEY_Arabic_tah: number
  const KEY_Arabic_tatweel: number
  const KEY_Arabic_tcheh: number
  const KEY_Arabic_teh: number
  const KEY_Arabic_tehmarbuta: number
  const KEY_Arabic_thal: number
  const KEY_Arabic_theh: number
  const KEY_Arabic_tteh: number
  const KEY_Arabic_veh: number
  const KEY_Arabic_waw: number
  const KEY_Arabic_yeh: number
  const KEY_Arabic_yeh_baree: number
  const KEY_Arabic_zah: number
  const KEY_Arabic_zain: number
  const KEY_Aring: number
  const KEY_Armenian_AT: number
  const KEY_Armenian_AYB: number
  const KEY_Armenian_BEN: number
  const KEY_Armenian_CHA: number
  const KEY_Armenian_DA: number
  const KEY_Armenian_DZA: number
  const KEY_Armenian_E: number
  const KEY_Armenian_FE: number
  const KEY_Armenian_GHAT: number
  const KEY_Armenian_GIM: number
  const KEY_Armenian_HI: number
  const KEY_Armenian_HO: number
  const KEY_Armenian_INI: number
  const KEY_Armenian_JE: number
  const KEY_Armenian_KE: number
  const KEY_Armenian_KEN: number
  const KEY_Armenian_KHE: number
  const KEY_Armenian_LYUN: number
  const KEY_Armenian_MEN: number
  const KEY_Armenian_NU: number
  const KEY_Armenian_O: number
  const KEY_Armenian_PE: number
  const KEY_Armenian_PYUR: number
  const KEY_Armenian_RA: number
  const KEY_Armenian_RE: number
  const KEY_Armenian_SE: number
  const KEY_Armenian_SHA: number
  const KEY_Armenian_TCHE: number
  const KEY_Armenian_TO: number
  const KEY_Armenian_TSA: number
  const KEY_Armenian_TSO: number
  const KEY_Armenian_TYUN: number
  const KEY_Armenian_VEV: number
  const KEY_Armenian_VO: number
  const KEY_Armenian_VYUN: number
  const KEY_Armenian_YECH: number
  const KEY_Armenian_ZA: number
  const KEY_Armenian_ZHE: number
  const KEY_Armenian_accent: number
  const KEY_Armenian_amanak: number
  const KEY_Armenian_apostrophe: number
  const KEY_Armenian_at: number
  const KEY_Armenian_ayb: number
  const KEY_Armenian_ben: number
  const KEY_Armenian_but: number
  const KEY_Armenian_cha: number
  const KEY_Armenian_da: number
  const KEY_Armenian_dza: number
  const KEY_Armenian_e: number
  const KEY_Armenian_exclam: number
  const KEY_Armenian_fe: number
  const KEY_Armenian_full_stop: number
  const KEY_Armenian_ghat: number
  const KEY_Armenian_gim: number
  const KEY_Armenian_hi: number
  const KEY_Armenian_ho: number
  const KEY_Armenian_hyphen: number
  const KEY_Armenian_ini: number
  const KEY_Armenian_je: number
  const KEY_Armenian_ke: number
  const KEY_Armenian_ken: number
  const KEY_Armenian_khe: number
  const KEY_Armenian_ligature_ew: number
  const KEY_Armenian_lyun: number
  const KEY_Armenian_men: number
  const KEY_Armenian_nu: number
  const KEY_Armenian_o: number
  const KEY_Armenian_paruyk: number
  const KEY_Armenian_pe: number
  const KEY_Armenian_pyur: number
  const KEY_Armenian_question: number
  const KEY_Armenian_ra: number
  const KEY_Armenian_re: number
  const KEY_Armenian_se: number
  const KEY_Armenian_separation_mark: number
  const KEY_Armenian_sha: number
  const KEY_Armenian_shesht: number
  const KEY_Armenian_tche: number
  const KEY_Armenian_to: number
  const KEY_Armenian_tsa: number
  const KEY_Armenian_tso: number
  const KEY_Armenian_tyun: number
  const KEY_Armenian_verjaket: number
  const KEY_Armenian_vev: number
  const KEY_Armenian_vo: number
  const KEY_Armenian_vyun: number
  const KEY_Armenian_yech: number
  const KEY_Armenian_yentamna: number
  const KEY_Armenian_za: number
  const KEY_Armenian_zhe: number
  const KEY_Atilde: number
  const KEY_AudibleBell_Enable: number
  const KEY_AudioCycleTrack: number
  const KEY_AudioForward: number
  const KEY_AudioLowerVolume: number
  const KEY_AudioMedia: number
  const KEY_AudioMicMute: number
  const KEY_AudioMute: number
  const KEY_AudioNext: number
  const KEY_AudioPause: number
  const KEY_AudioPlay: number
  const KEY_AudioPreset: number
  const KEY_AudioPrev: number
  const KEY_AudioRaiseVolume: number
  const KEY_AudioRandomPlay: number
  const KEY_AudioRecord: number
  const KEY_AudioRepeat: number
  const KEY_AudioRewind: number
  const KEY_AudioStop: number
  const KEY_Away: number
  const KEY_B: number
  const KEY_Babovedot: number
  const KEY_Back: number
  const KEY_BackForward: number
  const KEY_BackSpace: number
  const KEY_Battery: number
  const KEY_Begin: number
  const KEY_Blue: number
  const KEY_Bluetooth: number
  const KEY_Book: number
  const KEY_BounceKeys_Enable: number
  const KEY_Break: number
  const KEY_BrightnessAdjust: number
  const KEY_Byelorussian_SHORTU: number
  const KEY_Byelorussian_shortu: number
  const KEY_C: number
  const KEY_CD: number
  const KEY_CH: number
  const KEY_C_H: number
  const KEY_C_h: number
  const KEY_Cabovedot: number
  const KEY_Cacute: number
  const KEY_Calculator: number
  const KEY_Calendar: number
  const KEY_Cancel: number
  const KEY_Caps_Lock: number
  const KEY_Ccaron: number
  const KEY_Ccedilla: number
  const KEY_Ccircumflex: number
  const KEY_Ch: number
  const KEY_Clear: number
  const KEY_ClearGrab: number
  const KEY_Close: number
  const KEY_Codeinput: number
  const KEY_ColonSign: number
  const KEY_Community: number
  const KEY_ContrastAdjust: number
  const KEY_Control_L: number
  const KEY_Control_R: number
  const KEY_Copy: number
  const KEY_CruzeiroSign: number
  const KEY_Cut: number
  const KEY_CycleAngle: number
  const KEY_Cyrillic_A: number
  const KEY_Cyrillic_BE: number
  const KEY_Cyrillic_CHE: number
  const KEY_Cyrillic_CHE_descender: number
  const KEY_Cyrillic_CHE_vertstroke: number
  const KEY_Cyrillic_DE: number
  const KEY_Cyrillic_DZHE: number
  const KEY_Cyrillic_E: number
  const KEY_Cyrillic_EF: number
  const KEY_Cyrillic_EL: number
  const KEY_Cyrillic_EM: number
  const KEY_Cyrillic_EN: number
  const KEY_Cyrillic_EN_descender: number
  const KEY_Cyrillic_ER: number
  const KEY_Cyrillic_ES: number
  const KEY_Cyrillic_GHE: number
  const KEY_Cyrillic_GHE_bar: number
  const KEY_Cyrillic_HA: number
  const KEY_Cyrillic_HARDSIGN: number
  const KEY_Cyrillic_HA_descender: number
  const KEY_Cyrillic_I: number
  const KEY_Cyrillic_IE: number
  const KEY_Cyrillic_IO: number
  const KEY_Cyrillic_I_macron: number
  const KEY_Cyrillic_JE: number
  const KEY_Cyrillic_KA: number
  const KEY_Cyrillic_KA_descender: number
  const KEY_Cyrillic_KA_vertstroke: number
  const KEY_Cyrillic_LJE: number
  const KEY_Cyrillic_NJE: number
  const KEY_Cyrillic_O: number
  const KEY_Cyrillic_O_bar: number
  const KEY_Cyrillic_PE: number
  const KEY_Cyrillic_SCHWA: number
  const KEY_Cyrillic_SHA: number
  const KEY_Cyrillic_SHCHA: number
  const KEY_Cyrillic_SHHA: number
  const KEY_Cyrillic_SHORTI: number
  const KEY_Cyrillic_SOFTSIGN: number
  const KEY_Cyrillic_TE: number
  const KEY_Cyrillic_TSE: number
  const KEY_Cyrillic_U: number
  const KEY_Cyrillic_U_macron: number
  const KEY_Cyrillic_U_straight: number
  const KEY_Cyrillic_U_straight_bar: number
  const KEY_Cyrillic_VE: number
  const KEY_Cyrillic_YA: number
  const KEY_Cyrillic_YERU: number
  const KEY_Cyrillic_YU: number
  const KEY_Cyrillic_ZE: number
  const KEY_Cyrillic_ZHE: number
  const KEY_Cyrillic_ZHE_descender: number
  const KEY_Cyrillic_a: number
  const KEY_Cyrillic_be: number
  const KEY_Cyrillic_che: number
  const KEY_Cyrillic_che_descender: number
  const KEY_Cyrillic_che_vertstroke: number
  const KEY_Cyrillic_de: number
  const KEY_Cyrillic_dzhe: number
  const KEY_Cyrillic_e: number
  const KEY_Cyrillic_ef: number
  const KEY_Cyrillic_el: number
  const KEY_Cyrillic_em: number
  const KEY_Cyrillic_en: number
  const KEY_Cyrillic_en_descender: number
  const KEY_Cyrillic_er: number
  const KEY_Cyrillic_es: number
  const KEY_Cyrillic_ghe: number
  const KEY_Cyrillic_ghe_bar: number
  const KEY_Cyrillic_ha: number
  const KEY_Cyrillic_ha_descender: number
  const KEY_Cyrillic_hardsign: number
  const KEY_Cyrillic_i: number
  const KEY_Cyrillic_i_macron: number
  const KEY_Cyrillic_ie: number
  const KEY_Cyrillic_io: number
  const KEY_Cyrillic_je: number
  const KEY_Cyrillic_ka: number
  const KEY_Cyrillic_ka_descender: number
  const KEY_Cyrillic_ka_vertstroke: number
  const KEY_Cyrillic_lje: number
  const KEY_Cyrillic_nje: number
  const KEY_Cyrillic_o: number
  const KEY_Cyrillic_o_bar: number
  const KEY_Cyrillic_pe: number
  const KEY_Cyrillic_schwa: number
  const KEY_Cyrillic_sha: number
  const KEY_Cyrillic_shcha: number
  const KEY_Cyrillic_shha: number
  const KEY_Cyrillic_shorti: number
  const KEY_Cyrillic_softsign: number
  const KEY_Cyrillic_te: number
  const KEY_Cyrillic_tse: number
  const KEY_Cyrillic_u: number
  const KEY_Cyrillic_u_macron: number
  const KEY_Cyrillic_u_straight: number
  const KEY_Cyrillic_u_straight_bar: number
  const KEY_Cyrillic_ve: number
  const KEY_Cyrillic_ya: number
  const KEY_Cyrillic_yeru: number
  const KEY_Cyrillic_yu: number
  const KEY_Cyrillic_ze: number
  const KEY_Cyrillic_zhe: number
  const KEY_Cyrillic_zhe_descender: number
  const KEY_D: number
  const KEY_DOS: number
  const KEY_Dabovedot: number
  const KEY_Dcaron: number
  const KEY_Delete: number
  const KEY_Display: number
  const KEY_Documents: number
  const KEY_DongSign: number
  const KEY_Down: number
  const KEY_Dstroke: number
  const KEY_E: number
  const KEY_ENG: number
  const KEY_ETH: number
  const KEY_EZH: number
  const KEY_Eabovedot: number
  const KEY_Eacute: number
  const KEY_Ebelowdot: number
  const KEY_Ecaron: number
  const KEY_Ecircumflex: number
  const KEY_Ecircumflexacute: number
  const KEY_Ecircumflexbelowdot: number
  const KEY_Ecircumflexgrave: number
  const KEY_Ecircumflexhook: number
  const KEY_Ecircumflextilde: number
  const KEY_EcuSign: number
  const KEY_Ediaeresis: number
  const KEY_Egrave: number
  const KEY_Ehook: number
  const KEY_Eisu_Shift: number
  const KEY_Eisu_toggle: number
  const KEY_Eject: number
  const KEY_Emacron: number
  const KEY_End: number
  const KEY_Eogonek: number
  const KEY_Escape: number
  const KEY_Eth: number
  const KEY_Etilde: number
  const KEY_EuroSign: number
  const KEY_Excel: number
  const KEY_Execute: number
  const KEY_Explorer: number
  const KEY_F: number
  const KEY_F1: number
  const KEY_F10: number
  const KEY_F11: number
  const KEY_F12: number
  const KEY_F13: number
  const KEY_F14: number
  const KEY_F15: number
  const KEY_F16: number
  const KEY_F17: number
  const KEY_F18: number
  const KEY_F19: number
  const KEY_F2: number
  const KEY_F20: number
  const KEY_F21: number
  const KEY_F22: number
  const KEY_F23: number
  const KEY_F24: number
  const KEY_F25: number
  const KEY_F26: number
  const KEY_F27: number
  const KEY_F28: number
  const KEY_F29: number
  const KEY_F3: number
  const KEY_F30: number
  const KEY_F31: number
  const KEY_F32: number
  const KEY_F33: number
  const KEY_F34: number
  const KEY_F35: number
  const KEY_F4: number
  const KEY_F5: number
  const KEY_F6: number
  const KEY_F7: number
  const KEY_F8: number
  const KEY_F9: number
  const KEY_FFrancSign: number
  const KEY_Fabovedot: number
  const KEY_Farsi_0: number
  const KEY_Farsi_1: number
  const KEY_Farsi_2: number
  const KEY_Farsi_3: number
  const KEY_Farsi_4: number
  const KEY_Farsi_5: number
  const KEY_Farsi_6: number
  const KEY_Farsi_7: number
  const KEY_Farsi_8: number
  const KEY_Farsi_9: number
  const KEY_Farsi_yeh: number
  const KEY_Favorites: number
  const KEY_Finance: number
  const KEY_Find: number
  const KEY_First_Virtual_Screen: number
  const KEY_Forward: number
  const KEY_FrameBack: number
  const KEY_FrameForward: number
  const KEY_G: number
  const KEY_Gabovedot: number
  const KEY_Game: number
  const KEY_Gbreve: number
  const KEY_Gcaron: number
  const KEY_Gcedilla: number
  const KEY_Gcircumflex: number
  const KEY_Georgian_an: number
  const KEY_Georgian_ban: number
  const KEY_Georgian_can: number
  const KEY_Georgian_char: number
  const KEY_Georgian_chin: number
  const KEY_Georgian_cil: number
  const KEY_Georgian_don: number
  const KEY_Georgian_en: number
  const KEY_Georgian_fi: number
  const KEY_Georgian_gan: number
  const KEY_Georgian_ghan: number
  const KEY_Georgian_hae: number
  const KEY_Georgian_har: number
  const KEY_Georgian_he: number
  const KEY_Georgian_hie: number
  const KEY_Georgian_hoe: number
  const KEY_Georgian_in: number
  const KEY_Georgian_jhan: number
  const KEY_Georgian_jil: number
  const KEY_Georgian_kan: number
  const KEY_Georgian_khar: number
  const KEY_Georgian_las: number
  const KEY_Georgian_man: number
  const KEY_Georgian_nar: number
  const KEY_Georgian_on: number
  const KEY_Georgian_par: number
  const KEY_Georgian_phar: number
  const KEY_Georgian_qar: number
  const KEY_Georgian_rae: number
  const KEY_Georgian_san: number
  const KEY_Georgian_shin: number
  const KEY_Georgian_tan: number
  const KEY_Georgian_tar: number
  const KEY_Georgian_un: number
  const KEY_Georgian_vin: number
  const KEY_Georgian_we: number
  const KEY_Georgian_xan: number
  const KEY_Georgian_zen: number
  const KEY_Georgian_zhar: number
  const KEY_Go: number
  const KEY_Greek_ALPHA: number
  const KEY_Greek_ALPHAaccent: number
  const KEY_Greek_BETA: number
  const KEY_Greek_CHI: number
  const KEY_Greek_DELTA: number
  const KEY_Greek_EPSILON: number
  const KEY_Greek_EPSILONaccent: number
  const KEY_Greek_ETA: number
  const KEY_Greek_ETAaccent: number
  const KEY_Greek_GAMMA: number
  const KEY_Greek_IOTA: number
  const KEY_Greek_IOTAaccent: number
  const KEY_Greek_IOTAdiaeresis: number
  const KEY_Greek_IOTAdieresis: number
  const KEY_Greek_KAPPA: number
  const KEY_Greek_LAMBDA: number
  const KEY_Greek_LAMDA: number
  const KEY_Greek_MU: number
  const KEY_Greek_NU: number
  const KEY_Greek_OMEGA: number
  const KEY_Greek_OMEGAaccent: number
  const KEY_Greek_OMICRON: number
  const KEY_Greek_OMICRONaccent: number
  const KEY_Greek_PHI: number
  const KEY_Greek_PI: number
  const KEY_Greek_PSI: number
  const KEY_Greek_RHO: number
  const KEY_Greek_SIGMA: number
  const KEY_Greek_TAU: number
  const KEY_Greek_THETA: number
  const KEY_Greek_UPSILON: number
  const KEY_Greek_UPSILONaccent: number
  const KEY_Greek_UPSILONdieresis: number
  const KEY_Greek_XI: number
  const KEY_Greek_ZETA: number
  const KEY_Greek_accentdieresis: number
  const KEY_Greek_alpha: number
  const KEY_Greek_alphaaccent: number
  const KEY_Greek_beta: number
  const KEY_Greek_chi: number
  const KEY_Greek_delta: number
  const KEY_Greek_epsilon: number
  const KEY_Greek_epsilonaccent: number
  const KEY_Greek_eta: number
  const KEY_Greek_etaaccent: number
  const KEY_Greek_finalsmallsigma: number
  const KEY_Greek_gamma: number
  const KEY_Greek_horizbar: number
  const KEY_Greek_iota: number
  const KEY_Greek_iotaaccent: number
  const KEY_Greek_iotaaccentdieresis: number
  const KEY_Greek_iotadieresis: number
  const KEY_Greek_kappa: number
  const KEY_Greek_lambda: number
  const KEY_Greek_lamda: number
  const KEY_Greek_mu: number
  const KEY_Greek_nu: number
  const KEY_Greek_omega: number
  const KEY_Greek_omegaaccent: number
  const KEY_Greek_omicron: number
  const KEY_Greek_omicronaccent: number
  const KEY_Greek_phi: number
  const KEY_Greek_pi: number
  const KEY_Greek_psi: number
  const KEY_Greek_rho: number
  const KEY_Greek_sigma: number
  const KEY_Greek_switch: number
  const KEY_Greek_tau: number
  const KEY_Greek_theta: number
  const KEY_Greek_upsilon: number
  const KEY_Greek_upsilonaccent: number
  const KEY_Greek_upsilonaccentdieresis: number
  const KEY_Greek_upsilondieresis: number
  const KEY_Greek_xi: number
  const KEY_Greek_zeta: number
  const KEY_Green: number
  const KEY_H: number
  const KEY_Hangul: number
  const KEY_Hangul_A: number
  const KEY_Hangul_AE: number
  const KEY_Hangul_AraeA: number
  const KEY_Hangul_AraeAE: number
  const KEY_Hangul_Banja: number
  const KEY_Hangul_Cieuc: number
  const KEY_Hangul_Codeinput: number
  const KEY_Hangul_Dikeud: number
  const KEY_Hangul_E: number
  const KEY_Hangul_EO: number
  const KEY_Hangul_EU: number
  const KEY_Hangul_End: number
  const KEY_Hangul_Hanja: number
  const KEY_Hangul_Hieuh: number
  const KEY_Hangul_I: number
  const KEY_Hangul_Ieung: number
  const KEY_Hangul_J_Cieuc: number
  const KEY_Hangul_J_Dikeud: number
  const KEY_Hangul_J_Hieuh: number
  const KEY_Hangul_J_Ieung: number
  const KEY_Hangul_J_Jieuj: number
  const KEY_Hangul_J_Khieuq: number
  const KEY_Hangul_J_Kiyeog: number
  const KEY_Hangul_J_KiyeogSios: number
  const KEY_Hangul_J_KkogjiDalrinIeung: number
  const KEY_Hangul_J_Mieum: number
  const KEY_Hangul_J_Nieun: number
  const KEY_Hangul_J_NieunHieuh: number
  const KEY_Hangul_J_NieunJieuj: number
  const KEY_Hangul_J_PanSios: number
  const KEY_Hangul_J_Phieuf: number
  const KEY_Hangul_J_Pieub: number
  const KEY_Hangul_J_PieubSios: number
  const KEY_Hangul_J_Rieul: number
  const KEY_Hangul_J_RieulHieuh: number
  const KEY_Hangul_J_RieulKiyeog: number
  const KEY_Hangul_J_RieulMieum: number
  const KEY_Hangul_J_RieulPhieuf: number
  const KEY_Hangul_J_RieulPieub: number
  const KEY_Hangul_J_RieulSios: number
  const KEY_Hangul_J_RieulTieut: number
  const KEY_Hangul_J_Sios: number
  const KEY_Hangul_J_SsangKiyeog: number
  const KEY_Hangul_J_SsangSios: number
  const KEY_Hangul_J_Tieut: number
  const KEY_Hangul_J_YeorinHieuh: number
  const KEY_Hangul_Jamo: number
  const KEY_Hangul_Jeonja: number
  const KEY_Hangul_Jieuj: number
  const KEY_Hangul_Khieuq: number
  const KEY_Hangul_Kiyeog: number
  const KEY_Hangul_KiyeogSios: number
  const KEY_Hangul_KkogjiDalrinIeung: number
  const KEY_Hangul_Mieum: number
  const KEY_Hangul_MultipleCandidate: number
  const KEY_Hangul_Nieun: number
  const KEY_Hangul_NieunHieuh: number
  const KEY_Hangul_NieunJieuj: number
  const KEY_Hangul_O: number
  const KEY_Hangul_OE: number
  const KEY_Hangul_PanSios: number
  const KEY_Hangul_Phieuf: number
  const KEY_Hangul_Pieub: number
  const KEY_Hangul_PieubSios: number
  const KEY_Hangul_PostHanja: number
  const KEY_Hangul_PreHanja: number
  const KEY_Hangul_PreviousCandidate: number
  const KEY_Hangul_Rieul: number
  const KEY_Hangul_RieulHieuh: number
  const KEY_Hangul_RieulKiyeog: number
  const KEY_Hangul_RieulMieum: number
  const KEY_Hangul_RieulPhieuf: number
  const KEY_Hangul_RieulPieub: number
  const KEY_Hangul_RieulSios: number
  const KEY_Hangul_RieulTieut: number
  const KEY_Hangul_RieulYeorinHieuh: number
  const KEY_Hangul_Romaja: number
  const KEY_Hangul_SingleCandidate: number
  const KEY_Hangul_Sios: number
  const KEY_Hangul_Special: number
  const KEY_Hangul_SsangDikeud: number
  const KEY_Hangul_SsangJieuj: number
  const KEY_Hangul_SsangKiyeog: number
  const KEY_Hangul_SsangPieub: number
  const KEY_Hangul_SsangSios: number
  const KEY_Hangul_Start: number
  const KEY_Hangul_SunkyeongeumMieum: number
  const KEY_Hangul_SunkyeongeumPhieuf: number
  const KEY_Hangul_SunkyeongeumPieub: number
  const KEY_Hangul_Tieut: number
  const KEY_Hangul_U: number
  const KEY_Hangul_WA: number
  const KEY_Hangul_WAE: number
  const KEY_Hangul_WE: number
  const KEY_Hangul_WEO: number
  const KEY_Hangul_WI: number
  const KEY_Hangul_YA: number
  const KEY_Hangul_YAE: number
  const KEY_Hangul_YE: number
  const KEY_Hangul_YEO: number
  const KEY_Hangul_YI: number
  const KEY_Hangul_YO: number
  const KEY_Hangul_YU: number
  const KEY_Hangul_YeorinHieuh: number
  const KEY_Hangul_switch: number
  const KEY_Hankaku: number
  const KEY_Hcircumflex: number
  const KEY_Hebrew_switch: number
  const KEY_Help: number
  const KEY_Henkan: number
  const KEY_Henkan_Mode: number
  const KEY_Hibernate: number
  const KEY_Hiragana: number
  const KEY_Hiragana_Katakana: number
  const KEY_History: number
  const KEY_Home: number
  const KEY_HomePage: number
  const KEY_HotLinks: number
  const KEY_Hstroke: number
  const KEY_Hyper_L: number
  const KEY_Hyper_R: number
  const KEY_I: number
  const KEY_ISO_Center_Object: number
  const KEY_ISO_Continuous_Underline: number
  const KEY_ISO_Discontinuous_Underline: number
  const KEY_ISO_Emphasize: number
  const KEY_ISO_Enter: number
  const KEY_ISO_Fast_Cursor_Down: number
  const KEY_ISO_Fast_Cursor_Left: number
  const KEY_ISO_Fast_Cursor_Right: number
  const KEY_ISO_Fast_Cursor_Up: number
  const KEY_ISO_First_Group: number
  const KEY_ISO_First_Group_Lock: number
  const KEY_ISO_Group_Latch: number
  const KEY_ISO_Group_Lock: number
  const KEY_ISO_Group_Shift: number
  const KEY_ISO_Last_Group: number
  const KEY_ISO_Last_Group_Lock: number
  const KEY_ISO_Left_Tab: number
  const KEY_ISO_Level2_Latch: number
  const KEY_ISO_Level3_Latch: number
  const KEY_ISO_Level3_Lock: number
  const KEY_ISO_Level3_Shift: number
  const KEY_ISO_Level5_Latch: number
  const KEY_ISO_Level5_Lock: number
  const KEY_ISO_Level5_Shift: number
  const KEY_ISO_Lock: number
  const KEY_ISO_Move_Line_Down: number
  const KEY_ISO_Move_Line_Up: number
  const KEY_ISO_Next_Group: number
  const KEY_ISO_Next_Group_Lock: number
  const KEY_ISO_Partial_Line_Down: number
  const KEY_ISO_Partial_Line_Up: number
  const KEY_ISO_Partial_Space_Left: number
  const KEY_ISO_Partial_Space_Right: number
  const KEY_ISO_Prev_Group: number
  const KEY_ISO_Prev_Group_Lock: number
  const KEY_ISO_Release_Both_Margins: number
  const KEY_ISO_Release_Margin_Left: number
  const KEY_ISO_Release_Margin_Right: number
  const KEY_ISO_Set_Margin_Left: number
  const KEY_ISO_Set_Margin_Right: number
  const KEY_Iabovedot: number
  const KEY_Iacute: number
  const KEY_Ibelowdot: number
  const KEY_Ibreve: number
  const KEY_Icircumflex: number
  const KEY_Idiaeresis: number
  const KEY_Igrave: number
  const KEY_Ihook: number
  const KEY_Imacron: number
  const KEY_Insert: number
  const KEY_Iogonek: number
  const KEY_Itilde: number
  const KEY_J: number
  const KEY_Jcircumflex: number
  const KEY_K: number
  const KEY_KP_0: number
  const KEY_KP_1: number
  const KEY_KP_2: number
  const KEY_KP_3: number
  const KEY_KP_4: number
  const KEY_KP_5: number
  const KEY_KP_6: number
  const KEY_KP_7: number
  const KEY_KP_8: number
  const KEY_KP_9: number
  const KEY_KP_Add: number
  const KEY_KP_Begin: number
  const KEY_KP_Decimal: number
  const KEY_KP_Delete: number
  const KEY_KP_Divide: number
  const KEY_KP_Down: number
  const KEY_KP_End: number
  const KEY_KP_Enter: number
  const KEY_KP_Equal: number
  const KEY_KP_F1: number
  const KEY_KP_F2: number
  const KEY_KP_F3: number
  const KEY_KP_F4: number
  const KEY_KP_Home: number
  const KEY_KP_Insert: number
  const KEY_KP_Left: number
  const KEY_KP_Multiply: number
  const KEY_KP_Next: number
  const KEY_KP_Page_Down: number
  const KEY_KP_Page_Up: number
  const KEY_KP_Prior: number
  const KEY_KP_Right: number
  const KEY_KP_Separator: number
  const KEY_KP_Space: number
  const KEY_KP_Subtract: number
  const KEY_KP_Tab: number
  const KEY_KP_Up: number
  const KEY_Kana_Lock: number
  const KEY_Kana_Shift: number
  const KEY_Kanji: number
  const KEY_Kanji_Bangou: number
  const KEY_Katakana: number
  const KEY_KbdBrightnessDown: number
  const KEY_KbdBrightnessUp: number
  const KEY_KbdLightOnOff: number
  const KEY_Kcedilla: number
  const KEY_Keyboard: number
  const KEY_Korean_Won: number
  const KEY_L: number
  const KEY_L1: number
  const KEY_L10: number
  const KEY_L2: number
  const KEY_L3: number
  const KEY_L4: number
  const KEY_L5: number
  const KEY_L6: number
  const KEY_L7: number
  const KEY_L8: number
  const KEY_L9: number
  const KEY_Lacute: number
  const KEY_Last_Virtual_Screen: number
  const KEY_Launch0: number
  const KEY_Launch1: number
  const KEY_Launch2: number
  const KEY_Launch3: number
  const KEY_Launch4: number
  const KEY_Launch5: number
  const KEY_Launch6: number
  const KEY_Launch7: number
  const KEY_Launch8: number
  const KEY_Launch9: number
  const KEY_LaunchA: number
  const KEY_LaunchB: number
  const KEY_LaunchC: number
  const KEY_LaunchD: number
  const KEY_LaunchE: number
  const KEY_LaunchF: number
  const KEY_Lbelowdot: number
  const KEY_Lcaron: number
  const KEY_Lcedilla: number
  const KEY_Left: number
  const KEY_LightBulb: number
  const KEY_Linefeed: number
  const KEY_LiraSign: number
  const KEY_LogGrabInfo: number
  const KEY_LogOff: number
  const KEY_LogWindowTree: number
  const KEY_Lstroke: number
  const KEY_M: number
  const KEY_Mabovedot: number
  const KEY_Macedonia_DSE: number
  const KEY_Macedonia_GJE: number
  const KEY_Macedonia_KJE: number
  const KEY_Macedonia_dse: number
  const KEY_Macedonia_gje: number
  const KEY_Macedonia_kje: number
  const KEY_Mae_Koho: number
  const KEY_Mail: number
  const KEY_MailForward: number
  const KEY_Market: number
  const KEY_Massyo: number
  const KEY_Meeting: number
  const KEY_Memo: number
  const KEY_Menu: number
  const KEY_MenuKB: number
  const KEY_MenuPB: number
  const KEY_Messenger: number
  const KEY_Meta_L: number
  const KEY_Meta_R: number
  const KEY_MillSign: number
  const KEY_ModeLock: number
  const KEY_Mode_switch: number
  const KEY_MonBrightnessDown: number
  const KEY_MonBrightnessUp: number
  const KEY_MouseKeys_Accel_Enable: number
  const KEY_MouseKeys_Enable: number
  const KEY_Muhenkan: number
  const KEY_Multi_key: number
  const KEY_MultipleCandidate: number
  const KEY_Music: number
  const KEY_MyComputer: number
  const KEY_MySites: number
  const KEY_N: number
  const KEY_Nacute: number
  const KEY_NairaSign: number
  const KEY_Ncaron: number
  const KEY_Ncedilla: number
  const KEY_New: number
  const KEY_NewSheqelSign: number
  const KEY_News: number
  const KEY_Next: number
  const KEY_Next_VMode: number
  const KEY_Next_Virtual_Screen: number
  const KEY_Ntilde: number
  const KEY_Num_Lock: number
  const KEY_O: number
  const KEY_OE: number
  const KEY_Oacute: number
  const KEY_Obarred: number
  const KEY_Obelowdot: number
  const KEY_Ocaron: number
  const KEY_Ocircumflex: number
  const KEY_Ocircumflexacute: number
  const KEY_Ocircumflexbelowdot: number
  const KEY_Ocircumflexgrave: number
  const KEY_Ocircumflexhook: number
  const KEY_Ocircumflextilde: number
  const KEY_Odiaeresis: number
  const KEY_Odoubleacute: number
  const KEY_OfficeHome: number
  const KEY_Ograve: number
  const KEY_Ohook: number
  const KEY_Ohorn: number
  const KEY_Ohornacute: number
  const KEY_Ohornbelowdot: number
  const KEY_Ohorngrave: number
  const KEY_Ohornhook: number
  const KEY_Ohorntilde: number
  const KEY_Omacron: number
  const KEY_Ooblique: number
  const KEY_Open: number
  const KEY_OpenURL: number
  const KEY_Option: number
  const KEY_Oslash: number
  const KEY_Otilde: number
  const KEY_Overlay1_Enable: number
  const KEY_Overlay2_Enable: number
  const KEY_P: number
  const KEY_Pabovedot: number
  const KEY_Page_Down: number
  const KEY_Page_Up: number
  const KEY_Paste: number
  const KEY_Pause: number
  const KEY_PesetaSign: number
  const KEY_Phone: number
  const KEY_Pictures: number
  const KEY_Pointer_Accelerate: number
  const KEY_Pointer_Button1: number
  const KEY_Pointer_Button2: number
  const KEY_Pointer_Button3: number
  const KEY_Pointer_Button4: number
  const KEY_Pointer_Button5: number
  const KEY_Pointer_Button_Dflt: number
  const KEY_Pointer_DblClick1: number
  const KEY_Pointer_DblClick2: number
  const KEY_Pointer_DblClick3: number
  const KEY_Pointer_DblClick4: number
  const KEY_Pointer_DblClick5: number
  const KEY_Pointer_DblClick_Dflt: number
  const KEY_Pointer_DfltBtnNext: number
  const KEY_Pointer_DfltBtnPrev: number
  const KEY_Pointer_Down: number
  const KEY_Pointer_DownLeft: number
  const KEY_Pointer_DownRight: number
  const KEY_Pointer_Drag1: number
  const KEY_Pointer_Drag2: number
  const KEY_Pointer_Drag3: number
  const KEY_Pointer_Drag4: number
  const KEY_Pointer_Drag5: number
  const KEY_Pointer_Drag_Dflt: number
  const KEY_Pointer_EnableKeys: number
  const KEY_Pointer_Left: number
  const KEY_Pointer_Right: number
  const KEY_Pointer_Up: number
  const KEY_Pointer_UpLeft: number
  const KEY_Pointer_UpRight: number
  const KEY_PowerDown: number
  const KEY_PowerOff: number
  const KEY_Prev_VMode: number
  const KEY_Prev_Virtual_Screen: number
  const KEY_PreviousCandidate: number
  const KEY_Print: number
  const KEY_Prior: number
  const KEY_Q: number
  const KEY_R: number
  const KEY_R1: number
  const KEY_R10: number
  const KEY_R11: number
  const KEY_R12: number
  const KEY_R13: number
  const KEY_R14: number
  const KEY_R15: number
  const KEY_R2: number
  const KEY_R3: number
  const KEY_R4: number
  const KEY_R5: number
  const KEY_R6: number
  const KEY_R7: number
  const KEY_R8: number
  const KEY_R9: number
  const KEY_RFKill: number
  const KEY_Racute: number
  const KEY_Rcaron: number
  const KEY_Rcedilla: number
  const KEY_Red: number
  const KEY_Redo: number
  const KEY_Refresh: number
  const KEY_Reload: number
  const KEY_RepeatKeys_Enable: number
  const KEY_Reply: number
  const KEY_Return: number
  const KEY_Right: number
  const KEY_RockerDown: number
  const KEY_RockerEnter: number
  const KEY_RockerUp: number
  const KEY_Romaji: number
  const KEY_RotateWindows: number
  const KEY_RotationKB: number
  const KEY_RotationPB: number
  const KEY_RupeeSign: number
  const KEY_S: number
  const KEY_SCHWA: number
  const KEY_Sabovedot: number
  const KEY_Sacute: number
  const KEY_Save: number
  const KEY_Scaron: number
  const KEY_Scedilla: number
  const KEY_Scircumflex: number
  const KEY_ScreenSaver: number
  const KEY_ScrollClick: number
  const KEY_ScrollDown: number
  const KEY_ScrollUp: number
  const KEY_Scroll_Lock: number
  const KEY_Search: number
  const KEY_Select: number
  const KEY_SelectButton: number
  const KEY_Send: number
  const KEY_Serbian_DJE: number
  const KEY_Serbian_DZE: number
  const KEY_Serbian_JE: number
  const KEY_Serbian_LJE: number
  const KEY_Serbian_NJE: number
  const KEY_Serbian_TSHE: number
  const KEY_Serbian_dje: number
  const KEY_Serbian_dze: number
  const KEY_Serbian_je: number
  const KEY_Serbian_lje: number
  const KEY_Serbian_nje: number
  const KEY_Serbian_tshe: number
  const KEY_Shift_L: number
  const KEY_Shift_Lock: number
  const KEY_Shift_R: number
  const KEY_Shop: number
  const KEY_SingleCandidate: number
  const KEY_Sinh_a: number
  const KEY_Sinh_aa: number
  const KEY_Sinh_aa2: number
  const KEY_Sinh_ae: number
  const KEY_Sinh_ae2: number
  const KEY_Sinh_aee: number
  const KEY_Sinh_aee2: number
  const KEY_Sinh_ai: number
  const KEY_Sinh_ai2: number
  const KEY_Sinh_al: number
  const KEY_Sinh_au: number
  const KEY_Sinh_au2: number
  const KEY_Sinh_ba: number
  const KEY_Sinh_bha: number
  const KEY_Sinh_ca: number
  const KEY_Sinh_cha: number
  const KEY_Sinh_dda: number
  const KEY_Sinh_ddha: number
  const KEY_Sinh_dha: number
  const KEY_Sinh_dhha: number
  const KEY_Sinh_e: number
  const KEY_Sinh_e2: number
  const KEY_Sinh_ee: number
  const KEY_Sinh_ee2: number
  const KEY_Sinh_fa: number
  const KEY_Sinh_ga: number
  const KEY_Sinh_gha: number
  const KEY_Sinh_h2: number
  const KEY_Sinh_ha: number
  const KEY_Sinh_i: number
  const KEY_Sinh_i2: number
  const KEY_Sinh_ii: number
  const KEY_Sinh_ii2: number
  const KEY_Sinh_ja: number
  const KEY_Sinh_jha: number
  const KEY_Sinh_jnya: number
  const KEY_Sinh_ka: number
  const KEY_Sinh_kha: number
  const KEY_Sinh_kunddaliya: number
  const KEY_Sinh_la: number
  const KEY_Sinh_lla: number
  const KEY_Sinh_lu: number
  const KEY_Sinh_lu2: number
  const KEY_Sinh_luu: number
  const KEY_Sinh_luu2: number
  const KEY_Sinh_ma: number
  const KEY_Sinh_mba: number
  const KEY_Sinh_na: number
  const KEY_Sinh_ndda: number
  const KEY_Sinh_ndha: number
  const KEY_Sinh_ng: number
  const KEY_Sinh_ng2: number
  const KEY_Sinh_nga: number
  const KEY_Sinh_nja: number
  const KEY_Sinh_nna: number
  const KEY_Sinh_nya: number
  const KEY_Sinh_o: number
  const KEY_Sinh_o2: number
  const KEY_Sinh_oo: number
  const KEY_Sinh_oo2: number
  const KEY_Sinh_pa: number
  const KEY_Sinh_pha: number
  const KEY_Sinh_ra: number
  const KEY_Sinh_ri: number
  const KEY_Sinh_rii: number
  const KEY_Sinh_ru2: number
  const KEY_Sinh_ruu2: number
  const KEY_Sinh_sa: number
  const KEY_Sinh_sha: number
  const KEY_Sinh_ssha: number
  const KEY_Sinh_tha: number
  const KEY_Sinh_thha: number
  const KEY_Sinh_tta: number
  const KEY_Sinh_ttha: number
  const KEY_Sinh_u: number
  const KEY_Sinh_u2: number
  const KEY_Sinh_uu: number
  const KEY_Sinh_uu2: number
  const KEY_Sinh_va: number
  const KEY_Sinh_ya: number
  const KEY_Sleep: number
  const KEY_SlowKeys_Enable: number
  const KEY_Spell: number
  const KEY_SplitScreen: number
  const KEY_Standby: number
  const KEY_Start: number
  const KEY_StickyKeys_Enable: number
  const KEY_Stop: number
  const KEY_Subtitle: number
  const KEY_Super_L: number
  const KEY_Super_R: number
  const KEY_Support: number
  const KEY_Suspend: number
  const KEY_Switch_VT_1: number
  const KEY_Switch_VT_10: number
  const KEY_Switch_VT_11: number
  const KEY_Switch_VT_12: number
  const KEY_Switch_VT_2: number
  const KEY_Switch_VT_3: number
  const KEY_Switch_VT_4: number
  const KEY_Switch_VT_5: number
  const KEY_Switch_VT_6: number
  const KEY_Switch_VT_7: number
  const KEY_Switch_VT_8: number
  const KEY_Switch_VT_9: number
  const KEY_Sys_Req: number
  const KEY_T: number
  const KEY_THORN: number
  const KEY_Tab: number
  const KEY_Tabovedot: number
  const KEY_TaskPane: number
  const KEY_Tcaron: number
  const KEY_Tcedilla: number
  const KEY_Terminal: number
  const KEY_Terminate_Server: number
  const KEY_Thai_baht: number
  const KEY_Thai_bobaimai: number
  const KEY_Thai_chochan: number
  const KEY_Thai_chochang: number
  const KEY_Thai_choching: number
  const KEY_Thai_chochoe: number
  const KEY_Thai_dochada: number
  const KEY_Thai_dodek: number
  const KEY_Thai_fofa: number
  const KEY_Thai_fofan: number
  const KEY_Thai_hohip: number
  const KEY_Thai_honokhuk: number
  const KEY_Thai_khokhai: number
  const KEY_Thai_khokhon: number
  const KEY_Thai_khokhuat: number
  const KEY_Thai_khokhwai: number
  const KEY_Thai_khorakhang: number
  const KEY_Thai_kokai: number
  const KEY_Thai_lakkhangyao: number
  const KEY_Thai_lekchet: number
  const KEY_Thai_lekha: number
  const KEY_Thai_lekhok: number
  const KEY_Thai_lekkao: number
  const KEY_Thai_leknung: number
  const KEY_Thai_lekpaet: number
  const KEY_Thai_leksam: number
  const KEY_Thai_leksi: number
  const KEY_Thai_leksong: number
  const KEY_Thai_leksun: number
  const KEY_Thai_lochula: number
  const KEY_Thai_loling: number
  const KEY_Thai_lu: number
  const KEY_Thai_maichattawa: number
  const KEY_Thai_maiek: number
  const KEY_Thai_maihanakat: number
  const KEY_Thai_maihanakat_maitho: number
  const KEY_Thai_maitaikhu: number
  const KEY_Thai_maitho: number
  const KEY_Thai_maitri: number
  const KEY_Thai_maiyamok: number
  const KEY_Thai_moma: number
  const KEY_Thai_ngongu: number
  const KEY_Thai_nikhahit: number
  const KEY_Thai_nonen: number
  const KEY_Thai_nonu: number
  const KEY_Thai_oang: number
  const KEY_Thai_paiyannoi: number
  const KEY_Thai_phinthu: number
  const KEY_Thai_phophan: number
  const KEY_Thai_phophung: number
  const KEY_Thai_phosamphao: number
  const KEY_Thai_popla: number
  const KEY_Thai_rorua: number
  const KEY_Thai_ru: number
  const KEY_Thai_saraa: number
  const KEY_Thai_saraaa: number
  const KEY_Thai_saraae: number
  const KEY_Thai_saraaimaimalai: number
  const KEY_Thai_saraaimaimuan: number
  const KEY_Thai_saraam: number
  const KEY_Thai_sarae: number
  const KEY_Thai_sarai: number
  const KEY_Thai_saraii: number
  const KEY_Thai_sarao: number
  const KEY_Thai_sarau: number
  const KEY_Thai_saraue: number
  const KEY_Thai_sarauee: number
  const KEY_Thai_sarauu: number
  const KEY_Thai_sorusi: number
  const KEY_Thai_sosala: number
  const KEY_Thai_soso: number
  const KEY_Thai_sosua: number
  const KEY_Thai_thanthakhat: number
  const KEY_Thai_thonangmontho: number
  const KEY_Thai_thophuthao: number
  const KEY_Thai_thothahan: number
  const KEY_Thai_thothan: number
  const KEY_Thai_thothong: number
  const KEY_Thai_thothung: number
  const KEY_Thai_topatak: number
  const KEY_Thai_totao: number
  const KEY_Thai_wowaen: number
  const KEY_Thai_yoyak: number
  const KEY_Thai_yoying: number
  const KEY_Thorn: number
  const KEY_Time: number
  const KEY_ToDoList: number
  const KEY_Tools: number
  const KEY_TopMenu: number
  const KEY_TouchpadOff: number
  const KEY_TouchpadOn: number
  const KEY_TouchpadToggle: number
  const KEY_Touroku: number
  const KEY_Travel: number
  const KEY_Tslash: number
  const KEY_U: number
  const KEY_UWB: number
  const KEY_Uacute: number
  const KEY_Ubelowdot: number
  const KEY_Ubreve: number
  const KEY_Ucircumflex: number
  const KEY_Udiaeresis: number
  const KEY_Udoubleacute: number
  const KEY_Ugrave: number
  const KEY_Uhook: number
  const KEY_Uhorn: number
  const KEY_Uhornacute: number
  const KEY_Uhornbelowdot: number
  const KEY_Uhorngrave: number
  const KEY_Uhornhook: number
  const KEY_Uhorntilde: number
  const KEY_Ukrainian_GHE_WITH_UPTURN: number
  const KEY_Ukrainian_I: number
  const KEY_Ukrainian_IE: number
  const KEY_Ukrainian_YI: number
  const KEY_Ukrainian_ghe_with_upturn: number
  const KEY_Ukrainian_i: number
  const KEY_Ukrainian_ie: number
  const KEY_Ukrainian_yi: number
  const KEY_Ukranian_I: number
  const KEY_Ukranian_JE: number
  const KEY_Ukranian_YI: number
  const KEY_Ukranian_i: number
  const KEY_Ukranian_je: number
  const KEY_Ukranian_yi: number
  const KEY_Umacron: number
  const KEY_Undo: number
  const KEY_Ungrab: number
  const KEY_Uogonek: number
  const KEY_Up: number
  const KEY_Uring: number
  const KEY_User1KB: number
  const KEY_User2KB: number
  const KEY_UserPB: number
  const KEY_Utilde: number
  const KEY_V: number
  const KEY_VendorHome: number
  const KEY_Video: number
  const KEY_View: number
  const KEY_VoidSymbol: number
  const KEY_W: number
  const KEY_WLAN: number
  const KEY_WWAN: number
  const KEY_WWW: number
  const KEY_Wacute: number
  const KEY_WakeUp: number
  const KEY_Wcircumflex: number
  const KEY_Wdiaeresis: number
  const KEY_WebCam: number
  const KEY_Wgrave: number
  const KEY_WheelButton: number
  const KEY_WindowClear: number
  const KEY_WonSign: number
  const KEY_Word: number
  const KEY_X: number
  const KEY_Xabovedot: number
  const KEY_Xfer: number
  const KEY_Y: number
  const KEY_Yacute: number
  const KEY_Ybelowdot: number
  const KEY_Ycircumflex: number
  const KEY_Ydiaeresis: number
  const KEY_Yellow: number
  const KEY_Ygrave: number
  const KEY_Yhook: number
  const KEY_Ytilde: number
  const KEY_Z: number
  const KEY_Zabovedot: number
  const KEY_Zacute: number
  const KEY_Zcaron: number
  const KEY_Zen_Koho: number
  const KEY_Zenkaku: number
  const KEY_Zenkaku_Hankaku: number
  const KEY_ZoomIn: number
  const KEY_ZoomOut: number
  const KEY_Zstroke: number
  const KEY_a: number
  const KEY_aacute: number
  const KEY_abelowdot: number
  const KEY_abovedot: number
  const KEY_abreve: number
  const KEY_abreveacute: number
  const KEY_abrevebelowdot: number
  const KEY_abrevegrave: number
  const KEY_abrevehook: number
  const KEY_abrevetilde: number
  const KEY_acircumflex: number
  const KEY_acircumflexacute: number
  const KEY_acircumflexbelowdot: number
  const KEY_acircumflexgrave: number
  const KEY_acircumflexhook: number
  const KEY_acircumflextilde: number
  const KEY_acute: number
  const KEY_adiaeresis: number
  const KEY_ae: number
  const KEY_agrave: number
  const KEY_ahook: number
  const KEY_amacron: number
  const KEY_ampersand: number
  const KEY_aogonek: number
  const KEY_apostrophe: number
  const KEY_approxeq: number
  const KEY_approximate: number
  const KEY_aring: number
  const KEY_asciicircum: number
  const KEY_asciitilde: number
  const KEY_asterisk: number
  const KEY_at: number
  const KEY_atilde: number
  const KEY_b: number
  const KEY_babovedot: number
  const KEY_backslash: number
  const KEY_ballotcross: number
  const KEY_bar: number
  const KEY_because: number
  const KEY_blank: number
  const KEY_botintegral: number
  const KEY_botleftparens: number
  const KEY_botleftsqbracket: number
  const KEY_botleftsummation: number
  const KEY_botrightparens: number
  const KEY_botrightsqbracket: number
  const KEY_botrightsummation: number
  const KEY_bott: number
  const KEY_botvertsummationconnector: number
  const KEY_braceleft: number
  const KEY_braceright: number
  const KEY_bracketleft: number
  const KEY_bracketright: number
  const KEY_braille_blank: number
  const KEY_braille_dot_1: number
  const KEY_braille_dot_10: number
  const KEY_braille_dot_2: number
  const KEY_braille_dot_3: number
  const KEY_braille_dot_4: number
  const KEY_braille_dot_5: number
  const KEY_braille_dot_6: number
  const KEY_braille_dot_7: number
  const KEY_braille_dot_8: number
  const KEY_braille_dot_9: number
  const KEY_braille_dots_1: number
  const KEY_braille_dots_12: number
  const KEY_braille_dots_123: number
  const KEY_braille_dots_1234: number
  const KEY_braille_dots_12345: number
  const KEY_braille_dots_123456: number
  const KEY_braille_dots_1234567: number
  const KEY_braille_dots_12345678: number
  const KEY_braille_dots_1234568: number
  const KEY_braille_dots_123457: number
  const KEY_braille_dots_1234578: number
  const KEY_braille_dots_123458: number
  const KEY_braille_dots_12346: number
  const KEY_braille_dots_123467: number
  const KEY_braille_dots_1234678: number
  const KEY_braille_dots_123468: number
  const KEY_braille_dots_12347: number
  const KEY_braille_dots_123478: number
  const KEY_braille_dots_12348: number
  const KEY_braille_dots_1235: number
  const KEY_braille_dots_12356: number
  const KEY_braille_dots_123567: number
  const KEY_braille_dots_1235678: number
  const KEY_braille_dots_123568: number
  const KEY_braille_dots_12357: number
  const KEY_braille_dots_123578: number
  const KEY_braille_dots_12358: number
  const KEY_braille_dots_1236: number
  const KEY_braille_dots_12367: number
  const KEY_braille_dots_123678: number
  const KEY_braille_dots_12368: number
  const KEY_braille_dots_1237: number
  const KEY_braille_dots_12378: number
  const KEY_braille_dots_1238: number
  const KEY_braille_dots_124: number
  const KEY_braille_dots_1245: number
  const KEY_braille_dots_12456: number
  const KEY_braille_dots_124567: number
  const KEY_braille_dots_1245678: number
  const KEY_braille_dots_124568: number
  const KEY_braille_dots_12457: number
  const KEY_braille_dots_124578: number
  const KEY_braille_dots_12458: number
  const KEY_braille_dots_1246: number
  const KEY_braille_dots_12467: number
  const KEY_braille_dots_124678: number
  const KEY_braille_dots_12468: number
  const KEY_braille_dots_1247: number
  const KEY_braille_dots_12478: number
  const KEY_braille_dots_1248: number
  const KEY_braille_dots_125: number
  const KEY_braille_dots_1256: number
  const KEY_braille_dots_12567: number
  const KEY_braille_dots_125678: number
  const KEY_braille_dots_12568: number
  const KEY_braille_dots_1257: number
  const KEY_braille_dots_12578: number
  const KEY_braille_dots_1258: number
  const KEY_braille_dots_126: number
  const KEY_braille_dots_1267: number
  const KEY_braille_dots_12678: number
  const KEY_braille_dots_1268: number
  const KEY_braille_dots_127: number
  const KEY_braille_dots_1278: number
  const KEY_braille_dots_128: number
  const KEY_braille_dots_13: number
  const KEY_braille_dots_134: number
  const KEY_braille_dots_1345: number
  const KEY_braille_dots_13456: number
  const KEY_braille_dots_134567: number
  const KEY_braille_dots_1345678: number
  const KEY_braille_dots_134568: number
  const KEY_braille_dots_13457: number
  const KEY_braille_dots_134578: number
  const KEY_braille_dots_13458: number
  const KEY_braille_dots_1346: number
  const KEY_braille_dots_13467: number
  const KEY_braille_dots_134678: number
  const KEY_braille_dots_13468: number
  const KEY_braille_dots_1347: number
  const KEY_braille_dots_13478: number
  const KEY_braille_dots_1348: number
  const KEY_braille_dots_135: number
  const KEY_braille_dots_1356: number
  const KEY_braille_dots_13567: number
  const KEY_braille_dots_135678: number
  const KEY_braille_dots_13568: number
  const KEY_braille_dots_1357: number
  const KEY_braille_dots_13578: number
  const KEY_braille_dots_1358: number
  const KEY_braille_dots_136: number
  const KEY_braille_dots_1367: number
  const KEY_braille_dots_13678: number
  const KEY_braille_dots_1368: number
  const KEY_braille_dots_137: number
  const KEY_braille_dots_1378: number
  const KEY_braille_dots_138: number
  const KEY_braille_dots_14: number
  const KEY_braille_dots_145: number
  const KEY_braille_dots_1456: number
  const KEY_braille_dots_14567: number
  const KEY_braille_dots_145678: number
  const KEY_braille_dots_14568: number
  const KEY_braille_dots_1457: number
  const KEY_braille_dots_14578: number
  const KEY_braille_dots_1458: number
  const KEY_braille_dots_146: number
  const KEY_braille_dots_1467: number
  const KEY_braille_dots_14678: number
  const KEY_braille_dots_1468: number
  const KEY_braille_dots_147: number
  const KEY_braille_dots_1478: number
  const KEY_braille_dots_148: number
  const KEY_braille_dots_15: number
  const KEY_braille_dots_156: number
  const KEY_braille_dots_1567: number
  const KEY_braille_dots_15678: number
  const KEY_braille_dots_1568: number
  const KEY_braille_dots_157: number
  const KEY_braille_dots_1578: number
  const KEY_braille_dots_158: number
  const KEY_braille_dots_16: number
  const KEY_braille_dots_167: number
  const KEY_braille_dots_1678: number
  const KEY_braille_dots_168: number
  const KEY_braille_dots_17: number
  const KEY_braille_dots_178: number
  const KEY_braille_dots_18: number
  const KEY_braille_dots_2: number
  const KEY_braille_dots_23: number
  const KEY_braille_dots_234: number
  const KEY_braille_dots_2345: number
  const KEY_braille_dots_23456: number
  const KEY_braille_dots_234567: number
  const KEY_braille_dots_2345678: number
  const KEY_braille_dots_234568: number
  const KEY_braille_dots_23457: number
  const KEY_braille_dots_234578: number
  const KEY_braille_dots_23458: number
  const KEY_braille_dots_2346: number
  const KEY_braille_dots_23467: number
  const KEY_braille_dots_234678: number
  const KEY_braille_dots_23468: number
  const KEY_braille_dots_2347: number
  const KEY_braille_dots_23478: number
  const KEY_braille_dots_2348: number
  const KEY_braille_dots_235: number
  const KEY_braille_dots_2356: number
  const KEY_braille_dots_23567: number
  const KEY_braille_dots_235678: number
  const KEY_braille_dots_23568: number
  const KEY_braille_dots_2357: number
  const KEY_braille_dots_23578: number
  const KEY_braille_dots_2358: number
  const KEY_braille_dots_236: number
  const KEY_braille_dots_2367: number
  const KEY_braille_dots_23678: number
  const KEY_braille_dots_2368: number
  const KEY_braille_dots_237: number
  const KEY_braille_dots_2378: number
  const KEY_braille_dots_238: number
  const KEY_braille_dots_24: number
  const KEY_braille_dots_245: number
  const KEY_braille_dots_2456: number
  const KEY_braille_dots_24567: number
  const KEY_braille_dots_245678: number
  const KEY_braille_dots_24568: number
  const KEY_braille_dots_2457: number
  const KEY_braille_dots_24578: number
  const KEY_braille_dots_2458: number
  const KEY_braille_dots_246: number
  const KEY_braille_dots_2467: number
  const KEY_braille_dots_24678: number
  const KEY_braille_dots_2468: number
  const KEY_braille_dots_247: number
  const KEY_braille_dots_2478: number
  const KEY_braille_dots_248: number
  const KEY_braille_dots_25: number
  const KEY_braille_dots_256: number
  const KEY_braille_dots_2567: number
  const KEY_braille_dots_25678: number
  const KEY_braille_dots_2568: number
  const KEY_braille_dots_257: number
  const KEY_braille_dots_2578: number
  const KEY_braille_dots_258: number
  const KEY_braille_dots_26: number
  const KEY_braille_dots_267: number
  const KEY_braille_dots_2678: number
  const KEY_braille_dots_268: number
  const KEY_braille_dots_27: number
  const KEY_braille_dots_278: number
  const KEY_braille_dots_28: number
  const KEY_braille_dots_3: number
  const KEY_braille_dots_34: number
  const KEY_braille_dots_345: number
  const KEY_braille_dots_3456: number
  const KEY_braille_dots_34567: number
  const KEY_braille_dots_345678: number
  const KEY_braille_dots_34568: number
  const KEY_braille_dots_3457: number
  const KEY_braille_dots_34578: number
  const KEY_braille_dots_3458: number
  const KEY_braille_dots_346: number
  const KEY_braille_dots_3467: number
  const KEY_braille_dots_34678: number
  const KEY_braille_dots_3468: number
  const KEY_braille_dots_347: number
  const KEY_braille_dots_3478: number
  const KEY_braille_dots_348: number
  const KEY_braille_dots_35: number
  const KEY_braille_dots_356: number
  const KEY_braille_dots_3567: number
  const KEY_braille_dots_35678: number
  const KEY_braille_dots_3568: number
  const KEY_braille_dots_357: number
  const KEY_braille_dots_3578: number
  const KEY_braille_dots_358: number
  const KEY_braille_dots_36: number
  const KEY_braille_dots_367: number
  const KEY_braille_dots_3678: number
  const KEY_braille_dots_368: number
  const KEY_braille_dots_37: number
  const KEY_braille_dots_378: number
  const KEY_braille_dots_38: number
  const KEY_braille_dots_4: number
  const KEY_braille_dots_45: number
  const KEY_braille_dots_456: number
  const KEY_braille_dots_4567: number
  const KEY_braille_dots_45678: number
  const KEY_braille_dots_4568: number
  const KEY_braille_dots_457: number
  const KEY_braille_dots_4578: number
  const KEY_braille_dots_458: number
  const KEY_braille_dots_46: number
  const KEY_braille_dots_467: number
  const KEY_braille_dots_4678: number
  const KEY_braille_dots_468: number
  const KEY_braille_dots_47: number
  const KEY_braille_dots_478: number
  const KEY_braille_dots_48: number
  const KEY_braille_dots_5: number
  const KEY_braille_dots_56: number
  const KEY_braille_dots_567: number
  const KEY_braille_dots_5678: number
  const KEY_braille_dots_568: number
  const KEY_braille_dots_57: number
  const KEY_braille_dots_578: number
  const KEY_braille_dots_58: number
  const KEY_braille_dots_6: number
  const KEY_braille_dots_67: number
  const KEY_braille_dots_678: number
  const KEY_braille_dots_68: number
  const KEY_braille_dots_7: number
  const KEY_braille_dots_78: number
  const KEY_braille_dots_8: number
  const KEY_breve: number
  const KEY_brokenbar: number
  const KEY_c: number
  const KEY_c_h: number
  const KEY_cabovedot: number
  const KEY_cacute: number
  const KEY_careof: number
  const KEY_caret: number
  const KEY_caron: number
  const KEY_ccaron: number
  const KEY_ccedilla: number
  const KEY_ccircumflex: number
  const KEY_cedilla: number
  const KEY_cent: number
  const KEY_ch: number
  const KEY_checkerboard: number
  const KEY_checkmark: number
  const KEY_circle: number
  const KEY_club: number
  const KEY_colon: number
  const KEY_comma: number
  const KEY_containsas: number
  const KEY_copyright: number
  const KEY_cr: number
  const KEY_crossinglines: number
  const KEY_cuberoot: number
  const KEY_currency: number
  const KEY_cursor: number
  const KEY_d: number
  const KEY_dabovedot: number
  const KEY_dagger: number
  const KEY_dcaron: number
  const KEY_dead_A: number
  const KEY_dead_E: number
  const KEY_dead_I: number
  const KEY_dead_O: number
  const KEY_dead_U: number
  const KEY_dead_a: number
  const KEY_dead_abovecomma: number
  const KEY_dead_abovedot: number
  const KEY_dead_abovereversedcomma: number
  const KEY_dead_abovering: number
  const KEY_dead_aboveverticalline: number
  const KEY_dead_acute: number
  const KEY_dead_belowbreve: number
  const KEY_dead_belowcircumflex: number
  const KEY_dead_belowcomma: number
  const KEY_dead_belowdiaeresis: number
  const KEY_dead_belowdot: number
  const KEY_dead_belowmacron: number
  const KEY_dead_belowring: number
  const KEY_dead_belowtilde: number
  const KEY_dead_belowverticalline: number
  const KEY_dead_breve: number
  const KEY_dead_capital_schwa: number
  const KEY_dead_caron: number
  const KEY_dead_cedilla: number
  const KEY_dead_circumflex: number
  const KEY_dead_currency: number
  const KEY_dead_dasia: number
  const KEY_dead_diaeresis: number
  const KEY_dead_doubleacute: number
  const KEY_dead_doublegrave: number
  const KEY_dead_e: number
  const KEY_dead_grave: number
  const KEY_dead_greek: number
  const KEY_dead_hook: number
  const KEY_dead_horn: number
  const KEY_dead_i: number
  const KEY_dead_invertedbreve: number
  const KEY_dead_iota: number
  const KEY_dead_longsolidusoverlay: number
  const KEY_dead_lowline: number
  const KEY_dead_macron: number
  const KEY_dead_o: number
  const KEY_dead_ogonek: number
  const KEY_dead_perispomeni: number
  const KEY_dead_psili: number
  const KEY_dead_semivoiced_sound: number
  const KEY_dead_small_schwa: number
  const KEY_dead_stroke: number
  const KEY_dead_tilde: number
  const KEY_dead_u: number
  const KEY_dead_voiced_sound: number
  const KEY_decimalpoint: number
  const KEY_degree: number
  const KEY_diaeresis: number
  const KEY_diamond: number
  const KEY_digitspace: number
  const KEY_dintegral: number
  const KEY_division: number
  const KEY_dollar: number
  const KEY_doubbaselinedot: number
  const KEY_doubleacute: number
  const KEY_doubledagger: number
  const KEY_doublelowquotemark: number
  const KEY_downarrow: number
  const KEY_downcaret: number
  const KEY_downshoe: number
  const KEY_downstile: number
  const KEY_downtack: number
  const KEY_dstroke: number
  const KEY_e: number
  const KEY_eabovedot: number
  const KEY_eacute: number
  const KEY_ebelowdot: number
  const KEY_ecaron: number
  const KEY_ecircumflex: number
  const KEY_ecircumflexacute: number
  const KEY_ecircumflexbelowdot: number
  const KEY_ecircumflexgrave: number
  const KEY_ecircumflexhook: number
  const KEY_ecircumflextilde: number
  const KEY_ediaeresis: number
  const KEY_egrave: number
  const KEY_ehook: number
  const KEY_eightsubscript: number
  const KEY_eightsuperior: number
  const KEY_elementof: number
  const KEY_ellipsis: number
  const KEY_em3space: number
  const KEY_em4space: number
  const KEY_emacron: number
  const KEY_emdash: number
  const KEY_emfilledcircle: number
  const KEY_emfilledrect: number
  const KEY_emopencircle: number
  const KEY_emopenrectangle: number
  const KEY_emptyset: number
  const KEY_emspace: number
  const KEY_endash: number
  const KEY_enfilledcircbullet: number
  const KEY_enfilledsqbullet: number
  const KEY_eng: number
  const KEY_enopencircbullet: number
  const KEY_enopensquarebullet: number
  const KEY_enspace: number
  const KEY_eogonek: number
  const KEY_equal: number
  const KEY_eth: number
  const KEY_etilde: number
  const KEY_exclam: number
  const KEY_exclamdown: number
  const KEY_ezh: number
  const KEY_f: number
  const KEY_fabovedot: number
  const KEY_femalesymbol: number
  const KEY_ff: number
  const KEY_figdash: number
  const KEY_filledlefttribullet: number
  const KEY_filledrectbullet: number
  const KEY_filledrighttribullet: number
  const KEY_filledtribulletdown: number
  const KEY_filledtribulletup: number
  const KEY_fiveeighths: number
  const KEY_fivesixths: number
  const KEY_fivesubscript: number
  const KEY_fivesuperior: number
  const KEY_fourfifths: number
  const KEY_foursubscript: number
  const KEY_foursuperior: number
  const KEY_fourthroot: number
  const KEY_function: number
  const KEY_g: number
  const KEY_gabovedot: number
  const KEY_gbreve: number
  const KEY_gcaron: number
  const KEY_gcedilla: number
  const KEY_gcircumflex: number
  const KEY_grave: number
  const KEY_greater: number
  const KEY_greaterthanequal: number
  const KEY_guillemotleft: number
  const KEY_guillemotright: number
  const KEY_h: number
  const KEY_hairspace: number
  const KEY_hcircumflex: number
  const KEY_heart: number
  const KEY_hebrew_aleph: number
  const KEY_hebrew_ayin: number
  const KEY_hebrew_bet: number
  const KEY_hebrew_beth: number
  const KEY_hebrew_chet: number
  const KEY_hebrew_dalet: number
  const KEY_hebrew_daleth: number
  const KEY_hebrew_doublelowline: number
  const KEY_hebrew_finalkaph: number
  const KEY_hebrew_finalmem: number
  const KEY_hebrew_finalnun: number
  const KEY_hebrew_finalpe: number
  const KEY_hebrew_finalzade: number
  const KEY_hebrew_finalzadi: number
  const KEY_hebrew_gimel: number
  const KEY_hebrew_gimmel: number
  const KEY_hebrew_he: number
  const KEY_hebrew_het: number
  const KEY_hebrew_kaph: number
  const KEY_hebrew_kuf: number
  const KEY_hebrew_lamed: number
  const KEY_hebrew_mem: number
  const KEY_hebrew_nun: number
  const KEY_hebrew_pe: number
  const KEY_hebrew_qoph: number
  const KEY_hebrew_resh: number
  const KEY_hebrew_samech: number
  const KEY_hebrew_samekh: number
  const KEY_hebrew_shin: number
  const KEY_hebrew_taf: number
  const KEY_hebrew_taw: number
  const KEY_hebrew_tet: number
  const KEY_hebrew_teth: number
  const KEY_hebrew_waw: number
  const KEY_hebrew_yod: number
  const KEY_hebrew_zade: number
  const KEY_hebrew_zadi: number
  const KEY_hebrew_zain: number
  const KEY_hebrew_zayin: number
  const KEY_hexagram: number
  const KEY_horizconnector: number
  const KEY_horizlinescan1: number
  const KEY_horizlinescan3: number
  const KEY_horizlinescan5: number
  const KEY_horizlinescan7: number
  const KEY_horizlinescan9: number
  const KEY_hstroke: number
  const KEY_ht: number
  const KEY_hyphen: number
  const KEY_i: number
  const KEY_iTouch: number
  const KEY_iacute: number
  const KEY_ibelowdot: number
  const KEY_ibreve: number
  const KEY_icircumflex: number
  const KEY_identical: number
  const KEY_idiaeresis: number
  const KEY_idotless: number
  const KEY_ifonlyif: number
  const KEY_igrave: number
  const KEY_ihook: number
  const KEY_imacron: number
  const KEY_implies: number
  const KEY_includedin: number
  const KEY_includes: number
  const KEY_infinity: number
  const KEY_integral: number
  const KEY_intersection: number
  const KEY_iogonek: number
  const KEY_itilde: number
  const KEY_j: number
  const KEY_jcircumflex: number
  const KEY_jot: number
  const KEY_k: number
  const KEY_kana_A: number
  const KEY_kana_CHI: number
  const KEY_kana_E: number
  const KEY_kana_FU: number
  const KEY_kana_HA: number
  const KEY_kana_HE: number
  const KEY_kana_HI: number
  const KEY_kana_HO: number
  const KEY_kana_HU: number
  const KEY_kana_I: number
  const KEY_kana_KA: number
  const KEY_kana_KE: number
  const KEY_kana_KI: number
  const KEY_kana_KO: number
  const KEY_kana_KU: number
  const KEY_kana_MA: number
  const KEY_kana_ME: number
  const KEY_kana_MI: number
  const KEY_kana_MO: number
  const KEY_kana_MU: number
  const KEY_kana_N: number
  const KEY_kana_NA: number
  const KEY_kana_NE: number
  const KEY_kana_NI: number
  const KEY_kana_NO: number
  const KEY_kana_NU: number
  const KEY_kana_O: number
  const KEY_kana_RA: number
  const KEY_kana_RE: number
  const KEY_kana_RI: number
  const KEY_kana_RO: number
  const KEY_kana_RU: number
  const KEY_kana_SA: number
  const KEY_kana_SE: number
  const KEY_kana_SHI: number
  const KEY_kana_SO: number
  const KEY_kana_SU: number
  const KEY_kana_TA: number
  const KEY_kana_TE: number
  const KEY_kana_TI: number
  const KEY_kana_TO: number
  const KEY_kana_TSU: number
  const KEY_kana_TU: number
  const KEY_kana_U: number
  const KEY_kana_WA: number
  const KEY_kana_WO: number
  const KEY_kana_YA: number
  const KEY_kana_YO: number
  const KEY_kana_YU: number
  const KEY_kana_a: number
  const KEY_kana_closingbracket: number
  const KEY_kana_comma: number
  const KEY_kana_conjunctive: number
  const KEY_kana_e: number
  const KEY_kana_fullstop: number
  const KEY_kana_i: number
  const KEY_kana_middledot: number
  const KEY_kana_o: number
  const KEY_kana_openingbracket: number
  const KEY_kana_switch: number
  const KEY_kana_tsu: number
  const KEY_kana_tu: number
  const KEY_kana_u: number
  const KEY_kana_ya: number
  const KEY_kana_yo: number
  const KEY_kana_yu: number
  const KEY_kappa: number
  const KEY_kcedilla: number
  const KEY_kra: number
  const KEY_l: number
  const KEY_lacute: number
  const KEY_latincross: number
  const KEY_lbelowdot: number
  const KEY_lcaron: number
  const KEY_lcedilla: number
  const KEY_leftanglebracket: number
  const KEY_leftarrow: number
  const KEY_leftcaret: number
  const KEY_leftdoublequotemark: number
  const KEY_leftmiddlecurlybrace: number
  const KEY_leftopentriangle: number
  const KEY_leftpointer: number
  const KEY_leftradical: number
  const KEY_leftshoe: number
  const KEY_leftsinglequotemark: number
  const KEY_leftt: number
  const KEY_lefttack: number
  const KEY_less: number
  const KEY_lessthanequal: number
  const KEY_lf: number
  const KEY_logicaland: number
  const KEY_logicalor: number
  const KEY_lowleftcorner: number
  const KEY_lowrightcorner: number
  const KEY_lstroke: number
  const KEY_m: number
  const KEY_mabovedot: number
  const KEY_macron: number
  const KEY_malesymbol: number
  const KEY_maltesecross: number
  const KEY_marker: number
  const KEY_masculine: number
  const KEY_minus: number
  const KEY_minutes: number
  const KEY_mu: number
  const KEY_multiply: number
  const KEY_musicalflat: number
  const KEY_musicalsharp: number
  const KEY_n: number
  const KEY_nabla: number
  const KEY_nacute: number
  const KEY_ncaron: number
  const KEY_ncedilla: number
  const KEY_ninesubscript: number
  const KEY_ninesuperior: number
  const KEY_nl: number
  const KEY_nobreakspace: number
  const KEY_notapproxeq: number
  const KEY_notelementof: number
  const KEY_notequal: number
  const KEY_notidentical: number
  const KEY_notsign: number
  const KEY_ntilde: number
  const KEY_numbersign: number
  const KEY_numerosign: number
  const KEY_o: number
  const KEY_oacute: number
  const KEY_obarred: number
  const KEY_obelowdot: number
  const KEY_ocaron: number
  const KEY_ocircumflex: number
  const KEY_ocircumflexacute: number
  const KEY_ocircumflexbelowdot: number
  const KEY_ocircumflexgrave: number
  const KEY_ocircumflexhook: number
  const KEY_ocircumflextilde: number
  const KEY_odiaeresis: number
  const KEY_odoubleacute: number
  const KEY_oe: number
  const KEY_ogonek: number
  const KEY_ograve: number
  const KEY_ohook: number
  const KEY_ohorn: number
  const KEY_ohornacute: number
  const KEY_ohornbelowdot: number
  const KEY_ohorngrave: number
  const KEY_ohornhook: number
  const KEY_ohorntilde: number
  const KEY_omacron: number
  const KEY_oneeighth: number
  const KEY_onefifth: number
  const KEY_onehalf: number
  const KEY_onequarter: number
  const KEY_onesixth: number
  const KEY_onesubscript: number
  const KEY_onesuperior: number
  const KEY_onethird: number
  const KEY_ooblique: number
  const KEY_openrectbullet: number
  const KEY_openstar: number
  const KEY_opentribulletdown: number
  const KEY_opentribulletup: number
  const KEY_ordfeminine: number
  const KEY_oslash: number
  const KEY_otilde: number
  const KEY_overbar: number
  const KEY_overline: number
  const KEY_p: number
  const KEY_pabovedot: number
  const KEY_paragraph: number
  const KEY_parenleft: number
  const KEY_parenright: number
  const KEY_partdifferential: number
  const KEY_partialderivative: number
  const KEY_percent: number
  const KEY_period: number
  const KEY_periodcentered: number
  const KEY_permille: number
  const KEY_phonographcopyright: number
  const KEY_plus: number
  const KEY_plusminus: number
  const KEY_prescription: number
  const KEY_prolongedsound: number
  const KEY_punctspace: number
  const KEY_q: number
  const KEY_quad: number
  const KEY_question: number
  const KEY_questiondown: number
  const KEY_quotedbl: number
  const KEY_quoteleft: number
  const KEY_quoteright: number
  const KEY_r: number
  const KEY_racute: number
  const KEY_radical: number
  const KEY_rcaron: number
  const KEY_rcedilla: number
  const KEY_registered: number
  const KEY_rightanglebracket: number
  const KEY_rightarrow: number
  const KEY_rightcaret: number
  const KEY_rightdoublequotemark: number
  const KEY_rightmiddlecurlybrace: number
  const KEY_rightmiddlesummation: number
  const KEY_rightopentriangle: number
  const KEY_rightpointer: number
  const KEY_rightshoe: number
  const KEY_rightsinglequotemark: number
  const KEY_rightt: number
  const KEY_righttack: number
  const KEY_s: number
  const KEY_sabovedot: number
  const KEY_sacute: number
  const KEY_scaron: number
  const KEY_scedilla: number
  const KEY_schwa: number
  const KEY_scircumflex: number
  const KEY_script_switch: number
  const KEY_seconds: number
  const KEY_section: number
  const KEY_semicolon: number
  const KEY_semivoicedsound: number
  const KEY_seveneighths: number
  const KEY_sevensubscript: number
  const KEY_sevensuperior: number
  const KEY_signaturemark: number
  const KEY_signifblank: number
  const KEY_similarequal: number
  const KEY_singlelowquotemark: number
  const KEY_sixsubscript: number
  const KEY_sixsuperior: number
  const KEY_slash: number
  const KEY_soliddiamond: number
  const KEY_space: number
  const KEY_squareroot: number
  const KEY_ssharp: number
  const KEY_sterling: number
  const KEY_stricteq: number
  const KEY_t: number
  const KEY_tabovedot: number
  const KEY_tcaron: number
  const KEY_tcedilla: number
  const KEY_telephone: number
  const KEY_telephonerecorder: number
  const KEY_therefore: number
  const KEY_thinspace: number
  const KEY_thorn: number
  const KEY_threeeighths: number
  const KEY_threefifths: number
  const KEY_threequarters: number
  const KEY_threesubscript: number
  const KEY_threesuperior: number
  const KEY_tintegral: number
  const KEY_topintegral: number
  const KEY_topleftparens: number
  const KEY_topleftradical: number
  const KEY_topleftsqbracket: number
  const KEY_topleftsummation: number
  const KEY_toprightparens: number
  const KEY_toprightsqbracket: number
  const KEY_toprightsummation: number
  const KEY_topt: number
  const KEY_topvertsummationconnector: number
  const KEY_trademark: number
  const KEY_trademarkincircle: number
  const KEY_tslash: number
  const KEY_twofifths: number
  const KEY_twosubscript: number
  const KEY_twosuperior: number
  const KEY_twothirds: number
  const KEY_u: number
  const KEY_uacute: number
  const KEY_ubelowdot: number
  const KEY_ubreve: number
  const KEY_ucircumflex: number
  const KEY_udiaeresis: number
  const KEY_udoubleacute: number
  const KEY_ugrave: number
  const KEY_uhook: number
  const KEY_uhorn: number
  const KEY_uhornacute: number
  const KEY_uhornbelowdot: number
  const KEY_uhorngrave: number
  const KEY_uhornhook: number
  const KEY_uhorntilde: number
  const KEY_umacron: number
  const KEY_underbar: number
  const KEY_underscore: number
  const KEY_union: number
  const KEY_uogonek: number
  const KEY_uparrow: number
  const KEY_upcaret: number
  const KEY_upleftcorner: number
  const KEY_uprightcorner: number
  const KEY_upshoe: number
  const KEY_upstile: number
  const KEY_uptack: number
  const KEY_uring: number
  const KEY_utilde: number
  const KEY_v: number
  const KEY_variation: number
  const KEY_vertbar: number
  const KEY_vertconnector: number
  const KEY_voicedsound: number
  const KEY_vt: number
  const KEY_w: number
  const KEY_wacute: number
  const KEY_wcircumflex: number
  const KEY_wdiaeresis: number
  const KEY_wgrave: number
  const KEY_x: number
  const KEY_xabovedot: number
  const KEY_y: number
  const KEY_yacute: number
  const KEY_ybelowdot: number
  const KEY_ycircumflex: number
  const KEY_ydiaeresis: number
  const KEY_yen: number
  const KEY_ygrave: number
  const KEY_yhook: number
  const KEY_ytilde: number
  const KEY_z: number
  const KEY_zabovedot: number
  const KEY_zacute: number
  const KEY_zcaron: number
  const KEY_zerosubscript: number
  const KEY_zerosuperior: number
  const KEY_zstroke: number
  /**
   * A mask covering all entries in `GdkModifierType`.
   */
  const MODIFIER_MASK: number
  /**
   * This is the priority that the idle handler processing surface updates
   * is given in the main loop.
   */
  const PRIORITY_REDRAW: number
  /**
   * The main way to not draw GL content in GTK.
   *
   * It takes a render buffer ID (`source_type` == GL_RENDERBUFFER) or a texture
   * id (`source_type` == GL_TEXTURE) and draws it onto `cr` with an OVER operation,
   * respecting the current clip. The top left corner of the rectangle specified
   * by `x,` `y,` `width` and `height` will be drawn at the current (0,0) position of
   * the `cairo_t`.
   *
   * This will work for *all* `cairo_t`, as long as `surface` is realized, but the
   * fallback implementation that reads back the pixels from the buffer may be
   * used in the general case. In the case of direct drawing to a surface with
   * no special effects applied to `cr` it will however use a more efficient
   * approach.
   *
   * For GL_RENDERBUFFER the code will always fall back to software for buffers
   * with alpha components, so make sure you use GL_TEXTURE if using alpha.
   *
   * Calling this may change the current GL context.
   * @param cr a cairo context
   * @param surface The surface we're rendering for (not necessarily into)
   * @param source The GL ID of the source buffer
   * @param sourceType The type of the `source`
   * @param bufferScale The scale-factor that the `source` buffer is allocated for
   * @param x The source x position in `source` to start copying from in GL coordinates
   * @param y The source y position in `source` to start copying from in GL coordinates
   * @param width The width of the region to draw
   * @param height The height of the region to draw
   */
  function cairoDrawFromGl(
    cr: cairo.Context,
    surface: Surface,
    source: number,
    sourceType: number,
    bufferScale: number,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Adds the given rectangle to the current path of `cr`.
   * @param cr a cairo context
   * @param rectangle a `GdkRectangle`
   */
  function cairoRectangle(cr: cairo.Context, rectangle: Rectangle): void
  /**
   * Adds the given region to the current path of `cr`.
   * @param cr a cairo context
   * @param region a `cairo_region_t`
   */
  function cairoRegion(cr: cairo.Context, region: cairo.Region): void
  /**
   * Creates region that covers the area where the given
   * `surface` is more than 50% opaque.
   *
   * This function takes into account device offsets that might be
   * set with cairo_surface_set_device_offset().
   * @param surface a cairo surface
   * @returns A `cairo_region_t`
   */
  function cairoRegionCreateFromSurface(surface: cairo.Surface): cairo.Region
  /**
   * Sets the given pixbuf as the source pattern for `cr`.
   *
   * The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
   * so that the origin of `pixbuf` is `pixbuf_x,` `pixbuf_y`.
   * @param cr a cairo context
   * @param pixbuf a `GdkPixbuf`
   * @param pixbufX X coordinate of location to place upper left corner of `pixbuf`
   * @param pixbufY Y coordinate of location to place upper left corner of `pixbuf`
   */
  function cairoSetSourcePixbuf(
    cr: cairo.Context,
    pixbuf: GdkPixbuf.Pixbuf,
    pixbufX: number,
    pixbufY: number
  ): void
  /**
   * Sets the specified `GdkRGBA` as the source color of `cr`.
   * @param cr a cairo context
   * @param rgba a `GdkRGBA`
   */
  function cairoSetSourceRgba(cr: cairo.Context, rgba: RGBA): void
  /**
   * Read content from the given input stream and deserialize it, asynchronously.
   *
   * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
   * indicate a higher priority.
   *
   * When the operation is finished, `callback` will be called. You must then
   * call [func`Gdk`.content_deserialize_finish] to get the result of the operation.
   * @param stream a `GInputStream` to read the serialized content from
   * @param mimeType the mime type to deserialize from
   * @param type the GType to deserialize from
   * @param ioPriority the I/O priority of the operation
   * @param cancellable optional `GCancellable` object
   * @param callback callback to call when the operation is done
   */
  function contentDeserializeAsync(
    stream: Gio.InputStream,
    mimeType: string,
    type: GObject.GType,
    ioPriority: number,
    cancellable: Gio.Cancellable | null,
    callback: Gio.AsyncReadyCallback | null
  ): void
  /**
   * Finishes a content deserialization operation.
   * @param result the `GAsyncResult`
   * @returns %TRUE if the operation was successful. In this case,   @value is set. %FALSE if an error occurred. In this case,   @error is set
   */
  function contentDeserializeFinish(
    result: Gio.AsyncResult
  ): [/* returnType */ boolean, /* value */ any]
  /**
   * Parses the given `string` into `GdkContentFormats` and
   * returns the formats.
   *
   * Strings printed via [method`Gdk`.ContentFormats.to_string]
   * can be read in again successfully using this function.
   *
   * If `string` does not describe valid content formats, %NULL
   * is returned.
   * @param string the string to parse
   * @returns the content formats if @string is valid
   */
  function contentFormatsParse(string: string): ContentFormats | null
  /**
   * Registers a function to deserialize object of a given type.
   * @param mimeType the mime type which the function can deserialize from
   * @param type the type of objects that the function creates
   * @param deserialize the callback
   */
  function contentRegisterDeserializer(
    mimeType: string,
    type: GObject.GType,
    deserialize: ContentDeserializeFunc
  ): void
  /**
   * Registers a function to serialize objects of a given type.
   * @param type the type of objects that the function can serialize
   * @param mimeType the mime type to serialize to
   * @param serialize the callback
   */
  function contentRegisterSerializer(
    type: GObject.GType,
    mimeType: string,
    serialize: ContentSerializeFunc
  ): void
  /**
   * Serialize content and write it to the given output stream, asynchronously.
   *
   * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
   * indicate a higher priority.
   *
   * When the operation is finished, `callback` will be called. You must then
   * call [func`Gdk`.content_serialize_finish] to get the result of the operation.
   * @param stream a `GOutputStream` to write the serialized content to
   * @param mimeType the mime type to serialize to
   * @param value the content to serialize
   * @param ioPriority the I/O priority of the operation
   * @param cancellable optional `GCancellable` object
   * @param callback callback to call when the operation is done
   */
  function contentSerializeAsync(
    stream: Gio.OutputStream,
    mimeType: string,
    value: any,
    ioPriority: number,
    cancellable: Gio.Cancellable | null,
    callback: Gio.AsyncReadyCallback | null
  ): void
  /**
   * Finishes a content serialization operation.
   * @param result the `GAsyncResult`
   * @returns %TRUE if the operation was successful, %FALSE if an   error occurred. In this case, @error is set
   */
  function contentSerializeFinish(result: Gio.AsyncResult): boolean
  function dmabufErrorQuark(): GLib.Quark
  /**
   * Checks if `action` represents a single action or includes
   * multiple actions.
   *
   * When `action` is 0 - ie no action was given, %TRUE
   * is returned.
   * @param action a `GdkDragAction`
   * @returns %TRUE if exactly one action was given
   */
  function dragActionIsUnique(action: DragAction): boolean
  function dragSurfaceSizeGetType(): GObject.GType
  /**
   * Returns the relative angle from `event1` to `event2`.
   *
   * The relative angle is the angle between the X axis and the line
   * through both events' positions. The rotation direction for positive
   * angles is from the positive X axis towards the positive Y axis.
   *
   * This assumes that both events have X/Y information.
   * If not, this function returns %FALSE.
   * @param event1 first `GdkEvent`
   * @param event2 second `GdkEvent`
   * @returns %TRUE if the angle could be calculated.
   */
  function eventsGetAngle(
    event1: Event,
    event2: Event
  ): [/* returnType */ boolean, /* angle */ number]
  /**
   * Returns the point halfway between the events' positions.
   *
   * This assumes that both events have X/Y information.
   * If not, this function returns %FALSE.
   * @param event1 first `GdkEvent`
   * @param event2 second `GdkEvent`
   * @returns %TRUE if the center could be calculated.
   */
  function eventsGetCenter(
    event1: Event,
    event2: Event
  ): [/* returnType */ boolean, /* x */ number, /* y */ number]
  /**
   * Returns the distance between the event locations.
   *
   * This assumes that both events have X/Y information.
   * If not, this function returns %FALSE.
   * @param event1 first `GdkEvent`
   * @param event2 second `GdkEvent`
   * @returns %TRUE if the distance could be calculated.
   */
  function eventsGetDistance(
    event1: Event,
    event2: Event
  ): [/* returnType */ boolean, /* distance */ number]
  function glErrorQuark(): GLib.Quark
  /**
   * Canonicalizes the given mime type and interns the result.
   *
   * If `string` is not a valid mime type, %NULL is returned instead.
   * See RFC 2048 for the syntax if mime types.
   * @param string string of a potential mime type
   * @returns An interned string for the canonicalized   mime type or %NULL if the string wasn't a valid mime type
   */
  function internMimeType(string: string): string | null
  /**
   * Obtains the upper- and lower-case versions of the keyval `symbol`.
   *
   * Examples of keyvals are `GDK_KEY_a`, `GDK_KEY_Enter`, `GDK_KEY_F1`, etc.
   * @param symbol a keyval
   */
  function keyvalConvertCase(
    symbol: number
  ): [/* lower */ number, /* upper */ number]
  /**
   * Converts a key name to a key value.
   *
   * The names are the same as those in the
   * `gdk/gdkkeysyms.h` header file
   * but without the leading “GDK_KEY_”.
   * @param keyvalName a key name
   * @returns the corresponding key value, or %GDK_KEY_VoidSymbol   if the key name is not a valid key
   */
  function keyvalFromName(keyvalName: string): number
  /**
   * Returns %TRUE if the given key value is in lower case.
   * @param keyval a key value.
   * @returns %TRUE if @keyval is in lower case, or if @keyval is not   subject to case conversion.
   */
  function keyvalIsLower(keyval: number): boolean
  /**
   * Returns %TRUE if the given key value is in upper case.
   * @param keyval a key value.
   * @returns %TRUE if @keyval is in upper case, or if @keyval is not subject to  case conversion.
   */
  function keyvalIsUpper(keyval: number): boolean
  /**
   * Converts a key value into a symbolic name.
   *
   * The names are the same as those in the
   * `gdk/gdkkeysyms.h` header file
   * but without the leading “GDK_KEY_”.
   * @param keyval a key value
   * @returns a string containing the name   of the key
   */
  function keyvalName(keyval: number): string | null
  /**
   * Converts a key value to lower case, if applicable.
   * @param keyval a key value.
   * @returns the lower case form of @keyval, or @keyval itself if it is already  in lower case or it is not subject to case conversion.
   */
  function keyvalToLower(keyval: number): number
  /**
   * Convert from a GDK key symbol to the corresponding Unicode
   * character.
   *
   * Note that the conversion does not take the current locale
   * into consideration, which might be expected for particular
   * keyvals, such as %GDK_KEY_KP_Decimal.
   * @param keyval a GDK key symbol
   * @returns the corresponding unicode character, or 0 if there   is no corresponding character.
   */
  function keyvalToUnicode(keyval: number): number
  /**
   * Converts a key value to upper case, if applicable.
   * @param keyval a key value.
   * @returns the upper case form of @keyval, or @keyval itself if it is already   in upper case or it is not subject to case conversion.
   */
  function keyvalToUpper(keyval: number): number
  /**
   * Returns a paintable that has the given intrinsic size and draws nothing.
   *
   * This is often useful for implementing the
   * [vfunc`Gdk`.Paintable.get_current_image] virtual function
   * when the paintable is in an incomplete state (like a
   * [GtkMediaStream](../gtk4/class.MediaStream.html) before receiving
   * the first frame).
   * @param intrinsicWidth The intrinsic width to report. Can be 0 for no width.
   * @param intrinsicHeight The intrinsic height to report. Can be 0 for no height.
   * @returns a `GdkPaintable`
   */
  function paintableNewEmpty(
    intrinsicWidth: number,
    intrinsicHeight: number
  ): Paintable
  /**
   * Transfers image data from a `cairo_surface_t` and converts it
   * to a `GdkPixbuf`.
   *
   * This allows you to efficiently read individual pixels from cairo surfaces.
   *
   * This function will create an RGB pixbuf with 8 bits per channel.
   * The pixbuf will contain an alpha channel if the `surface` contains one.
   * @param surface surface to copy from
   * @param srcX Source X coordinate within `surface`
   * @param srcY Source Y coordinate within `surface`
   * @param width Width in pixels of region to get
   * @param height Height in pixels of region to get
   * @returns A newly-created pixbuf with a   reference count of 1
   */
  function pixbufGetFromSurface(
    surface: cairo.Surface,
    srcX: number,
    srcY: number,
    width: number,
    height: number
  ): GdkPixbuf.Pixbuf | null
  /**
   * Creates a new pixbuf from `texture`.
   *
   * This should generally not be used in newly written code as later
   * stages will almost certainly convert the pixbuf back into a texture
   * to draw it on screen.
   * @param texture a `GdkTexture`
   * @returns a new `GdkPixbuf`
   */
  function pixbufGetFromTexture(texture: Texture): GdkPixbuf.Pixbuf | null
  /**
   * Sets a list of backends that GDK should try to use.
   *
   * This can be useful if your application does not
   * work with certain GDK backends.
   *
   * By default, GDK tries all included backends.
   *
   * For example:
   *
   * ```c
   * gdk_set_allowed_backends ("wayland,macos,*");
   * ```
   *
   * instructs GDK to try the Wayland backend first, followed by the
   * MacOs backend, and then all others.
   *
   * If the `GDK_BACKEND` environment variable is set, it determines
   * what backends are tried in what order, while still respecting the
   * set of allowed backends that are specified by this function.
   *
   * The possible backend names are:
   *
   *   - `broadway`
   *   - `macos`
   *   - `wayland`.
   *   - `win32`
   *   - `x11`
   *
   * You can also include a `*` in the list to try all remaining backends.
   *
   * This call must happen prior to functions that open a display, such
   * as [func`Gdk`.Display.open], `gtk_init()`, or `gtk_init_check()`
   * in order to take effect.
   * @param backends a comma-separated list of backends
   */
  function setAllowedBackends(backends: string): void
  function textureErrorQuark(): GLib.Quark
  function toplevelSizeGetType(): GObject.GType
  /**
   * Convert from a Unicode character to a key symbol.
   * @param wc a Unicode character
   * @returns the corresponding GDK key symbol, if one exists.   or, if there is no corresponding symbol, wc | 0x01000000
   */
  function unicodeToKeyval(wc: number): number
  function vulkanErrorQuark(): GLib.Quark
  /**
   * The type of a function that can be registered with gdk_content_register_deserializer().
   *
   * When the function gets called to operate on content, it can call functions on the
   * `deserializer` object to obtain the mime type, input stream, user data, etc. for its
   * operation.
   * @callback
   * @param deserializer a `GdkContentDeserializer`
   */
  interface ContentDeserializeFunc {
    (deserializer: ContentDeserializer): void
  }
  /**
   * The type of a function that can be registered with gdk_content_register_serializer().
   *
   * When the function gets called to operate on content, it can call functions on the
   * `serializer` object to obtain the mime type, output stream, user data, etc. for its
   * operation.
   * @callback
   * @param serializer a `GdkContentSerializer`
   */
  interface ContentSerializeFunc {
    (serializer: ContentSerializer): void
  }
  module DevicePad {
    // Constructor properties interface

    interface ConstructorProperties
      extends Device.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface DevicePad extends Device {
    // Own properties of Gdk-4.0.Gdk.DevicePad

    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.DevicePad

    /**
     * Returns the group the given `feature` and `idx` belong to.
     *
     * f the feature or index do not exist in `pad,` -1 is returned.
     * @param feature the feature type to get the group from
     * @param featureIdx the index of the feature to get the group from
     * @returns The group number of the queried pad feature.
     */
    getFeatureGroup(feature: DevicePadFeature, featureIdx: number): number
    /**
     * Returns the number of modes that `group` may have.
     * @param groupIdx group to get the number of available modes from
     * @returns The number of modes available in @group.
     */
    getGroupNModes(groupIdx: number): number
    /**
     * Returns the number of features a tablet pad has.
     * @param feature a pad feature
     * @returns The amount of elements of type @feature that this pad has.
     */
    getNFeatures(feature: DevicePadFeature): number
    /**
     * Returns the number of groups this pad device has.
     *
     * Pads have at least one group. A pad group is a subcollection of
     * buttons/strip/rings that is affected collectively by a same
     * current mode.
     * @returns The number of button/ring/strip groups in the pad.
     */
    getNGroups(): number

    // Class property signals of Gdk-4.0.Gdk.DevicePad

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::caps-lock-state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::caps-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::caps-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::caps-lock-state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::caps-lock-state", ...args: any[]): void
    connect(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::direction", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::has-bidi-layouts",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-bidi-layouts",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-bidi-layouts",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-bidi-layouts",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-bidi-layouts", ...args: any[]): void
    connect(
      sigName: "notify::has-cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-cursor", ...args: any[]): void
    connect(
      sigName: "notify::modifier-state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modifier-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modifier-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modifier-state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modifier-state", ...args: any[]): void
    connect(
      sigName: "notify::n-axes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-axes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-axes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-axes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-axes", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::num-lock-state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::num-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::num-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::num-lock-state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::num-lock-state", ...args: any[]): void
    connect(
      sigName: "notify::num-touches",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::num-touches",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::num-touches",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::num-touches",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::num-touches", ...args: any[]): void
    connect(
      sigName: "notify::product-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::product-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::product-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::product-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::product-id", ...args: any[]): void
    connect(
      sigName: "notify::scroll-lock-state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scroll-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scroll-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scroll-lock-state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scroll-lock-state", ...args: any[]): void
    connect(sigName: "notify::seat", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::seat",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::seat",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::seat",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::seat", ...args: any[]): void
    connect(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::source", ...args: any[]): void
    connect(sigName: "notify::tool", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tool",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tool",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tool",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tool", ...args: any[]): void
    connect(
      sigName: "notify::vendor-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vendor-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vendor-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vendor-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vendor-id", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkDevicePad` is an interface implemented by devices of type
   * %GDK_SOURCE_TABLET_PAD
   *
   * It allows querying the features provided by the pad device.
   *
   * Tablet pads may contain one or more groups, each containing a subset
   * of the buttons/rings/strips available. [method`Gdk`.DevicePad.get_n_groups]
   * can be used to obtain the number of groups, [method`Gdk`.DevicePad.get_n_features]
   * and [method`Gdk`.DevicePad.get_feature_group] can be combined to find out
   * the number of buttons/rings/strips the device has, and how are they grouped.
   *
   * Each of those groups have different modes, which may be used to map each
   * individual pad feature to multiple actions. Only one mode is effective
   * (current) for each given group, different groups may have different
   * current modes. The number of available modes in a group can be found
   * out through [method`Gdk`.DevicePad.get_group_n_modes], and the current mode
   * for a given group will be notified through events of type `GDK_PAD_GROUP_MODE`.
   * @interface
   */
  class DevicePad extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.DevicePad

    static name: string

    // Constructors of Gdk-4.0.Gdk.DevicePad

    constructor(config?: DevicePad.ConstructorProperties)
    _init(config?: DevicePad.ConstructorProperties): void
  }

  module DragSurface {
    // Signal callback interfaces

    /**
     * Signal callback interface for `compute-size`
     */
    interface ComputeSizeSignalCallback {
      (size: DragSurfaceSize): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Surface.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface DragSurface extends Surface {
    // Own properties of Gdk-4.0.Gdk.DragSurface

    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.DragSurface

    /**
     * Present `drag_surface`.
     * @param width the unconstrained drag_surface width to layout
     * @param height the unconstrained drag_surface height to layout
     * @returns %FALSE if it failed to be presented, otherwise %TRUE.
     */
    present(width: number, height: number): boolean

    // Own signals of Gdk-4.0.Gdk.DragSurface

    connect(
      sigName: "compute-size",
      callback: DragSurface.ComputeSizeSignalCallback
    ): number
    on(
      sigName: "compute-size",
      callback: DragSurface.ComputeSizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "compute-size",
      callback: DragSurface.ComputeSizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "compute-size",
      callback: DragSurface.ComputeSizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "compute-size", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.DragSurface

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::frame-clock", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mapped", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkDragSurface` is an interface for surfaces used during DND.
   * @interface
   */
  class DragSurface extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.DragSurface

    static name: string

    // Constructors of Gdk-4.0.Gdk.DragSurface

    constructor(config?: DragSurface.ConstructorProperties)
    _init(config?: DragSurface.ConstructorProperties): void
  }

  module Paintable {
    // Signal callback interfaces

    /**
     * Signal callback interface for `invalidate-contents`
     */
    interface InvalidateContentsSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `invalidate-size`
     */
    interface InvalidateSizeSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Paintable {
    // Own properties of Gdk-4.0.Gdk.Paintable

    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Paintable

    /**
     * Compute a concrete size for the `GdkPaintable`.
     *
     * Applies the sizing algorithm outlined in the
     * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
     * to the given `paintable`. See that link for more details.
     *
     * It is not necessary to call this function when both `specified_width`
     * and `specified_height` are known, but it is useful to call this
     * function in GtkWidget:measure implementations to compute the
     * other dimension when only one dimension is given.
     * @param specifiedWidth the width `paintable` could be drawn into or   0.0 if unknown
     * @param specifiedHeight the height `paintable` could be drawn into or   0.0 if unknown
     * @param defaultWidth the width `paintable` would be drawn into if   no other constraints were given
     * @param defaultHeight the height `paintable` would be drawn into if   no other constraints were given
     */
    computeConcreteSize(
      specifiedWidth: number,
      specifiedHeight: number,
      defaultWidth: number,
      defaultHeight: number
    ): [/* concreteWidth */ number, /* concreteHeight */ number]
    // Has conflict: getCurrentImage(): Paintable
    // Has conflict: getFlags(): PaintableFlags
    // Has conflict: getIntrinsicAspectRatio(): number
    // Has conflict: getIntrinsicHeight(): number
    // Has conflict: getIntrinsicWidth(): number
    /**
     * Called by implementations of `GdkPaintable` to invalidate their contents.
     *
     * Unless the contents are invalidated, implementations must guarantee that
     * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
     *
     * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
     * signal.
     *
     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
     * it must not call this function.
     */
    invalidateContents(): void
    /**
     * Called by implementations of `GdkPaintable` to invalidate their size.
     *
     * As long as the size is not invalidated, `paintable` must return the same
     * values for its intrinsic width, height and aspect ratio.
     *
     * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
     * signal.
     *
     * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
     * it must not call this function.
     */
    invalidateSize(): void
    // Has conflict: snapshot(snapshot: Snapshot, width: number, height: number): void

    // Own virtual methods of Gdk-4.0.Gdk.Paintable

    /**
     * Gets an immutable paintable for the current contents displayed by `paintable`.
     *
     * This is useful when you want to retain the current state of an animation,
     * for example to take a screenshot of a running animation.
     *
     * If the `paintable` is already immutable, it will return itself.
     * @virtual
     * @returns An immutable paintable for the current   contents of @paintable
     */
    getCurrentImage(): Paintable
    /**
     * Get flags for the paintable.
     *
     * This is oftentimes useful for optimizations.
     *
     * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
     * @virtual
     * @returns The `GdkPaintableFlags` for this paintable
     */
    getFlags(): PaintableFlags
    /**
     * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
     *
     * The aspect ratio is the width divided by the height, so a value of 0.5
     * means that the `paintable` prefers to be displayed twice as high as it
     * is wide. Consumers of this interface can use this to preserve aspect
     * ratio when displaying the paintable.
     *
     * This is a purely informational value and does not in any way limit the
     * values that may be passed to [method`Gdk`.Paintable.snapshot].
     *
     * Usually when a `paintable` returns nonzero values from
     * [method`Gdk`.Paintable.get_intrinsic_width] and
     * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
     * should conform to those values, though that is not required.
     *
     * If the `paintable` does not have a preferred aspect ratio,
     * it returns 0. Negative values are never returned.
     * @virtual
     * @returns the intrinsic aspect ratio of @paintable or 0 if none.
     */
    getIntrinsicAspectRatio(): number
    /**
     * Gets the preferred height the `paintable` would like to be displayed at.
     *
     * Consumers of this interface can use this to reserve enough space to draw
     * the paintable.
     *
     * This is a purely informational value and does not in any way limit the
     * values that may be passed to [method`Gdk`.Paintable.snapshot].
     *
     * If the `paintable` does not have a preferred height, it returns 0.
     * Negative values are never returned.
     * @virtual
     * @returns the intrinsic height of @paintable or 0 if none.
     */
    getIntrinsicHeight(): number
    /**
     * Gets the preferred width the `paintable` would like to be displayed at.
     *
     * Consumers of this interface can use this to reserve enough space to draw
     * the paintable.
     *
     * This is a purely informational value and does not in any way limit the
     * values that may be passed to [method`Gdk`.Paintable.snapshot].
     *
     * If the `paintable` does not have a preferred width, it returns 0.
     * Negative values are never returned.
     * @virtual
     * @returns the intrinsic width of @paintable or 0 if none.
     */
    getIntrinsicWidth(): number
    /**
     * Snapshots the given paintable with the given `width` and `height`.
     *
     * The paintable is drawn at the current (0,0) offset of the `snapshot`.
     * If `width` and `height` are not larger than zero, this function will
     * do nothing.
     * @virtual
     * @param snapshot a `GdkSnapshot` to snapshot to
     * @param width width to snapshot in
     * @param height height to snapshot in
     */
    snapshot(snapshot: Snapshot, width: number, height: number): void

    // Own signals of Gdk-4.0.Gdk.Paintable

    connect(
      sigName: "invalidate-contents",
      callback: Paintable.InvalidateContentsSignalCallback
    ): number
    on(
      sigName: "invalidate-contents",
      callback: Paintable.InvalidateContentsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "invalidate-contents",
      callback: Paintable.InvalidateContentsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "invalidate-contents",
      callback: Paintable.InvalidateContentsSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "invalidate-contents", ...args: any[]): void
    connect(
      sigName: "invalidate-size",
      callback: Paintable.InvalidateSizeSignalCallback
    ): number
    on(
      sigName: "invalidate-size",
      callback: Paintable.InvalidateSizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "invalidate-size",
      callback: Paintable.InvalidateSizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "invalidate-size",
      callback: Paintable.InvalidateSizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "invalidate-size", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Paintable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkPaintable` is a simple interface used by GTK to represent content that
   * can be painted.
   *
   * The content of a `GdkPaintable` can be painted anywhere at any size
   * without requiring any sort of layout. The interface is inspired by
   * similar concepts elsewhere, such as
   * [ClutterContent](https://developer.gnome.org/clutter/stable/ClutterContent.html),
   * [HTML/CSS Paint Sources](https://www.w3.org/TR/css-images-4/#paint-source),
   * or [SVG Paint Servers](https://www.w3.org/TR/SVG2/pservers.html).
   *
   * A `GdkPaintable` can be snapshot at any time and size using
   * [method`Gdk`.Paintable.snapshot]. How the paintable interprets that size and
   * if it scales or centers itself into the given rectangle is implementation
   * defined, though if you are implementing a `GdkPaintable` and don't know what
   * to do, it is suggested that you scale your paintable ignoring any potential
   * aspect ratio.
   *
   * The contents that a `GdkPaintable` produces may depend on the [class`Gdk`.Snapshot]
   * passed to it. For example, paintables may decide to use more detailed images
   * on higher resolution screens or when OpenGL is available. A `GdkPaintable`
   * will however always produce the same output for the same snapshot.
   *
   * A `GdkPaintable` may change its contents, meaning that it will now produce
   * a different output with the same snapshot. Once that happens, it will call
   * [method`Gdk`.Paintable.invalidate_contents] which will emit the
   * [signal`Gdk`.Paintable::invalidate-contents] signal. If a paintable is known
   * to never change its contents, it will set the %GDK_PAINTABLE_STATIC_CONTENTS
   * flag. If a consumer cannot deal with changing contents, it may call
   * [method`Gdk`.Paintable.get_current_image] which will return a static
   * paintable and use that.
   *
   * A paintable can report an intrinsic (or preferred) size or aspect ratio it
   * wishes to be rendered at, though it doesn't have to. Consumers of the interface
   * can use this information to layout thepaintable appropriately. Just like the
   * contents, the size of a paintable can change. A paintable will indicate this
   * by calling [method`Gdk`.Paintable.invalidate_size] which will emit the
   * [signal`Gdk`.Paintable::invalidate-size] signal. And just like for contents,
   * if a paintable is known to never change its size, it will set the
   * %GDK_PAINTABLE_STATIC_SIZE flag.
   *
   * Besides API for applications, there are some functions that are only
   * useful for implementing subclasses and should not be used by applications:
   * [method`Gdk`.Paintable.invalidate_contents],
   * [method`Gdk`.Paintable.invalidate_size],
   * [func`Gdk`.Paintable.new_empty].
   * @interface
   */
  class Paintable extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Paintable

    static name: string

    // Constructors of Gdk-4.0.Gdk.Paintable

    constructor(config?: Paintable.ConstructorProperties)
    _init(config?: Paintable.ConstructorProperties): void
    /**
     * Returns a paintable that has the given intrinsic size and draws nothing.
     *
     * This is often useful for implementing the
     * [vfunc`Gdk`.Paintable.get_current_image] virtual function
     * when the paintable is in an incomplete state (like a
     * [GtkMediaStream](../gtk4/class.MediaStream.html) before receiving
     * the first frame).
     * @param intrinsicWidth The intrinsic width to report. Can be 0 for no width.
     * @param intrinsicHeight The intrinsic height to report. Can be 0 for no height.
     * @returns a `GdkPaintable`
     */
    static newEmpty(intrinsicWidth: number, intrinsicHeight: number): Paintable
  }

  module Popup {
    // Constructor properties interface

    interface ConstructorProperties
      extends Surface.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Popup

      /**
       * Whether to hide on outside clicks.
       */
      autohide?: boolean | null
      /**
       * The parent surface.
       */
      parent?: Surface | null
    }
  }

  interface Popup extends Surface {
    // Own properties of Gdk-4.0.Gdk.Popup

    /**
     * Whether to hide on outside clicks.
     */
    readonly autohide: boolean
    /**
     * The parent surface.
     */
    readonly parent: Surface
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Popup

    /**
     * Returns whether this popup is set to hide on outside clicks.
     * @returns %TRUE if @popup will autohide
     */
    getAutohide(): boolean
    /**
     * Returns the parent surface of a popup.
     * @returns the parent surface
     */
    getParent(): Surface | null
    /**
     * Obtains the position of the popup relative to its parent.
     * @returns the X coordinate of @popup position
     */
    getPositionX(): number
    /**
     * Obtains the position of the popup relative to its parent.
     * @returns the Y coordinate of @popup position
     */
    getPositionY(): number
    /**
     * Gets the current popup rectangle anchor.
     *
     * The value returned may change after calling [method`Gdk`.Popup.present],
     * or after the [signal`Gdk`.Surface::layout] signal is emitted.
     * @returns the current rectangle anchor value of @popup
     */
    getRectAnchor(): Gravity
    /**
     * Gets the current popup surface anchor.
     *
     * The value returned may change after calling [method`Gdk`.Popup.present],
     * or after the [signal`Gdk`.Surface::layout] signal is emitted.
     * @returns the current surface anchor value of @popup
     */
    getSurfaceAnchor(): Gravity
    /**
     * Present `popup` after having processed the `GdkPopupLayout` rules.
     *
     * If the popup was previously now showing, it will be showed,
     * otherwise it will change position according to `layout`.
     *
     * After calling this function, the result should be handled in response
     * to the [signal`Gdk`.Surface::layout] signal being emitted. The resulting
     * popup position can be queried using [method`Gdk`.Popup.get_position_x],
     * [method`Gdk`.Popup.get_position_y], and the resulting size will be sent as
     * parameters in the layout signal. Use [method`Gdk`.Popup.get_rect_anchor]
     * and [method`Gdk`.Popup.get_surface_anchor] to get the resulting anchors.
     *
     * Presenting may fail, for example if the `popup` is set to autohide
     * and is immediately hidden upon being presented. If presenting failed,
     * the [signal`Gdk`.Surface::layout] signal will not me emitted.
     * @param width the unconstrained popup width to layout
     * @param height the unconstrained popup height to layout
     * @param layout the `GdkPopupLayout` object used to layout
     * @returns %FALSE if it failed to be presented, otherwise %TRUE.
     */
    present(width: number, height: number, layout: PopupLayout): boolean

    // Class property signals of Gdk-4.0.Gdk.Popup

    connect(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::autohide", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::frame-clock", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mapped", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkPopup` is a surface that is attached to another surface.
   *
   * The `GdkPopup` is positioned relative to its parent surface.
   *
   * `GdkPopup`s are typically used to implement menus and similar popups.
   * They can be modal, which is indicated by the [property`Gdk`.Popup:autohide]
   * property.
   * @interface
   */
  class Popup extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Popup

    static name: string

    // Constructors of Gdk-4.0.Gdk.Popup

    constructor(config?: Popup.ConstructorProperties)
    _init(config?: Popup.ConstructorProperties): void
  }

  module Toplevel {
    // Signal callback interfaces

    /**
     * Signal callback interface for `compute-size`
     */
    interface ComputeSizeSignalCallback {
      (size: ToplevelSize): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Surface.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Toplevel

      /**
       * Whether the window manager should add decorations.
       */
      decorated?: boolean | null
      /**
       * Whether the window manager should allow to close the surface.
       */
      deletable?: boolean | null
      /**
       * The fullscreen mode of the surface.
       */
      fullscreen_mode?: FullscreenMode | null
      /**
       * A list of textures to use as icon.
       */
      icon_list?: any | null
      /**
       * Whether the surface is modal.
       */
      modal?: boolean | null
      /**
       * The startup ID of the surface.
       *
       * See [class`Gdk`.AppLaunchContext] for more information about
       * startup feedback.
       */
      startup_id?: string | null
      /**
       * The title of the surface.
       */
      title?: string | null
      /**
       * The transient parent of the surface.
       */
      transient_for?: Surface | null
    }
  }

  interface Toplevel extends Surface {
    // Own properties of Gdk-4.0.Gdk.Toplevel

    /**
     * Whether the window manager should add decorations.
     */
    decorated: boolean
    /**
     * Whether the window manager should allow to close the surface.
     */
    deletable: boolean
    /**
     * The fullscreen mode of the surface.
     */
    fullscreenMode: FullscreenMode
    /**
     * A list of textures to use as icon.
     */
    iconList: any
    /**
     * Whether the surface is modal.
     */
    modal: boolean
    /**
     * Whether the surface should inhibit keyboard shortcuts.
     */
    readonly shortcutsInhibited: boolean
    /**
     * The startup ID of the surface.
     *
     * See [class`Gdk`.AppLaunchContext] for more information about
     * startup feedback.
     */
    startupId: string | null
    /**
     * The state of the toplevel.
     */
    readonly state: ToplevelState
    /**
     * The title of the surface.
     */
    title: string | null
    /**
     * The transient parent of the surface.
     */
    transientFor: Surface
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Toplevel

    /**
     * Begins an interactive move operation.
     *
     * You might use this function to implement draggable titlebars.
     * @param device the device used for the operation
     * @param button the button being used to drag, or 0 for a keyboard-initiated drag
     * @param x surface X coordinate of mouse click that began the drag
     * @param y surface Y coordinate of mouse click that began the drag
     * @param timestamp timestamp of mouse click that began the drag (use   [method`Gdk`.Event.get_time])
     */
    beginMove(
      device: Device,
      button: number,
      x: number,
      y: number,
      timestamp: number
    ): void
    /**
     * Begins an interactive resize operation.
     *
     * You might use this function to implement a “window resize grip.”
     * @param edge the edge or corner from which the drag is started
     * @param device the device used for the operation
     * @param button the button being used to drag, or 0 for a keyboard-initiated drag
     * @param x surface X coordinate of mouse click that began the drag
     * @param y surface Y coordinate of mouse click that began the drag
     * @param timestamp timestamp of mouse click that began the drag (use   [method`Gdk`.Event.get_time])
     */
    beginResize(
      edge: SurfaceEdge,
      device: Device | null,
      button: number,
      x: number,
      y: number,
      timestamp: number
    ): void
    /**
     * Sets keyboard focus to `surface`.
     *
     * In most cases, [gtk_window_present_with_time()](../gtk4/method.Window.present_with_time.html)
     * should be used on a [GtkWindow](../gtk4/class.Window.html), rather than
     * calling this function.
     * @param timestamp timestamp of the event triggering the surface focus
     */
    focus(timestamp: number): void
    /**
     * Gets the bitwise or of the currently active surface state flags,
     * from the `GdkToplevelState` enumeration.
     * @returns surface state bitfield
     */
    getState(): ToplevelState
    /**
     * Requests that the `toplevel` inhibit the system shortcuts.
     *
     * This is asking the desktop environment/windowing system to let all
     * keyboard events reach the surface, as long as it is focused, instead
     * of triggering system actions.
     *
     * If granted, the rerouting remains active until the default shortcuts
     * processing is restored with [method`Gdk`.Toplevel.restore_system_shortcuts],
     * or the request is revoked by the desktop environment, windowing system
     * or the user.
     *
     * A typical use case for this API is remote desktop or virtual machine
     * viewers which need to inhibit the default system keyboard shortcuts
     * so that the remote session or virtual host gets those instead of the
     * local environment.
     *
     * The windowing system or desktop environment may ask the user to grant
     * or deny the request or even choose to ignore the request entirely.
     *
     * The caller can be notified whenever the request is granted or revoked
     * by listening to the [property`Gdk`.Toplevel:shortcuts-inhibited] property.
     * @param event the `GdkEvent` that is triggering the inhibit   request, or %NULL if none is available
     */
    inhibitSystemShortcuts(event: Event | null): void
    /**
     * Asks to lower the `toplevel` below other windows.
     *
     * The windowing system may choose to ignore the request.
     * @returns %TRUE if the surface was lowered
     */
    lower(): boolean
    /**
     * Asks to minimize the `toplevel`.
     *
     * The windowing system may choose to ignore the request.
     * @returns %TRUE if the surface was minimized
     */
    minimize(): boolean
    /**
     * Present `toplevel` after having processed the `GdkToplevelLayout` rules.
     *
     * If the toplevel was previously not showing, it will be showed,
     * otherwise it will change layout according to `layout`.
     *
     * GDK may emit the [signal`Gdk`.Toplevel::compute-size] signal to let
     * the user of this toplevel compute the preferred size of the toplevel
     * surface.
     *
     * Presenting is asynchronous and the specified layout parameters are not
     * guaranteed to be respected.
     * @param layout the `GdkToplevelLayout` object used to layout
     */
    present(layout: ToplevelLayout): void
    /**
     * Restore default system keyboard shortcuts which were previously
     * inhibited.
     *
     * This undoes the effect of [method`Gdk`.Toplevel.inhibit_system_shortcuts].
     */
    restoreSystemShortcuts(): void
    /**
     * Sets the toplevel to be decorated.
     *
     * Setting `decorated` to %FALSE hints the desktop environment
     * that the surface has its own, client-side decorations and
     * does not need to have window decorations added.
     * @param decorated %TRUE to request decorations
     */
    setDecorated(decorated: boolean): void
    /**
     * Sets the toplevel to be deletable.
     *
     * Setting `deletable` to %TRUE hints the desktop environment
     * that it should offer the user a way to close the surface.
     * @param deletable %TRUE to request a delete button
     */
    setDeletable(deletable: boolean): void
    /**
     * Sets a list of icons for the surface.
     *
     * One of these will be used to represent the surface in iconic form.
     * The icon may be shown in window lists or task bars. Which icon
     * size is shown depends on the window manager. The window manager
     * can scale the icon but setting several size icons can give better
     * image quality.
     *
     * Note that some platforms don't support surface icons.
     * @param surfaces A list of textures to use as icon, of different sizes
     */
    setIconList(surfaces: Texture[]): void
    /**
     * Sets the toplevel to be modal.
     *
     * The application can use this hint to tell the
     * window manager that a certain surface has modal
     * behaviour. The window manager can use this information
     * to handle modal surfaces in a special way.
     *
     * You should only use this on surfaces for which you have
     * previously called [method`Gdk`.Toplevel.set_transient_for].
     * @param modal %TRUE if the surface is modal, %FALSE otherwise.
     */
    setModal(modal: boolean): void
    /**
     * Sets the startup notification ID.
     *
     * When using GTK, typically you should use
     * [gtk_window_set_startup_id()](../gtk4/method.Window.set_startup_id.html)
     * instead of this low-level function.
     * @param startupId a string with startup-notification identifier
     */
    setStartupId(startupId: string): void
    /**
     * Sets the title of a toplevel surface.
     *
     * The title maybe be displayed in the titlebar,
     * in lists of windows, etc.
     * @param title title of `surface`
     */
    setTitle(title: string): void
    /**
     * Sets a transient-for parent.
     *
     * Indicates to the window manager that `surface` is a transient
     * dialog associated with the application surface `parent`. This
     * allows the window manager to do things like center `surface`
     * on `parent` and keep `surface` above `parent`.
     *
     * See [gtk_window_set_transient_for()](../gtk4/method.Window.set_transient_for.html)
     * if you’re using [GtkWindow](../gtk4/class.Window.html).
     * @param parent another toplevel `GdkSurface`
     */
    setTransientFor(parent: Surface): void
    /**
     * Asks the windowing system to show the window menu.
     *
     * The window menu is the menu shown when right-clicking the titlebar
     * on traditional windows managed by the window manager. This is useful
     * for windows using client-side decorations, activating it with a
     * right-click on the window decorations.
     * @param event a `GdkEvent` to show the menu for
     * @returns %TRUE if the window menu was shown and %FALSE otherwise.
     */
    showWindowMenu(event: Event): boolean
    /**
     * Returns whether the desktop environment supports
     * tiled window states.
     * @returns %TRUE if the desktop environment supports tiled window states
     */
    supportsEdgeConstraints(): boolean
    titlebarGesture(gesture: TitlebarGesture): boolean

    // Own signals of Gdk-4.0.Gdk.Toplevel

    connect(
      sigName: "compute-size",
      callback: Toplevel.ComputeSizeSignalCallback
    ): number
    on(
      sigName: "compute-size",
      callback: Toplevel.ComputeSizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "compute-size",
      callback: Toplevel.ComputeSizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "compute-size",
      callback: Toplevel.ComputeSizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "compute-size", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Toplevel

    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::fullscreen-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreen-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreen-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreen-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreen-mode", ...args: any[]): void
    connect(
      sigName: "notify::icon-list",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-list",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-list",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-list",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-list", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::shortcuts-inhibited",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shortcuts-inhibited",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shortcuts-inhibited",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shortcuts-inhibited",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shortcuts-inhibited", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::frame-clock", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mapped", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkToplevel` is a freestanding toplevel surface.
   *
   * The `GdkToplevel` interface provides useful APIs for interacting with
   * the windowing system, such as controlling maximization and size of the
   * surface, setting icons and transient parents for dialogs.
   * @interface
   */
  class Toplevel extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Toplevel

    static name: string

    // Constructors of Gdk-4.0.Gdk.Toplevel

    constructor(config?: Toplevel.ConstructorProperties)
    _init(config?: Toplevel.ConstructorProperties): void
  }

  module AppLaunchContext {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.AppLaunchContext.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.AppLaunchContext

      /**
       * The display that the `GdkAppLaunchContext` is on.
       */
      display?: Display | null
    }
  }

  interface AppLaunchContext {
    // Own properties of Gdk-4.0.Gdk.AppLaunchContext

    /**
     * The display that the `GdkAppLaunchContext` is on.
     */
    readonly display: Display
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.AppLaunchContext

    /**
     * Gets the `GdkDisplay` that `context` is for.
     * @returns the display of @context
     */
    getDisplay(): Display

    // Overloads of getDisplay

    /**
     * Gets the display string for the `context`. This is used to ensure new
     * applications are started on the same display as the launching
     * application, by setting the `DISPLAY` environment variable.
     * @virtual
     * @param info a #GAppInfo
     * @param files a #GList of #GFile objects
     * @returns a display string for the display.
     */
    getDisplay(info: Gio.AppInfo, files: Gio.File[]): string | null
    /**
     * Sets the workspace on which applications will be launched.
     *
     * This only works when running under a window manager that
     * supports multiple workspaces, as described in the
     * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
     * Specifically this sets the `_NET_WM_DESKTOP` property described
     * in that spec.
     *
     * This only works when using the X11 backend.
     *
     * When the workspace is not specified or `desktop` is set to -1,
     * it is up to the window manager to pick one, typically it will
     * be the current workspace.
     * @param desktop the number of a workspace, or -1
     */
    setDesktop(desktop: number): void
    /**
     * Sets the icon for applications that are launched with this
     * context.
     *
     * Window Managers can use this information when displaying startup
     * notification.
     *
     * See also [method`Gdk`.AppLaunchContext.set_icon_name].
     * @param icon a `GIcon`
     */
    setIcon(icon: Gio.Icon | null): void
    /**
     * Sets the icon for applications that are launched with this context.
     *
     * The `icon_name` will be interpreted in the same way as the Icon field
     * in desktop files. See also [method`Gdk`.AppLaunchContext.set_icon].
     *
     * If both `icon` and `icon_name` are set, the `icon_name` takes priority.
     * If neither `icon` or `icon_name` is set, the icon is taken from either
     * the file that is passed to launched application or from the `GAppInfo`
     * for the launched application itself.
     * @param iconName an icon name
     */
    setIconName(iconName: string | null): void
    /**
     * Sets the timestamp of `context`.
     *
     * The timestamp should ideally be taken from the event that
     * triggered the launch.
     *
     * Window managers can use this information to avoid moving the
     * focus to the newly launched application when the user is busy
     * typing in another window. This is also known as 'focus stealing
     * prevention'.
     * @param timestamp a timestamp
     */
    setTimestamp(timestamp: number): void

    // Class property signals of Gdk-4.0.Gdk.AppLaunchContext

    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkAppLaunchContext` handles launching an application in a graphical context.
   *
   * It is an implementation of `GAppLaunchContext` that provides startup
   * notification and allows to launch applications on a specific workspace.
   *
   * ## Launching an application
   *
   * ```c
   * GdkAppLaunchContext *context;
   *
   * context = gdk_display_get_app_launch_context (display);
   *
   * gdk_app_launch_context_set_timestamp (gdk_event_get_time (event));
   *
   * if (!g_app_info_launch_default_for_uri ("http://www.gtk.org", context, &error))
   *   g_warning ("Launching failed: %s\n", error->message);
   *
   * g_object_unref (context);
   * ```
   * @class
   */
  class AppLaunchContext extends Gio.AppLaunchContext {
    // Own properties of Gdk-4.0.Gdk.AppLaunchContext

    static name: string

    // Constructors of Gdk-4.0.Gdk.AppLaunchContext

    constructor(config?: AppLaunchContext.ConstructorProperties)
    _init(config?: AppLaunchContext.ConstructorProperties): void
  }

  interface ButtonEvent {
    // Owm methods of Gdk-4.0.Gdk.ButtonEvent

    /**
     * Extract the button number from a button event.
     * @returns the button of @event
     */
    getButton(): number
  }

  /**
   * An event related to a button on a pointer device.
   * @class
   */
  class ButtonEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.ButtonEvent

    static name: string
  }

  module CairoContext {
    // Constructor properties interface

    interface ConstructorProperties extends DrawContext.ConstructorProperties {}
  }

  interface CairoContext {
    // Own properties of Gdk-4.0.Gdk.CairoContext

    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.CairoContext

    /**
     * Retrieves a Cairo context to be used to draw on the `GdkSurface`
     * of `context`.
     *
     * A call to [method`Gdk`.DrawContext.begin_frame] with this
     * `context` must have been done or this function will return %NULL.
     *
     * The returned context is guaranteed to be valid until
     * [method`Gdk`.DrawContext.end_frame] is called.
     * @returns a Cairo context   to draw on `GdkSurface
     */
    cairoCreate(): cairo.Context | null

    // Class property signals of Gdk-4.0.Gdk.CairoContext

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkCairoContext` is an object representing the platform-specific
   * draw context.
   *
   * `GdkCairoContext`s are created for a surface using
   * [method`Gdk`.Surface.create_cairo_context], and the context
   * can then be used to draw on that surface.
   * @class
   */
  class CairoContext extends DrawContext {
    // Own properties of Gdk-4.0.Gdk.CairoContext

    static name: string

    // Constructors of Gdk-4.0.Gdk.CairoContext

    constructor(config?: CairoContext.ConstructorProperties)
    _init(config?: CairoContext.ConstructorProperties): void
  }

  module Clipboard {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Clipboard

      /**
       * The `GdkDisplay` that the clipboard belongs to.
       */
      display?: Display | null
    }
  }

  interface Clipboard {
    // Own properties of Gdk-4.0.Gdk.Clipboard

    /**
     * The `GdkContentProvider` or %NULL if the clipboard is empty or contents are
     * provided otherwise.
     */
    readonly content: ContentProvider
    /**
     * The `GdkDisplay` that the clipboard belongs to.
     */
    readonly display: Display
    /**
     * The possible formats that the clipboard can provide its data in.
     */
    readonly formats: ContentFormats
    /**
     * %TRUE if the contents of the clipboard are owned by this process.
     */
    readonly local: boolean
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Clipboard

    /**
     * Returns the `GdkContentProvider` currently set on `clipboard`.
     *
     * If the `clipboard` is empty or its contents are not owned by the
     * current process, %NULL will be returned.
     * @returns The content of a clipboard   if the clipboard does not maintain any content
     */
    getContent(): ContentProvider | null
    /**
     * Gets the `GdkDisplay` that the clipboard was created for.
     * @returns a `GdkDisplay`
     */
    getDisplay(): Display
    /**
     * Gets the formats that the clipboard can provide its current contents in.
     * @returns The formats of the clipboard
     */
    getFormats(): ContentFormats
    /**
     * Returns if the clipboard is local.
     *
     * A clipboard is considered local if it was last claimed
     * by the running application.
     *
     * Note that [method`Gdk`.Clipboard.get_content] may return %NULL
     * even on a local clipboard. In this case the clipboard is empty.
     * @returns %TRUE if the clipboard is local
     */
    isLocal(): boolean
    /**
     * Asynchronously requests an input stream to read the `clipboard'`s
     * contents from.
     *
     * When the operation is finished `callback` will be called. You must then
     * call [method`Gdk`.Clipboard.read_finish] to get the result of the operation.
     *
     * The clipboard will choose the most suitable mime type from the given list
     * to fulfill the request, preferring the ones listed first.
     * @param mimeTypes a %NULL-terminated array of mime types to choose from
     * @param ioPriority the I/O priority of the request
     * @param cancellable optional `GCancellable` object
     * @param callback callback to call when the request is satisfied
     */
    readAsync(
      mimeTypes: string[],
      ioPriority: number,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous clipboard read.
     *
     * See [method`Gdk`.Clipboard.read_async].
     * @param result a `GAsyncResult`
     * @returns a `GInputStream`
     */
    readFinish(
      result: Gio.AsyncResult
    ): [/* returnType */ Gio.InputStream | null, /* outMimeType */ string]
    /**
     * Asynchronously request the `clipboard` contents converted to a string.
     *
     * When the operation is finished `callback` will be called. You must then
     * call [method`Gdk`.Clipboard.read_text_finish] to get the result.
     *
     * This is a simple wrapper around [method`Gdk`.Clipboard.read_value_async].
     * Use that function or [method`Gdk`.Clipboard.read_async] directly if you
     * need more control over the operation.
     * @param cancellable optional `GCancellable` object
     * @param callback callback to call when the request is satisfied
     */
    readTextAsync(
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous clipboard read.
     *
     * See [method`Gdk`.Clipboard.read_text_async].
     * @param result a `GAsyncResult`
     * @returns a new string
     */
    readTextFinish(result: Gio.AsyncResult): string | null
    /**
     * Asynchronously request the `clipboard` contents converted to a `GdkPixbuf`.
     *
     * When the operation is finished `callback` will be called. You must then
     * call [method`Gdk`.Clipboard.read_texture_finish] to get the result.
     *
     * This is a simple wrapper around [method`Gdk`.Clipboard.read_value_async].
     * Use that function or [method`Gdk`.Clipboard.read_async] directly if you
     * need more control over the operation.
     * @param cancellable optional `GCancellable` object, %NULL to ignore.
     * @param callback callback to call when the request is satisfied
     */
    readTextureAsync(
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous clipboard read.
     *
     * See [method`Gdk`.Clipboard.read_texture_async].
     * @param result a `GAsyncResult`
     * @returns a new `GdkTexture`
     */
    readTextureFinish(result: Gio.AsyncResult): Texture | null
    /**
     * Asynchronously request the `clipboard` contents converted to the given
     * `type`.
     *
     * When the operation is finished `callback` will be called. You must then call
     * [method`Gdk`.Clipboard.read_value_finish] to get the resulting `GValue`.
     *
     * For local clipboard contents that are available in the given `GType`,
     * the value will be copied directly. Otherwise, GDK will try to use
     * [func`content_deserialize_async]` to convert the clipboard's data.
     * @param type a `GType` to read
     * @param ioPriority the I/O priority of the request
     * @param cancellable optional `GCancellable` object
     * @param callback callback to call when the request is satisfied
     */
    readValueAsync(
      type: GObject.GType,
      ioPriority: number,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous clipboard read.
     *
     * See [method`Gdk`.Clipboard.read_value_async].
     * @param result a `GAsyncResult`
     * @returns a `GValue` containing the result.
     */
    readValueFinish(result: Gio.AsyncResult): any
    /**
     * Sets a new content provider on `clipboard`.
     *
     * The clipboard will claim the `GdkDisplay`'s resources and advertise
     * these new contents to other applications.
     *
     * In the rare case of a failure, this function will return %FALSE. The
     * clipboard will then continue reporting its old contents and ignore
     * `provider`.
     *
     * If the contents are read by either an external application or the
     * `clipboard'`s read functions, `clipboard` will select the best format to
     * transfer the contents and then request that format from `provider`.
     * @param provider the new contents of `clipboard`   or %NULL to clear the clipboard
     * @returns %TRUE if setting the clipboard succeeded
     */
    setContent(provider: ContentProvider | null): boolean
    /**
     * Sets the `clipboard` to contain the given `value`.
     * @param value a `GValue` to set
     */
    set(value: any): void
    /**
     * Asynchronously instructs the `clipboard` to store its contents remotely.
     *
     * If the clipboard is not local, this function does nothing but report success.
     *
     * The `callback` must call [method`Gdk`.Clipboard.store_finish].
     *
     * The purpose of this call is to preserve clipboard contents beyond the
     * lifetime of an application, so this function is typically called on
     * exit. Depending on the platform, the functionality may not be available
     * unless a "clipboard manager" is running.
     *
     * This function is called automatically when a
     * [GtkApplication](../gtk4/class.Application.html)
     * is shut down, so you likely don't need to call it.
     * @param ioPriority the I/O priority of the request
     * @param cancellable optional `GCancellable` object
     * @param callback callback to call when the request is satisfied
     */
    storeAsync(
      ioPriority: number,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous clipboard store.
     *
     * See [method`Gdk`.Clipboard.store_async].
     * @param result a `GAsyncResult`
     * @returns %TRUE if storing was successful.
     */
    storeFinish(result: Gio.AsyncResult): boolean

    // Own signals of Gdk-4.0.Gdk.Clipboard

    connect(
      sigName: "changed",
      callback: Clipboard.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: Clipboard.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Clipboard.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Clipboard.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Clipboard

    connect(
      sigName: "notify::content",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::formats", ...args: any[]): void
    connect(
      sigName: "notify::local",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::local",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::local",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::local", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GdkClipboard` object represents data shared between applications or
   * inside an application.
   *
   * To get a `GdkClipboard` object, use [method`Gdk`.Display.get_clipboard] or
   * [method`Gdk`.Display.get_primary_clipboard]. You can find out about the data
   * that is currently available in a clipboard using
   * [method`Gdk`.Clipboard.get_formats].
   *
   * To make text or image data available in a clipboard, use
   * [method`Gdk`.Clipboard.set_text] or [method`Gdk`.Clipboard.set_texture].
   * For other data, you can use [method`Gdk`.Clipboard.set_content], which
   * takes a [class`Gdk`.ContentProvider] object.
   *
   * To read textual or image data from a clipboard, use
   * [method`Gdk`.Clipboard.read_text_async] or
   * [method`Gdk`.Clipboard.read_texture_async]. For other data, use
   * [method`Gdk`.Clipboard.read_async], which provides a `GInputStream` object.
   * @class
   */
  class Clipboard extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Clipboard

    static name: string

    // Constructors of Gdk-4.0.Gdk.Clipboard

    constructor(config?: Clipboard.ConstructorProperties)
    _init(config?: Clipboard.ConstructorProperties): void
  }

  module ContentDeserializer {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.AsyncResult.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface ContentDeserializer extends Gio.AsyncResult {
    // Own properties of Gdk-4.0.Gdk.ContentDeserializer

    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.ContentDeserializer

    /**
     * Gets the cancellable for the current operation.
     *
     * This is the `GCancellable` that was passed to [func`Gdk`.content_deserialize_async].
     * @returns the cancellable for the current operation
     */
    getCancellable(): Gio.Cancellable | null
    /**
     * Gets the `GType` to create an instance of.
     * @returns the `GType` for the current operation
     */
    getGtype(): GObject.GType
    /**
     * Gets the input stream for the current operation.
     *
     * This is the stream that was passed to [func`Gdk`.content_deserialize_async].
     * @returns the input stream for the current operation
     */
    getInputStream(): Gio.InputStream
    /**
     * Gets the mime type to deserialize from.
     * @returns the mime type for the current operation
     */
    getMimeType(): string
    /**
     * Gets the I/O priority for the current operation.
     *
     * This is the priority that was passed to [func`Gdk`.content_deserialize_async].
     * @returns the I/O priority for the current operation
     */
    getPriority(): number
    /**
     * Gets the data that was associated with the current operation.
     *
     * See [method`Gdk`.ContentDeserializer.set_task_data].
     * @returns the task data for @deserializer
     */
    getTaskData(): any | null
    /**
     * Gets the user data that was passed when the deserializer was registered.
     * @returns the user data for this deserializer
     */
    getUserData(): any | null

    // Overloads of getUserData

    /**
     * Gets the user data from a #GAsyncResult.
     * @virtual
     * @returns the user data for @res.
     */
    getUserData(): any | null
    /**
     * Gets the `GValue` to store the deserialized object in.
     * @returns the `GValue` for the current operation
     */
    getValue(): any
    /**
     * Indicate that the deserialization has ended with an error.
     *
     * This function consumes `error`.
     * @param error a `GError`
     */
    returnError(error: GLib.Error): void
    /**
     * Indicate that the deserialization has been successfully completed.
     */
    returnSuccess(): void
    /**
     * Associate data with the current deserialization operation.
     * @param data data to associate with this operation
     * @param notify destroy notify for `data`
     */
    setTaskData(data: any | null, notify: GLib.DestroyNotify): void

    // Class property signals of Gdk-4.0.Gdk.ContentDeserializer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkContentDeserializer` is used to deserialize content received via
   * inter-application data transfers.
   *
   * The `GdkContentDeserializer` transforms serialized content that is
   * identified by a mime type into an object identified by a GType.
   *
   * GTK provides serializers and deserializers for common data types
   * such as text, colors, images or file lists. To register your own
   * deserialization functions, use [func`content_register_deserializer]`.
   *
   * Also see [class`Gdk`.ContentSerializer].
   * @class
   */
  class ContentDeserializer extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.ContentDeserializer

    static name: string

    // Constructors of Gdk-4.0.Gdk.ContentDeserializer

    constructor(config?: ContentDeserializer.ConstructorProperties)
    _init(config?: ContentDeserializer.ConstructorProperties): void
  }

  module ContentProvider {
    // Signal callback interfaces

    /**
     * Signal callback interface for `content-changed`
     */
    interface ContentChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ContentProvider {
    // Own properties of Gdk-4.0.Gdk.ContentProvider

    /**
     * The possible formats that the provider can provide its data in.
     */
    readonly formats: ContentFormats
    /**
     * The subset of formats that clipboard managers should store this provider's data in.
     */
    readonly storableFormats: ContentFormats
    __gtype__: number

    // Own fields of Gdk-4.0.Gdk.ContentProvider

    parent: GObject.Object

    // Owm methods of Gdk-4.0.Gdk.ContentProvider

    // Has conflict: contentChanged(): void
    // Has conflict: getValue(): [ /* returnType */ boolean, /* value */ any ]
    // Has conflict: refFormats(): ContentFormats
    // Has conflict: refStorableFormats(): ContentFormats
    // Has conflict: writeMimeTypeAsync(mimeType: string, stream: Gio.OutputStream, ioPriority: number, cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback | null): void
    // Has conflict: writeMimeTypeFinish(result: Gio.AsyncResult): boolean

    // Own virtual methods of Gdk-4.0.Gdk.ContentProvider

    attachClipboard(clipboard: Clipboard): void
    /**
     * Emits the ::content-changed signal.
     * @virtual
     */
    contentChanged(): void
    detachClipboard(clipboard: Clipboard): void
    /**
     * Gets the contents of `provider` stored in `value`.
     *
     * The `value` will have been initialized to the `GType` the value should be
     * provided in. This given `GType` does not need to be listed in the formats
     * returned by [method`Gdk`.ContentProvider.ref_formats]. However, if the
     * given `GType` is not supported, this operation can fail and
     * `G_IO_ERROR_NOT_SUPPORTED` will be reported.
     * @virtual
     * @returns %TRUE if the value was set successfully. Otherwise   @error will be set to describe the failure.
     */
    getValue(): [/* returnType */ boolean, /* value */ any]
    /**
     * Gets the formats that the provider can provide its current contents in.
     * @virtual
     * @returns The formats of the provider
     */
    refFormats(): ContentFormats
    /**
     * Gets the formats that the provider suggests other applications to store
     * the data in.
     *
     * An example of such an application would be a clipboard manager.
     *
     * This can be assumed to be a subset of [method`Gdk`.ContentProvider.ref_formats].
     * @virtual
     * @returns The storable formats of the provider
     */
    refStorableFormats(): ContentFormats
    /**
     * Asynchronously writes the contents of `provider` to `stream` in the given
     * `mime_type`.
     *
     * When the operation is finished `callback` will be called. You must then call
     * [method`Gdk`.ContentProvider.write_mime_type_finish] to get the result
     * of the operation.
     *
     * The given mime type does not need to be listed in the formats returned by
     * [method`Gdk`.ContentProvider.ref_formats]. However, if the given `GType` is
     * not supported, `G_IO_ERROR_NOT_SUPPORTED` will be reported.
     *
     * The given `stream` will not be closed.
     * @virtual
     * @param mimeType the mime type to provide the data in
     * @param stream the `GOutputStream` to write to
     * @param ioPriority I/O priority of the request.
     * @param cancellable optional `GCancellable` object, %NULL to ignore.
     * @param callback callback to call when the request is satisfied
     */
    writeMimeTypeAsync(
      mimeType: string,
      stream: Gio.OutputStream,
      ioPriority: number,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an asynchronous write operation.
     *
     * See [method`Gdk`.ContentProvider.write_mime_type_async].
     * @virtual
     * @param result a `GAsyncResult`
     * @returns %TRUE if the operation was completed successfully. Otherwise   @error will be set to describe the failure.
     */
    writeMimeTypeFinish(result: Gio.AsyncResult): boolean

    // Own signals of Gdk-4.0.Gdk.ContentProvider

    connect(
      sigName: "content-changed",
      callback: ContentProvider.ContentChangedSignalCallback
    ): number
    on(
      sigName: "content-changed",
      callback: ContentProvider.ContentChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "content-changed",
      callback: ContentProvider.ContentChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "content-changed",
      callback: ContentProvider.ContentChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "content-changed", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.ContentProvider

    connect(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::formats", ...args: any[]): void
    connect(
      sigName: "notify::storable-formats",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::storable-formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::storable-formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::storable-formats",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::storable-formats", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkContentProvider` is used to provide content for the clipboard or
   * for drag-and-drop operations in a number of formats.
   *
   * To create a `GdkContentProvider`, use [ctor`Gdk`.ContentProvider.new_for_value]
   * or [ctor`Gdk`.ContentProvider.new_for_bytes].
   *
   * GDK knows how to handle common text and image formats out-of-the-box. See
   * [class`Gdk`.ContentSerializer] and [class`Gdk`.ContentDeserializer] if you want
   * to add support for application-specific data formats.
   * @class
   */
  class ContentProvider extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.ContentProvider

    static name: string

    // Constructors of Gdk-4.0.Gdk.ContentProvider

    constructor(config?: ContentProvider.ConstructorProperties)
    /**
     * Create a content provider that provides the given `bytes` as data for
     * the given `mime_type`.
     * @constructor
     * @param mimeType the mime type
     * @param bytes a `GBytes` with the data for `mime_type`
     * @returns a new `GdkContentProvider`
     */
    static newForBytes(mimeType: string, bytes: any): ContentProvider
    /**
     * Create a content provider that provides the given `value`.
     * @constructor
     * @param value a `GValue`
     * @returns a new `GdkContentProvider`
     */
    static newForValue(value: any): ContentProvider
    /**
     * Creates a content provider that represents all the given `providers`.
     *
     * Whenever data needs to be written, the union provider will try the given
     * `providers` in the given order and the first one supporting a format will
     * be chosen to provide it.
     *
     * This allows an easy way to support providing data in different formats.
     * For example, an image may be provided by its file and by the image
     * contents with a call such as
     * ```c
     * gdk_content_provider_new_union ((GdkContentProvider *[2]) {
     *                                   gdk_content_provider_new_typed (G_TYPE_FILE, file),
     *                                   gdk_content_provider_new_typed (G_TYPE_TEXTURE, texture)
     *                                 }, 2);
     * ```
     * @constructor
     * @param providers The `GdkContentProvider`s to present the union of
     * @returns a new `GdkContentProvider`
     */
    static newUnion(providers: ContentProvider[] | null): ContentProvider
    _init(config?: ContentProvider.ConstructorProperties): void
  }

  module ContentSerializer {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.AsyncResult.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface ContentSerializer extends Gio.AsyncResult {
    // Own properties of Gdk-4.0.Gdk.ContentSerializer

    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.ContentSerializer

    /**
     * Gets the cancellable for the current operation.
     *
     * This is the `GCancellable` that was passed to [func`content_serialize_async]`.
     * @returns the cancellable for the current operation
     */
    getCancellable(): Gio.Cancellable | null
    /**
     * Gets the `GType` to of the object to serialize.
     * @returns the `GType` for the current operation
     */
    getGtype(): GObject.GType
    /**
     * Gets the mime type to serialize to.
     * @returns the mime type for the current operation
     */
    getMimeType(): string
    /**
     * Gets the output stream for the current operation.
     *
     * This is the stream that was passed to [func`content_serialize_async]`.
     * @returns the output stream for the current operation
     */
    getOutputStream(): Gio.OutputStream
    /**
     * Gets the I/O priority for the current operation.
     *
     * This is the priority that was passed to [func`content_serialize_async]`.
     * @returns the I/O priority for the current operation
     */
    getPriority(): number
    /**
     * Gets the data that was associated with the current operation.
     *
     * See [method`Gdk`.ContentSerializer.set_task_data].
     * @returns the task data for @serializer
     */
    getTaskData(): any | null
    /**
     * Gets the user data that was passed when the serializer was registered.
     * @returns the user data for this serializer
     */
    getUserData(): any | null

    // Overloads of getUserData

    /**
     * Gets the user data from a #GAsyncResult.
     * @virtual
     * @returns the user data for @res.
     */
    getUserData(): any | null
    /**
     * Gets the `GValue` to read the object to serialize from.
     * @returns the `GValue` for the current operation
     */
    getValue(): any
    /**
     * Indicate that the serialization has ended with an error.
     *
     * This function consumes `error`.
     * @param error a `GError`
     */
    returnError(error: GLib.Error): void
    /**
     * Indicate that the serialization has been successfully completed.
     */
    returnSuccess(): void
    /**
     * Associate data with the current serialization operation.
     * @param data data to associate with this operation
     * @param notify destroy notify for `data`
     */
    setTaskData(data: any | null, notify: GLib.DestroyNotify): void

    // Class property signals of Gdk-4.0.Gdk.ContentSerializer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkContentSerializer` is used to serialize content for
   * inter-application data transfers.
   *
   * The `GdkContentSerializer` transforms an object that is identified
   * by a GType into a serialized form (i.e. a byte stream) that is
   * identified by a mime type.
   *
   * GTK provides serializers and deserializers for common data types
   * such as text, colors, images or file lists. To register your own
   * serialization functions, use [func`Gdk`.content_register_serializer].
   *
   * Also see [class`Gdk`.ContentDeserializer].
   * @class
   */
  class ContentSerializer extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.ContentSerializer

    static name: string

    // Constructors of Gdk-4.0.Gdk.ContentSerializer

    constructor(config?: ContentSerializer.ConstructorProperties)
    _init(config?: ContentSerializer.ConstructorProperties): void
  }

  interface CrossingEvent {
    // Owm methods of Gdk-4.0.Gdk.CrossingEvent

    /**
     * Extracts the notify detail from a crossing event.
     * @returns the notify detail of @event
     */
    getDetail(): NotifyType
    /**
     * Checks if the `event` surface is the focus surface.
     * @returns %TRUE if the surface is the focus surface
     */
    getFocus(): boolean
    /**
     * Extracts the crossing mode from a crossing event.
     * @returns the mode of @event
     */
    getMode(): CrossingMode
  }

  /**
   * An event caused by a pointing device moving between surfaces.
   * @class
   */
  class CrossingEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.CrossingEvent

    static name: string
  }

  module Cursor {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Cursor

      /**
       * Cursor to fall back to if this cursor cannot be displayed.
       */
      fallback?: Cursor | null
      /**
       * X position of the cursor hotspot in the cursor image.
       */
      hotspot_x?: number | null
      /**
       * Y position of the cursor hotspot in the cursor image.
       */
      hotspot_y?: number | null
      /**
       * Name of this this cursor.
       *
       * The name will be %NULL if the cursor was created from a texture.
       */
      name?: string | null
      /**
       * The texture displayed by this cursor.
       *
       * The texture will be %NULL if the cursor was created from a name.
       */
      texture?: Texture | null
    }
  }

  interface Cursor {
    // Own properties of Gdk-4.0.Gdk.Cursor

    /**
     * Cursor to fall back to if this cursor cannot be displayed.
     */
    readonly fallback: Cursor
    /**
     * X position of the cursor hotspot in the cursor image.
     */
    readonly hotspotX: number
    /**
     * Y position of the cursor hotspot in the cursor image.
     */
    readonly hotspotY: number
    /**
     * Name of this this cursor.
     *
     * The name will be %NULL if the cursor was created from a texture.
     */
    readonly name: string | null
    /**
     * The texture displayed by this cursor.
     *
     * The texture will be %NULL if the cursor was created from a name.
     */
    readonly texture: Texture
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Cursor

    /**
     * Returns the fallback for this `cursor`.
     *
     * The fallback will be used if this cursor is not available on a given
     * `GdkDisplay`. For named cursors, this can happen when using nonstandard
     * names or when using an incomplete cursor theme. For textured cursors,
     * this can happen when the texture is too large or when the `GdkDisplay`
     * it is used on does not support textured cursors.
     * @returns the fallback of the cursor or %NULL   to use the default cursor as fallback
     */
    getFallback(): Cursor | null
    /**
     * Returns the horizontal offset of the hotspot.
     *
     * The hotspot indicates the pixel that will be directly above the cursor.
     *
     * Note that named cursors may have a nonzero hotspot, but this function
     * will only return the hotspot position for cursors created with
     * [ctor`Gdk`.Cursor.new_from_texture].
     * @returns the horizontal offset of the hotspot or 0 for named cursors
     */
    getHotspotX(): number
    /**
     * Returns the vertical offset of the hotspot.
     *
     * The hotspot indicates the pixel that will be directly above the cursor.
     *
     * Note that named cursors may have a nonzero hotspot, but this function
     * will only return the hotspot position for cursors created with
     * [ctor`Gdk`.Cursor.new_from_texture].
     * @returns the vertical offset of the hotspot or 0 for named cursors
     */
    getHotspotY(): number
    /**
     * Returns the name of the cursor.
     *
     * If the cursor is not a named cursor, %NULL will be returned.
     * @returns the name of the cursor or %NULL   if it is not a named cursor
     */
    getName(): string | null
    /**
     * Returns the texture for the cursor.
     *
     * If the cursor is a named cursor, %NULL will be returned.
     * @returns the texture for cursor or %NULL   if it is a named cursor
     */
    getTexture(): Texture | null

    // Class property signals of Gdk-4.0.Gdk.Cursor

    connect(
      sigName: "notify::fallback",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fallback",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fallback", ...args: any[]): void
    connect(
      sigName: "notify::hotspot-x",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hotspot-x",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hotspot-x",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hotspot-x",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hotspot-x", ...args: any[]): void
    connect(
      sigName: "notify::hotspot-y",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hotspot-y",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hotspot-y",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hotspot-y",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hotspot-y", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::texture",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::texture",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::texture",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::texture",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::texture", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkCursor` is used to create and destroy cursors.
   *
   * Cursors are immutable objects, so once you created them, there is no way
   * to modify them later. You should create a new cursor when you want to change
   * something about it.
   *
   * Cursors by themselves are not very interesting: they must be bound to a
   * window for users to see them. This is done with [method`Gdk`.Surface.set_cursor]
   * or [method`Gdk`.Surface.set_device_cursor]. Applications will typically
   * use higher-level GTK functions such as [gtk_widget_set_cursor()](../gtk4/method.Widget.set_cursor.html)
   * instead.
   *
   * Cursors are not bound to a given [class`Gdk`.Display], so they can be shared.
   * However, the appearance of cursors may vary when used on different
   * platforms.
   *
   * ## Named and texture cursors
   *
   * There are multiple ways to create cursors. The platform's own cursors
   * can be created with [ctor`Gdk`.Cursor.new_from_name]. That function lists
   * the commonly available names that are shared with the CSS specification.
   * Other names may be available, depending on the platform in use. On some
   * platforms, what images are used for named cursors may be influenced by
   * the cursor theme.
   *
   * Another option to create a cursor is to use [ctor`Gdk`.Cursor.new_from_texture]
   * and provide an image to use for the cursor.
   *
   * To ease work with unsupported cursors, a fallback cursor can be provided.
   * If a [class`Gdk`.Surface] cannot use a cursor because of the reasons mentioned
   * above, it will try the fallback cursor. Fallback cursors can themselves have
   * fallback cursors again, so it is possible to provide a chain of progressively
   * easier to support cursors. If none of the provided cursors can be supported,
   * the default cursor will be the ultimate fallback.
   * @class
   */
  class Cursor extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Cursor

    static name: string

    // Constructors of Gdk-4.0.Gdk.Cursor

    constructor(config?: Cursor.ConstructorProperties)
    /**
     * Creates a new cursor by looking up `name` in the current cursor
     * theme.
     *
     * A recommended set of cursor names that will work across different
     * platforms can be found in the CSS specification:
     *
     * | | | | |
     * | --- | --- | ---- | --- |
     * | "none" | ![](default_cursor.png) "default" | ![](help_cursor.png) "help" | ![](pointer_cursor.png) "pointer" |
     * | ![](context_menu_cursor.png) "context-menu" | ![](progress_cursor.png) "progress" | ![](wait_cursor.png) "wait" | ![](cell_cursor.png) "cell" |
     * | ![](crosshair_cursor.png) "crosshair" | ![](text_cursor.png) "text" | ![](vertical_text_cursor.png) "vertical-text" | ![](alias_cursor.png) "alias" |
     * | ![](copy_cursor.png) "copy" | ![](no_drop_cursor.png) "no-drop" | ![](move_cursor.png) "move" | ![](not_allowed_cursor.png) "not-allowed" |
     * | ![](grab_cursor.png) "grab" | ![](grabbing_cursor.png) "grabbing" | ![](all_scroll_cursor.png) "all-scroll" | ![](col_resize_cursor.png) "col-resize" |
     * | ![](row_resize_cursor.png) "row-resize" | ![](n_resize_cursor.png) "n-resize" | ![](e_resize_cursor.png) "e-resize" | ![](s_resize_cursor.png) "s-resize" |
     * | ![](w_resize_cursor.png) "w-resize" | ![](ne_resize_cursor.png) "ne-resize" | ![](nw_resize_cursor.png) "nw-resize" | ![](sw_resize_cursor.png) "sw-resize" |
     * | ![](se_resize_cursor.png) "se-resize" | ![](ew_resize_cursor.png) "ew-resize" | ![](ns_resize_cursor.png) "ns-resize" | ![](nesw_resize_cursor.png) "nesw-resize" |
     * | ![](nwse_resize_cursor.png) "nwse-resize" | ![](zoom_in_cursor.png) "zoom-in" | ![](zoom_out_cursor.png) "zoom-out" | |
     * @constructor
     * @param name the name of the cursor
     * @param fallback %NULL or the `GdkCursor` to fall back to when   this one cannot be supported
     * @returns a new `GdkCursor`, or %NULL if there is no   cursor with the given name
     */
    static newFromName(name: string, fallback: Cursor | null): Cursor
    /**
     * Creates a new cursor from a `GdkTexture`.
     * @constructor
     * @param texture the texture providing the pixel data
     * @param hotspotX the horizontal offset of the “hotspot” of the cursor
     * @param hotspotY the vertical offset of the “hotspot” of the cursor
     * @param fallback the `GdkCursor` to fall back to when   this one cannot be supported
     * @returns a new `GdkCursor`
     */
    static newFromTexture(
      texture: Texture,
      hotspotX: number,
      hotspotY: number,
      fallback: Cursor | null
    ): Cursor
    _init(config?: Cursor.ConstructorProperties): void
  }

  interface DNDEvent {
    // Owm methods of Gdk-4.0.Gdk.DNDEvent

    /**
     * Gets the `GdkDrop` object from a DND event.
     * @returns the drop
     */
    getDrop(): Drop | null
  }

  /**
   * An event related to drag and drop operations.
   * @class
   */
  class DNDEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.DNDEvent

    static name: string
  }

  interface DeleteEvent {}

  /**
   * An event related to closing a top-level surface.
   * @class
   */
  class DeleteEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.DeleteEvent

    static name: string
  }

  module Device {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `tool-changed`
     */
    interface ToolChangedSignalCallback {
      (tool: DeviceTool): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Device

      /**
       * The `GdkDisplay` the `GdkDevice` pertains to.
       */
      display?: Display | null
      /**
       * Whether the device is represented by a cursor on the screen.
       */
      has_cursor?: boolean | null
      /**
       * The device name.
       */
      name?: string | null
      /**
       * The maximal number of concurrent touches on a touch device.
       *
       * Will be 0 if the device is not a touch device or if the number
       * of touches is unknown.
       */
      num_touches?: number | null
      /**
       * Product ID of this device.
       *
       * See [method`Gdk`.Device.get_product_id].
       */
      product_id?: string | null
      /**
       * `GdkSeat` of this device.
       */
      seat?: Seat | null
      /**
       * Source type for the device.
       */
      source?: InputSource | null
      /**
       * Vendor ID of this device.
       *
       * See [method`Gdk`.Device.get_vendor_id].
       */
      vendor_id?: string | null
    }
  }

  interface Device {
    // Own properties of Gdk-4.0.Gdk.Device

    /**
     * Whether Caps Lock is on.
     *
     * This is only relevant for keyboard devices.
     */
    readonly capsLockState: boolean
    /**
     * The direction of the current layout.
     *
     * This is only relevant for keyboard devices.
     */
    readonly direction: Pango.Direction
    /**
     * The `GdkDisplay` the `GdkDevice` pertains to.
     */
    readonly display: Display
    /**
     * Whether the device has both right-to-left and left-to-right layouts.
     *
     * This is only relevant for keyboard devices.
     */
    readonly hasBidiLayouts: boolean
    /**
     * Whether the device is represented by a cursor on the screen.
     */
    readonly hasCursor: boolean
    /**
     * The current modifier state of the device.
     *
     * This is only relevant for keyboard devices.
     */
    readonly modifierState: ModifierType
    /**
     * Number of axes in the device.
     */
    readonly nAxes: number
    /**
     * The device name.
     */
    readonly name: string | null
    /**
     * Whether Num Lock is on.
     *
     * This is only relevant for keyboard devices.
     */
    readonly numLockState: boolean
    /**
     * The maximal number of concurrent touches on a touch device.
     *
     * Will be 0 if the device is not a touch device or if the number
     * of touches is unknown.
     */
    readonly numTouches: number
    /**
     * Product ID of this device.
     *
     * See [method`Gdk`.Device.get_product_id].
     */
    readonly productId: string | null
    /**
     * Whether Scroll Lock is on.
     *
     * This is only relevant for keyboard devices.
     */
    readonly scrollLockState: boolean
    /**
     * `GdkSeat` of this device.
     */
    seat: Seat
    /**
     * Source type for the device.
     */
    readonly source: InputSource
    /**
     * The `GdkDeviceTool` that is currently used with this device.
     */
    readonly tool: DeviceTool
    /**
     * Vendor ID of this device.
     *
     * See [method`Gdk`.Device.get_vendor_id].
     */
    readonly vendorId: string | null
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Device

    /**
     * Retrieves whether the Caps Lock modifier of the keyboard is locked.
     *
     * This is only relevant for keyboard devices.
     * @returns %TRUE if Caps Lock is on for @device
     */
    getCapsLockState(): boolean
    /**
     * Retrieves the current tool for `device`.
     * @returns the `GdkDeviceTool`
     */
    getDeviceTool(): DeviceTool | null
    /**
     * Returns the direction of effective layout of the keyboard.
     *
     * This is only relevant for keyboard devices.
     *
     * The direction of a layout is the direction of the majority
     * of its symbols. See [func`Pango`.unichar_direction].
     * @returns %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL   if it can determine the direction. %PANGO_DIRECTION_NEUTRAL   otherwise
     */
    getDirection(): Pango.Direction
    /**
     * Returns the `GdkDisplay` to which `device` pertains.
     * @returns a `GdkDisplay`
     */
    getDisplay(): Display
    /**
     * Determines whether the pointer follows device motion.
     *
     * This is not meaningful for keyboard devices, which
     * don't have a pointer.
     * @returns %TRUE if the pointer follows device motion
     */
    getHasCursor(): boolean
    /**
     * Retrieves the current modifier state of the keyboard.
     *
     * This is only relevant for keyboard devices.
     * @returns the current modifier state
     */
    getModifierState(): ModifierType
    /**
     * The name of the device, suitable for showing in a user interface.
     * @returns a name
     */
    getName(): string
    /**
     * Retrieves whether the Num Lock modifier of the keyboard is locked.
     *
     * This is only relevant for keyboard devices.
     * @returns %TRUE if Num Lock is on for @device
     */
    getNumLockState(): boolean
    /**
     * Retrieves the number of touch points associated to `device`.
     * @returns the number of touch points
     */
    getNumTouches(): number
    /**
     * Returns the product ID of this device.
     *
     * This ID is retrieved from the device, and does not change.
     * See [method`Gdk`.Device.get_vendor_id] for more information.
     * @returns the product ID
     */
    getProductId(): string | null
    /**
     * Retrieves whether the Scroll Lock modifier of the keyboard is locked.
     *
     * This is only relevant for keyboard devices.
     * @returns %TRUE if Scroll Lock is on for @device
     */
    getScrollLockState(): boolean
    /**
     * Returns the `GdkSeat` the device belongs to.
     * @returns a `GdkSeat`
     */
    getSeat(): Seat
    /**
     * Determines the type of the device.
     * @returns a `GdkInputSource`
     */
    getSource(): InputSource
    /**
     * Obtains the surface underneath `device,` returning the location of the
     * device in `win_x` and `win_y`.
     *
     * Returns %NULL if the surface tree under `device` is not known to GDK
     * (for example, belongs to another application).
     * @returns the `GdkSurface` under the   device position
     */
    getSurfaceAtPosition(): [
      /* returnType */ Surface | null,
      /* winX */ number,
      /* winY */ number,
    ]
    /**
     * Returns the timestamp of the last activity for this device.
     *
     * In practice, this means the timestamp of the last event that was
     * received from the OS for this device. (GTK may occasionally produce
     * events for a device that are not received from the OS, and will not
     * update the timestamp).
     * @returns the timestamp of the last activity for this device
     */
    getTimestamp(): number
    /**
     * Returns the vendor ID of this device.
     *
     * This ID is retrieved from the device, and does not change.
     *
     * This function, together with [method`Gdk`.Device.get_product_id],
     * can be used to eg. compose `GSettings` paths to store settings
     * for this device.
     *
     * ```c
     *  static GSettings *
     *  get_device_settings (GdkDevice *device)
     *  {
     *    const char *vendor, *product;
     *    GSettings *settings;
     *    GdkDevice *device;
     *    char *path;
     *
     *    vendor = gdk_device_get_vendor_id (device);
     *    product = gdk_device_get_product_id (device);
     *
     *    path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, product);
     *    settings = g_settings_new_with_path (DEVICE_SCHEMA, path);
     *    g_free (path);
     *
     *    return settings;
     *  }
     * ```
     * @returns the vendor ID
     */
    getVendorId(): string | null

    // Own signals of Gdk-4.0.Gdk.Device

    connect(sigName: "changed", callback: Device.ChangedSignalCallback): number
    on(
      sigName: "changed",
      callback: Device.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Device.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Device.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "tool-changed",
      callback: Device.ToolChangedSignalCallback
    ): number
    on(
      sigName: "tool-changed",
      callback: Device.ToolChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "tool-changed",
      callback: Device.ToolChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "tool-changed",
      callback: Device.ToolChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "tool-changed", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Device

    connect(
      sigName: "notify::caps-lock-state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::caps-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::caps-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::caps-lock-state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::caps-lock-state", ...args: any[]): void
    connect(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::direction", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::has-bidi-layouts",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-bidi-layouts",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-bidi-layouts",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-bidi-layouts",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-bidi-layouts", ...args: any[]): void
    connect(
      sigName: "notify::has-cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-cursor", ...args: any[]): void
    connect(
      sigName: "notify::modifier-state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modifier-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modifier-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modifier-state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modifier-state", ...args: any[]): void
    connect(
      sigName: "notify::n-axes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-axes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-axes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-axes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-axes", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::num-lock-state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::num-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::num-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::num-lock-state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::num-lock-state", ...args: any[]): void
    connect(
      sigName: "notify::num-touches",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::num-touches",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::num-touches",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::num-touches",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::num-touches", ...args: any[]): void
    connect(
      sigName: "notify::product-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::product-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::product-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::product-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::product-id", ...args: any[]): void
    connect(
      sigName: "notify::scroll-lock-state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scroll-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scroll-lock-state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scroll-lock-state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scroll-lock-state", ...args: any[]): void
    connect(sigName: "notify::seat", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::seat",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::seat",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::seat",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::seat", ...args: any[]): void
    connect(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::source", ...args: any[]): void
    connect(sigName: "notify::tool", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tool",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tool",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tool",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tool", ...args: any[]): void
    connect(
      sigName: "notify::vendor-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vendor-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vendor-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vendor-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vendor-id", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GdkDevice` object represents an input device, such
   * as a keyboard, a mouse, or a touchpad.
   *
   * See the [class`Gdk`.Seat] documentation for more information
   * about the various kinds of devices, and their relationships.
   * @interface
   */
  class Device extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Device

    static name: string

    // Constructors of Gdk-4.0.Gdk.Device

    constructor(config?: Device.ConstructorProperties)
    _init(config?: Device.ConstructorProperties): void
  }

  module DeviceTool {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.DeviceTool

      /**
       * The axes of the tool.
       */
      axes?: AxisFlags | null
      /**
       * The hardware ID of the tool.
       */
      hardware_id?: number | null
      /**
       * The serial number of the tool.
       */
      serial?: number | null
      /**
       * The type of the tool.
       */
      tool_type?: DeviceToolType | null
    }
  }

  interface DeviceTool {
    // Own properties of Gdk-4.0.Gdk.DeviceTool

    /**
     * The axes of the tool.
     */
    readonly axes: AxisFlags
    /**
     * The hardware ID of the tool.
     */
    readonly hardwareId: number
    /**
     * The serial number of the tool.
     */
    readonly serial: number
    /**
     * The type of the tool.
     */
    readonly toolType: DeviceToolType
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.DeviceTool

    /**
     * Gets the axes of the tool.
     * @returns the axes of @tool
     */
    getAxes(): AxisFlags
    /**
     * Gets the hardware ID of this tool, or 0 if it's not known.
     *
     * When non-zero, the identifier is unique for the given tool model,
     * meaning that two identical tools will share the same `hardware_id,`
     * but will have different serial numbers (see
     * [method`Gdk`.DeviceTool.get_serial]).
     *
     * This is a more concrete (and device specific) method to identify
     * a `GdkDeviceTool` than [method`Gdk`.DeviceTool.get_tool_type],
     * as a tablet may support multiple devices with the same
     * `GdkDeviceToolType`, but different hardware identifiers.
     * @returns The hardware identifier of this tool.
     */
    getHardwareId(): number
    /**
     * Gets the serial number of this tool.
     *
     * This value can be used to identify a physical tool
     * (eg. a tablet pen) across program executions.
     * @returns The serial ID for this tool
     */
    getSerial(): number
    /**
     * Gets the `GdkDeviceToolType` of the tool.
     * @returns The physical type for this tool. This can be used to   figure out what sort of pen is being used, such as an airbrush   or a pencil.
     */
    getToolType(): DeviceToolType

    // Class property signals of Gdk-4.0.Gdk.DeviceTool

    connect(sigName: "notify::axes", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::axes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::axes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::axes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::axes", ...args: any[]): void
    connect(
      sigName: "notify::hardware-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hardware-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hardware-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hardware-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hardware-id", ...args: any[]): void
    connect(
      sigName: "notify::serial",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::serial",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::serial",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::serial",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::serial", ...args: any[]): void
    connect(
      sigName: "notify::tool-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tool-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tool-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tool-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tool-type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A physical tool associated to a `GdkDevice`.
   * @class
   */
  class DeviceTool extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.DeviceTool

    static name: string

    // Constructors of Gdk-4.0.Gdk.DeviceTool

    constructor(config?: DeviceTool.ConstructorProperties)
    _init(config?: DeviceTool.ConstructorProperties): void
  }

  module Display {
    // Signal callback interfaces

    /**
     * Signal callback interface for `closed`
     */
    interface ClosedSignalCallback {
      (isError: boolean): void
    }

    /**
     * Signal callback interface for `opened`
     */
    interface OpenedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `seat-added`
     */
    interface SeatAddedSignalCallback {
      (seat: Seat): void
    }

    /**
     * Signal callback interface for `seat-removed`
     */
    interface SeatRemovedSignalCallback {
      (seat: Seat): void
    }

    /**
     * Signal callback interface for `setting-changed`
     */
    interface SettingChangedSignalCallback {
      (setting: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Display {
    // Own properties of Gdk-4.0.Gdk.Display

    /**
     * %TRUE if the display properly composites the alpha channel.
     */
    readonly composited: boolean
    /**
     * The dma-buf formats that are supported on this display
     */
    readonly dmabufFormats: DmabufFormats
    /**
     * %TRUE if the display supports input shapes.
     */
    readonly inputShapes: boolean
    /**
     * %TRUE if the display supports an alpha channel.
     */
    readonly rgba: boolean
    /**
     * %TRUE if the display supports extensible frames.
     */
    readonly shadowWidth: boolean
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Display

    /**
     * Emits a short beep on `display`
     */
    beep(): void
    /**
     * Closes the connection to the windowing system for the given display.
     *
     * This cleans up associated resources.
     */
    close(): void
    /**
     * Creates a new `GdkGLContext` for the `GdkDisplay`.
     *
     * The context is disconnected from any particular surface or surface
     * and cannot be used to draw to any surface. It can only be used to
     * draw to non-surface framebuffers like textures.
     *
     * If the creation of the `GdkGLContext` failed, `error` will be set.
     * Before using the returned `GdkGLContext`, you will need to
     * call [method`Gdk`.GLContext.make_current] or [method`Gdk`.GLContext.realize].
     * @returns the newly created `GdkGLContext`
     */
    createGlContext(): GLContext
    /**
     * Returns %TRUE if there is an ongoing grab on `device` for `display`.
     * @param device a `GdkDevice`
     * @returns %TRUE if there is a grab in effect for @device.
     */
    deviceIsGrabbed(device: Device): boolean
    /**
     * Flushes any requests queued for the windowing system.
     *
     * This happens automatically when the main loop blocks waiting for new events,
     * but if your application is drawing without returning control to the main loop,
     * you may need to call this function explicitly. A common case where this function
     * needs to be called is when an application is executing drawing commands
     * from a thread other than the thread where the main loop is running.
     *
     * This is most useful for X11. On windowing systems where requests are
     * handled synchronously, this function will do nothing.
     */
    flush(): void
    /**
     * Returns a `GdkAppLaunchContext` suitable for launching
     * applications on the given display.
     * @returns a new `GdkAppLaunchContext` for @display
     */
    getAppLaunchContext(): AppLaunchContext
    /**
     * Gets the clipboard used for copy/paste operations.
     * @returns the display's clipboard
     */
    getClipboard(): Clipboard
    /**
     * Returns the default `GdkSeat` for this display.
     *
     * Note that a display may not have a seat. In this case,
     * this function will return %NULL.
     * @returns the default seat.
     */
    getDefaultSeat(): Seat | null
    /**
     * Returns the dma-buf formats that are supported on this display.
     *
     * GTK may use OpenGL or Vulkan to support some formats.
     * Calling this function will then initialize them if they aren't yet.
     *
     * The formats returned by this function can be used for negotiating
     * buffer formats with producers such as v4l, pipewire or GStreamer.
     *
     * To learn more about dma-bufs, see [class`Gdk`.DmabufTextureBuilder].
     * @returns a `GdkDmabufFormats` object
     */
    getDmabufFormats(): DmabufFormats
    /**
     * Gets the monitor in which the largest area of `surface`
     * resides.
     * @param surface a `GdkSurface`
     * @returns the monitor with the largest   overlap with @surface
     */
    getMonitorAtSurface(surface: Surface): Monitor | null
    /**
     * Gets the list of monitors associated with this display.
     *
     * Subsequent calls to this function will always return the
     * same list for the same display.
     *
     * You can listen to the GListModel::items-changed signal on
     * this list to monitor changes to the monitor of this display.
     * @returns a `GListModel` of `GdkMonitor`
     */
    getMonitors(): Gio.ListModel
    /**
     * Gets the name of the display.
     * @returns a string representing the display name. This string is owned   by GDK and should not be modified or freed.
     */
    getName(): string
    /**
     * Gets the clipboard used for the primary selection.
     *
     * On backends where the primary clipboard is not supported natively,
     * GDK emulates this clipboard locally.
     * @returns the primary clipboard
     */
    getPrimaryClipboard(): Clipboard
    /**
     * Retrieves a desktop-wide setting such as double-click time
     * for the `display`.
     * @param name the name of the setting
     * @param value location to store the value of the setting
     * @returns %TRUE if the setting existed and a value was stored   in @value, %FALSE otherwise
     */
    getSetting(name: string, value: any): boolean
    /**
     * Gets the startup notification ID for a Wayland display, or %NULL
     * if no ID has been defined.
     * @returns the startup notification ID for @display
     */
    getStartupNotificationId(): string | null
    /**
     * Finds out if the display has been closed.
     * @returns %TRUE if the display is closed.
     */
    isClosed(): boolean
    /**
     * Returns whether surfaces can reasonably be expected to have
     * their alpha channel drawn correctly on the screen.
     *
     * Check [method`Gdk`.Display.is_rgba] for whether the display
     * supports an alpha channel.
     *
     * On X11 this function returns whether a compositing manager is
     * compositing on `display`.
     *
     * On modern displays, this value is always %TRUE.
     * @returns Whether surfaces with RGBA visuals can reasonably   be expected to have their alpha channels drawn correctly   on the screen.
     */
    isComposited(): boolean
    /**
     * Returns whether surfaces on this `display` are created with an
     * alpha channel.
     *
     * Even if a %TRUE is returned, it is possible that the
     * surface’s alpha channel won’t be honored when displaying the
     * surface on the screen: in particular, for X an appropriate
     * windowing manager and compositing manager must be running to
     * provide appropriate display. Use [method`Gdk`.Display.is_composited]
     * to check if that is the case.
     *
     * On modern displays, this value is always %TRUE.
     * @returns %TRUE if surfaces are created with an alpha channel or   %FALSE if the display does not support this functionality.
     */
    isRgba(): boolean
    /**
     * Returns the list of seats known to `display`.
     * @returns the   list of seats known to the `GdkDisplay`
     */
    listSeats(): Seat[]
    /**
     * Returns the keyvals bound to `keycode`.
     *
     * The Nth `GdkKeymapKey` in `keys` is bound to the Nth keyval in `keyvals`.
     *
     * When a keycode is pressed by the user, the keyval from
     * this list of entries is selected by considering the effective
     * keyboard group and level.
     *
     * Free the returned arrays with g_free().
     * @param keycode a keycode
     * @returns %TRUE if there were any entries
     */
    mapKeycode(
      keycode: number
    ): [
      /* returnType */ boolean,
      /* keys */ KeymapKey[],
      /* keyvals */ number[],
    ]
    /**
     * Obtains a list of keycode/group/level combinations that will
     * generate `keyval`.
     *
     * Groups and levels are two kinds of keyboard mode; in general, the level
     * determines whether the top or bottom symbol on a key is used, and the
     * group determines whether the left or right symbol is used.
     *
     * On US keyboards, the shift key changes the keyboard level, and there
     * are no groups. A group switch key might convert a keyboard between
     * Hebrew to English modes, for example.
     *
     * `GdkEventKey` contains a %group field that indicates the active
     * keyboard group. The level is computed from the modifier mask.
     *
     * The returned array should be freed with g_free().
     * @param keyval a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc.
     * @returns %TRUE if keys were found and returned
     */
    mapKeyval(
      keyval: number
    ): [/* returnType */ boolean, /* keys */ KeymapKey[]]
    /**
     * Indicates to the GUI environment that the application has
     * finished loading, using a given identifier.
     *
     * GTK will call this function automatically for [GtkWindow](../gtk4/class.Window.html)
     * with custom startup-notification identifier unless
     * [gtk_window_set_auto_startup_notification()](../gtk4/method.Window.set_auto_startup_notification.html)
     * is called to disable that feature.
     * @param startupId a startup-notification identifier, for which   notification process should be completed
     */
    notifyStartupComplete(startupId: string): void
    /**
     * Checks that OpenGL is available for `self` and ensures that it is
     * properly initialized.
     * When this fails, an `error` will be set describing the error and this
     * function returns %FALSE.
     *
     * Note that even if this function succeeds, creating a `GdkGLContext`
     * may still fail.
     *
     * This function is idempotent. Calling it multiple times will just
     * return the same value or error.
     *
     * You never need to call this function, GDK will call it automatically
     * as needed. But you can use it as a check when setting up code that
     * might make use of OpenGL.
     * @returns %TRUE if the display supports OpenGL
     */
    prepareGl(): boolean
    /**
     * Adds the given event to the event queue for `display`.
     * @param event a `GdkEvent`
     */
    putEvent(event: Event): void
    /**
     * Returns %TRUE if the display supports input shapes.
     *
     * This means that [method`Gdk`.Surface.set_input_region] can
     * be used to modify the input shape of surfaces on `display`.
     *
     * On modern displays, this value is always %TRUE.
     * @returns %TRUE if surfaces with modified input shape are supported
     */
    supportsInputShapes(): boolean
    /**
     * Returns whether it's possible for a surface to draw outside of the window area.
     *
     * If %TRUE is returned the application decides if it wants to draw shadows.
     * If %FALSE is returned, the compositor decides if it wants to draw shadows.
     * @returns %TRUE if surfaces can draw shadows or   %FALSE if the display does not support this functionality.
     */
    supportsShadowWidth(): boolean
    /**
     * Flushes any requests queued for the windowing system and waits until all
     * requests have been handled.
     *
     * This is often used for making sure that the display is synchronized
     * with the current state of the program. Calling [method`Gdk`.Display.sync]
     * before [method`GdkX1`1.Display.error_trap_pop] makes sure that any errors
     * generated from earlier requests are handled before the error trap is removed.
     *
     * This is most useful for X11. On windowing systems where requests are
     * handled synchronously, this function will do nothing.
     */
    sync(): void
    /**
     * Translates the contents of a `GdkEventKey` into a keyval, effective group,
     * and level.
     *
     * Modifiers that affected the translation and are thus unavailable for
     * application use are returned in `consumed_modifiers`.
     *
     * The `effective_group` is the group that was actually used for the
     * translation; some keys such as Enter are not affected by the active
     * keyboard group. The `level` is derived from `state`.
     *
     * `consumed_modifiers` gives modifiers that should be masked out
     * from `state` when comparing this key press to a keyboard shortcut.
     * For instance, on a US keyboard, the `plus` symbol is shifted, so
     * when comparing a key press to a `<Control>plus` accelerator `<Shift>`
     * should be masked out.
     *
     * This function should rarely be needed, since `GdkEventKey` already
     * contains the translated keyval. It is exported for the benefit of
     * virtualized test environments.
     * @param keycode a keycode
     * @param state a modifier state
     * @param group active keyboard group
     * @returns %TRUE if there was a keyval bound to keycode/state/group.
     */
    translateKey(
      keycode: number,
      state: ModifierType,
      group: number
    ): [
      /* returnType */ boolean,
      /* keyval */ number,
      /* effectiveGroup */ number,
      /* level */ number,
      /* consumed */ ModifierType,
    ]

    // Own signals of Gdk-4.0.Gdk.Display

    connect(sigName: "closed", callback: Display.ClosedSignalCallback): number
    on(
      sigName: "closed",
      callback: Display.ClosedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "closed",
      callback: Display.ClosedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "closed",
      callback: Display.ClosedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "closed", ...args: any[]): void
    connect(sigName: "opened", callback: Display.OpenedSignalCallback): number
    on(
      sigName: "opened",
      callback: Display.OpenedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "opened",
      callback: Display.OpenedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "opened",
      callback: Display.OpenedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "opened", ...args: any[]): void
    connect(
      sigName: "seat-added",
      callback: Display.SeatAddedSignalCallback
    ): number
    on(
      sigName: "seat-added",
      callback: Display.SeatAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "seat-added",
      callback: Display.SeatAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "seat-added",
      callback: Display.SeatAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "seat-added", ...args: any[]): void
    connect(
      sigName: "seat-removed",
      callback: Display.SeatRemovedSignalCallback
    ): number
    on(
      sigName: "seat-removed",
      callback: Display.SeatRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "seat-removed",
      callback: Display.SeatRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "seat-removed",
      callback: Display.SeatRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "seat-removed", ...args: any[]): void
    connect(
      sigName: "setting-changed",
      callback: Display.SettingChangedSignalCallback
    ): number
    on(
      sigName: "setting-changed",
      callback: Display.SettingChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "setting-changed",
      callback: Display.SettingChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "setting-changed",
      callback: Display.SettingChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "setting-changed", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Display

    connect(
      sigName: "notify::composited",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::composited",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::composited",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::composited",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::composited", ...args: any[]): void
    connect(
      sigName: "notify::dmabuf-formats",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::dmabuf-formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::dmabuf-formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::dmabuf-formats",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::dmabuf-formats", ...args: any[]): void
    connect(
      sigName: "notify::input-shapes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-shapes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-shapes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-shapes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-shapes", ...args: any[]): void
    connect(sigName: "notify::rgba", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rgba", ...args: any[]): void
    connect(
      sigName: "notify::shadow-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shadow-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shadow-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shadow-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shadow-width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkDisplay` objects are the GDK representation of a workstation.
   *
   * Their purpose are two-fold:
   *
   * - To manage and provide information about input devices (pointers, keyboards, etc)
   * - To manage and provide information about output devices (monitors, projectors, etc)
   *
   * Most of the input device handling has been factored out into separate
   * [class`Gdk`.Seat] objects. Every display has a one or more seats, which
   * can be accessed with [method`Gdk`.Display.get_default_seat] and
   * [method`Gdk`.Display.list_seats].
   *
   * Output devices are represented by [class`Gdk`.Monitor] objects, which can
   * be accessed with [method`Gdk`.Display.get_monitor_at_surface] and similar APIs.
   * @class
   */
  class Display extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Display

    static name: string

    // Constructors of Gdk-4.0.Gdk.Display

    constructor(config?: Display.ConstructorProperties)
    _init(config?: Display.ConstructorProperties): void
    /**
     * Gets the default `GdkDisplay`.
     *
     * This is a convenience function for:
     *
     *     gdk_display_manager_get_default_display (gdk_display_manager_get ())
     * @returns a `GdkDisplay`, or %NULL if   there is no default display
     */
    static getDefault(): Display | null
    /**
     * Opens a display.
     *
     * If opening the display fails, `NULL` is returned.
     * @param displayName the name of the display to open
     * @returns a `GdkDisplay`
     */
    static open(displayName: string | null): Display | null
  }

  module DisplayManager {
    // Signal callback interfaces

    /**
     * Signal callback interface for `display-opened`
     */
    interface DisplayOpenedSignalCallback {
      (display: Display): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.DisplayManager

      /**
       * The default display.
       */
      default_display?: Display | null
    }
  }

  interface DisplayManager {
    // Own properties of Gdk-4.0.Gdk.DisplayManager

    /**
     * The default display.
     */
    defaultDisplay: Display
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.DisplayManager

    /**
     * Gets the default `GdkDisplay`.
     * @returns a `GdkDisplay`
     */
    getDefaultDisplay(): Display | null
    /**
     * List all currently open displays.
     * @returns a newly   allocated `GSList` of `GdkDisplay` objects
     */
    listDisplays(): Display[]
    /**
     * Opens a display.
     * @param name the name of the display to open
     * @returns a `GdkDisplay`, or %NULL   if the display could not be opened
     */
    openDisplay(name: string | null): Display | null
    /**
     * Sets `display` as the default display.
     * @param display a `GdkDisplay`
     */
    setDefaultDisplay(display: Display): void

    // Own signals of Gdk-4.0.Gdk.DisplayManager

    connect(
      sigName: "display-opened",
      callback: DisplayManager.DisplayOpenedSignalCallback
    ): number
    on(
      sigName: "display-opened",
      callback: DisplayManager.DisplayOpenedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "display-opened",
      callback: DisplayManager.DisplayOpenedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "display-opened",
      callback: DisplayManager.DisplayOpenedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "display-opened", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.DisplayManager

    connect(
      sigName: "notify::default-display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-display", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A singleton object that offers notification when displays appear or
   * disappear.
   *
   * You can use [func`Gdk`.DisplayManager.get] to obtain the `GdkDisplayManager`
   * singleton, but that should be rarely necessary. Typically, initializing
   * GTK opens a display that you can work with without ever accessing the
   * `GdkDisplayManager`.
   *
   * The GDK library can be built with support for multiple backends.
   * The `GdkDisplayManager` object determines which backend is used
   * at runtime.
   *
   * In the rare case that you need to influence which of the backends
   * is being used, you can use [func`Gdk`.set_allowed_backends]. Note
   * that you need to call this function before initializing GTK.
   *
   * ## Backend-specific code
   *
   * When writing backend-specific code that is supposed to work with
   * multiple GDK backends, you have to consider both compile time and
   * runtime. At compile time, use the `GDK_WINDOWING_X11`, `GDK_WINDOWING_WIN32`
   * macros, etc. to find out which backends are present in the GDK library
   * you are building your application against. At runtime, use type-check
   * macros like GDK_IS_X11_DISPLAY() to find out which backend is in use:
   *
   * ```c
   * #ifdef GDK_WINDOWING_X11
   *   if (GDK_IS_X11_DISPLAY (display))
   *     {
   *       // make X11-specific calls here
   *     }
   *   else
   * #endif
   * #ifdef GDK_WINDOWING_MACOS
   *   if (GDK_IS_MACOS_DISPLAY (display))
   *     {
   *       // make Quartz-specific calls here
   *     }
   *   else
   * #endif
   *   g_error ("Unsupported GDK backend");
   * ```
   * @class
   */
  class DisplayManager extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.DisplayManager

    static name: string

    // Constructors of Gdk-4.0.Gdk.DisplayManager

    constructor(config?: DisplayManager.ConstructorProperties)
    _init(config?: DisplayManager.ConstructorProperties): void
    /**
     * Gets the singleton `GdkDisplayManager` object.
     *
     * When called for the first time, this function consults the
     * `GDK_BACKEND` environment variable to find out which of the
     * supported GDK backends to use (in case GDK has been compiled
     * with multiple backends).
     *
     * Applications can use [func`set_allowed_backends]` to limit what
     * backends will be used.
     * @returns The global `GdkDisplayManager` singleton
     */
    static get(): DisplayManager
  }

  module DmabufTexture {
    // Constructor properties interface

    interface ConstructorProperties
      extends Paintable.ConstructorProperties,
        Gio.Icon.ConstructorProperties,
        Gio.LoadableIcon.ConstructorProperties,
        Texture.ConstructorProperties {}
  }

  interface DmabufTexture extends Paintable, Gio.Icon, Gio.LoadableIcon {
    // Own properties of Gdk-4.0.Gdk.DmabufTexture

    __gtype__: number

    // Class property signals of Gdk-4.0.Gdk.DmabufTexture

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkTexture` representing a DMA buffer.
   *
   * To create a `GdkDmabufTexture`, use the auxiliary
   * [class`Gdk`.DmabufTextureBuilder] object.
   *
   * Dma-buf textures can only be created on Linux.
   * @class
   */
  class DmabufTexture extends Texture {
    // Own properties of Gdk-4.0.Gdk.DmabufTexture

    static name: string

    // Constructors of Gdk-4.0.Gdk.DmabufTexture

    constructor(config?: DmabufTexture.ConstructorProperties)
    _init(config?: DmabufTexture.ConstructorProperties): void
  }

  module DmabufTextureBuilder {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.DmabufTextureBuilder

      /**
       * The display that this texture will be used on.
       */
      display?: Display | null
      /**
       * The format of the texture, as a fourcc value.
       */
      fourcc?: number | null
      /**
       * The height of the texture.
       */
      height?: number | null
      /**
       * The modifier.
       */
      modifier?: number | null
      /**
       * The number of planes of the texture.
       *
       * Note that you can set properties for other planes,
       * but they will be ignored when constructing the texture.
       */
      n_planes?: number | null
      /**
       * Whether the alpha channel is premultiplied into the others.
       *
       * Only relevant if the format has alpha.
       */
      premultiplied?: boolean | null
      /**
       * The update region for [property`Gdk`.GLTextureBuilder:update-texture].
       */
      update_region?: cairo.Region | null
      /**
       * The texture [property`Gdk`.DmabufTextureBuilder:update-region] is an update for.
       */
      update_texture?: Texture | null
      /**
       * The width of the texture.
       */
      width?: number | null
    }
  }

  interface DmabufTextureBuilder {
    // Own properties of Gdk-4.0.Gdk.DmabufTextureBuilder

    /**
     * The display that this texture will be used on.
     */
    display: Display
    /**
     * The format of the texture, as a fourcc value.
     */
    fourcc: number
    /**
     * The height of the texture.
     */
    height: number
    /**
     * The modifier.
     */
    modifier: number
    /**
     * The number of planes of the texture.
     *
     * Note that you can set properties for other planes,
     * but they will be ignored when constructing the texture.
     */
    nPlanes: number
    /**
     * Whether the alpha channel is premultiplied into the others.
     *
     * Only relevant if the format has alpha.
     */
    premultiplied: boolean
    /**
     * The update region for [property`Gdk`.GLTextureBuilder:update-texture].
     */
    updateRegion: cairo.Region
    /**
     * The texture [property`Gdk`.DmabufTextureBuilder:update-region] is an update for.
     */
    updateTexture: Texture
    /**
     * The width of the texture.
     */
    width: number
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.DmabufTextureBuilder

    /**
     * Builds a new `GdkTexture` with the values set up in the builder.
     *
     * It is a programming error to call this function if any mandatory
     * property has not been set.
     *
     * If the dmabuf is not supported by GTK, %NULL will be returned and `error` will be set.
     *
     * The `destroy` function gets called when the returned texture gets released.
     *
     * It is possible to call this function multiple times to create multiple textures,
     * possibly with changing properties in between.
     *
     * It is the responsibility of the caller to keep the file descriptors for the planes
     * open until the created texture is no longer used, and close them afterwards (possibly
     * using the `destroy` notify).
     *
     * Not all formats defined in the `drm_fourcc.h` header are supported. You can use
     * [method`Gdk`.Display.get_dmabuf_formats] to get a list of supported formats.
     * @param destroy destroy function to be called when the texture is   released
     * @param data user data to pass to the destroy function
     * @returns a newly built `GdkTexture` or `NULL`   if the format is not supported
     */
    build(destroy: GLib.DestroyNotify | null, data: any | null): Texture | null
    /**
     * Returns the display that this texture builder is
     * associated with.
     * @returns the display
     */
    getDisplay(): Display
    /**
     * Gets the file descriptor for a plane.
     * @param plane the plane to get the fd for
     * @returns the file descriptor
     */
    getFd(plane: number): number
    /**
     * Gets the format previously set via gdk_dmabuf_texture_builder_set_fourcc()
     * or 0 if the format wasn't set.
     *
     * The format is specified as a fourcc code.
     * @returns The format
     */
    getFourcc(): number
    /**
     * Gets the height previously set via gdk_dmabuf_texture_builder_set_height() or
     * 0 if the height wasn't set.
     * @returns The height
     */
    getHeight(): number
    /**
     * Gets the modifier value.
     * @returns the modifier
     */
    getModifier(): number
    /**
     * Gets the number of planes.
     * @returns The number of planes
     */
    getNPlanes(): number
    /**
     * Gets the offset value for a plane.
     * @param plane the plane to get the offset for
     * @returns the offset
     */
    getOffset(plane: number): number
    /**
     * Whether the data is premultiplied.
     * @returns whether the data is premultiplied
     */
    getPremultiplied(): boolean
    /**
     * Gets the stride value for a plane.
     * @param plane the plane to get the stride for
     * @returns the stride
     */
    getStride(plane: number): number
    /**
     * Gets the region previously set via gdk_dmabuf_texture_builder_set_update_region() or
     * %NULL if none was set.
     * @returns The region
     */
    getUpdateRegion(): cairo.Region | null
    /**
     * Gets the texture previously set via gdk_dmabuf_texture_builder_set_update_texture() or
     * %NULL if none was set.
     * @returns The texture
     */
    getUpdateTexture(): Texture | null
    /**
     * Gets the width previously set via gdk_dmabuf_texture_builder_set_width() or
     * 0 if the width wasn't set.
     * @returns The width
     */
    getWidth(): number
    /**
     * Sets the display that this texture builder is
     * associated with.
     *
     * The display is used to determine the supported
     * dma-buf formats.
     * @param display the display
     */
    setDisplay(display: Display): void
    /**
     * Sets the file descriptor for a plane.
     * @param plane the plane to set the fd for
     * @param fd the file descriptor
     */
    setFd(plane: number, fd: number): void
    /**
     * Sets the format of the texture.
     *
     * The format is specified as a fourcc code.
     *
     * The format must be set before calling [method`Gdk`.GLTextureBuilder.build].
     * @param fourcc the texture's format or 0 to unset
     */
    setFourcc(fourcc: number): void
    /**
     * Sets the height of the texture.
     *
     * The height must be set before calling [method`Gdk`.GLTextureBuilder.build].
     * @param height the texture's height or 0 to unset
     */
    setHeight(height: number): void
    /**
     * Sets the modifier.
     * @param modifier the modifier value
     */
    setModifier(modifier: number): void
    /**
     * Sets the number of planes of the texture.
     * @param nPlanes the number of planes
     */
    setNPlanes(nPlanes: number): void
    /**
     * Sets the offset for a plane.
     * @param plane the plane to set the offset for
     * @param offset the offset value
     */
    setOffset(plane: number, offset: number): void
    /**
     * Sets whether the data is premultiplied.
     *
     * Unless otherwise specified, all formats including alpha channels are assumed
     * to be premultiplied.
     * @param premultiplied whether the data is premultiplied
     */
    setPremultiplied(premultiplied: boolean): void
    /**
     * Sets the stride for a plane.
     *
     * The stride must be set for all planes before calling [method`Gdk`.GLTextureBuilder.build].
     * @param plane the plane to set the stride for
     * @param stride the stride value
     */
    setStride(plane: number, stride: number): void
    /**
     * Sets the region to be updated by this texture. Together with
     * [property`Gdk`.DmabufTextureBuilder:update-texture] this describes an
     * update of a previous texture.
     *
     * When rendering animations of large textures, it is possible that
     * consecutive textures are only updating contents in parts of the texture.
     * It is then possible to describe this update via these two properties,
     * so that GTK can avoid rerendering parts that did not change.
     *
     * An example would be a screen recording where only the mouse pointer moves.
     * @param region the region to update
     */
    setUpdateRegion(region: cairo.Region | null): void
    /**
     * Sets the texture to be updated by this texture. See
     * [method`Gdk`.DmabufTextureBuilder.set_update_region] for an explanation.
     * @param texture the texture to update
     */
    setUpdateTexture(texture: Texture | null): void
    /**
     * Sets the width of the texture.
     *
     * The width must be set before calling [method`Gdk`.GLTextureBuilder.build].
     * @param width The texture's width or 0 to unset
     */
    setWidth(width: number): void

    // Class property signals of Gdk-4.0.Gdk.DmabufTextureBuilder

    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::fourcc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fourcc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fourcc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fourcc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fourcc", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::modifier",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modifier",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modifier",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modifier",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modifier", ...args: any[]): void
    connect(
      sigName: "notify::n-planes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-planes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-planes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-planes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-planes", ...args: any[]): void
    connect(
      sigName: "notify::premultiplied",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::premultiplied",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::premultiplied",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::premultiplied",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::premultiplied", ...args: any[]): void
    connect(
      sigName: "notify::update-region",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::update-region",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::update-region",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::update-region",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::update-region", ...args: any[]): void
    connect(
      sigName: "notify::update-texture",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::update-texture",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::update-texture",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::update-texture",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::update-texture", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkDmabufTextureBuilder` is a builder used to construct [class`Gdk`.Texture]
   * objects from DMA buffers.
   *
   * DMA buffers are commonly called **_dma-bufs_**.
   *
   * DMA buffers are a feature of the Linux kernel to enable efficient buffer and
   * memory sharing between hardware such as codecs, GPUs, displays, cameras and the
   * kernel drivers controlling them. For example, a decoder may want its output to
   * be directly shared with the display server for rendering without a copy.
   *
   * Any device driver which participates in DMA buffer sharing, can do so as either
   * the exporter or importer of buffers (or both).
   *
   * The memory that is shared via DMA buffers is usually stored in non-system memory
   * (maybe in device's local memory or something else not directly accessible by the
   * CPU), and accessing this memory from the CPU may have higher-than-usual overhead.
   *
   * In particular for graphics data, it is not uncommon that data consists of multiple
   * separate blocks of memory, for example one block for each of the red, green and
   * blue channels. These blocks are called **_planes_**. DMA buffers can have up to
   * four planes. Even if the memory is a single block, the data can be organized in
   * multiple planes, by specifying offsets from the beginning of the data.
   *
   * DMA buffers are exposed to user-space as file descriptors allowing to pass them
   * between processes. If a DMA buffer has multiple planes, there is one file
   * descriptor per plane.
   *
   * The format of the data (for graphics data, essentially its colorspace) is described
   * by a 32-bit integer. These format identifiers are defined in the header file `drm_fourcc.h`
   * and commonly referred to as **_fourcc_** values, since they are identified by 4 ASCII
   * characters. Additionally, each DMA buffer has a **_modifier_**, which is a 64-bit integer
   * that describes driver-specific details of the memory layout, such as tiling or compression.
   *
   * For historical reasons, some producers of dma-bufs don't provide an explicit modifier, but
   * instead return `DMA_FORMAT_MOD_INVALID` to indicate that their modifier is **_implicit_**.
   * GTK tries to accommodate this situation by accepting `DMA_FORMAT_MOD_INVALID` as modifier.
   *
   * The operation of `GdkDmabufTextureBuilder` is quite simple: Create a texture builder,
   * set all the necessary properties, and then call [method`Gdk`.DmabufTextureBuilder.build]
   * to create the new texture.
   *
   * The required properties for a dma-buf texture are
   *
   *  * The width and height in pixels
   *
   *  * The `fourcc` code and `modifier` which identify the format and memory layout of the dma-buf
   *
   *  * The file descriptor, offset and stride for each of the planes
   *
   * `GdkDmabufTextureBuilder` can be used for quick one-shot construction of
   * textures as well as kept around and reused to construct multiple textures.
   *
   * For further information, see
   *
   * * The Linux kernel [documentation](https://docs.kernel.org/driver-api/dma-buf.html)
   *
   * * The header file [drm_fourcc.h](https://gitlab.freedesktop.org/mesa/drm/-/blob/main/include/drm/drm_fourcc.h)
   * @class
   */
  class DmabufTextureBuilder extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.DmabufTextureBuilder

    static name: string

    // Constructors of Gdk-4.0.Gdk.DmabufTextureBuilder

    constructor(config?: DmabufTextureBuilder.ConstructorProperties)
    /**
     * Creates a new texture builder.
     * @constructor
     * @returns the new `GdkTextureBuilder`
     */
    constructor()
    /**
     * Creates a new texture builder.
     * @constructor
     * @returns the new `GdkTextureBuilder`
     */
    static new(): DmabufTextureBuilder
    _init(config?: DmabufTextureBuilder.ConstructorProperties): void
  }

  module Drag {
    // Signal callback interfaces

    /**
     * Signal callback interface for `cancel`
     */
    interface CancelSignalCallback {
      (reason: DragCancelReason): void
    }

    /**
     * Signal callback interface for `dnd-finished`
     */
    interface DndFinishedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `drop-performed`
     */
    interface DropPerformedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Drag

      /**
       * The possible actions of this drag.
       */
      actions?: DragAction | null
      /**
       * The `GdkContentProvider`.
       */
      content?: ContentProvider | null
      /**
       * The `GdkDevice` that is performing the drag.
       */
      device?: Device | null
      /**
       * The possible formats that the drag can provide its data in.
       */
      formats?: ContentFormats | null
      /**
       * The currently selected action of the drag.
       */
      selected_action?: DragAction | null
      /**
       * The surface where the drag originates.
       */
      surface?: Surface | null
    }
  }

  interface Drag {
    // Own properties of Gdk-4.0.Gdk.Drag

    /**
     * The possible actions of this drag.
     */
    actions: DragAction
    /**
     * The `GdkContentProvider`.
     */
    readonly content: ContentProvider
    /**
     * The `GdkDevice` that is performing the drag.
     */
    readonly device: Device
    /**
     * The `GdkDisplay` that the drag belongs to.
     */
    readonly display: Display
    /**
     * The possible formats that the drag can provide its data in.
     */
    readonly formats: ContentFormats
    /**
     * The currently selected action of the drag.
     */
    selectedAction: DragAction
    /**
     * The surface where the drag originates.
     */
    readonly surface: Surface
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Drag

    /**
     * Informs GDK that the drop ended.
     *
     * Passing %FALSE for `success` may trigger a drag cancellation
     * animation.
     *
     * This function is called by the drag source, and should be the
     * last call before dropping the reference to the `drag`.
     *
     * The `GdkDrag` will only take the first [method`Gdk`.Drag.drop_done]
     * call as effective, if this function is called multiple times,
     * all subsequent calls will be ignored.
     * @param success whether the drag was ultimatively successful
     */
    dropDone(success: boolean): void
    /**
     * Determines the bitmask of possible actions proposed by the source.
     * @returns the `GdkDragAction` flags
     */
    getActions(): DragAction
    /**
     * Returns the `GdkContentProvider` associated to the `GdkDrag` object.
     * @returns The `GdkContentProvider` associated to @drag.
     */
    getContent(): ContentProvider
    /**
     * Returns the `GdkDevice` associated to the `GdkDrag` object.
     * @returns The `GdkDevice` associated to @drag.
     */
    getDevice(): Device
    /**
     * Gets the `GdkDisplay` that the drag object was created for.
     * @returns a `GdkDisplay`
     */
    getDisplay(): Display
    /**
     * Returns the surface on which the drag icon should be rendered
     * during the drag operation.
     *
     * Note that the surface may not be available until the drag operation
     * has begun. GDK will move the surface in accordance with the ongoing
     * drag operation. The surface is owned by `drag` and will be destroyed
     * when the drag operation is over.
     * @returns the drag surface
     */
    getDragSurface(): Surface | null
    /**
     * Retrieves the formats supported by this `GdkDrag` object.
     * @returns a `GdkContentFormats`
     */
    getFormats(): ContentFormats
    /**
     * Determines the action chosen by the drag destination.
     * @returns a `GdkDragAction` value
     */
    getSelectedAction(): DragAction
    /**
     * Returns the `GdkSurface` where the drag originates.
     * @returns The `GdkSurface` where the drag originates
     */
    getSurface(): Surface
    /**
     * Sets the position of the drag surface that will be kept
     * under the cursor hotspot.
     *
     * Initially, the hotspot is at the top left corner of the drag surface.
     * @param hotX x coordinate of the drag surface hotspot
     * @param hotY y coordinate of the drag surface hotspot
     */
    setHotspot(hotX: number, hotY: number): void

    // Own signals of Gdk-4.0.Gdk.Drag

    connect(sigName: "cancel", callback: Drag.CancelSignalCallback): number
    on(
      sigName: "cancel",
      callback: Drag.CancelSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cancel",
      callback: Drag.CancelSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cancel",
      callback: Drag.CancelSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cancel", ...args: any[]): void
    connect(
      sigName: "dnd-finished",
      callback: Drag.DndFinishedSignalCallback
    ): number
    on(
      sigName: "dnd-finished",
      callback: Drag.DndFinishedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "dnd-finished",
      callback: Drag.DndFinishedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "dnd-finished",
      callback: Drag.DndFinishedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "dnd-finished", ...args: any[]): void
    connect(
      sigName: "drop-performed",
      callback: Drag.DropPerformedSignalCallback
    ): number
    on(
      sigName: "drop-performed",
      callback: Drag.DropPerformedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drop-performed",
      callback: Drag.DropPerformedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drop-performed",
      callback: Drag.DropPerformedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drop-performed", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Drag

    connect(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::actions", ...args: any[]): void
    connect(
      sigName: "notify::content",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content", ...args: any[]): void
    connect(
      sigName: "notify::device",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::device",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::device",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::device",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::device", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::formats", ...args: any[]): void
    connect(
      sigName: "notify::selected-action",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected-action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected-action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected-action",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected-action", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GdkDrag` object represents the source of an ongoing DND operation.
   *
   * A `GdkDrag` is created when a drag is started, and stays alive for duration of
   * the DND operation. After a drag has been started with [func`Gdk`.Drag.begin],
   * the caller gets informed about the status of the ongoing drag operation
   * with signals on the `GdkDrag` object.
   *
   * GTK provides a higher level abstraction based on top of these functions,
   * and so they are not normally needed in GTK applications. See the
   * "Drag and Drop" section of the GTK documentation for more information.
   * @class
   */
  class Drag extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Drag

    static name: string

    // Constructors of Gdk-4.0.Gdk.Drag

    constructor(config?: Drag.ConstructorProperties)
    _init(config?: Drag.ConstructorProperties): void
    /**
     * Starts a drag and creates a new drag context for it.
     *
     * This function is called by the drag source. After this call, you
     * probably want to set up the drag icon using the surface returned
     * by [method`Gdk`.Drag.get_drag_surface].
     *
     * This function returns a reference to the [class`Gdk`.Drag] object,
     * but GTK keeps its own reference as well, as long as the DND operation
     * is going on.
     *
     * Note: if `actions` include %GDK_ACTION_MOVE, you need to listen for
     * the [signal`Gdk`.Drag::dnd-finished] signal and delete the data at
     * the source if [method`Gdk`.Drag.get_selected_action] returns
     * %GDK_ACTION_MOVE.
     * @param surface the source surface for this drag
     * @param device the device that controls this drag
     * @param content the offered content
     * @param actions the actions supported by this drag
     * @param dx the x offset to `device'`s position where the drag nominally started
     * @param dy the y offset to `device'`s position where the drag nominally started
     * @returns a newly created `GdkDrag`
     */
    static begin(
      surface: Surface,
      device: Device,
      content: ContentProvider,
      actions: DragAction,
      dx: number,
      dy: number
    ): Drag | null
  }

  module DrawContext {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.DrawContext

      /**
       * The `GdkDisplay` used to create the `GdkDrawContext`.
       */
      display?: Display | null
      /**
       * The `GdkSurface` the context is bound to.
       */
      surface?: Surface | null
    }
  }

  interface DrawContext {
    // Own properties of Gdk-4.0.Gdk.DrawContext

    /**
     * The `GdkDisplay` used to create the `GdkDrawContext`.
     */
    readonly display: Display
    /**
     * The `GdkSurface` the context is bound to.
     */
    readonly surface: Surface
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.DrawContext

    /**
     * Indicates that you are beginning the process of redrawing `region`
     * on the `context'`s surface.
     *
     * Calling this function begins a drawing operation using `context` on the
     * surface that `context` was created from. The actual requirements and
     * guarantees for the drawing operation vary for different implementations
     * of drawing, so a [class`Gdk`.CairoContext] and a [class`Gdk`.GLContext]
     * need to be treated differently.
     *
     * A call to this function is a requirement for drawing and must be
     * followed by a call to [method`Gdk`.DrawContext.end_frame], which will
     * complete the drawing operation and ensure the contents become visible
     * on screen.
     *
     * Note that the `region` passed to this function is the minimum region that
     * needs to be drawn and depending on implementation, windowing system and
     * hardware in use, it might be necessary to draw a larger region. Drawing
     * implementation must use [method`Gdk`.DrawContext.get_frame_region] to
     * query the region that must be drawn.
     *
     * When using GTK, the widget system automatically places calls to
     * gdk_draw_context_begin_frame() and gdk_draw_context_end_frame() via the
     * use of [GskRenderer](../gsk4/class.Renderer.html)s, so application code
     * does not need to call these functions explicitly.
     * @param region minimum region that should be drawn
     */
    beginFrame(region: cairo.Region): void
    /**
     * Ends a drawing operation started with gdk_draw_context_begin_frame().
     *
     * This makes the drawing available on screen.
     * See [method`Gdk`.DrawContext.begin_frame] for more details about drawing.
     *
     * When using a [class`Gdk`.GLContext], this function may call `glFlush()`
     * implicitly before returning; it is not recommended to call `glFlush()`
     * explicitly before calling this function.
     */
    endFrame(): void
    /**
     * Retrieves the `GdkDisplay` the `context` is created for
     * @returns the `GdkDisplay`
     */
    getDisplay(): Display | null
    /**
     * Retrieves the region that is currently being repainted.
     *
     * After a call to [method`Gdk`.DrawContext.begin_frame] this function will
     * return a union of the region passed to that function and the area of the
     * surface that the `context` determined needs to be repainted.
     *
     * If `context` is not in between calls to [method`Gdk`.DrawContext.begin_frame]
     * and [method`Gdk`.DrawContext.end_frame], %NULL will be returned.
     * @returns a Cairo region
     */
    getFrameRegion(): cairo.Region | null
    /**
     * Retrieves the surface that `context` is bound to.
     * @returns a `GdkSurface`
     */
    getSurface(): Surface | null
    /**
     * Returns %TRUE if `context` is in the process of drawing to its surface.
     *
     * This is the case between calls to [method`Gdk`.DrawContext.begin_frame]
     * and [method`Gdk`.DrawContext.end_frame]. In this situation, drawing commands
     * may be effecting the contents of the `context'`s surface.
     * @returns %TRUE if the context is between [method@Gdk.DrawContext.begin_frame]   and [method@Gdk.DrawContext.end_frame] calls.
     */
    isInFrame(): boolean

    // Class property signals of Gdk-4.0.Gdk.DrawContext

    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Base class for objects implementing different rendering methods.
   *
   * `GdkDrawContext` is the base object used by contexts implementing different
   * rendering methods, such as [class`Gdk`.CairoContext] or [class`Gdk`.GLContext].
   * It provides shared functionality between those contexts.
   *
   * You will always interact with one of those subclasses.
   *
   * A `GdkDrawContext` is always associated with a single toplevel surface.
   * @class
   */
  class DrawContext extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.DrawContext

    static name: string

    // Constructors of Gdk-4.0.Gdk.DrawContext

    constructor(config?: DrawContext.ConstructorProperties)
    _init(config?: DrawContext.ConstructorProperties): void
  }

  module Drop {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Drop

      /**
       * The possible actions for this drop
       */
      actions?: DragAction | null
      /**
       * The `GdkDevice` performing the drop
       */
      device?: Device | null
      /**
       * The `GdkDrag` that initiated this drop
       */
      drag?: Drag | null
      /**
       * The possible formats that the drop can provide its data in.
       */
      formats?: ContentFormats | null
      /**
       * The `GdkSurface` the drop happens on
       */
      surface?: Surface | null
    }
  }

  interface Drop {
    // Own properties of Gdk-4.0.Gdk.Drop

    /**
     * The possible actions for this drop
     */
    readonly actions: DragAction
    /**
     * The `GdkDevice` performing the drop
     */
    readonly device: Device
    /**
     * The `GdkDisplay` that the drop belongs to.
     */
    readonly display: Display
    /**
     * The `GdkDrag` that initiated this drop
     */
    readonly drag: Drag
    /**
     * The possible formats that the drop can provide its data in.
     */
    readonly formats: ContentFormats
    /**
     * The `GdkSurface` the drop happens on
     */
    readonly surface: Surface
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Drop

    /**
     * Ends the drag operation after a drop.
     *
     * The `action` must be a single action selected from the actions
     * available via [method`Gdk`.Drop.get_actions].
     * @param action the action performed by the destination or 0 if the drop failed
     */
    finish(action: DragAction): void
    /**
     * Returns the possible actions for this `GdkDrop`.
     *
     * If this value contains multiple actions - i.e.
     * [func`Gdk`.DragAction.is_unique] returns %FALSE for the result -
     * [method`Gdk`.Drop.finish] must choose the action to use when
     * accepting the drop. This will only happen if you passed
     * %GDK_ACTION_ASK as one of the possible actions in
     * [method`Gdk`.Drop.status]. %GDK_ACTION_ASK itself will not
     * be included in the actions returned by this function.
     *
     * This value may change over the lifetime of the [class`Gdk`.Drop]
     * both as a response to source side actions as well as to calls to
     * [method`Gdk`.Drop.status] or [method`Gdk`.Drop.finish]. The source
     * side will not change this value anymore once a drop has started.
     * @returns The possible `GdkDragActions`
     */
    getActions(): DragAction
    /**
     * Returns the `GdkDevice` performing the drop.
     * @returns The `GdkDevice` performing the drop.
     */
    getDevice(): Device
    /**
     * Gets the `GdkDisplay` that `self` was created for.
     * @returns a `GdkDisplay`
     */
    getDisplay(): Display
    /**
     * If this is an in-app drag-and-drop operation, returns the `GdkDrag`
     * that corresponds to this drop.
     *
     * If it is not, %NULL is returned.
     * @returns the corresponding `GdkDrag`
     */
    getDrag(): Drag | null
    /**
     * Returns the `GdkContentFormats` that the drop offers the data
     * to be read in.
     * @returns The possible `GdkContentFormats`
     */
    getFormats(): ContentFormats
    /**
     * Returns the `GdkSurface` performing the drop.
     * @returns The `GdkSurface` performing the drop.
     */
    getSurface(): Surface
    /**
     * Asynchronously read the dropped data from a `GdkDrop`
     * in a format that complies with one of the mime types.
     * @param mimeTypes pointer to an array of mime types
     * @param ioPriority the I/O priority for the read operation
     * @param cancellable optional `GCancellable` object
     * @param callback a `GAsyncReadyCallback` to call when   the request is satisfied
     */
    readAsync(
      mimeTypes: string[],
      ioPriority: number,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async drop read operation.
     *
     * Note that you must not use blocking read calls on the returned stream
     * in the GTK thread, since some platforms might require communication with
     * GTK to complete the data transfer. You can use async APIs such as
     * g_input_stream_read_bytes_async().
     *
     * See [method`Gdk`.Drop.read_async].
     * @param result a `GAsyncResult`
     * @returns the `GInputStream`
     */
    readFinish(
      result: Gio.AsyncResult
    ): [/* returnType */ Gio.InputStream | null, /* outMimeType */ string]
    /**
     * Asynchronously request the drag operation's contents converted
     * to the given `type`.
     *
     * When the operation is finished `callback` will be called. You must
     * then call [method`Gdk`.Drop.read_value_finish] to get the resulting
     * `GValue`.
     *
     * For local drag-and-drop operations that are available in the given
     * `GType`, the value will be copied directly. Otherwise, GDK will
     * try to use [func`Gdk`.content_deserialize_async] to convert the data.
     * @param type a `GType` to read
     * @param ioPriority the I/O priority of the request.
     * @param cancellable optional `GCancellable` object, %NULL to ignore.
     * @param callback callback to call when the request is satisfied
     */
    readValueAsync(
      type: GObject.GType,
      ioPriority: number,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes an async drop read.
     *
     * See [method`Gdk`.Drop.read_value_async].
     * @param result a `GAsyncResult`
     * @returns a `GValue` containing the result.
     */
    readValueFinish(result: Gio.AsyncResult): any
    /**
     * Selects all actions that are potentially supported by the destination.
     *
     * When calling this function, do not restrict the passed in actions to
     * the ones provided by [method`Gdk`.Drop.get_actions]. Those actions may
     * change in the future, even depending on the actions you provide here.
     *
     * The `preferred` action is a hint to the drag-and-drop mechanism about which
     * action to use when multiple actions are possible.
     *
     * This function should be called by drag destinations in response to
     * %GDK_DRAG_ENTER or %GDK_DRAG_MOTION events. If the destination does
     * not yet know the exact actions it supports, it should set any possible
     * actions first and then later call this function again.
     * @param actions Supported actions of the destination, or 0 to indicate    that a drop will not be accepted
     * @param preferred A unique action that's a member of `actions` indicating the    preferred action
     */
    status(actions: DragAction, preferred: DragAction): void

    // Class property signals of Gdk-4.0.Gdk.Drop

    connect(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::actions", ...args: any[]): void
    connect(
      sigName: "notify::device",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::device",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::device",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::device",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::device", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(sigName: "notify::drag", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::drag",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::drag",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::drag",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::drag", ...args: any[]): void
    connect(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::formats", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GdkDrop` object represents the target of an ongoing DND operation.
   *
   * Possible drop sites get informed about the status of the ongoing drag
   * operation with events of type %GDK_DRAG_ENTER, %GDK_DRAG_LEAVE,
   * %GDK_DRAG_MOTION and %GDK_DROP_START. The `GdkDrop` object can be obtained
   * from these [class`Gdk`.Event] types using [method`Gdk`.DNDEvent.get_drop].
   *
   * The actual data transfer is initiated from the target side via an async
   * read, using one of the `GdkDrop` methods for this purpose:
   * [method`Gdk`.Drop.read_async] or [method`Gdk`.Drop.read_value_async].
   *
   * GTK provides a higher level abstraction based on top of these functions,
   * and so they are not normally needed in GTK applications. See the
   * "Drag and Drop" section of the GTK documentation for more information.
   * @class
   */
  class Drop extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Drop

    static name: string

    // Constructors of Gdk-4.0.Gdk.Drop

    constructor(config?: Drop.ConstructorProperties)
    _init(config?: Drop.ConstructorProperties): void
  }

  interface Event {
    // Owm methods of Gdk-4.0.Gdk.Event

    /**
     * Returns the relative angle from `event1` to `event2`.
     *
     * The relative angle is the angle between the X axis and the line
     * through both events' positions. The rotation direction for positive
     * angles is from the positive X axis towards the positive Y axis.
     *
     * This assumes that both events have X/Y information.
     * If not, this function returns %FALSE.
     * @param event2 second `GdkEvent`
     * @returns %TRUE if the angle could be calculated.
     */
    getAngle(event2: Event): [/* returnType */ boolean, /* angle */ number]
    /**
     * Returns the point halfway between the events' positions.
     *
     * This assumes that both events have X/Y information.
     * If not, this function returns %FALSE.
     * @param event2 second `GdkEvent`
     * @returns %TRUE if the center could be calculated.
     */
    getCenter(
      event2: Event
    ): [/* returnType */ boolean, /* x */ number, /* y */ number]
    /**
     * Returns the distance between the event locations.
     *
     * This assumes that both events have X/Y information.
     * If not, this function returns %FALSE.
     * @param event2 second `GdkEvent`
     * @returns %TRUE if the distance could be calculated.
     */
    getDistance(
      event2: Event
    ): [/* returnType */ boolean, /* distance */ number]
    /**
     * Extracts all axis values from an event.
     *
     * To find out which axes are used, use [method`Gdk`.DeviceTool.get_axes]
     * on the device tool returned by [method`Gdk`.Event.get_device_tool].
     * @returns %TRUE on success, otherwise %FALSE
     */
    getAxes(): [/* returnType */ boolean, /* axes */ number[]]
    /**
     * Extract the axis value for a particular axis use from
     * an event structure.
     *
     * To find out which axes are used, use [method`Gdk`.DeviceTool.get_axes]
     * on the device tool returned by [method`Gdk`.Event.get_device_tool].
     * @param axisUse the axis use to look for
     * @returns %TRUE if the specified axis was found, otherwise %FALSE
     */
    getAxis(axisUse: AxisUse): [/* returnType */ boolean, /* value */ number]
    /**
     * Returns the device of an event.
     * @returns a `GdkDevice`
     */
    getDevice(): Device | null
    /**
     * Returns a `GdkDeviceTool` representing the tool that
     * caused the event.
     *
     * If the was not generated by a device that supports
     * different tools (such as a tablet), this function will
     * return %NULL.
     *
     * Note: the `GdkDeviceTool` will be constant during
     * the application lifetime, if settings must be stored
     * persistently across runs, see [method`Gdk`.DeviceTool.get_serial].
     * @returns The current device tool
     */
    getDeviceTool(): DeviceTool | null
    /**
     * Retrieves the display associated to the `event`.
     * @returns a `GdkDisplay`
     */
    getDisplay(): Display | null
    /**
     * Returns the event sequence to which the event belongs.
     *
     * Related touch events are connected in a sequence. Other
     * events typically don't have event sequence information.
     * @returns the event sequence that the event belongs to
     */
    getEventSequence(): EventSequence
    /**
     * Retrieves the type of the event.
     * @returns a `GdkEvent`Type
     */
    getEventType(): EventType
    /**
     * Retrieves the history of the device that `event` is for, as a list of
     * time and coordinates.
     *
     * The history includes positions that are not delivered as separate events
     * to the application because they occurred in the same frame as `event`.
     *
     * Note that only motion and scroll events record history, and motion
     * events do it only if one of the mouse buttons is down, or the device
     * has a tool.
     * @returns an   array of time and coordinates
     */
    getHistory(): TimeCoord[] | null
    /**
     * Returns the modifier state field of an event.
     * @returns the modifier state of @event
     */
    getModifierState(): ModifierType
    /**
     * Returns whether this event is an 'emulated' pointer event.
     *
     * Emulated pointer events typically originate from a touch events.
     * @returns %TRUE if this event is emulated
     */
    getPointerEmulated(): boolean
    /**
     * Extract the event surface relative x/y coordinates from an event.
     *
     * This position is in [surface coordinates](coordinates.html).
     */
    getPosition(): [/* returnType */ boolean, /* x */ number, /* y */ number]
    /**
     * Returns the seat that originated the event.
     * @returns a `GdkSeat`.
     */
    getSeat(): Seat | null
    /**
     * Extracts the surface associated with an event.
     * @returns The `GdkSurface` associated with the event
     */
    getSurface(): Surface | null
    /**
     * Returns the timestamp of `event`.
     *
     * Not all events have timestamps. In that case, this function
     * returns %GDK_CURRENT_TIME.
     * @returns timestamp field from @event
     */
    getTime(): number
    /**
     * Increase the ref count of `event`.
     * @returns @event
     */
    ref(): Event
    /**
     * Returns whether a `GdkEvent` should trigger a context menu,
     * according to platform conventions.
     *
     * The right mouse button typically triggers context menus.
     *
     * This function should always be used instead of simply checking for
     * event->button == %GDK_BUTTON_SECONDARY.
     * @returns %TRUE if the event should trigger a context menu.
     */
    triggersContextMenu(): boolean
    /**
     * Decrease the ref count of `event`.
     *
     * If the last reference is dropped, the structure is freed.
     */
    unref(): void
  }

  /**
   * `GdkEvent`s are immutable data structures, created by GDK to
   * represent windowing system events.
   *
   * In GTK applications the events are handled automatically by toplevel
   * widgets and passed on to the event controllers of appropriate widgets,
   * so using `GdkEvent` and its related API is rarely needed.
   * @class
   */
  class Event {
    // Own properties of Gdk-4.0.Gdk.Event

    static name: string
  }

  interface FocusEvent {
    // Owm methods of Gdk-4.0.Gdk.FocusEvent

    /**
     * Extracts whether this event is about focus entering or
     * leaving the surface.
     * @returns %TRUE of the focus is entering
     */
    getIn(): boolean
  }

  /**
   * An event related to a keyboard focus change.
   * @class
   */
  class FocusEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.FocusEvent

    static name: string
  }

  module FrameClock {
    // Signal callback interfaces

    /**
     * Signal callback interface for `after-paint`
     */
    interface AfterPaintSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `before-paint`
     */
    interface BeforePaintSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `flush-events`
     */
    interface FlushEventsSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `layout`
     */
    interface LayoutSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `paint`
     */
    interface PaintSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `resume-events`
     */
    interface ResumeEventsSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `update`
     */
    interface UpdateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface FrameClock {
    // Own properties of Gdk-4.0.Gdk.FrameClock

    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.FrameClock

    /**
     * Starts updates for an animation.
     *
     * Until a matching call to [method`Gdk`.FrameClock.end_updating] is made,
     * the frame clock will continually request a new frame with the
     * %GDK_FRAME_CLOCK_PHASE_UPDATE phase. This function may be called multiple
     * times and frames will be requested until gdk_frame_clock_end_updating()
     * is called the same number of times.
     */
    beginUpdating(): void
    /**
     * Stops updates for an animation.
     *
     * See the documentation for [method`Gdk`.FrameClock.begin_updating].
     */
    endUpdating(): void
    /**
     * Gets the frame timings for the current frame.
     * @returns the `GdkFrameTimings` for the   frame currently being processed, or even no frame is being   processed, for the previous frame. Before any frames have been   processed, returns %NULL.
     */
    getCurrentTimings(): FrameTimings | null
    /**
     * Calculates the current frames-per-second, based on the
     * frame timings of `frame_clock`.
     * @returns the current fps, as a `double`
     */
    getFps(): number
    /**
     * `GdkFrameClock` maintains a 64-bit counter that increments for
     * each frame drawn.
     * @returns inside frame processing, the value of the frame counter   for the current frame. Outside of frame processing, the frame   counter for the last frame.
     */
    getFrameCounter(): number
    /**
     * Gets the time that should currently be used for animations.
     *
     * Inside the processing of a frame, it’s the time used to compute the
     * animation position of everything in a frame. Outside of a frame, it's
     * the time of the conceptual “previous frame,” which may be either
     * the actual previous frame time, or if that’s too old, an updated
     * time.
     * @returns a timestamp in microseconds, in the timescale of  of g_get_monotonic_time().
     */
    getFrameTime(): number
    /**
     * Returns the frame counter for the oldest frame available in history.
     *
     * `GdkFrameClock` internally keeps a history of `GdkFrameTimings`
     * objects for recent frames that can be retrieved with
     * [method`Gdk`.FrameClock.get_timings]. The set of stored frames
     * is the set from the counter values given by
     * [method`Gdk`.FrameClock.get_history_start] and
     * [method`Gdk`.FrameClock.get_frame_counter], inclusive.
     * @returns the frame counter value for the oldest frame  that is available in the internal frame history of the  `GdkFrameClock`
     */
    getHistoryStart(): number
    /**
     * Predicts a presentation time, based on history.
     *
     * Using the frame history stored in the frame clock, finds the last
     * known presentation time and refresh interval, and assuming that
     * presentation times are separated by the refresh interval,
     * predicts a presentation time that is a multiple of the refresh
     * interval after the last presentation time, and later than `base_time`.
     * @param baseTime base time for determining a presentaton time
     */
    getRefreshInfo(
      baseTime: number
    ): [/* refreshIntervalReturn */ number, /* presentationTimeReturn */ number]
    /**
     * Retrieves a `GdkFrameTimings` object holding timing information
     * for the current frame or a recent frame.
     *
     * The `GdkFrameTimings` object may not yet be complete: see
     * [method`Gdk`.FrameTimings.get_complete] and
     * [method`Gdk`.FrameClock.get_history_start].
     * @param frameCounter the frame counter value identifying the frame to  be received
     * @returns the `GdkFrameTimings` object   for the specified frame, or %NULL if it is not available
     */
    getTimings(frameCounter: number): FrameTimings | null
    /**
     * Asks the frame clock to run a particular phase.
     *
     * The signal corresponding the requested phase will be emitted the next
     * time the frame clock processes. Multiple calls to
     * gdk_frame_clock_request_phase() will be combined together
     * and only one frame processed. If you are displaying animated
     * content and want to continually request the
     * %GDK_FRAME_CLOCK_PHASE_UPDATE phase for a period of time,
     * you should use [method`Gdk`.FrameClock.begin_updating] instead,
     * since this allows GTK to adjust system parameters to get maximally
     * smooth animations.
     * @param phase the phase that is requested
     */
    requestPhase(phase: FrameClockPhase): void

    // Own signals of Gdk-4.0.Gdk.FrameClock

    connect(
      sigName: "after-paint",
      callback: FrameClock.AfterPaintSignalCallback
    ): number
    on(
      sigName: "after-paint",
      callback: FrameClock.AfterPaintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "after-paint",
      callback: FrameClock.AfterPaintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "after-paint",
      callback: FrameClock.AfterPaintSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "after-paint", ...args: any[]): void
    connect(
      sigName: "before-paint",
      callback: FrameClock.BeforePaintSignalCallback
    ): number
    on(
      sigName: "before-paint",
      callback: FrameClock.BeforePaintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "before-paint",
      callback: FrameClock.BeforePaintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "before-paint",
      callback: FrameClock.BeforePaintSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "before-paint", ...args: any[]): void
    connect(
      sigName: "flush-events",
      callback: FrameClock.FlushEventsSignalCallback
    ): number
    on(
      sigName: "flush-events",
      callback: FrameClock.FlushEventsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "flush-events",
      callback: FrameClock.FlushEventsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "flush-events",
      callback: FrameClock.FlushEventsSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "flush-events", ...args: any[]): void
    connect(
      sigName: "layout",
      callback: FrameClock.LayoutSignalCallback
    ): number
    on(
      sigName: "layout",
      callback: FrameClock.LayoutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "layout",
      callback: FrameClock.LayoutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "layout",
      callback: FrameClock.LayoutSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "layout", ...args: any[]): void
    connect(sigName: "paint", callback: FrameClock.PaintSignalCallback): number
    on(
      sigName: "paint",
      callback: FrameClock.PaintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "paint",
      callback: FrameClock.PaintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "paint",
      callback: FrameClock.PaintSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "paint", ...args: any[]): void
    connect(
      sigName: "resume-events",
      callback: FrameClock.ResumeEventsSignalCallback
    ): number
    on(
      sigName: "resume-events",
      callback: FrameClock.ResumeEventsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "resume-events",
      callback: FrameClock.ResumeEventsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "resume-events",
      callback: FrameClock.ResumeEventsSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "resume-events", ...args: any[]): void
    connect(
      sigName: "update",
      callback: FrameClock.UpdateSignalCallback
    ): number
    on(
      sigName: "update",
      callback: FrameClock.UpdateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "update",
      callback: FrameClock.UpdateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "update",
      callback: FrameClock.UpdateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "update", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.FrameClock

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkFrameClock` tells the application when to update and repaint
   * a surface.
   *
   * This may be synced to the vertical refresh rate of the monitor, for example.
   * Even when the frame clock uses a simple timer rather than a hardware-based
   * vertical sync, the frame clock helps because it ensures everything paints at
   * the same time (reducing the total number of frames).
   *
   * The frame clock can also automatically stop painting when it knows the frames
   * will not be visible, or scale back animation framerates.
   *
   * `GdkFrameClock` is designed to be compatible with an OpenGL-based implementation
   * or with mozRequestAnimationFrame in Firefox, for example.
   *
   * A frame clock is idle until someone requests a frame with
   * [method`Gdk`.FrameClock.request_phase]. At some later point that makes sense
   * for the synchronization being implemented, the clock will process a frame and
   * emit signals for each phase that has been requested. (See the signals of the
   * `GdkFrameClock` class for documentation of the phases.
   * %GDK_FRAME_CLOCK_PHASE_UPDATE and the [signal`Gdk`.FrameClock::update] signal
   * are most interesting for application writers, and are used to update the
   * animations, using the frame time given by [method`Gdk`.FrameClock.get_frame_time].
   *
   * The frame time is reported in microseconds and generally in the same
   * timescale as g_get_monotonic_time(), however, it is not the same
   * as g_get_monotonic_time(). The frame time does not advance during
   * the time a frame is being painted, and outside of a frame, an attempt
   * is made so that all calls to [method`Gdk`.FrameClock.get_frame_time] that
   * are called at a “similar” time get the same value. This means that
   * if different animations are timed by looking at the difference in
   * time between an initial value from [method`Gdk`.FrameClock.get_frame_time]
   * and the value inside the [signal`Gdk`.FrameClock::update] signal of the clock,
   * they will stay exactly synchronized.
   * @class
   */
  class FrameClock extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.FrameClock

    static name: string

    // Constructors of Gdk-4.0.Gdk.FrameClock

    constructor(config?: FrameClock.ConstructorProperties)
    _init(config?: FrameClock.ConstructorProperties): void
  }

  module GLContext {
    // Constructor properties interface

    interface ConstructorProperties extends DrawContext.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.GLContext

      /**
       * The allowed APIs.
       */
      allowed_apis?: GLAPI | null
      /**
       * Always %NULL
       *
       * As many contexts can share data now and no single shared context exists
       * anymore, this function has been deprecated and now always returns %NULL.
       */
      shared_context?: GLContext | null
    }
  }

  interface GLContext {
    // Own properties of Gdk-4.0.Gdk.GLContext

    /**
     * The allowed APIs.
     */
    allowedApis: GLAPI
    /**
     * The API currently in use.
     */
    readonly api: GLAPI
    /**
     * Always %NULL
     *
     * As many contexts can share data now and no single shared context exists
     * anymore, this function has been deprecated and now always returns %NULL.
     */
    readonly sharedContext: GLContext
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.GLContext

    /**
     * Gets the allowed APIs set via gdk_gl_context_set_allowed_apis().
     * @returns the allowed APIs
     */
    getAllowedApis(): GLAPI
    /**
     * Gets the API currently in use.
     *
     * If the renderer has not been realized yet, 0 is returned.
     * @returns the currently used API
     */
    getApi(): GLAPI
    /**
     * Retrieves whether the context is doing extra validations and runtime checking.
     *
     * See [method`Gdk`.GLContext.set_debug_enabled].
     * @returns %TRUE if debugging is enabled
     */
    getDebugEnabled(): boolean
    /**
     * Retrieves the display the `context` is created for
     * @returns a `GdkDisplay`
     */
    getDisplay(): Display | null
    /**
     * Retrieves whether the context is forward-compatible.
     *
     * See [method`Gdk`.GLContext.set_forward_compatible].
     * @returns %TRUE if the context should be forward-compatible
     */
    getForwardCompatible(): boolean
    /**
     * Retrieves required OpenGL version set as a requirement for the `context`
     * realization. It will not change even if a greater OpenGL version is supported
     * and used after the `context` is realized. See
     * [method`Gdk`.GLContext.get_version] for the real version in use.
     *
     * See [method`Gdk`.GLContext.set_required_version].
     */
    getRequiredVersion(): [/* major */ number | null, /* minor */ number | null]
    /**
     * Used to retrieves the `GdkGLContext` that this `context` share data with.
     *
     * As many contexts can share data now and no single shared context exists
     * anymore, this function has been deprecated and now always returns %NULL.
     * @returns %NULL
     */
    getSharedContext(): GLContext | null
    /**
     * Retrieves the surface used by the `context`.
     * @returns a `GdkSurface`
     */
    getSurface(): Surface | null
    /**
     * Checks whether the `context` is using an OpenGL or OpenGL ES profile.
     * @returns %TRUE if the `GdkGLContext` is using an OpenGL ES profile; %FALSE if other profile is in use of if the @context has not yet been realized.
     */
    getUseEs(): boolean
    /**
     * Retrieves the OpenGL version of the `context`.
     *
     * The `context` must be realized prior to calling this function.
     */
    getVersion(): [/* major */ number, /* minor */ number]
    /**
     * Whether the `GdkGLContext` is in legacy mode or not.
     *
     * The `GdkGLContext` must be realized before calling this function.
     *
     * When realizing a GL context, GDK will try to use the OpenGL 3.2 core
     * profile; this profile removes all the OpenGL API that was deprecated
     * prior to the 3.2 version of the specification. If the realization is
     * successful, this function will return %FALSE.
     *
     * If the underlying OpenGL implementation does not support core profiles,
     * GDK will fall back to a pre-3.2 compatibility profile, and this function
     * will return %TRUE.
     *
     * You can use the value returned by this function to decide which kind
     * of OpenGL API to use, or whether to do extension discovery, or what
     * kind of shader programs to load.
     * @returns %TRUE if the GL context is in legacy mode
     */
    isLegacy(): boolean
    /**
     * Checks if the two GL contexts can share resources.
     *
     * When they can, the texture IDs from `other` can be used in `self`. This
     * is particularly useful when passing `GdkGLTexture` objects between
     * different contexts.
     *
     * Contexts created for the same display with the same properties will
     * always be compatible, even if they are created for different surfaces.
     * For other contexts it depends on the GL backend.
     *
     * Both contexts must be realized for this check to succeed. If either one
     * is not, this function will return %FALSE.
     * @param other the `GdkGLContext` that should be compatible with `self`
     * @returns %TRUE if the two GL contexts are compatible.
     */
    isShared(other: GLContext): boolean
    /**
     * Makes the `context` the current one.
     */
    makeCurrent(): void
    /**
     * Realizes the given `GdkGLContext`.
     *
     * It is safe to call this function on a realized `GdkGLContext`.
     * @returns %TRUE if the context is realized
     */
    realize(): boolean
    /**
     * Sets the allowed APIs. When gdk_gl_context_realize() is called, only the
     * allowed APIs will be tried. If you set this to 0, realizing will always fail.
     *
     * If you set it on a realized context, the property will not have any effect.
     * It is only relevant during gdk_gl_context_realize().
     *
     * By default, all APIs are allowed.
     * @param apis the allowed APIs
     */
    setAllowedApis(apis: GLAPI): void
    /**
     * Sets whether the `GdkGLContext` should perform extra validations and
     * runtime checking.
     *
     * This is useful during development, but has additional overhead.
     *
     * The `GdkGLContext` must not be realized or made current prior to
     * calling this function.
     * @param enabled whether to enable debugging in the context
     */
    setDebugEnabled(enabled: boolean): void
    /**
     * Sets whether the `GdkGLContext` should be forward-compatible.
     *
     * Forward-compatible contexts must not support OpenGL functionality that
     * has been marked as deprecated in the requested version; non-forward
     * compatible contexts, on the other hand, must support both deprecated and
     * non deprecated functionality.
     *
     * The `GdkGLContext` must not be realized or made current prior to calling
     * this function.
     * @param compatible whether the context should be forward-compatible
     */
    setForwardCompatible(compatible: boolean): void
    /**
     * Sets the major and minor version of OpenGL to request.
     *
     * Setting `major` and `minor` to zero will use the default values.
     *
     * Setting `major` and `minor` lower than the minimum versions required
     * by GTK will result in the context choosing the minimum version.
     *
     * The `context` must not be realized or made current prior to calling
     * this function.
     * @param major the major version to request
     * @param minor the minor version to request
     */
    setRequiredVersion(major: number, minor: number): void
    /**
     * Requests that GDK create an OpenGL ES context instead of an OpenGL one.
     *
     * Not all platforms support OpenGL ES.
     *
     * The `context` must not have been realized.
     *
     * By default, GDK will attempt to automatically detect whether the
     * underlying GL implementation is OpenGL or OpenGL ES once the `context`
     * is realized.
     *
     * You should check the return value of [method`Gdk`.GLContext.get_use_es]
     * after calling [method`Gdk`.GLContext.realize] to decide whether to use
     * the OpenGL or OpenGL ES API, extensions, or shaders.
     * @param useEs whether the context should use OpenGL ES instead of OpenGL,   or -1 to allow auto-detection
     */
    setUseEs(useEs: number): void

    // Class property signals of Gdk-4.0.Gdk.GLContext

    connect(
      sigName: "notify::allowed-apis",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::allowed-apis",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::allowed-apis",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::allowed-apis",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::allowed-apis", ...args: any[]): void
    connect(sigName: "notify::api", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::api",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::api",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::api",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::api", ...args: any[]): void
    connect(
      sigName: "notify::shared-context",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shared-context",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shared-context",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shared-context",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shared-context", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkGLContext` is an object representing a platform-specific
   * OpenGL draw context.
   *
   * `GdkGLContext`s are created for a surface using
   * [method`Gdk`.Surface.create_gl_context], and the context will match
   * the characteristics of the surface.
   *
   * A `GdkGLContext` is not tied to any particular normal framebuffer.
   * For instance, it cannot draw to the surface back buffer. The GDK
   * repaint system is in full control of the painting to that. Instead,
   * you can create render buffers or textures and use [func`cairo_draw_from_gl]`
   * in the draw function of your widget to draw them. Then GDK will handle
   * the integration of your rendering with that of other widgets.
   *
   * Support for `GdkGLContext` is platform-specific and context creation
   * can fail, returning %NULL context.
   *
   * A `GdkGLContext` has to be made "current" in order to start using
   * it, otherwise any OpenGL call will be ignored.
   *
   * ## Creating a new OpenGL context
   *
   * In order to create a new `GdkGLContext` instance you need a `GdkSurface`,
   * which you typically get during the realize call of a widget.
   *
   * A `GdkGLContext` is not realized until either [method`Gdk`.GLContext.make_current]
   * or [method`Gdk`.GLContext.realize] is called. It is possible to specify
   * details of the GL context like the OpenGL version to be used, or whether
   * the GL context should have extra state validation enabled after calling
   * [method`Gdk`.Surface.create_gl_context] by calling [method`Gdk`.GLContext.realize].
   * If the realization fails you have the option to change the settings of
   * the `GdkGLContext` and try again.
   *
   * ## Using a GdkGLContext
   *
   * You will need to make the `GdkGLContext` the current context before issuing
   * OpenGL calls; the system sends OpenGL commands to whichever context is current.
   * It is possible to have multiple contexts, so you always need to ensure that
   * the one which you want to draw with is the current one before issuing commands:
   *
   * ```c
   * gdk_gl_context_make_current (context);
   * ```
   *
   * You can now perform your drawing using OpenGL commands.
   *
   * You can check which `GdkGLContext` is the current one by using
   * [func`Gdk`.GLContext.get_current]; you can also unset any `GdkGLContext`
   * that is currently set by calling [func`Gdk`.GLContext.clear_current].
   * @class
   */
  class GLContext extends DrawContext {
    // Own properties of Gdk-4.0.Gdk.GLContext

    static name: string

    // Constructors of Gdk-4.0.Gdk.GLContext

    constructor(config?: GLContext.ConstructorProperties)
    _init(config?: GLContext.ConstructorProperties): void
    /**
     * Clears the current `GdkGLContext`.
     *
     * Any OpenGL call after this function returns will be ignored
     * until [method`Gdk`.GLContext.make_current] is called.
     */
    static clearCurrent(): void
    /**
     * Retrieves the current `GdkGLContext`.
     * @returns the current `GdkGLContext`
     */
    static getCurrent(): GLContext | null
  }

  module GLTexture {
    // Constructor properties interface

    interface ConstructorProperties
      extends Paintable.ConstructorProperties,
        Gio.Icon.ConstructorProperties,
        Gio.LoadableIcon.ConstructorProperties,
        Texture.ConstructorProperties {}
  }

  interface GLTexture extends Paintable, Gio.Icon, Gio.LoadableIcon {
    // Own properties of Gdk-4.0.Gdk.GLTexture

    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.GLTexture

    /**
     * Releases the GL resources held by a `GdkGLTexture`.
     *
     * The texture contents are still available via the
     * [method`Gdk`.Texture.download] function, after this
     * function has been called.
     */
    release(): void

    // Class property signals of Gdk-4.0.Gdk.GLTexture

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A GdkTexture representing a GL texture object.
   * @class
   */
  class GLTexture extends Texture {
    // Own properties of Gdk-4.0.Gdk.GLTexture

    static name: string

    // Constructors of Gdk-4.0.Gdk.GLTexture

    constructor(config?: GLTexture.ConstructorProperties)
    /**
     * Creates a new texture for an existing GL texture.
     *
     * Note that the GL texture must not be modified until `destroy` is called,
     * which will happen when the GdkTexture object is finalized, or due to
     * an explicit call of [method`Gdk`.GLTexture.release].
     * @constructor
     * @param context a `GdkGLContext`
     * @param id the ID of a texture that was created with `context`
     * @param width the nominal width of the texture
     * @param height the nominal height of the texture
     * @param destroy a destroy notify that will be called when the GL resources   are released
     * @param data data that gets passed to `destroy`
     * @returns A newly-created   `GdkTexture`
     */
    constructor(
      context: GLContext,
      id: number,
      width: number,
      height: number,
      destroy: GLib.DestroyNotify,
      data: any | null
    )
    /**
     * Creates a new texture for an existing GL texture.
     *
     * Note that the GL texture must not be modified until `destroy` is called,
     * which will happen when the GdkTexture object is finalized, or due to
     * an explicit call of [method`Gdk`.GLTexture.release].
     * @constructor
     * @param context a `GdkGLContext`
     * @param id the ID of a texture that was created with `context`
     * @param width the nominal width of the texture
     * @param height the nominal height of the texture
     * @param destroy a destroy notify that will be called when the GL resources   are released
     * @param data data that gets passed to `destroy`
     * @returns A newly-created   `GdkTexture`
     */
    static new(
      context: GLContext,
      id: number,
      width: number,
      height: number,
      destroy: GLib.DestroyNotify,
      data: any | null
    ): GLTexture
    _init(config?: GLTexture.ConstructorProperties): void
  }

  module GLTextureBuilder {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.GLTextureBuilder

      /**
       * The context owning the texture.
       */
      context?: GLContext | null
      /**
       * The format when downloading the texture.
       */
      format?: MemoryFormat | null
      /**
       * If the texture has a mipmap.
       */
      has_mipmap?: boolean | null
      /**
       * The height of the texture.
       */
      height?: number | null
      /**
       * The texture ID to use.
       */
      id?: number | null
      /**
       * An optional `GLSync` object.
       *
       * If this is set, GTK will wait on it before using the texture.
       */
      sync?: any | null
      /**
       * The update region for [property`Gdk`.GLTextureBuilder:update-texture].
       */
      update_region?: cairo.Region | null
      /**
       * The texture [property`Gdk`.GLTextureBuilder:update-region] is an update for.
       */
      update_texture?: Texture | null
      /**
       * The width of the texture.
       */
      width?: number | null
    }
  }

  interface GLTextureBuilder {
    // Own properties of Gdk-4.0.Gdk.GLTextureBuilder

    /**
     * The context owning the texture.
     */
    context: GLContext
    /**
     * The format when downloading the texture.
     */
    format: MemoryFormat
    /**
     * If the texture has a mipmap.
     */
    hasMipmap: boolean
    /**
     * The height of the texture.
     */
    height: number
    /**
     * The texture ID to use.
     */
    id: number
    /**
     * An optional `GLSync` object.
     *
     * If this is set, GTK will wait on it before using the texture.
     */
    sync: any
    /**
     * The update region for [property`Gdk`.GLTextureBuilder:update-texture].
     */
    updateRegion: cairo.Region
    /**
     * The texture [property`Gdk`.GLTextureBuilder:update-region] is an update for.
     */
    updateTexture: Texture
    /**
     * The width of the texture.
     */
    width: number
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.GLTextureBuilder

    /**
     * Builds a new `GdkTexture` with the values set up in the builder.
     *
     * The `destroy` function gets called when the returned texture gets released;
     * either when the texture is finalized or by an explicit call to
     * [method`Gdk`.GLTexture.release]. It should release all GL resources associated
     * with the texture, such as the [property`Gdk`.GLTextureBuilder:id] and the
     * [property`Gdk`.GLTextureBuilder:sync].
     *
     * Note that it is a programming error to call this function if any mandatory
     * property has not been set.
     *
     * It is possible to call this function multiple times to create multiple textures,
     * possibly with changing properties in between.
     * @param destroy destroy function to be called when the texture is   released
     * @param data user data to pass to the destroy function
     * @returns a newly built `GdkTexture`
     */
    build(destroy: GLib.DestroyNotify | null, data: any | null): Texture
    /**
     * Gets the context previously set via gdk_gl_texture_builder_set_context() or
     * %NULL if none was set.
     * @returns The context
     */
    getContext(): GLContext | null
    /**
     * Gets the format previously set via gdk_gl_texture_builder_set_format().
     * @returns The format
     */
    getFormat(): MemoryFormat
    /**
     * Gets whether the texture has a mipmap.
     * @returns Whether the texture has a mipmap
     */
    getHasMipmap(): boolean
    /**
     * Gets the height previously set via gdk_gl_texture_builder_set_height() or
     * 0 if the height wasn't set.
     * @returns The height
     */
    getHeight(): number
    /**
     * Gets the texture id previously set via gdk_gl_texture_builder_set_id() or
     * 0 if the id wasn't set.
     * @returns The id
     */
    getId(): number
    /**
     * Gets the `GLsync` previously set via gdk_gl_texture_builder_set_sync().
     * @returns the `GLSync`
     */
    getSync(): any | null
    /**
     * Gets the region previously set via gdk_gl_texture_builder_set_update_region() or
     * %NULL if none was set.
     * @returns The region
     */
    getUpdateRegion(): cairo.Region | null
    /**
     * Gets the texture previously set via gdk_gl_texture_builder_set_update_texture() or
     * %NULL if none was set.
     * @returns The texture
     */
    getUpdateTexture(): Texture | null
    /**
     * Gets the width previously set via gdk_gl_texture_builder_set_width() or
     * 0 if the width wasn't set.
     * @returns The width
     */
    getWidth(): number
    /**
     * Sets the context to be used for the texture. This is the context that owns
     * the texture.
     *
     * The context must be set before calling [method`Gdk`.GLTextureBuilder.build].
     * @param context The context the texture beongs to or %NULL to unset
     */
    setContext(context: GLContext | null): void
    /**
     * Sets the format of the texture. The default is `GDK_MEMORY_R8G8B8A8_PREMULTIPLIED`.
     *
     * The format is the preferred format the texture data should be downloaded to. The
     * format must be supported by the GL version of [property`Gdk`.GLTextureBuilder:context].
     *
     * GDK's texture download code assumes that the format corresponds to the storage
     * parameters of the GL texture in an obvious way. For example, a format of
     * `GDK_MEMORY_R16G16B16A16_PREMULTIPLIED` is expected to be stored as `GL_RGBA16`
     * texture, and `GDK_MEMORY_G8A8` is expected to be stored as `GL_RG8` texture.
     *
     * Setting the right format is particularly useful when using high bit depth textures
     * to preserve the bit depth, to set the correct value for unpremultiplied textures
     * and to make sure opaque textures are treated as such.
     *
     * Non-RGBA textures need to have swizzling parameters set up properly to be usable
     * in GSK's shaders.
     * @param format The texture's format
     */
    setFormat(format: MemoryFormat): void
    /**
     * Sets whether the texture has a mipmap. This allows the renderer and other users of the
     * generated texture to use a higher quality downscaling.
     *
     * Typically, the `glGenerateMipmap` function is used to generate a mimap.
     * @param hasMipmap Whether the texture has a mipmap
     */
    setHasMipmap(hasMipmap: boolean): void
    /**
     * Sets the height of the texture.
     *
     * The height must be set before calling [method`Gdk`.GLTextureBuilder.build].
     * @param height The texture's height or 0 to unset
     */
    setHeight(height: number): void
    /**
     * Sets the texture id of the texture. The texture id must remain unmodified
     * until the texture was finalized. See [method`Gdk`.GLTextureBuilder.build]
     * for a longer discussion.
     *
     * The id must be set before calling [method`Gdk`.GLTextureBuilder.build].
     * @param id The texture id to be used for creating the texture
     */
    setId(id: number): void
    /**
     * Sets the GLSync object to use for the texture.
     *
     * GTK will wait on this object before using the created `GdkTexture`.
     *
     * The `destroy` function that is passed to [method`Gdk`.GLTextureBuilder.build]
     * is responsible for freeing the sync object when it is no longer needed.
     * The texture builder does not destroy it and it is the callers
     * responsibility to make sure it doesn't leak.
     * @param sync the GLSync object
     */
    setSync(sync: any | null): void
    /**
     * Sets the region to be updated by this texture. Together with
     * [property`Gdk`.GLTextureBuilder:update-texture] this describes an
     * update of a previous texture.
     *
     * When rendering animations of large textures, it is possible that
     * consecutive textures are only updating contents in parts of the texture.
     * It is then possible to describe this update via these two properties,
     * so that GTK can avoid rerendering parts that did not change.
     *
     * An example would be a screen recording where only the mouse pointer moves.
     * @param region the region to update
     */
    setUpdateRegion(region: cairo.Region | null): void
    /**
     * Sets the texture to be updated by this texture. See
     * [method`Gdk`.GLTextureBuilder.set_update_region] for an explanation.
     * @param texture the texture to update
     */
    setUpdateTexture(texture: Texture | null): void
    /**
     * Sets the width of the texture.
     *
     * The width must be set before calling [method`Gdk`.GLTextureBuilder.build].
     * @param width The texture's width or 0 to unset
     */
    setWidth(width: number): void

    // Class property signals of Gdk-4.0.Gdk.GLTextureBuilder

    connect(
      sigName: "notify::context",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::context",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::context",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::context",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::context", ...args: any[]): void
    connect(
      sigName: "notify::format",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::format",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::format",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::format",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::format", ...args: any[]): void
    connect(
      sigName: "notify::has-mipmap",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-mipmap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-mipmap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-mipmap",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-mipmap", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(sigName: "notify::id", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::id", ...args: any[]): void
    connect(sigName: "notify::sync", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::sync",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sync",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sync",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sync", ...args: any[]): void
    connect(
      sigName: "notify::update-region",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::update-region",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::update-region",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::update-region",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::update-region", ...args: any[]): void
    connect(
      sigName: "notify::update-texture",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::update-texture",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::update-texture",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::update-texture",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::update-texture", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkGLTextureBuilder` is a builder used to construct [class`Gdk`.Texture] objects from
   * GL textures.
   *
   * The operation is quite simple: Create a texture builder, set all the necessary
   * properties - keep in mind that the properties [property`Gdk`.GLTextureBuilder:context],
   * [property`Gdk`.GLTextureBuilder:id], [property`Gdk`.GLTextureBuilder:width], and
   * [property`Gdk`.GLTextureBuilder:height] are mandatory - and then call
   * [method`Gdk`.GLTextureBuilder.build] to create the new texture.
   *
   * `GdkGLTextureBuilder` can be used for quick one-shot construction of
   * textures as well as kept around and reused to construct multiple textures.
   * @class
   */
  class GLTextureBuilder extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.GLTextureBuilder

    static name: string

    // Constructors of Gdk-4.0.Gdk.GLTextureBuilder

    constructor(config?: GLTextureBuilder.ConstructorProperties)
    /**
     * Creates a new texture builder.
     * @constructor
     * @returns the new `GdkTextureBuilder`
     */
    constructor()
    /**
     * Creates a new texture builder.
     * @constructor
     * @returns the new `GdkTextureBuilder`
     */
    static new(): GLTextureBuilder
    _init(config?: GLTextureBuilder.ConstructorProperties): void
  }

  interface GrabBrokenEvent {
    // Owm methods of Gdk-4.0.Gdk.GrabBrokenEvent

    /**
     * Extracts the grab surface from a grab broken event.
     * @returns the grab surface of @event
     */
    getGrabSurface(): Surface
    /**
     * Checks whether the grab broken event is for an implicit grab.
     * @returns %TRUE if the an implicit grab was broken
     */
    getImplicit(): boolean
  }

  /**
   * An event related to a broken windowing system grab.
   * @class
   */
  class GrabBrokenEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.GrabBrokenEvent

    static name: string
  }

  interface KeyEvent {
    // Owm methods of Gdk-4.0.Gdk.KeyEvent

    /**
     * Extracts the consumed modifiers from a key event.
     * @returns the consumed modifiers or @event
     */
    getConsumedModifiers(): ModifierType
    /**
     * Extracts the keycode from a key event.
     * @returns the keycode of @event
     */
    getKeycode(): number
    /**
     * Extracts the keyval from a key event.
     * @returns the keyval of @event
     */
    getKeyval(): number
    /**
     * Extracts the layout from a key event.
     * @returns the layout of @event
     */
    getLayout(): number
    /**
     * Extracts the shift level from a key event.
     * @returns the shift level of @event
     */
    getLevel(): number
    /**
     * Gets a keyval and modifier combination that will match
     * the event.
     *
     * See [method`Gdk`.KeyEvent.matches].
     * @returns %TRUE on success
     */
    getMatch(): [
      /* returnType */ boolean,
      /* keyval */ number,
      /* modifiers */ ModifierType,
    ]
    /**
     * Extracts whether the key event is for a modifier key.
     * @returns %TRUE if the @event is for a modifier key
     */
    isModifier(): boolean
    /**
     * Matches a key event against a keyval and modifiers.
     *
     * This is typically used to trigger keyboard shortcuts such as Ctrl-C.
     *
     * Partial matches are possible where the combination matches
     * if the currently active group is ignored.
     *
     * Note that we ignore Caps Lock for matching.
     * @param keyval the keyval to match
     * @param modifiers the modifiers to match
     * @returns a `GdkKeyMatch` value describing whether @event matches
     */
    matches(keyval: number, modifiers: ModifierType): KeyMatch
  }

  /**
   * An event related to a key-based device.
   * @class
   */
  class KeyEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.KeyEvent

    static name: string
  }

  module MemoryTexture {
    // Constructor properties interface

    interface ConstructorProperties
      extends Paintable.ConstructorProperties,
        Gio.Icon.ConstructorProperties,
        Gio.LoadableIcon.ConstructorProperties,
        Texture.ConstructorProperties {}
  }

  interface MemoryTexture extends Paintable, Gio.Icon, Gio.LoadableIcon {
    // Own properties of Gdk-4.0.Gdk.MemoryTexture

    __gtype__: number

    // Class property signals of Gdk-4.0.Gdk.MemoryTexture

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkTexture` representing image data in memory.
   * @class
   */
  class MemoryTexture extends Texture {
    // Own properties of Gdk-4.0.Gdk.MemoryTexture

    static name: string

    // Constructors of Gdk-4.0.Gdk.MemoryTexture

    constructor(config?: MemoryTexture.ConstructorProperties)
    /**
     * Creates a new texture for a blob of image data.
     *
     * The `GBytes` must contain `stride` × `height` pixels
     * in the given format.
     * @constructor
     * @param width the width of the texture
     * @param height the height of the texture
     * @param format the format of the data
     * @param bytes the `GBytes` containing the pixel data
     * @param stride rowstride for the data
     * @returns A newly-created `GdkTexture`
     */
    constructor(
      width: number,
      height: number,
      format: MemoryFormat,
      bytes: any,
      stride: number
    )
    /**
     * Creates a new texture for a blob of image data.
     *
     * The `GBytes` must contain `stride` × `height` pixels
     * in the given format.
     * @constructor
     * @param width the width of the texture
     * @param height the height of the texture
     * @param format the format of the data
     * @param bytes the `GBytes` containing the pixel data
     * @param stride rowstride for the data
     * @returns A newly-created `GdkTexture`
     */
    static new(
      width: number,
      height: number,
      format: MemoryFormat,
      bytes: any,
      stride: number
    ): MemoryTexture
    _init(config?: MemoryTexture.ConstructorProperties): void
  }

  module Monitor {
    // Signal callback interfaces

    /**
     * Signal callback interface for `invalidate`
     */
    interface InvalidateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Monitor

      /**
       * The `GdkDisplay` of the monitor.
       */
      display?: Display | null
    }
  }

  interface Monitor {
    // Own properties of Gdk-4.0.Gdk.Monitor

    /**
     * The connector name.
     */
    readonly connector: string | null
    /**
     * A short description of the monitor, meant for display to the user.
     */
    readonly description: string | null
    /**
     * The `GdkDisplay` of the monitor.
     */
    readonly display: Display
    /**
     * The geometry of the monitor.
     */
    readonly geometry: Rectangle
    /**
     * The height of the monitor, in millimeters.
     */
    readonly heightMm: number
    /**
     * The manufacturer name.
     */
    readonly manufacturer: string | null
    /**
     * The model name.
     */
    readonly model: string | null
    /**
     * The refresh rate, in milli-Hertz.
     */
    readonly refreshRate: number
    /**
     * The scale of the monitor.
     */
    readonly scale: number
    /**
     * The scale factor.
     *
     * The scale factor is the next larger integer,
     * compared to [property`Gdk`.Surface:scale].
     */
    readonly scaleFactor: number
    /**
     * The subpixel layout.
     */
    readonly subpixelLayout: SubpixelLayout
    /**
     * Whether the object is still valid.
     */
    readonly valid: boolean
    /**
     * The width of the monitor, in millimeters.
     */
    readonly widthMm: number
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Monitor

    /**
     * Gets the name of the monitor's connector, if available.
     *
     * These are strings such as "eDP-1", or "HDMI-2". They depend
     * on software and hardware configuration, and should not be
     * relied on as stable identifiers of a specific monitor.
     * @returns the name of the connector
     */
    getConnector(): string | null
    /**
     * Gets a string describing the monitor, if available.
     *
     * This can be used to identify a monitor in the UI.
     * @returns the monitor description
     */
    getDescription(): string | null
    /**
     * Gets the display that this monitor belongs to.
     * @returns the display
     */
    getDisplay(): Display
    /**
     * Retrieves the size and position of the monitor within the
     * display coordinate space.
     *
     * The returned geometry is in  ”application pixels”, not in
     * ”device pixels” (see [method`Gdk`.Monitor.get_scale]).
     */
    getGeometry(): /* geometry */ Rectangle
    /**
     * Gets the height in millimeters of the monitor.
     * @returns the physical height of the monitor
     */
    getHeightMm(): number
    /**
     * Gets the name or PNP ID of the monitor's manufacturer.
     *
     * Note that this value might also vary depending on actual
     * display backend.
     *
     * The PNP ID registry is located at
     * [https://uefi.org/pnp_id_list](https://uefi.org/pnp_id_list).
     * @returns the name of the manufacturer
     */
    getManufacturer(): string | null
    /**
     * Gets the string identifying the monitor model, if available.
     * @returns the monitor model
     */
    getModel(): string | null
    /**
     * Gets the refresh rate of the monitor, if available.
     *
     * The value is in milli-Hertz, so a refresh rate of 60Hz
     * is returned as 60000.
     * @returns the refresh rate in milli-Hertz, or 0
     */
    getRefreshRate(): number
    /**
     * Gets the internal scale factor that maps from monitor coordinates
     * to device pixels.
     *
     * This can be used if you want to create pixel based data for a
     * particular monitor, but most of the time you’re drawing to a surface
     * where it is better to use [method`Gdk`.Surface.get_scale] instead.
     * @returns the scale
     */
    getScale(): number
    /**
     * Gets the internal scale factor that maps from monitor coordinates
     * to device pixels.
     *
     * On traditional systems this is 1, but on very high density outputs
     * it can be a higher value (often 2).
     *
     * This can be used if you want to create pixel based data for a
     * particular monitor, but most of the time you’re drawing to a surface
     * where it is better to use [method`Gdk`.Surface.get_scale_factor] instead.
     * @returns the scale factor
     */
    getScaleFactor(): number
    /**
     * Gets information about the layout of red, green and blue
     * primaries for pixels.
     * @returns the subpixel layout
     */
    getSubpixelLayout(): SubpixelLayout
    /**
     * Gets the width in millimeters of the monitor.
     * @returns the physical width of the monitor
     */
    getWidthMm(): number
    /**
     * Returns %TRUE if the `monitor` object corresponds to a
     * physical monitor.
     *
     * The `monitor` becomes invalid when the physical monitor
     * is unplugged or removed.
     * @returns %TRUE if the object corresponds to a physical monitor
     */
    isValid(): boolean

    // Own signals of Gdk-4.0.Gdk.Monitor

    connect(
      sigName: "invalidate",
      callback: Monitor.InvalidateSignalCallback
    ): number
    on(
      sigName: "invalidate",
      callback: Monitor.InvalidateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "invalidate",
      callback: Monitor.InvalidateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "invalidate",
      callback: Monitor.InvalidateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "invalidate", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Monitor

    connect(
      sigName: "notify::connector",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::connector",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::connector",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::connector",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::connector", ...args: any[]): void
    connect(
      sigName: "notify::description",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::description",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::description", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::geometry",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::geometry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::geometry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::geometry",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::geometry", ...args: any[]): void
    connect(
      sigName: "notify::height-mm",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-mm",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-mm",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-mm",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-mm", ...args: any[]): void
    connect(
      sigName: "notify::manufacturer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::manufacturer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::manufacturer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::manufacturer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::manufacturer", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::refresh-rate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::refresh-rate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::refresh-rate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::refresh-rate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::refresh-rate", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::subpixel-layout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::subpixel-layout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::subpixel-layout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::subpixel-layout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::subpixel-layout", ...args: any[]): void
    connect(
      sigName: "notify::valid",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valid",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valid",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valid",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valid", ...args: any[]): void
    connect(
      sigName: "notify::width-mm",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-mm",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-mm",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-mm",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-mm", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkMonitor` objects represent the individual outputs that are
   * associated with a `GdkDisplay`.
   *
   * `GdkDisplay` keeps a `GListModel` to enumerate and monitor
   * monitors with [method`Gdk`.Display.get_monitors]. You can use
   * [method`Gdk`.Display.get_monitor_at_surface] to find a particular
   * monitor.
   * @class
   */
  class Monitor extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Monitor

    static name: string

    // Constructors of Gdk-4.0.Gdk.Monitor

    constructor(config?: Monitor.ConstructorProperties)
    _init(config?: Monitor.ConstructorProperties): void
  }

  interface MotionEvent {}

  /**
   * An event related to a pointer or touch device motion.
   * @class
   */
  class MotionEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.MotionEvent

    static name: string
  }

  interface PadEvent {
    // Owm methods of Gdk-4.0.Gdk.PadEvent

    /**
     * Extracts the information from a pad strip or ring event.
     */
    getAxisValue(): [/* index */ number, /* value */ number]
    /**
     * Extracts information about the pressed button from
     * a pad event.
     * @returns the button of @event
     */
    getButton(): number
    /**
     * Extracts group and mode information from a pad event.
     */
    getGroupMode(): [/* group */ number, /* mode */ number]
  }

  /**
   * An event related to a pad-based device.
   * @class
   */
  class PadEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.PadEvent

    static name: string
  }

  interface ProximityEvent {}

  /**
   * An event related to the proximity of a tool to a device.
   * @class
   */
  class ProximityEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.ProximityEvent

    static name: string
  }

  interface ScrollEvent {
    // Owm methods of Gdk-4.0.Gdk.ScrollEvent

    /**
     * Extracts the scroll deltas of a scroll event.
     *
     * The deltas will be zero unless the scroll direction
     * is %GDK_SCROLL_SMOOTH.
     *
     * For the representation unit of these deltas, see
     * [method`Gdk`.ScrollEvent.get_unit].
     */
    getDeltas(): [/* deltaX */ number, /* deltaY */ number]
    /**
     * Extracts the direction of a scroll event.
     * @returns the scroll direction of @event
     */
    getDirection(): ScrollDirection
    /**
     * Extracts the scroll delta unit of a scroll event.
     *
     * The unit will always be %GDK_SCROLL_UNIT_WHEEL if the scroll direction is not
     * %GDK_SCROLL_SMOOTH.
     * @returns the scroll unit.
     */
    getUnit(): ScrollUnit
    /**
     * Check whether a scroll event is a stop scroll event.
     *
     * Scroll sequences with smooth scroll information may provide
     * a stop scroll event once the interaction with the device finishes,
     * e.g. by lifting a finger. This stop scroll event is the signal
     * that a widget may trigger kinetic scrolling based on the current
     * velocity.
     *
     * Stop scroll events always have a delta of 0/0.
     * @returns %TRUE if the event is a scroll stop event
     */
    isStop(): boolean
  }

  /**
   * An event related to a scrolling motion.
   * @class
   */
  class ScrollEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.ScrollEvent

    static name: string
  }

  module Seat {
    // Signal callback interfaces

    /**
     * Signal callback interface for `device-added`
     */
    interface DeviceAddedSignalCallback {
      (device: Device): void
    }

    /**
     * Signal callback interface for `device-removed`
     */
    interface DeviceRemovedSignalCallback {
      (device: Device): void
    }

    /**
     * Signal callback interface for `tool-added`
     */
    interface ToolAddedSignalCallback {
      (tool: DeviceTool): void
    }

    /**
     * Signal callback interface for `tool-removed`
     */
    interface ToolRemovedSignalCallback {
      (tool: DeviceTool): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Seat

      /**
       * `GdkDisplay` of this seat.
       */
      display?: Display | null
    }
  }

  interface Seat {
    // Own properties of Gdk-4.0.Gdk.Seat

    /**
     * `GdkDisplay` of this seat.
     */
    readonly display: Display
    __gtype__: number

    // Own fields of Gdk-4.0.Gdk.Seat

    parentInstance: GObject.Object

    // Owm methods of Gdk-4.0.Gdk.Seat

    /**
     * Returns the capabilities this `GdkSeat` currently has.
     * @returns the seat capabilities
     */
    getCapabilities(): SeatCapabilities
    /**
     * Returns the devices that match the given capabilities.
     * @param capabilities capabilities to get devices for
     * @returns A list   of `GdkDevices`. The list must be freed with g_list_free(),   the elements are owned by GTK and must not be freed.
     */
    getDevices(capabilities: SeatCapabilities): Device[]
    /**
     * Returns the `GdkDisplay` this seat belongs to.
     * @returns a `GdkDisplay`. This object   is owned by GTK and must not be freed.
     */
    getDisplay(): Display
    /**
     * Returns the device that routes keyboard events.
     * @returns a `GdkDevice` with keyboard   capabilities. This object is owned by GTK and must not be freed.
     */
    getKeyboard(): Device | null
    /**
     * Returns the device that routes pointer events.
     * @returns a `GdkDevice` with pointer   capabilities. This object is owned by GTK and must not be freed.
     */
    getPointer(): Device | null
    /**
     * Returns all `GdkDeviceTools` that are known to the application.
     * @returns A list of tools. Free with g_list_free().
     */
    getTools(): DeviceTool[]

    // Own signals of Gdk-4.0.Gdk.Seat

    connect(
      sigName: "device-added",
      callback: Seat.DeviceAddedSignalCallback
    ): number
    on(
      sigName: "device-added",
      callback: Seat.DeviceAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "device-added",
      callback: Seat.DeviceAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "device-added",
      callback: Seat.DeviceAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "device-added", ...args: any[]): void
    connect(
      sigName: "device-removed",
      callback: Seat.DeviceRemovedSignalCallback
    ): number
    on(
      sigName: "device-removed",
      callback: Seat.DeviceRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "device-removed",
      callback: Seat.DeviceRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "device-removed",
      callback: Seat.DeviceRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "device-removed", ...args: any[]): void
    connect(
      sigName: "tool-added",
      callback: Seat.ToolAddedSignalCallback
    ): number
    on(
      sigName: "tool-added",
      callback: Seat.ToolAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "tool-added",
      callback: Seat.ToolAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "tool-added",
      callback: Seat.ToolAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "tool-added", ...args: any[]): void
    connect(
      sigName: "tool-removed",
      callback: Seat.ToolRemovedSignalCallback
    ): number
    on(
      sigName: "tool-removed",
      callback: Seat.ToolRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "tool-removed",
      callback: Seat.ToolRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "tool-removed",
      callback: Seat.ToolRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "tool-removed", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Seat

    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GdkSeat` object represents a collection of input devices
   * that belong to a user.
   * @class
   */
  class Seat extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Seat

    static name: string

    // Constructors of Gdk-4.0.Gdk.Seat

    constructor(config?: Seat.ConstructorProperties)
    _init(config?: Seat.ConstructorProperties): void
  }

  module Snapshot {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Snapshot {
    // Own properties of Gdk-4.0.Gdk.Snapshot

    __gtype__: number

    // Class property signals of Gdk-4.0.Gdk.Snapshot

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Base type for snapshot operations.
   *
   * The subclass of `GdkSnapshot` used by GTK is [GtkSnapshot](../gtk4/class.Snapshot.html).
   * @class
   */
  class Snapshot extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Snapshot

    static name: string

    // Constructors of Gdk-4.0.Gdk.Snapshot

    constructor(config?: Snapshot.ConstructorProperties)
    _init(config?: Snapshot.ConstructorProperties): void
  }

  module Surface {
    // Signal callback interfaces

    /**
     * Signal callback interface for `enter-monitor`
     */
    interface EnterMonitorSignalCallback {
      (monitor: Monitor): void
    }

    /**
     * Signal callback interface for `event`
     */
    interface EventSignalCallback {
      (event: Event): boolean
    }

    /**
     * Signal callback interface for `layout`
     */
    interface LayoutSignalCallback {
      (width: number, height: number): void
    }

    /**
     * Signal callback interface for `leave-monitor`
     */
    interface LeaveMonitorSignalCallback {
      (monitor: Monitor): void
    }

    /**
     * Signal callback interface for `render`
     */
    interface RenderSignalCallback {
      (region: cairo.Region): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Surface

      /**
       * The mouse pointer for the `GdkSurface`.
       */
      cursor?: Cursor | null
      /**
       * The `GdkDisplay` connection of the surface.
       */
      display?: Display | null
      /**
       * The `GdkFrameClock` of the surface.
       */
      frame_clock?: FrameClock | null
    }
  }

  interface Surface {
    // Own properties of Gdk-4.0.Gdk.Surface

    /**
     * The mouse pointer for the `GdkSurface`.
     */
    cursor: Cursor
    /**
     * The `GdkDisplay` connection of the surface.
     */
    readonly display: Display
    /**
     * The `GdkFrameClock` of the surface.
     */
    readonly frameClock: FrameClock
    /**
     * The height of the surface, in pixels.
     */
    readonly height: number
    /**
     * Whether the surface is mapped.
     */
    readonly mapped: boolean
    /**
     * The scale of the surface.
     */
    readonly scale: number
    /**
     * The scale factor of the surface.
     *
     * The scale factor is the next larger integer,
     * compared to [property`Gdk`.Surface:scale].
     */
    readonly scaleFactor: number
    /**
     * The width of the surface in pixels.
     */
    readonly width: number
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Surface

    /**
     * Emits a short beep associated to `surface`.
     *
     * If the display of `surface` does not support per-surface beeps,
     * emits a short beep on the display just as [method`Gdk`.Display.beep].
     */
    beep(): void
    /**
     * Creates a new `GdkCairoContext` for rendering on `surface`.
     * @returns the newly created `GdkCairoContext`
     */
    createCairoContext(): CairoContext
    /**
     * Creates a new `GdkGLContext` for the `GdkSurface`.
     *
     * The context is disconnected from any particular surface or surface.
     * If the creation of the `GdkGLContext` failed, `error` will be set.
     * Before using the returned `GdkGLContext`, you will need to
     * call [method`Gdk`.GLContext.make_current] or [method`Gdk`.GLContext.realize].
     * @returns the newly created `GdkGLContext`
     */
    createGlContext(): GLContext
    /**
     * Create a new Cairo surface that is as compatible as possible with the
     * given `surface`.
     *
     * For example the new surface will have the same fallback resolution
     * and font options as `surface`. Generally, the new surface will also
     * use the same backend as `surface,` unless that is not possible for
     * some reason. The type of the returned surface may be examined with
     * cairo_surface_get_type().
     *
     * Initially the surface contents are all 0 (transparent if contents
     * have transparency, black otherwise.)
     *
     * This function always returns a valid pointer, but it will return a
     * pointer to a “nil” surface if `other` is already in an error state
     * or any other error occurs.
     * @param content the content for the new surface
     * @param width width of the new surface
     * @param height height of the new surface
     * @returns a pointer to the newly allocated surface. The caller   owns the surface and should call cairo_surface_destroy() when done   with it.
     */
    createSimilarSurface(
      content: cairo.Content,
      width: number,
      height: number
    ): cairo.Surface
    /**
     * Sets an error and returns %NULL.
     * @returns %NULL
     */
    createVulkanContext(): VulkanContext
    /**
     * Destroys the window system resources associated with `surface` and
     * decrements `surface'`s reference count.
     *
     * The window system resources for all children of `surface` are also
     * destroyed, but the children’s reference counts are not decremented.
     *
     * Note that a surface will not be destroyed automatically when its
     * reference count reaches zero. You must call this function yourself
     * before that happens.
     */
    destroy(): void
    /**
     * Retrieves a `GdkCursor` pointer for the cursor currently set on the
     * `GdkSurface`.
     *
     * If the return value is %NULL then there is no custom cursor set on
     * the surface, and it is using the cursor for its parent surface.
     *
     * Use [method`Gdk`.Surface.set_cursor] to unset the cursor of the surface.
     * @returns a `GdkCursor`
     */
    getCursor(): Cursor | null
    /**
     * Retrieves a `GdkCursor` pointer for the `device` currently set on the
     * specified `GdkSurface`.
     *
     * If the return value is %NULL then there is no custom cursor set on the
     * specified surface, and it is using the cursor for its parent surface.
     *
     * Use [method`Gdk`.Surface.set_cursor] to unset the cursor of the surface.
     * @param device a pointer `GdkDevice`
     * @returns a `GdkCursor`
     */
    getDeviceCursor(device: Device): Cursor | null
    /**
     * Obtains the current device position and modifier state.
     *
     * The position is given in coordinates relative to the upper
     * left corner of `surface`.
     * @param device pointer `GdkDevice` to query to
     * @returns %TRUE if the device is over the surface
     */
    getDevicePosition(
      device: Device
    ): [
      /* returnType */ boolean,
      /* x */ number,
      /* y */ number,
      /* mask */ ModifierType,
    ]
    /**
     * Gets the `GdkDisplay` associated with a `GdkSurface`.
     * @returns the `GdkDisplay` associated with @surface
     */
    getDisplay(): Display
    /**
     * Gets the frame clock for the surface.
     *
     * The frame clock for a surface never changes unless the surface is
     * reparented to a new toplevel surface.
     * @returns the frame clock
     */
    getFrameClock(): FrameClock
    /**
     * Returns the height of the given `surface`.
     *
     * Surface size is reported in ”application pixels”, not
     * ”device pixels” (see [method`Gdk`.Surface.get_scale_factor]).
     * @returns The height of @surface
     */
    getHeight(): number
    /**
     * Checks whether the surface has been mapped.
     *
     * A surface is mapped with [method`Gdk`.Toplevel.present]
     * or [method`Gdk`.Popup.present].
     * @returns %TRUE if the surface is mapped
     */
    getMapped(): boolean
    /**
     * Returns the internal scale that maps from surface coordinates
     * to the actual device pixels.
     *
     * When the scale is bigger than 1, the windowing system prefers to get
     * buffers with a resolution that is bigger than the surface size (e.g.
     * to show the surface on a high-resolution display, or in a magnifier).
     *
     * Compare with [method`Gdk`.Surface.get_scale_factor], which returns the
     * next larger integer.
     *
     * The scale may change during the lifetime of the surface.
     * @returns the scale
     */
    getScale(): number
    /**
     * Returns the internal scale factor that maps from surface coordinates
     * to the actual device pixels.
     *
     * On traditional systems this is 1, but on very high density outputs
     * this can be a higher value (often 2). A higher value means that drawing
     * is automatically scaled up to a higher resolution, so any code doing
     * drawing will automatically look nicer. However, if you are supplying
     * pixel-based data the scale value can be used to determine whether to
     * use a pixel resource with higher resolution data.
     *
     * The scale factor may change during the lifetime of the surface.
     * @returns the scale factor
     */
    getScaleFactor(): number
    /**
     * Returns the width of the given `surface`.
     *
     * Surface size is reported in ”application pixels”, not
     * ”device pixels” (see [method`Gdk`.Surface.get_scale_factor]).
     * @returns The width of @surface
     */
    getWidth(): number
    /**
     * Hide the surface.
     *
     * For toplevel surfaces, withdraws them, so they will no longer be
     * known to the window manager; for all surfaces, unmaps them, so
     * they won’t be displayed. Normally done automatically as
     * part of [gtk_widget_hide()](../gtk4/method.Widget.hide.html).
     */
    hide(): void
    /**
     * Check to see if a surface is destroyed.
     * @returns %TRUE if the surface is destroyed
     */
    isDestroyed(): boolean
    /**
     * Forces a [signal`Gdk`.Surface::render] signal emission for `surface`
     * to be scheduled.
     *
     * This function is useful for implementations that track invalid
     * regions on their own.
     */
    queueRender(): void
    /**
     * Request a layout phase from the surface's frame clock.
     *
     * See [method`Gdk`.FrameClock.request_phase].
     */
    requestLayout(): void
    /**
     * Sets the default mouse pointer for a `GdkSurface`.
     *
     * Passing %NULL for the `cursor` argument means that `surface` will use
     * the cursor of its parent surface. Most surfaces should use this default.
     * Note that `cursor` must be for the same display as `surface`.
     *
     * Use [ctor`Gdk`.Cursor.new_from_name] or [ctor`Gdk`.Cursor.new_from_texture]
     * to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
     * @param cursor a `GdkCursor`
     */
    setCursor(cursor: Cursor | null): void
    /**
     * Sets a specific `GdkCursor` for a given device when it gets inside `surface`.
     *
     * Passing %NULL for the `cursor` argument means that `surface` will use the
     * cursor of its parent surface. Most surfaces should use this default.
     *
     * Use [ctor`Gdk`.Cursor.new_from_name] or [ctor`Gdk`.Cursor.new_from_texture]
     * to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
     * @param device a pointer `GdkDevice`
     * @param cursor a `GdkCursor`
     */
    setDeviceCursor(device: Device, cursor: Cursor): void
    /**
     * Apply the region to the surface for the purpose of event
     * handling.
     *
     * Mouse events which happen while the pointer position corresponds
     * to an unset bit in the mask will be passed on the surface below
     * `surface`.
     *
     * An input region is typically used with RGBA surfaces. The alpha
     * channel of the surface defines which pixels are invisible and
     * allows for nicely antialiased borders, and the input region
     * controls where the surface is “clickable”.
     *
     * Use [method`Gdk`.Display.supports_input_shapes] to find out if
     * a particular backend supports input regions.
     * @param region region of surface to be reactive
     */
    setInputRegion(region: cairo.Region): void
    /**
     * Marks a region of the `GdkSurface` as opaque.
     *
     * For optimisation purposes, compositing window managers may
     * like to not draw obscured regions of surfaces, or turn off blending
     * during for these regions. With RGB windows with no transparency,
     * this is just the shape of the window, but with ARGB32 windows, the
     * compositor does not know what regions of the window are transparent
     * or not.
     *
     * This function only works for toplevel surfaces.
     *
     * GTK will update this property automatically if the `surface` background
     * is opaque, as we know where the opaque regions are. If your surface
     * background is not opaque, please update this property in your
     * [GtkWidgetClass.css_changed](../gtk4/vfunc.Widget.css_changed.html) handler.
     * @param region a region, or %NULL to make the entire   surface opaque
     */
    setOpaqueRegion(region: cairo.Region | null): void
    /**
     * Translates coordinates between two surfaces.
     *
     * Note that this only works if `to` and `from` are popups or
     * transient-for to the same toplevel (directly or indirectly).
     * @param to the target surface
     * @param x coordinates to translate
     * @param y coordinates to translate
     * @returns %TRUE if the coordinates were successfully translated
     */
    translateCoordinates(
      to: Surface,
      x: number,
      y: number
    ): [/* returnType */ boolean, /* x */ number, /* y */ number]

    // Own signals of Gdk-4.0.Gdk.Surface

    connect(
      sigName: "enter-monitor",
      callback: Surface.EnterMonitorSignalCallback
    ): number
    on(
      sigName: "enter-monitor",
      callback: Surface.EnterMonitorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "enter-monitor",
      callback: Surface.EnterMonitorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "enter-monitor",
      callback: Surface.EnterMonitorSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "enter-monitor", ...args: any[]): void
    connect(sigName: "event", callback: Surface.EventSignalCallback): number
    on(
      sigName: "event",
      callback: Surface.EventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "event",
      callback: Surface.EventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "event",
      callback: Surface.EventSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "event", ...args: any[]): void
    connect(sigName: "layout", callback: Surface.LayoutSignalCallback): number
    on(
      sigName: "layout",
      callback: Surface.LayoutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "layout",
      callback: Surface.LayoutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "layout",
      callback: Surface.LayoutSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "layout", height: number, ...args: any[]): void
    connect(
      sigName: "leave-monitor",
      callback: Surface.LeaveMonitorSignalCallback
    ): number
    on(
      sigName: "leave-monitor",
      callback: Surface.LeaveMonitorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "leave-monitor",
      callback: Surface.LeaveMonitorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "leave-monitor",
      callback: Surface.LeaveMonitorSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "leave-monitor", ...args: any[]): void
    connect(sigName: "render", callback: Surface.RenderSignalCallback): number
    on(
      sigName: "render",
      callback: Surface.RenderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "render",
      callback: Surface.RenderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "render",
      callback: Surface.RenderSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "render", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.Surface

    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::frame-clock",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::frame-clock", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mapped",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mapped", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GdkSurface` is a rectangular region on the screen.
   *
   * It’s a low-level object, used to implement high-level objects
   * such as [GtkWindow](../gtk4/class.Window.html).
   *
   * The surfaces you see in practice are either [iface`Gdk`.Toplevel] or
   * [iface`Gdk`.Popup], and those interfaces provide much of the required
   * API to interact with these surfaces. Other, more specialized surface
   * types exist, but you will rarely interact with them directly.
   * @interface
   */
  class Surface extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Surface

    static name: string

    // Constructors of Gdk-4.0.Gdk.Surface

    constructor(config?: Surface.ConstructorProperties)
    /**
     * Create a new popup surface.
     *
     * The surface will be attached to `parent` and can be positioned
     * relative to it using [method`Gdk`.Popup.present].
     * @constructor
     * @param parent the parent surface to attach the surface to
     * @param autohide whether to hide the surface on outside clicks
     * @returns a new `GdkSurface`
     */
    static newPopup(parent: Surface, autohide: boolean): Surface
    /**
     * Creates a new toplevel surface.
     * @constructor
     * @param display the display to create the surface on
     * @returns the new `GdkSurface`
     */
    static newToplevel(display: Display): Surface
    _init(config?: Surface.ConstructorProperties): void
  }

  module Texture {
    // Constructor properties interface

    interface ConstructorProperties
      extends Paintable.ConstructorProperties,
        Gio.Icon.ConstructorProperties,
        Gio.LoadableIcon.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gdk-4.0.Gdk.Texture

      /**
       * The height of the texture, in pixels.
       */
      height?: number | null
      /**
       * The width of the texture, in pixels.
       */
      width?: number | null
    }
  }

  interface Texture extends Paintable, Gio.Icon, Gio.LoadableIcon {
    // Own properties of Gdk-4.0.Gdk.Texture

    /**
     * The height of the texture, in pixels.
     */
    readonly height: number
    /**
     * The width of the texture, in pixels.
     */
    readonly width: number
    __gtype__: number

    // Owm methods of Gdk-4.0.Gdk.Texture

    /**
     * Downloads the `texture` into local memory.
     *
     * This may be an expensive operation, as the actual texture data
     * may reside on a GPU or on a remote display server.
     *
     * The data format of the downloaded data is equivalent to
     * %CAIRO_FORMAT_ARGB32, so every downloaded pixel requires
     * 4 bytes of memory.
     *
     * Downloading a texture into a Cairo image surface:
     * ```c
     * surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
     *                                       gdk_texture_get_width (texture),
     *                                       gdk_texture_get_height (texture));
     * gdk_texture_download (texture,
     *                       cairo_image_surface_get_data (surface),
     *                       cairo_image_surface_get_stride (surface));
     * cairo_surface_mark_dirty (surface);
     * ```
     *
     * For more flexible download capabilities, see
     * [struct`Gdk`.TextureDownloader].
     * @param data pointer to enough memory to be filled with the   downloaded data of `texture`
     * @param stride rowstride in bytes
     */
    download(data: number[], stride: number): void
    /**
     * Gets the memory format most closely associated with the data of
     * the texture.
     *
     * Note that it may not be an exact match for texture data
     * stored on the GPU or with compression.
     *
     * The format can give an indication about the bit depth and opacity
     * of the texture and is useful to determine the best format for
     * downloading the texture.
     * @returns the preferred format for the texture's data
     */
    getFormat(): MemoryFormat
    /**
     * Returns the height of the `texture,` in pixels.
     * @returns the height of the `GdkTexture`
     */
    getHeight(): number
    /**
     * Returns the width of `texture,` in pixels.
     * @returns the width of the `GdkTexture`
     */
    getWidth(): number
    /**
     * Store the given `texture` to the `filename` as a PNG file.
     *
     * This is a utility function intended for debugging and testing.
     * If you want more control over formats, proper error handling or
     * want to store to a [iface`Gio`.File] or other location, you might want to
     * use [method`Gdk`.Texture.save_to_png_bytes] or look into the
     * gdk-pixbuf library.
     * @param filename the filename to store to
     * @returns %TRUE if saving succeeded, %FALSE on failure.
     */
    saveToPng(filename: string): boolean
    /**
     * Store the given `texture` in memory as a PNG file.
     *
     * Use [ctor`Gdk`.Texture.new_from_bytes] to read it back.
     *
     * If you want to serialize a texture, this is a convenient and
     * portable way to do that.
     *
     * If you need more control over the generated image, such as
     * attaching metadata, you should look into an image handling
     * library such as the gdk-pixbuf library.
     *
     * If you are dealing with high dynamic range float data, you
     * might also want to consider [method`Gdk`.Texture.save_to_tiff_bytes]
     * instead.
     * @returns a newly allocated `GBytes` containing PNG data
     */
    saveToPngBytes(): any
    /**
     * Store the given `texture` to the `filename` as a TIFF file.
     *
     * GTK will attempt to store data without loss.
     * @param filename the filename to store to
     * @returns %TRUE if saving succeeded, %FALSE on failure.
     */
    saveToTiff(filename: string): boolean
    /**
     * Store the given `texture` in memory as a TIFF file.
     *
     * Use [ctor`Gdk`.Texture.new_from_bytes] to read it back.
     *
     * This function is intended to store a representation of the
     * texture's data that is as accurate as possible. This is
     * particularly relevant when working with high dynamic range
     * images and floating-point texture data.
     *
     * If that is not your concern and you are interested in a
     * smaller size and a more portable format, you might want to
     * use [method`Gdk`.Texture.save_to_png_bytes].
     * @returns a newly allocated `GBytes` containing TIFF data
     */
    saveToTiffBytes(): any

    // Class property signals of Gdk-4.0.Gdk.Texture

    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkTexture` is the basic element used to refer to pixel data.
   *
   * It is primarily meant for pixel data that will not change over
   * multiple frames, and will be used for a long time.
   *
   * There are various ways to create `GdkTexture` objects from a
   * [class`GdkPixbuf`.Pixbuf], or from bytes stored in memory, a file, or a
   * [struct`Gio`.Resource].
   *
   * The ownership of the pixel data is transferred to the `GdkTexture`
   * instance; you can only make a copy of it, via [method`Gdk`.Texture.download].
   *
   * `GdkTexture` is an immutable object: That means you cannot change
   * anything about it other than increasing the reference count via
   * [method`GObject`.Object.ref], and consequently, it is a thread-safe object.
   * @class
   */
  class Texture extends GObject.Object {
    // Own properties of Gdk-4.0.Gdk.Texture

    static name: string

    // Constructors of Gdk-4.0.Gdk.Texture

    constructor(config?: Texture.ConstructorProperties)
    /**
     * Creates a new texture object representing the `GdkPixbuf`.
     *
     * This function is threadsafe, so that you can e.g. use GTask
     * and [method`Gio`.Task.run_in_thread] to avoid blocking the main thread
     * while loading a big image.
     * @constructor
     * @param pixbuf a `GdkPixbuf`
     * @returns a new `GdkTexture`
     */
    static newForPixbuf(pixbuf: GdkPixbuf.Pixbuf): Texture
    /**
     * Creates a new texture by loading an image from memory,
     *
     * The file format is detected automatically. The supported formats
     * are PNG, JPEG and TIFF, though more formats might be available.
     *
     * If %NULL is returned, then `error` will be set.
     *
     * This function is threadsafe, so that you can e.g. use GTask
     * and [method`Gio`.Task.run_in_thread] to avoid blocking the main thread
     * while loading a big image.
     * @constructor
     * @param bytes a `GBytes` containing the data to load
     * @returns A newly-created `GdkTexture`
     */
    static newFromBytes(bytes: any): Texture
    /**
     * Creates a new texture by loading an image from a file.
     *
     * The file format is detected automatically. The supported formats
     * are PNG, JPEG and TIFF, though more formats might be available.
     *
     * If %NULL is returned, then `error` will be set.
     *
     * This function is threadsafe, so that you can e.g. use GTask
     * and [method`Gio`.Task.run_in_thread] to avoid blocking the main thread
     * while loading a big image.
     * @constructor
     * @param file `GFile` to load
     * @returns A newly-created `GdkTexture`
     */
    static newFromFile(file: Gio.File): Texture
    /**
     * Creates a new texture by loading an image from a file.
     *
     * The file format is detected automatically. The supported formats
     * are PNG, JPEG and TIFF, though more formats might be available.
     *
     * If %NULL is returned, then `error` will be set.
     *
     * This function is threadsafe, so that you can e.g. use GTask
     * and [method`Gio`.Task.run_in_thread] to avoid blocking the main thread
     * while loading a big image.
     * @constructor
     * @param path the filename to load
     * @returns A newly-created `GdkTexture`
     */
    static newFromFilename(path: string): Texture
    /**
     * Creates a new texture by loading an image from a resource.
     *
     * The file format is detected automatically. The supported formats
     * are PNG and JPEG, though more formats might be available.
     *
     * It is a fatal error if `resource_path` does not specify a valid
     * image resource and the program will abort if that happens.
     * If you are unsure about the validity of a resource, use
     * [ctor`Gdk`.Texture.new_from_file] to load it.
     *
     * This function is threadsafe, so that you can e.g. use GTask
     * and [method`Gio`.Task.run_in_thread] to avoid blocking the main thread
     * while loading a big image.
     * @constructor
     * @param resourcePath the path of the resource file
     * @returns A newly-created `GdkTexture`
     */
    static newFromResource(resourcePath: string): Texture
    _init(config?: Texture.ConstructorProperties): void
  }

  interface TouchEvent {
    // Owm methods of Gdk-4.0.Gdk.TouchEvent

    /**
     * Extracts whether a touch event is emulating a pointer event.
     * @returns %TRUE if @event is emulating
     */
    getEmulatingPointer(): boolean
  }

  /**
   * An event related to a touch-based device.
   * @class
   */
  class TouchEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.TouchEvent

    static name: string
  }

  interface TouchpadEvent {
    // Owm methods of Gdk-4.0.Gdk.TouchpadEvent

    /**
     * Extracts delta information from a touchpad event.
     */
    getDeltas(): [/* dx */ number, /* dy */ number]
    /**
     * Extracts the touchpad gesture phase from a touchpad event.
     * @returns the gesture phase of @event
     */
    getGesturePhase(): TouchpadGesturePhase
    /**
     * Extracts the number of fingers from a touchpad event.
     * @returns the number of fingers for @event
     */
    getNFingers(): number
    /**
     * Extracts the angle delta from a touchpad pinch event.
     * @returns the angle delta of @event
     */
    getPinchAngleDelta(): number
    /**
     * Extracts the scale from a touchpad pinch event.
     * @returns the scale of @event
     */
    getPinchScale(): number
  }

  /**
   * An event related to a gesture on a touchpad device.
   *
   * Unlike touchscreens, where the windowing system sends basic
   * sequences of begin, update, end events, and leaves gesture
   * recognition to the clients, touchpad gestures are typically
   * processed by the system, resulting in these events.
   * @class
   */
  class TouchpadEvent extends Event {
    // Own properties of Gdk-4.0.Gdk.TouchpadEvent

    static name: string
  }

  module VulkanContext {
    // Signal callback interfaces

    /**
     * Signal callback interface for `images-updated`
     */
    interface ImagesUpdatedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.Initable.ConstructorProperties,
        DrawContext.ConstructorProperties {}
  }

  interface VulkanContext extends Gio.Initable {
    // Own properties of Gdk-4.0.Gdk.VulkanContext

    __gtype__: number

    // Own signals of Gdk-4.0.Gdk.VulkanContext

    connect(
      sigName: "images-updated",
      callback: VulkanContext.ImagesUpdatedSignalCallback
    ): number
    on(
      sigName: "images-updated",
      callback: VulkanContext.ImagesUpdatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "images-updated",
      callback: VulkanContext.ImagesUpdatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "images-updated",
      callback: VulkanContext.ImagesUpdatedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "images-updated", ...args: any[]): void

    // Class property signals of Gdk-4.0.Gdk.VulkanContext

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GdkVulkanContext` is an object representing the platform-specific
   * Vulkan draw context.
   *
   * `GdkVulkanContext`s are created for a surface using
   * [method`Gdk`.Surface.create_vulkan_context], and the context will match
   * the characteristics of the surface.
   *
   * Support for `GdkVulkanContext` is platform-specific and context creation
   * can fail, returning %NULL context.
   * @class
   */
  class VulkanContext extends DrawContext {
    // Own properties of Gdk-4.0.Gdk.VulkanContext

    static name: string

    // Constructors of Gdk-4.0.Gdk.VulkanContext

    constructor(config?: VulkanContext.ConstructorProperties)
    _init(config?: VulkanContext.ConstructorProperties): void
  }

  interface ContentFormats {
    // Owm methods of Gdk-4.0.Gdk.ContentFormats

    /**
     * Checks if a given `GType` is part of the given `formats`.
     * @param type the `GType` to search for
     * @returns %TRUE if the `GType` was found
     */
    containGtype(type: GObject.GType): boolean
    /**
     * Checks if a given mime type is part of the given `formats`.
     * @param mimeType the mime type to search for
     * @returns %TRUE if the mime_type was found
     */
    containMimeType(mimeType: string): boolean
    /**
     * Gets the `GType`s included in `formats`.
     *
     * Note that `formats` may not contain any `GType`s, in particular when
     * they are empty. In that case %NULL will be returned.
     * @returns %G_TYPE_INVALID-terminated array of types included in @formats
     */
    getGtypes(): GObject.GType[] | null
    /**
     * Gets the mime types included in `formats`.
     *
     * Note that `formats` may not contain any mime types, in particular
     * when they are empty. In that case %NULL will be returned.
     * @returns %NULL-terminated array of interned strings of mime types included   in @formats
     */
    getMimeTypes(): string[] | null
    /**
     * Checks if `first` and `second` have any matching formats.
     * @param second the `GdkContentFormats` to intersect with
     * @returns %TRUE if a matching format was found.
     */
    match(second: ContentFormats): boolean
    /**
     * Finds the first `GType` from `first` that is also contained
     * in `second`.
     *
     * If no matching `GType` is found, %G_TYPE_INVALID is returned.
     * @param second the `GdkContentFormats` to intersect with
     * @returns The first common `GType` or %G_TYPE_INVALID if none.
     */
    matchGtype(second: ContentFormats): GObject.GType
    /**
     * Finds the first mime type from `first` that is also contained
     * in `second`.
     *
     * If no matching mime type is found, %NULL is returned.
     * @param second the `GdkContentFormats` to intersect with
     * @returns The first common mime type or %NULL if none
     */
    matchMimeType(second: ContentFormats): string | null
    /**
     * Prints the given `formats` into a string for human consumption.
     *
     * The result of this function can later be parsed with
     * [func`Gdk`.ContentFormats.parse].
     * @param string a `GString` to print into
     */
    print(string: GLib.String): void
    /**
     * Increases the reference count of a `GdkContentFormats` by one.
     * @returns the passed in `GdkContentFormats`.
     */
    ref(): ContentFormats
    /**
     * Prints the given `formats` into a human-readable string.
     *
     * The resulting string can be parsed with [func`Gdk`.ContentFormats.parse].
     *
     * This is a small wrapper around [method`Gdk`.ContentFormats.print]
     * to help when debugging.
     * @returns a new string
     */
    toString(): string | null
    /**
     * Append all missing types from `second` to `first,` in the order
     * they had in `second`.
     * @param second the `GdkContentFormats` to merge from
     * @returns a new `GdkContentFormats`
     */
    union(second: ContentFormats): ContentFormats
    /**
     * Add GTypes for mime types in `formats` for which deserializers are
     * registered.
     * @returns a new `GdkContentFormats`
     */
    unionDeserializeGtypes(): ContentFormats
    /**
     * Add mime types for GTypes in `formats` for which deserializers are
     * registered.
     * @returns a new `GdkContentFormats`
     */
    unionDeserializeMimeTypes(): ContentFormats
    /**
     * Add GTypes for the mime types in `formats` for which serializers are
     * registered.
     * @returns a new `GdkContentFormats`
     */
    unionSerializeGtypes(): ContentFormats
    /**
     * Add mime types for GTypes in `formats` for which serializers are
     * registered.
     * @returns a new `GdkContentFormats`
     */
    unionSerializeMimeTypes(): ContentFormats
    /**
     * Decreases the reference count of a `GdkContentFormats` by one.
     *
     * If the resulting reference count is zero, frees the formats.
     */
    unref(): void
  }

  /**
   * The `GdkContentFormats` structure is used to advertise and negotiate the
   * format of content.
   *
   * You will encounter `GdkContentFormats` when interacting with objects
   * controlling operations that pass data between different widgets, window
   * or application, like [class`Gdk`.Drag], [class`Gdk`.Drop],
   * [class`Gdk`.Clipboard] or [class`Gdk`.ContentProvider].
   *
   * GDK supports content in 2 forms: `GType` and mime type.
   * Using `GTypes` is meant only for in-process content transfers. Mime types
   * are meant to be used for data passing both in-process and out-of-process.
   * The details of how data is passed is described in the documentation of
   * the actual implementations. To transform between the two forms,
   * [class`Gdk`.ContentSerializer] and [class`Gdk`.ContentDeserializer] are used.
   *
   * A `GdkContentFormats` describes a set of possible formats content can be
   * exchanged in. It is assumed that this set is ordered. `GTypes` are more
   * important than mime types. Order between different `GTypes` or mime types
   * is the order they were added in, most important first. Functions that
   * care about order, such as [method`Gdk`.ContentFormats.union], will describe
   * in their documentation how they interpret that order, though in general the
   * order of the first argument is considered the primary order of the result,
   * followed by the order of further arguments.
   *
   * For debugging purposes, the function [method`Gdk`.ContentFormats.to_string]
   * exists. It will print a comma-separated list of formats from most important
   * to least important.
   *
   * `GdkContentFormats` is an immutable struct. After creation, you cannot change
   * the types it represents. Instead, new `GdkContentFormats` have to be created.
   * The [struct`Gdk`.ContentFormatsBuilder] structure is meant to help in this
   * endeavor.
   * @record
   */
  class ContentFormats {
    // Own properties of Gdk-4.0.Gdk.ContentFormats

    static name: string

    // Constructors of Gdk-4.0.Gdk.ContentFormats

    /**
     * Creates a new `GdkContentFormats` from an array of mime types.
     *
     * The mime types must be valid and different from each other or the
     * behavior of the return value is undefined. If you cannot guarantee
     * this, use [struct`Gdk`.ContentFormatsBuilder] instead.
     * @constructor
     * @param mimeTypes Pointer to an   array of mime types
     * @returns the new `GdkContentFormats`.
     */
    constructor(mimeTypes: string[] | null)
    /**
     * Creates a new `GdkContentFormats` from an array of mime types.
     *
     * The mime types must be valid and different from each other or the
     * behavior of the return value is undefined. If you cannot guarantee
     * this, use [struct`Gdk`.ContentFormatsBuilder] instead.
     * @constructor
     * @param mimeTypes Pointer to an   array of mime types
     * @returns the new `GdkContentFormats`.
     */
    static new(mimeTypes: string[] | null): ContentFormats
    /**
     * Creates a new `GdkContentFormats` for a given `GType`.
     * @constructor
     * @param type a `GType`
     * @returns a new `GdkContentFormats`
     */
    static newForGtype(type: GObject.GType): ContentFormats
    /**
     * Parses the given `string` into `GdkContentFormats` and
     * returns the formats.
     *
     * Strings printed via [method`Gdk`.ContentFormats.to_string]
     * can be read in again successfully using this function.
     *
     * If `string` does not describe valid content formats, %NULL
     * is returned.
     * @param string the string to parse
     * @returns the content formats if @string is valid
     */
    static parse(string: string): ContentFormats | null
  }

  interface ContentFormatsBuilder {
    // Owm methods of Gdk-4.0.Gdk.ContentFormatsBuilder

    /**
     * Appends all formats from `formats` to `builder,` skipping those that
     * already exist.
     * @param formats the formats to add
     */
    addFormats(formats: ContentFormats): void
    /**
     * Appends `type` to `builder` if it has not already been added.
     * @param type a `GType`
     */
    addGtype(type: GObject.GType): void
    /**
     * Appends `mime_type` to `builder` if it has not already been added.
     * @param mimeType a mime type
     */
    addMimeType(mimeType: string): void
    /**
     * Acquires a reference on the given `builder`.
     *
     * This function is intended primarily for bindings.
     * `GdkContentFormatsBuilder` objects should not be kept around.
     * @returns the given `GdkContentFormatsBuilder`   with its reference count increased
     */
    ref(): ContentFormatsBuilder
    /**
     * Creates a new `GdkContentFormats` from the given `builder`.
     *
     * The given `GdkContentFormatsBuilder` is reset once this function returns;
     * you cannot call this function multiple times on the same `builder` instance.
     *
     * This function is intended primarily for bindings. C code should use
     * [method`Gdk`.ContentFormatsBuilder.free_to_formats].
     * @returns the newly created `GdkContentFormats`   with all the formats added to @builder
     */
    toFormats(): ContentFormats
    /**
     * Releases a reference on the given `builder`.
     */
    unref(): void
  }

  /**
   * A `GdkContentFormatsBuilder` is an auxiliary struct used to create
   * new `GdkContentFormats`, and should not be kept around.
   * @record
   */
  class ContentFormatsBuilder {
    // Own properties of Gdk-4.0.Gdk.ContentFormatsBuilder

    static name: string

    // Constructors of Gdk-4.0.Gdk.ContentFormatsBuilder

    /**
     * Create a new `GdkContentFormatsBuilder` object.
     *
     * The resulting builder would create an empty `GdkContentFormats`.
     * Use addition functions to add types to it.
     * @constructor
     * @returns a new `GdkContentFormatsBuilder`
     */
    constructor()
    /**
     * Create a new `GdkContentFormatsBuilder` object.
     *
     * The resulting builder would create an empty `GdkContentFormats`.
     * Use addition functions to add types to it.
     * @constructor
     * @returns a new `GdkContentFormatsBuilder`
     */
    static new(): ContentFormatsBuilder
  }

  interface ContentProviderClass {
    // Own fields of Gdk-4.0.Gdk.ContentProviderClass

    parentClass: GObject.ObjectClass
    /**
     * Signal class closure for `GdkContentProvider::content-changed`
     * @field
     */
    contentChanged: (provider: ContentProvider) => void
    attachClipboard: (provider: ContentProvider, clipboard: Clipboard) => void
    detachClipboard: (provider: ContentProvider, clipboard: Clipboard) => void
    refFormats: (provider: ContentProvider) => ContentFormats
    refStorableFormats: (provider: ContentProvider) => ContentFormats
    writeMimeTypeAsync: (
      provider: ContentProvider,
      mimeType: string,
      stream: Gio.OutputStream,
      ioPriority: number,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ) => void
    writeMimeTypeFinish: (
      provider: ContentProvider,
      result: Gio.AsyncResult
    ) => boolean
    getValue: (
      provider: ContentProvider
    ) => [/* returnType */ boolean, /* value */ any]
  }

  /**
   * Class structure for `GdkContentProvider`.
   * @record
   */
  abstract class ContentProviderClass {
    // Own properties of Gdk-4.0.Gdk.ContentProviderClass

    static name: string
  }

  interface DevicePadInterface {}

  abstract class DevicePadInterface {
    // Own properties of Gdk-4.0.Gdk.DevicePadInterface

    static name: string
  }

  interface DmabufFormats {
    // Owm methods of Gdk-4.0.Gdk.DmabufFormats

    /**
     * Returns whether a given format is contained in `formats`.
     * @param fourcc a format code
     * @param modifier a format modifier
     * @returns `TRUE` if the format specified by the arguments   is part of @formats
     */
    contains(fourcc: number, modifier: number): boolean
    /**
     * Returns whether `formats1` and `formats2` contain the
     * same dmabuf formats, in the same order.
     * @param formats2 another `GdkDmabufFormats`
     * @returns `TRUE` if @formats1 and @formats2 are equal
     */
    equal(formats2: DmabufFormats | null): boolean
    /**
     * Gets the fourcc code and modifier for a format
     * that is contained in `formats`.
     * @param idx the index of the format to return
     */
    getFormat(idx: number): [/* fourcc */ number, /* modifier */ number]
    /**
     * Returns the number of formats that the `formats` object
     * contains.
     *
     * Note that DMA buffers are a Linux concept, so on other
     * platforms, [method`Gdk`.DmabufFormats.get_n_formats] will
     * always return zero.
     * @returns the number of formats
     */
    getNFormats(): number
    /**
     * Increases the reference count of `formats`.
     * @returns the passed-in object
     */
    ref(): DmabufFormats
    /**
     * Decreases the reference count of `formats`.
     *
     * When the reference count reaches zero,
     * the object is freed.
     */
    unref(): void
  }

  /**
   * The `GdkDmabufFormats` struct provides information about
   * supported DMA buffer formats.
   *
   * You can query whether a given format is supported with
   * [method`Gdk`.DmabufFormats.contains] and you can iterate
   * over the list of all supported formats with
   * [method`Gdk`.DmabufFormats.get_n_formats] and
   * [method`Gdk`.DmabufFormats.get_format].
   *
   * The list of supported formats is sorted by preference,
   * with the best formats coming first.
   *
   * The list may contains (format, modifier) pairs where the modifier
   * is `DMA_FORMAT_MOD_INVALID`, indicating that **_implicit modifiers_**
   * may be used with this format.
   *
   * See [class`Gdk`.DmabufTextureBuilder] for more information
   * about DMA buffers.
   *
   * Note that DMA buffers only exist on Linux.
   * @record
   */
  class DmabufFormats {
    // Own properties of Gdk-4.0.Gdk.DmabufFormats

    static name: string
  }

  interface DmabufTextureBuilderClass {}

  abstract class DmabufTextureBuilderClass {
    // Own properties of Gdk-4.0.Gdk.DmabufTextureBuilderClass

    static name: string
  }

  interface DmabufTextureClass {}

  abstract class DmabufTextureClass {
    // Own properties of Gdk-4.0.Gdk.DmabufTextureClass

    static name: string
  }

  interface DragSurfaceInterface {}

  /**
   * The `GdkDragSurfaceInterface` implementation is private to GDK.
   * @record
   */
  abstract class DragSurfaceInterface {
    // Own properties of Gdk-4.0.Gdk.DragSurfaceInterface

    static name: string
  }

  interface DragSurfaceSize {
    // Owm methods of Gdk-4.0.Gdk.DragSurfaceSize

    /**
     * Sets the size the drag surface prefers to be resized to.
     * @param width the width
     * @param height the height
     */
    setSize(width: number, height: number): void
  }

  /**
   * The `GdkDragSurfaceSize` struct contains information that is useful
   * to compute the size of a drag surface.
   * @record
   */
  class DragSurfaceSize {
    // Own properties of Gdk-4.0.Gdk.DragSurfaceSize

    static name: string
  }

  interface EventSequence {}

  /**
   * `GdkEventSequence` is an opaque type representing a sequence
   * of related touch events.
   * @record
   */
  class EventSequence {
    // Own properties of Gdk-4.0.Gdk.EventSequence

    static name: string
  }

  interface FileList {
    // Owm methods of Gdk-4.0.Gdk.FileList

    /**
     * Retrieves the list of files inside a `GdkFileList`.
     *
     * This function is meant for language bindings.
     * @returns the files inside the list
     */
    getFiles(): Gio.File[]
  }

  /**
   * An opaque type representing a list of files.
   * @record
   */
  class FileList {
    // Own properties of Gdk-4.0.Gdk.FileList

    static name: string

    // Constructors of Gdk-4.0.Gdk.FileList

    /**
     * Creates a new `GdkFileList` for the given array of files.
     *
     * This function is meant to be used by language bindings.
     * @constructor
     * @param files the files to add to the list
     * @returns the newly create files list
     */
    static newFromArray(files: Gio.File[]): FileList
    /**
     * Creates a new files list container from a singly linked list of
     * `GFile` instances.
     *
     * This function is meant to be used by language bindings
     * @constructor
     * @param files a list of files
     * @returns the newly created files list
     */
    static newFromList(files: Gio.File[]): FileList
  }

  interface FrameClockClass {}

  abstract class FrameClockClass {
    // Own properties of Gdk-4.0.Gdk.FrameClockClass

    static name: string
  }

  interface FrameClockPrivate {}

  class FrameClockPrivate {
    // Own properties of Gdk-4.0.Gdk.FrameClockPrivate

    static name: string
  }

  interface FrameTimings {
    // Owm methods of Gdk-4.0.Gdk.FrameTimings

    /**
     * Returns whether `timings` are complete.
     *
     * The timing information in a `GdkFrameTimings` is filled in
     * incrementally as the frame as drawn and passed off to the
     * window system for processing and display to the user. The
     * accessor functions for `GdkFrameTimings` can return 0 to
     * indicate an unavailable value for two reasons: either because
     * the information is not yet available, or because it isn't
     * available at all.
     *
     * Once this function returns %TRUE for a frame, you can be
     * certain that no further values will become available and be
     * stored in the `GdkFrameTimings`.
     * @returns %TRUE if all information that will be available   for the frame has been filled in.
     */
    getComplete(): boolean
    /**
     * Gets the frame counter value of the `GdkFrameClock` when
     * this frame was drawn.
     * @returns the frame counter value for this frame
     */
    getFrameCounter(): number
    /**
     * Returns the frame time for the frame.
     *
     * This is the time value that is typically used to time
     * animations for the frame. See [method`Gdk`.FrameClock.get_frame_time].
     * @returns the frame time for the frame, in the timescale  of g_get_monotonic_time()
     */
    getFrameTime(): number
    /**
     * Gets the predicted time at which this frame will be displayed.
     *
     * Although no predicted time may be available, if one is available,
     * it will be available while the frame is being generated, in contrast
     * to [method`Gdk`.FrameTimings.get_presentation_time], which is only
     * available after the frame has been presented.
     *
     * In general, if you are simply animating, you should use
     * [method`Gdk`.FrameClock.get_frame_time] rather than this function,
     * but this function is useful for applications that want exact control
     * over latency. For example, a movie player may want this information
     * for Audio/Video synchronization.
     * @returns The predicted time at which the frame will be presented,   in the timescale of g_get_monotonic_time(), or 0 if no predicted   presentation time is available.
     */
    getPredictedPresentationTime(): number
    /**
     * Reurns the presentation time.
     *
     * This is the time at which the frame became visible to the user.
     * @returns the time the frame was displayed to the user, in the   timescale of g_get_monotonic_time(), or 0 if no presentation   time is available. See [method@Gdk.FrameTimings.get_complete]
     */
    getPresentationTime(): number
    /**
     * Gets the natural interval between presentation times for
     * the display that this frame was displayed on.
     *
     * Frame presentation usually happens during the “vertical
     * blanking interval”.
     * @returns the refresh interval of the display, in microseconds,   or 0 if the refresh interval is not available.   See [method@Gdk.FrameTimings.get_complete].
     */
    getRefreshInterval(): number
    /**
     * Increases the reference count of `timings`.
     * @returns @timings
     */
    ref(): FrameTimings
    /**
     * Decreases the reference count of `timings`.
     *
     * If `timings` is no longer referenced, it will be freed.
     */
    unref(): void
  }

  /**
   * A `GdkFrameTimings` object holds timing information for a single frame
   * of the application’s displays.
   *
   * To retrieve `GdkFrameTimings` objects, use [method`Gdk`.FrameClock.get_timings]
   * or [method`Gdk`.FrameClock.get_current_timings]. The information in
   * `GdkFrameTimings` is useful for precise synchronization of video with
   * the event or audio streams, and for measuring quality metrics for the
   * application’s display, such as latency and jitter.
   * @record
   */
  class FrameTimings {
    // Own properties of Gdk-4.0.Gdk.FrameTimings

    static name: string
  }

  interface GLTextureBuilderClass {}

  abstract class GLTextureBuilderClass {
    // Own properties of Gdk-4.0.Gdk.GLTextureBuilderClass

    static name: string
  }

  interface GLTextureClass {}

  abstract class GLTextureClass {
    // Own properties of Gdk-4.0.Gdk.GLTextureClass

    static name: string
  }

  interface KeymapKey {
    // Own fields of Gdk-4.0.Gdk.KeymapKey

    /**
     * the hardware keycode. This is an identifying number for a
     *   physical key.
     * @field
     */
    keycode: number
    /**
     * indicates movement in a horizontal direction. Usually groups are used
     *   for two different languages. In group 0, a key might have two English
     *   characters, and in group 1 it might have two Hebrew characters. The Hebrew
     *   characters will be printed on the key next to the English characters.
     * @field
     */
    group: number
    /**
     * indicates which symbol on the key will be used, in a vertical direction.
     *   So on a standard US keyboard, the key with the number “1” on it also has the
     *   exclamation point ("!") character on it. The level indicates whether to use
     *   the “1” or the “!” symbol. The letter keys are considered to have a lowercase
     *   letter at level 0, and an uppercase letter at level 1, though only the
     *   uppercase letter is printed.
     * @field
     */
    level: number
  }

  /**
   * A `GdkKeymapKey` is a hardware key that can be mapped to a keyval.
   * @record
   */
  class KeymapKey {
    // Own properties of Gdk-4.0.Gdk.KeymapKey

    static name: string
  }

  interface MemoryTextureClass {}

  abstract class MemoryTextureClass {
    // Own properties of Gdk-4.0.Gdk.MemoryTextureClass

    static name: string
  }

  interface MonitorClass {}

  abstract class MonitorClass {
    // Own properties of Gdk-4.0.Gdk.MonitorClass

    static name: string
  }

  interface PaintableInterface {
    // Own fields of Gdk-4.0.Gdk.PaintableInterface

    /**
     * Snapshot the paintable. The given `width` and `height` are
     *   guaranteed to be larger than 0.0. The resulting snapshot must modify
     *   only the area in the rectangle from (0,0) to (width, height).
     *   This is the only function that must be implemented for this interface.
     * @field
     */
    snapshot: (
      paintable: Paintable,
      snapshot: Snapshot,
      width: number,
      height: number
    ) => void
    /**
     * return a `GdkPaintable` that does not change over
     *   time. This means the `GDK_PAINTABLE_STATIC_SIZE` and
     *   `GDK_PAINTABLE_STATIC_CONTENTS` flag are set.
     * @field
     */
    getCurrentImage: (paintable: Paintable) => Paintable
    /**
     * Get the flags for this instance. See [flags`Gdk`.PaintableFlags]
     *   for details.
     * @field
     */
    getFlags: (paintable: Paintable) => PaintableFlags
    /**
     * The preferred width for this object to be
     *   snapshot at or 0 if none. This is purely a hint. The object must still
     *   be able to render at any size.
     * @field
     */
    getIntrinsicWidth: (paintable: Paintable) => number
    /**
     * The preferred height for this object to be
     *   snapshot at or 0 if none. This is purely a hint. The object must still
     *   be able to render at any size.
     * @field
     */
    getIntrinsicHeight: (paintable: Paintable) => number
    /**
     * The preferred aspect ratio for this object
     *   or 0 if none. If both [vfunc`Gdk`.Paintable.get_intrinsic_width]
     *   and [vfunc`Gdk`.Paintable.get_intrinsic_height] return non-zero
     *   values, this function should return the aspect ratio computed from those.
     * @field
     */
    getIntrinsicAspectRatio: (paintable: Paintable) => number
  }

  /**
   * The list of functions that can be implemented for the `GdkPaintable`
   * interface.
   *
   * Note that apart from the [vfunc`Gdk`.Paintable.snapshot] function,
   * no virtual function of this interface is mandatory to implement, though it
   * is a good idea to implement [vfunc`Gdk`.Paintable.get_current_image]
   * for non-static paintables and [vfunc`Gdk`.Paintable.get_flags] if the
   * image is not dynamic as the default implementation returns no flags and
   * that will make the implementation likely quite slow.
   * @record
   */
  abstract class PaintableInterface {
    // Own properties of Gdk-4.0.Gdk.PaintableInterface

    static name: string
  }

  interface PopupInterface {}

  abstract class PopupInterface {
    // Own properties of Gdk-4.0.Gdk.PopupInterface

    static name: string
  }

  interface PopupLayout {
    // Owm methods of Gdk-4.0.Gdk.PopupLayout

    /**
     * Makes a copy of `layout`.
     * @returns a copy of @layout.
     */
    copy(): PopupLayout
    /**
     * Check whether `layout` and `other` has identical layout properties.
     * @param other another `GdkPopupLayout`
     * @returns %TRUE if @layout and @other have identical layout properties,   otherwise %FALSE.
     */
    equal(other: PopupLayout): boolean
    /**
     * Get the `GdkAnchorHints`.
     * @returns the `GdkAnchorHints`
     */
    getAnchorHints(): AnchorHints
    /**
     * Get the anchor rectangle.
     * @returns The anchor rectangle
     */
    getAnchorRect(): Rectangle
    /**
     * Retrieves the offset for the anchor rectangle.
     */
    getOffset(): [/* dx */ number, /* dy */ number]
    /**
     * Returns the anchor position on the anchor rectangle.
     * @returns the anchor on the anchor rectangle.
     */
    getRectAnchor(): Gravity
    /**
     * Obtains the shadow widths of this layout.
     */
    getShadowWidth(): [
      /* left */ number,
      /* right */ number,
      /* top */ number,
      /* bottom */ number,
    ]
    /**
     * Returns the anchor position on the popup surface.
     * @returns the anchor on the popup surface.
     */
    getSurfaceAnchor(): Gravity
    /**
     * Increases the reference count of `value`.
     * @returns the same @layout
     */
    ref(): PopupLayout
    /**
     * Set new anchor hints.
     *
     * The set `anchor_hints` determines how `surface` will be moved
     * if the anchor points cause it to move off-screen. For example,
     * %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
     * %GDK_GRAVITY_NORTH_EAST and vice versa if `surface` extends
     * beyond the left or right edges of the monitor.
     * @param anchorHints the new `GdkAnchorHints`
     */
    setAnchorHints(anchorHints: AnchorHints): void
    /**
     * Set the anchor rectangle.
     * @param anchorRect the new anchor rectangle
     */
    setAnchorRect(anchorRect: Rectangle): void
    /**
     * Offset the position of the anchor rectangle with the given delta.
     * @param dx x delta to offset the anchor rectangle with
     * @param dy y delta to offset the anchor rectangle with
     */
    setOffset(dx: number, dy: number): void
    /**
     * Set the anchor on the anchor rectangle.
     * @param anchor the new rect anchor
     */
    setRectAnchor(anchor: Gravity): void
    /**
     * Sets the shadow width of the popup.
     *
     * The shadow width corresponds to the part of the computed
     * surface size that would consist of the shadow margin
     * surrounding the window, would there be any.
     * @param left width of the left part of the shadow
     * @param right width of the right part of the shadow
     * @param top height of the top part of the shadow
     * @param bottom height of the bottom part of the shadow
     */
    setShadowWidth(
      left: number,
      right: number,
      top: number,
      bottom: number
    ): void
    /**
     * Set the anchor on the popup surface.
     * @param anchor the new popup surface anchor
     */
    setSurfaceAnchor(anchor: Gravity): void
    /**
     * Decreases the reference count of `value`.
     */
    unref(): void
  }

  /**
   * The `GdkPopupLayout` struct contains information that is
   * necessary position a [iface`Gdk`.Popup] relative to its parent.
   *
   * The positioning requires a negotiation with the windowing system,
   * since it depends on external constraints, such as the position of
   * the parent surface, and the screen dimensions.
   *
   * The basic ingredients are a rectangle on the parent surface,
   * and the anchor on both that rectangle and the popup. The anchors
   * specify a side or corner to place next to each other.
   *
   * ![Popup anchors](popup-anchors.png)
   *
   * For cases where placing the anchors next to each other would make
   * the popup extend offscreen, the layout includes some hints for how
   * to resolve this problem. The hints may suggest to flip the anchor
   * position to the other side, or to 'slide' the popup along a side,
   * or to resize it.
   *
   * ![Flipping popups](popup-flip.png)
   *
   * ![Sliding popups](popup-slide.png)
   *
   * These hints may be combined.
   *
   * Ultimatively, it is up to the windowing system to determine the position
   * and size of the popup. You can learn about the result by calling
   * [method`Gdk`.Popup.get_position_x], [method`Gdk`.Popup.get_position_y],
   * [method`Gdk`.Popup.get_rect_anchor] and [method`Gdk`.Popup.get_surface_anchor]
   * after the popup has been presented. This can be used to adjust the rendering.
   * For example, [GtkPopover](../gtk4/class.Popover.html) changes its arrow position
   * accordingly. But you have to be careful avoid changing the size of the popover,
   * or it has to be presented again.
   * @record
   */
  class PopupLayout {
    // Own properties of Gdk-4.0.Gdk.PopupLayout

    static name: string

    // Constructors of Gdk-4.0.Gdk.PopupLayout

    /**
     * Create a popup layout description.
     *
     * Used together with [method`Gdk`.Popup.present] to describe how a popup
     * surface should be placed and behave on-screen.
     *
     * `anchor_rect` is relative to the top-left corner of the surface's parent.
     * `rect_anchor` and `surface_anchor` determine anchor points on `anchor_rect`
     * and surface to pin together.
     *
     * The position of `anchor_rect'`s anchor point can optionally be offset using
     * [method`Gdk`.PopupLayout.set_offset], which is equivalent to offsetting the
     * position of surface.
     * @constructor
     * @param anchorRect the anchor `GdkRectangle` to align `surface` with
     * @param rectAnchor the point on `anchor_rect` to align with `surface'`s anchor point
     * @param surfaceAnchor the point on `surface` to align with `rect'`s anchor point
     * @returns newly created instance of `GdkPopupLayout`
     */
    constructor(
      anchorRect: Rectangle,
      rectAnchor: Gravity,
      surfaceAnchor: Gravity
    )
    /**
     * Create a popup layout description.
     *
     * Used together with [method`Gdk`.Popup.present] to describe how a popup
     * surface should be placed and behave on-screen.
     *
     * `anchor_rect` is relative to the top-left corner of the surface's parent.
     * `rect_anchor` and `surface_anchor` determine anchor points on `anchor_rect`
     * and surface to pin together.
     *
     * The position of `anchor_rect'`s anchor point can optionally be offset using
     * [method`Gdk`.PopupLayout.set_offset], which is equivalent to offsetting the
     * position of surface.
     * @constructor
     * @param anchorRect the anchor `GdkRectangle` to align `surface` with
     * @param rectAnchor the point on `anchor_rect` to align with `surface'`s anchor point
     * @param surfaceAnchor the point on `surface` to align with `rect'`s anchor point
     * @returns newly created instance of `GdkPopupLayout`
     */
    static new(
      anchorRect: Rectangle,
      rectAnchor: Gravity,
      surfaceAnchor: Gravity
    ): PopupLayout
  }

  interface RGBA {
    // Own fields of Gdk-4.0.Gdk.RGBA

    /**
     * The intensity of the red channel from 0.0 to 1.0 inclusive
     * @field
     */
    red: number
    /**
     * The intensity of the green channel from 0.0 to 1.0 inclusive
     * @field
     */
    green: number
    /**
     * The intensity of the blue channel from 0.0 to 1.0 inclusive
     * @field
     */
    blue: number
    /**
     * The opacity of the color from 0.0 for completely translucent to
     *   1.0 for opaque
     * @field
     */
    alpha: number

    // Owm methods of Gdk-4.0.Gdk.RGBA

    /**
     * Makes a copy of a `GdkRGBA`.
     *
     * The result must be freed through [method`Gdk`.RGBA.free].
     * @returns A newly allocated `GdkRGBA`, with the same contents as @rgba
     */
    copy(): RGBA
    /**
     * Compares two `GdkRGBA` colors.
     * @param p2 another `GdkRGBA`
     * @returns %TRUE if the two colors compare equal
     */
    equal(p2: RGBA): boolean
    /**
     * Frees a `GdkRGBA`.
     */
    free(): void
    /**
     * A hash function suitable for using for a hash
     * table that stores `GdkRGBA`s.
     * @returns The hash value for @p
     */
    hash(): number
    /**
     * Checks if an `rgba` value is transparent.
     *
     * That is, drawing with the value would not produce any change.
     * @returns %TRUE if the @rgba is clear
     */
    isClear(): boolean
    /**
     * Checks if an `rgba` value is opaque.
     *
     * That is, drawing with the value will not retain any results
     * from previous contents.
     * @returns %TRUE if the @rgba is opaque
     */
    isOpaque(): boolean
    /**
     * Parses a textual representation of a color.
     *
     * The string can be either one of:
     *
     * - A standard name (Taken from the CSS specification).
     * - A hexadecimal value in the form “\#rgb”, “\#rrggbb”,
     *   “\#rrrgggbbb” or ”\#rrrrggggbbbb”
     * - A hexadecimal value in the form “\#rgba”, “\#rrggbbaa”,
     *   or ”\#rrrrggggbbbbaaaa”
     * - A RGB color in the form “rgb(r,g,b)” (In this case the color
     *   will have full opacity)
     * - A RGBA color in the form “rgba(r,g,b,a)”
     * - A HSL color in the form "hsl(hue, saturation, lightness)"
     * - A HSLA color in the form "hsla(hue, saturation, lightness, alpha)"
     *
     * Where “r”, “g”, “b” and “a” are respectively the red, green,
     * blue and alpha color values. In the last two cases, “r”, “g”,
     * and “b” are either integers in the range 0 to 255 or percentage
     * values in the range 0% to 100%, and a is a floating point value
     * in the range 0 to 1.
     * @param spec the string specifying the color
     * @returns %TRUE if the parsing succeeded
     */
    parse(spec: string): boolean
    /**
     * Returns a textual specification of `rgba` in the form
     * `rgb(r,g,b)` or `rgba(r,g,b,a)`, where “r”, “g”, “b” and
     * “a” represent the red, green, blue and alpha values
     * respectively. “r”, “g”, and “b” are represented as integers
     * in the range 0 to 255, and “a” is represented as a floating
     * point value in the range 0 to 1.
     *
     * These string forms are string forms that are supported by
     * the CSS3 colors module, and can be parsed by [method`Gdk`.RGBA.parse].
     *
     * Note that this string representation may lose some precision,
     * since “r”, “g” and “b” are represented as 8-bit integers. If
     * this is a concern, you should use a different representation.
     * @returns A newly allocated text string
     */
    toString(): string | null
  }

  /**
   * A `GdkRGBA` is used to represent a color, in a way that is compatible
   * with cairo’s notion of color.
   *
   * `GdkRGBA` is a convenient way to pass colors around. It’s based on
   * cairo’s way to deal with colors and mirrors its behavior. All values
   * are in the range from 0.0 to 1.0 inclusive. So the color
   * (0.0, 0.0, 0.0, 0.0) represents transparent black and
   * (1.0, 1.0, 1.0, 1.0) is opaque white. Other values will
   * be clamped to this range when drawing.
   * @record
   */
  class RGBA {
    // Own properties of Gdk-4.0.Gdk.RGBA

    static name: string

    // Constructors of Gdk-4.0.Gdk.RGBA

    /**
     * Creates a new color from the given string. Passes value to `GdkRGBA.parse()`
     * @param value
     */
    static create(value: string): RGBA
  }

  interface Rectangle {
    // Own fields of Gdk-4.0.Gdk.Rectangle

    /**
     * the x coordinate of the top left corner
     * @field
     */
    x: number
    /**
     * the y coordinate of the top left corner
     * @field
     */
    y: number
    /**
     * the width of the rectangle
     * @field
     */
    width: number
    /**
     * the height of the rectangle
     * @field
     */
    height: number

    // Owm methods of Gdk-4.0.Gdk.Rectangle

    /**
     * Returns %TRUE if `rect` contains the point described by `x` and `y`.
     * @param x X coordinate
     * @param y Y coordinate
     * @returns %TRUE if @rect contains the point
     */
    containsPoint(x: number, y: number): boolean
    /**
     * Checks if the two given rectangles are equal.
     * @param rect2 a `GdkRectangle`
     * @returns %TRUE if the rectangles are equal.
     */
    equal(rect2: Rectangle): boolean
    /**
     * Calculates the intersection of two rectangles.
     *
     * It is allowed for `dest` to be the same as either `src1` or `src2`.
     * If the rectangles do not intersect, `dest’`s width and height is set
     * to 0 and its x and y values are undefined. If you are only interested
     * in whether the rectangles intersect, but not in the intersecting area
     * itself, pass %NULL for `dest`.
     * @param src2 a `GdkRectangle`
     * @returns %TRUE if the rectangles intersect.
     */
    intersect(src2: Rectangle): [/* returnType */ boolean, /* dest */ Rectangle]
    /**
     * Calculates the union of two rectangles.
     *
     * The union of rectangles `src1` and `src2` is the smallest rectangle which
     * includes both `src1` and `src2` within it. It is allowed for `dest` to be
     * the same as either `src1` or `src2`.
     *
     * Note that this function does not ignore 'empty' rectangles (ie. with
     * zero width or height).
     * @param src2 a `GdkRectangle`
     */
    union(src2: Rectangle): /* dest */ Rectangle
  }

  /**
   * A `GdkRectangle` data type for representing rectangles.
   *
   * `GdkRectangle` is identical to `cairo_rectangle_t`. Together with Cairo’s
   * `cairo_region_t` data type, these are the central types for representing
   * sets of pixels.
   *
   * The intersection of two rectangles can be computed with
   * [method`Gdk`.Rectangle.intersect]; to find the union of two rectangles use
   * [method`Gdk`.Rectangle.union].
   *
   * The `cairo_region_t` type provided by Cairo is usually used for managing
   * non-rectangular clipping of graphical operations.
   *
   * The Graphene library has a number of other data types for regions and
   * volumes in 2D and 3D.
   * @record
   */
  class Rectangle {
    // Own properties of Gdk-4.0.Gdk.Rectangle

    static name: string
  }

  interface SnapshotClass {}

  abstract class SnapshotClass {
    // Own properties of Gdk-4.0.Gdk.SnapshotClass

    static name: string
  }

  interface SurfaceClass {}

  abstract class SurfaceClass {
    // Own properties of Gdk-4.0.Gdk.SurfaceClass

    static name: string
  }

  interface TextureClass {}

  abstract class TextureClass {
    // Own properties of Gdk-4.0.Gdk.TextureClass

    static name: string
  }

  interface TextureDownloader {
    // Owm methods of Gdk-4.0.Gdk.TextureDownloader

    /**
     * Creates a copy of the downloader.
     *
     * This function is meant for language bindings.
     * @returns A copy of the downloader
     */
    copy(): TextureDownloader
    /**
     * Downloads the given texture pixels into a `GBytes`. The rowstride will
     * be stored in the stride value.
     *
     * This function will abort if it tries to download a large texture and
     * fails to allocate memory. If you think that may happen, you should handle
     * memory allocation yourself and use [method`Gdk`.TextureDownloader.download_into]
     * once allocation succeeded.
     * @returns The downloaded pixels
     */
    downloadBytes(): [/* returnType */ any, /* outStride */ number]
    /**
     * Downloads the `texture` into local memory.
     * @param data pointer to enough memory to be filled with the   downloaded data of the texture
     * @param stride rowstride in bytes
     */
    downloadInto(data: number[], stride: number): void
    /**
     * Frees the given downloader and all its associated resources.
     */
    free(): void
    /**
     * Gets the format that the data will be downloaded in.
     * @returns The format of the download
     */
    getFormat(): MemoryFormat
    /**
     * Gets the texture that the downloader will download.
     * @returns The texture to download
     */
    getTexture(): Texture
    /**
     * Sets the format the downloader will download.
     *
     * By default, GDK_MEMORY_DEFAULT is set.
     * @param format the format to use
     */
    setFormat(format: MemoryFormat): void
    /**
     * Changes the texture the downloader will download.
     * @param texture the new texture to download
     */
    setTexture(texture: Texture): void
  }

  /**
   * The `GdkTextureDownloader` is used to download the contents of a
   * [class`Gdk`.Texture].
   *
   * It is intended to be created as a short-term object for a single download,
   * but can be used for multiple downloads of different textures or with different
   * settings.
   *
   * `GdkTextureDownloader` can be used to convert data between different formats.
   * Create a `GdkTexture` for the existing format and then download it in a
   * different format.
   * @record
   */
  class TextureDownloader {
    // Own properties of Gdk-4.0.Gdk.TextureDownloader

    static name: string

    // Constructors of Gdk-4.0.Gdk.TextureDownloader

    /**
     * Creates a new texture downloader for `texture`.
     * @constructor
     * @param texture texture to download
     * @returns A new texture downloader
     */
    constructor(texture: Texture)
    /**
     * Creates a new texture downloader for `texture`.
     * @constructor
     * @param texture texture to download
     * @returns A new texture downloader
     */
    static new(texture: Texture): TextureDownloader
  }

  interface TimeCoord {
    // Own fields of Gdk-4.0.Gdk.TimeCoord

    /**
     * The timestamp for this event
     * @field
     */
    time: number
    /**
     * Flags indicating what axes are present, see [flags`Gdk`.AxisFlags]
     * @field
     */
    flags: AxisFlags
    /**
     * axis values, indexed by [enum`Gdk`.AxisUse]
     * @field
     */
    axes: number[]
  }

  /**
   * A `GdkTimeCoord` stores a single event in a motion history.
   *
   * To check whether an axis is present, check whether the corresponding
   * flag from the [flags`Gdk`.AxisFlags] enumeration is set in the `flags`
   * To access individual axis values, use the values of the values of
   * the [enum`Gdk`.AxisUse] enumerations as indices.
   * @record
   */
  class TimeCoord {
    // Own properties of Gdk-4.0.Gdk.TimeCoord

    static name: string
  }

  interface ToplevelInterface {}

  abstract class ToplevelInterface {
    // Own properties of Gdk-4.0.Gdk.ToplevelInterface

    static name: string
  }

  interface ToplevelLayout {
    // Owm methods of Gdk-4.0.Gdk.ToplevelLayout

    /**
     * Create a new `GdkToplevelLayout` and copy the contents of `layout` into it.
     * @returns a copy of @layout.
     */
    copy(): ToplevelLayout
    /**
     * Check whether `layout` and `other` has identical layout properties.
     * @param other another `GdkToplevelLayout`
     * @returns %TRUE if @layout and @other have identical layout properties,   otherwise %FALSE.
     */
    equal(other: ToplevelLayout): boolean
    /**
     * If the layout specifies whether to the toplevel should go fullscreen,
     * the value pointed to by `fullscreen` is set to %TRUE if it should go
     * fullscreen, or %FALSE, if it should go unfullscreen.
     * @returns whether the @layout specifies the fullscreen state for the toplevel
     */
    getFullscreen(): [/* returnType */ boolean, /* fullscreen */ boolean]
    /**
     * Returns the monitor that the layout is fullscreening
     * the surface on.
     * @returns the monitor on which @layout fullscreens
     */
    getFullscreenMonitor(): Monitor | null
    /**
     * If the layout specifies whether to the toplevel should go maximized,
     * the value pointed to by `maximized` is set to %TRUE if it should go
     * fullscreen, or %FALSE, if it should go unmaximized.
     * @returns whether the @layout specifies the maximized state for the toplevel
     */
    getMaximized(): [/* returnType */ boolean, /* maximized */ boolean]
    /**
     * Returns whether the layout should allow the user
     * to resize the surface.
     * @returns %TRUE if the layout is resizable
     */
    getResizable(): boolean
    /**
     * Increases the reference count of `layout`.
     * @returns the same @layout
     */
    ref(): ToplevelLayout
    /**
     * Sets whether the layout should cause the surface
     * to be fullscreen when presented.
     * @param fullscreen %TRUE to fullscreen the surface
     * @param monitor the monitor to fullscreen on
     */
    setFullscreen(fullscreen: boolean, monitor: Monitor | null): void
    /**
     * Sets whether the layout should cause the surface
     * to be maximized when presented.
     * @param maximized %TRUE to maximize
     */
    setMaximized(maximized: boolean): void
    /**
     * Sets whether the layout should allow the user
     * to resize the surface after it has been presented.
     * @param resizable %TRUE to allow resizing
     */
    setResizable(resizable: boolean): void
    /**
     * Decreases the reference count of `layout`.
     */
    unref(): void
  }

  /**
   * The `GdkToplevelLayout` struct contains information that
   * is necessary to present a sovereign window on screen.
   *
   * The `GdkToplevelLayout` struct is necessary for using
   * [method`Gdk`.Toplevel.present].
   *
   * Toplevel surfaces are sovereign windows that can be presented
   * to the user in various states (maximized, on all workspaces,
   * etc).
   * @record
   */
  class ToplevelLayout {
    // Own properties of Gdk-4.0.Gdk.ToplevelLayout

    static name: string

    // Constructors of Gdk-4.0.Gdk.ToplevelLayout

    /**
     * Create a toplevel layout description.
     *
     * Used together with gdk_toplevel_present() to describe
     * how a toplevel surface should be placed and behave on-screen.
     *
     * The size is in ”application pixels”, not
     * ”device pixels” (see gdk_surface_get_scale_factor()).
     * @constructor
     * @returns newly created instance of `GdkToplevelLayout`
     */
    constructor()
    /**
     * Create a toplevel layout description.
     *
     * Used together with gdk_toplevel_present() to describe
     * how a toplevel surface should be placed and behave on-screen.
     *
     * The size is in ”application pixels”, not
     * ”device pixels” (see gdk_surface_get_scale_factor()).
     * @constructor
     * @returns newly created instance of `GdkToplevelLayout`
     */
    static new(): ToplevelLayout
  }

  interface ToplevelSize {
    // Owm methods of Gdk-4.0.Gdk.ToplevelSize

    /**
     * Retrieves the bounds the toplevel is placed within.
     *
     * The bounds represent the largest size a toplevel may have while still being
     * able to fit within some type of boundary. Depending on the backend, this may
     * be equivalent to the dimensions of the work area or the monitor on which the
     * window is being presented on, or something else that limits the way a
     * toplevel can be presented.
     */
    getBounds(): [/* boundsWidth */ number, /* boundsHeight */ number]
    /**
     * Sets the minimum size of the toplevel.
     *
     * The minimum size corresponds to the limitations the toplevel can be shrunk
     * to, without resulting in incorrect painting. A user of a `GdkToplevel` should
     * calculate these given both the existing size, and the bounds retrieved from
     * the `GdkToplevelSize` object.
     *
     * The minimum size should be within the bounds (see
     * [method`Gdk`.ToplevelSize.get_bounds]).
     * @param minWidth the minimum width
     * @param minHeight the minimum height
     */
    setMinSize(minWidth: number, minHeight: number): void
    /**
     * Sets the shadows size of the toplevel.
     *
     * The shadow width corresponds to the part of the computed surface size
     * that would consist of the shadow margin surrounding the window, would
     * there be any.
     *
     * Shadow width should only be set if
     * [method`Gtk`.Display.supports_shadow_width] is %TRUE.
     * @param left width of the left part of the shadow
     * @param right width of the right part of the shadow
     * @param top height of the top part of the shadow
     * @param bottom height of the bottom part of the shadow
     */
    setShadowWidth(
      left: number,
      right: number,
      top: number,
      bottom: number
    ): void
    /**
     * Sets the size the toplevel prefers to be resized to.
     *
     * The size should be within the bounds (see
     * [method`Gdk`.ToplevelSize.get_bounds]). The set size should
     * be considered as a hint, and should not be assumed to be
     * respected by the windowing system, or backend.
     * @param width the width
     * @param height the height
     */
    setSize(width: number, height: number): void
  }

  /**
   * The `GdkToplevelSize` struct contains information that is useful
   * to compute the size of a toplevel.
   * @record
   */
  class ToplevelSize {
    // Own properties of Gdk-4.0.Gdk.ToplevelSize

    static name: string
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace Gsk {
  /**
   * The blend modes available for render nodes.
   *
   * The implementation of each blend mode is deferred to the
   * rendering pipeline.
   *
   * See <https://www.w3.org/TR/compositing-1/#blending> for more information
   * on blending and blend modes.
   */
  enum BlendMode {
    /**
     * The default blend mode, which specifies no blending
     */
    DEFAULT,
    /**
     * The source color is multiplied by the destination
     *   and replaces the destination
     */
    MULTIPLY,
    /**
     * Multiplies the complements of the destination and source
     *   color values, then complements the result.
     */
    SCREEN,
    /**
     * Multiplies or screens the colors, depending on the
     *   destination color value. This is the inverse of hard-list
     */
    OVERLAY,
    /**
     * Selects the darker of the destination and source colors
     */
    DARKEN,
    /**
     * Selects the lighter of the destination and source colors
     */
    LIGHTEN,
    /**
     * Brightens the destination color to reflect the source color
     */
    COLOR_DODGE,
    /**
     * Darkens the destination color to reflect the source color
     */
    COLOR_BURN,
    /**
     * Multiplies or screens the colors, depending on the source color value
     */
    HARD_LIGHT,
    /**
     * Darkens or lightens the colors, depending on the source color value
     */
    SOFT_LIGHT,
    /**
     * Subtracts the darker of the two constituent colors from the lighter color
     */
    DIFFERENCE,
    /**
     * Produces an effect similar to that of the difference mode but lower in contrast
     */
    EXCLUSION,
    /**
     * Creates a color with the hue and saturation of the source color and the luminosity of the destination color
     */
    COLOR,
    /**
     * Creates a color with the hue of the source color and the saturation and luminosity of the destination color
     */
    HUE,
    /**
     * Creates a color with the saturation of the source color and the hue and luminosity of the destination color
     */
    SATURATION,
    /**
     * Creates a color with the luminosity of the source color and the hue and saturation of the destination color
     */
    LUMINOSITY,
  }
  /**
   * The corner indices used by `GskRoundedRect`.
   */
  enum Corner {
    /**
     * The top left corner
     */
    TOP_LEFT,
    /**
     * The top right corner
     */
    TOP_RIGHT,
    /**
     * The bottom right corner
     */
    BOTTOM_RIGHT,
    /**
     * The bottom left corner
     */
    BOTTOM_LEFT,
  }
  /**
   * `GskFillRule` is used to select how paths are filled.
   *
   * Whether or not a point is included in the fill is determined by taking
   * a ray from that point to infinity and looking at intersections with the
   * path. The ray can be in any direction, as long as it doesn't pass through
   * the end point of a segment or have a tricky intersection such as
   * intersecting tangent to the path.
   *
   * (Note that filling is not actually implemented in this way. This
   * is just a description of the rule that is applied.)
   *
   * New entries may be added in future versions.
   */
  enum FillRule {
    /**
     * If the path crosses the ray from
     *   left-to-right, counts +1. If the path crosses the ray
     *   from right to left, counts -1. (Left and right are determined
     *   from the perspective of looking along the ray from the starting
     *   point.) If the total count is non-zero, the point will be filled.
     */
    WINDING,
    /**
     * Counts the total number of
     *   intersections, without regard to the orientation of the contour. If
     *   the total number of intersections is odd, the point will be
     *   filled.
     */
    EVEN_ODD,
  }
  /**
   * This defines the types of the uniforms that `GskGLShaders`
   * declare.
   *
   * It defines both what the type is called in the GLSL shader
   * code, and what the corresponding C type is on the Gtk side.
   */
  enum GLUniformType {
    /**
     * No type, used for uninitialized or unspecified values.
     */
    NONE,
    /**
     * A float uniform
     */
    FLOAT,
    /**
     * A GLSL int / gint32 uniform
     */
    INT,
    /**
     * A GLSL uint / guint32 uniform
     */
    UINT,
    /**
     * A GLSL bool / gboolean uniform
     */
    BOOL,
    /**
     * A GLSL vec2 / graphene_vec2_t uniform
     */
    VEC2,
    /**
     * A GLSL vec3 / graphene_vec3_t uniform
     */
    VEC3,
    /**
     * A GLSL vec4 / graphene_vec4_t uniform
     */
    VEC4,
  }
  /**
   * Specifies how to render the start and end points of contours or
   * dashes when stroking.
   *
   * The default line cap style is `GSK_LINE_CAP_BUTT`.
   *
   * New entries may be added in future versions.
   *
   * <figure>
   *   <picture>
   *     <source srcset="caps-dark.png" media="(prefers-color-scheme: dark)">
   *     <img alt="Line Cap Styles" src="caps-light.png">
   *   </picture>
   *   <figcaption>GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE</figcaption>
   * </figure>
   */
  enum LineCap {
    /**
     * Start and stop the line exactly at the start
     *   and end point
     */
    BUTT,
    /**
     * Use a round ending, the center of the circle
     *   is the start or end point
     */
    ROUND,
    /**
     * use squared ending, the center of the square
     *   is the start or end point
     */
    SQUARE,
  }
  /**
   * Specifies how to render the junction of two lines when stroking.
   *
   * The default line join style is `GSK_LINE_JOIN_MITER`.
   *
   * New entries may be added in future versions.
   *
   * <figure>
   *   <picture>
   *     <source srcset="join-dark.png" media="(prefers-color-scheme: dark)">
   *     <img alt="Line Join Styles" src="join-light.png">
   *   </picture>
   *   <figcaption>GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL</figcaption>
   * </figure>
   */
  enum LineJoin {
    /**
     * Use a sharp angled corner
     */
    MITER,
    /**
     * Use a round join, the center of the circle is
     *   the join point
     */
    ROUND,
    /**
     * use a cut-off join, the join is cut off at half
     *   the line width from the joint point
     */
    BEVEL,
  }
  /**
   * The mask modes available for mask nodes.
   */
  enum MaskMode {
    /**
     * Use the alpha channel of the mask
     */
    ALPHA,
    /**
     * Use the inverted alpha channel of the mask
     */
    INVERTED_ALPHA,
    /**
     * Use the luminance of the mask,
     *     multiplied by mask alpha
     */
    LUMINANCE,
    /**
     * Use the inverted luminance of the mask,
     *     multiplied by mask alpha
     */
    INVERTED_LUMINANCE,
  }
  /**
   * The values of the `GskPathDirection` enum are used to pick one
   * of the four tangents at a given point on the path.
   *
   * Note that the directions for `GSK_PATH_FROM_START/``GSK_PATH_TO_END` and
   * `GSK_PATH_TO_START/``GSK_PATH_FROM_END` will coincide for smooth points.
   * Only sharp turns will exhibit four different directions.
   *
   * <picture>
   *   <source srcset="directions-dark.png" media="(prefers-color-scheme: dark)">
   *   <img alt="Path Tangents" src="directions-light.png">
   * </picture>
   */
  enum PathDirection {
    /**
     * The tangent in path direction of the incoming side
     *   of the path
     */
    FROM_START,
    /**
     * The tangent against path direction of the incoming side
     *   of the path
     */
    TO_START,
    /**
     * The tangent in path direction of the outgoing side
     *   of the path
     */
    TO_END,
    /**
     * The tangent against path direction of the outgoing
     *   side of the path
     */
    FROM_END,
  }
  /**
   * Path operations are used to describe the segments of a `GskPath`.
   *
   * More values may be added in the future.
   */
  enum PathOperation {
    /**
     * A move-to operation, with 1 point describing the target point.
     */
    MOVE,
    /**
     * A close operation ending the current contour with a line back
     *   to the starting point. Two points describe the start and end of the line.
     */
    CLOSE,
    /**
     * A line-to operation, with 2 points describing the start and
     *   end point of a straight line.
     */
    LINE,
    /**
     * A curve-to operation describing a quadratic Bézier curve
     *   with 3 points describing the start point, the control point and the end
     *   point of the curve.
     */
    QUAD,
    /**
     * A curve-to operation describing a cubic Bézier curve with 4
     *   points describing the start point, the two control points and the end point
     *   of the curve.
     */
    CUBIC,
    /**
     * A rational quadratic Bézier curve with 3 points describing
     *   the start point, control point and end point of the curve. A weight for the
     *   curve will be passed, too.
     */
    CONIC,
  }
  /**
   * The type of a node determines what the node is rendering.
   */
  enum RenderNodeType {
    /**
     * Error type. No node will ever have this type.
     */
    NOT_A_RENDER_NODE,
    /**
     * A node containing a stack of children
     */
    CONTAINER_NODE,
    /**
     * A node drawing a `cairo_surface_t`
     */
    CAIRO_NODE,
    /**
     * A node drawing a single color rectangle
     */
    COLOR_NODE,
    /**
     * A node drawing a linear gradient
     */
    LINEAR_GRADIENT_NODE,
    /**
     * A node drawing a repeating linear gradient
     */
    REPEATING_LINEAR_GRADIENT_NODE,
    /**
     * A node drawing a radial gradient
     */
    RADIAL_GRADIENT_NODE,
    /**
     * A node drawing a repeating radial gradient
     */
    REPEATING_RADIAL_GRADIENT_NODE,
    /**
     * A node drawing a conic gradient
     */
    CONIC_GRADIENT_NODE,
    /**
     * A node stroking a border around an area
     */
    BORDER_NODE,
    /**
     * A node drawing a `GdkTexture`
     */
    TEXTURE_NODE,
    /**
     * A node drawing an inset shadow
     */
    INSET_SHADOW_NODE,
    /**
     * A node drawing an outset shadow
     */
    OUTSET_SHADOW_NODE,
    /**
     * A node that renders its child after applying a matrix transform
     */
    TRANSFORM_NODE,
    /**
     * A node that changes the opacity of its child
     */
    OPACITY_NODE,
    /**
     * A node that applies a color matrix to every pixel
     */
    COLOR_MATRIX_NODE,
    /**
     * A node that repeats the child's contents
     */
    REPEAT_NODE,
    /**
     * A node that clips its child to a rectangular area
     */
    CLIP_NODE,
    /**
     * A node that clips its child to a rounded rectangle
     */
    ROUNDED_CLIP_NODE,
    /**
     * A node that draws a shadow below its child
     */
    SHADOW_NODE,
    /**
     * A node that blends two children together
     */
    BLEND_NODE,
    /**
     * A node that cross-fades between two children
     */
    CROSS_FADE_NODE,
    /**
     * A node containing a glyph string
     */
    TEXT_NODE,
    /**
     * A node that applies a blur
     */
    BLUR_NODE,
    /**
     * Debug information that does not affect the rendering
     */
    DEBUG_NODE,
    /**
     * A node that uses OpenGL fragment shaders to render
     */
    GL_SHADER_NODE,
    /**
     * A node drawing a `GdkTexture` scaled and filtered.
     */
    TEXTURE_SCALE_NODE,
    /**
     * A node that masks one child with another.
     */
    MASK_NODE,
    /**
     * A node that fills a path.
     */
    FILL_NODE,
    /**
     * A node that strokes a path.
     */
    STROKE_NODE,
    /**
     * A node that possibly redirects part of the scene graph to a subsurface.
     */
    SUBSURFACE_NODE,
  }
  /**
   * The filters used when scaling texture data.
   *
   * The actual implementation of each filter is deferred to the
   * rendering pipeline.
   */
  enum ScalingFilter {
    /**
     * linear interpolation filter
     */
    LINEAR,
    /**
     * nearest neighbor interpolation filter
     */
    NEAREST,
    /**
     * linear interpolation along each axis,
     *   plus mipmap generation, with linear interpolation along the mipmap
     *   levels
     */
    TRILINEAR,
  }
  /**
   * Errors that can happen during (de)serialization.
   */
  enum SerializationError {
    /**
     * The format can not be identified
     */
    UNSUPPORTED_FORMAT,
    /**
     * The version of the data is not
     *   understood
     */
    UNSUPPORTED_VERSION,
    /**
     * The given data may not exist in
     *   a proper serialization
     */
    INVALID_DATA,
  }
  /**
   * The categories of matrices relevant for GSK and GTK.
   *
   * Note that any category includes matrices of all later categories.
   * So if you want to for example check if a matrix is a 2D matrix,
   * `category >= GSK_TRANSFORM_CATEGORY_2D` is the way to do this.
   *
   * Also keep in mind that rounding errors may cause matrices to not
   * conform to their categories. Otherwise, matrix operations done via
   * multiplication will not worsen categories. So for the matrix
   * multiplication `C = A * B`, `category(C) = MIN (category(A), category(B))`.
   */
  enum TransformCategory {
    /**
     * The category of the matrix has not been
     *   determined.
     */
    UNKNOWN,
    /**
     * Analyzing the matrix concluded that it does
     *   not fit in any other category.
     */
    ANY,
    /**
     * The matrix is a 3D matrix. This means that
     *   the w column (the last column) has the values (0, 0, 0, 1).
     */
    TODO_3D,
    /**
     * The matrix is a 2D matrix. This is equivalent
     *   to graphene_matrix_is_2d() returning %TRUE. In particular, this
     *   means that Cairo can deal with the matrix.
     */
    TODO_2D,
    /**
     * The matrix is a combination of 2D scale
     *   and 2D translation operations. In particular, this means that any
     *   rectangle can be transformed exactly using this matrix.
     */
    TODO_2D_AFFINE,
    /**
     * The matrix is a 2D translation.
     */
    TODO_2D_TRANSLATE,
    /**
     * The matrix is the identity matrix.
     */
    IDENTITY,
  }
  /**
   * Flags that can be passed to gsk_path_foreach() to influence what
   * kinds of operations the path is decomposed into.
   *
   * By default, [method`Gsk`.Path.foreach] will only emit a path with all
   * operations flattened to straight lines to allow for maximum compatibility.
   * The only operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and
   * `GSK_PATH_CLOSE`.
   * @bitfield
   */
  enum PathForeachFlags {
    /**
     * The default behavior, only allow lines.
     */
    ONLY_LINES,
    /**
     * Allow emission of `GSK_PATH_QUAD` operations
     */
    QUAD,
    /**
     * Allow emission of `GSK_PATH_CUBIC` operations.
     */
    CUBIC,
    /**
     * Allow emission of `GSK_PATH_CONIC` operations.
     */
    CONIC,
  }
  /**
   * This is a convenience function that constructs a `GskPath`
   * from a serialized form.
   *
   * The string is expected to be in (a superset of)
   * [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData),
   * as e.g. produced by [method`Gsk`.Path.to_string].
   *
   * A high-level summary of the syntax:
   *
   * - `M x y` Move to `(x, y)`
   * - `L x y` Add a line from the current point to `(x, y)`
   * - `Q x1 y1 x2 y2` Add a quadratic Bézier from the current point to `(x2, y2)`, with control point `(x1, y1)`
   * - `C x1 y1 x2 y2 x3 y3` Add a cubic Bézier from the current point to `(x3, y3)`, with control points `(x1, y1)` and `(x2, y2)`
   * - `Z` Close the contour by drawing a line back to the start point
   * - `H x` Add a horizontal line from the current point to the given x value
   * - `V y` Add a vertical line from the current point to the given y value
   * - `T x2 y2` Add a quadratic Bézier, using the reflection of the previous segments' control point as control point
   * - `S x2 y2 x3 y3` Add a cubic Bézier, using the reflection of the previous segments' second control point as first control point
   * - `A rx ry r l s x y` Add an elliptical arc from the current point to `(x, y)` with radii rx and ry. See the SVG documentation for how the other parameters influence the arc.
   * - `O x1 y1 x2 y2 w` Add a rational quadratic Bézier from the current point to `(x2, y2)` with control point `(x1, y1)` and weight `w`.
   *
   * All the commands have lowercase variants that interpret coordinates
   * relative to the current point.
   *
   * The `O` command is an extension that is not supported in SVG.
   * @param string a string
   * @returns a new `GskPath`, or `NULL` if @string could not be parsed
   */
  function pathParse(string: string): Path | null
  function serializationErrorQuark(): GLib.Quark
  /**
   * Checks if 2 strokes are identical.
   * @param stroke1 the first `GskStroke`
   * @param stroke2 the second `GskStroke`
   * @returns `TRUE` if the 2 strokes are equal, `FALSE` otherwise
   */
  function strokeEqual(stroke1: any | null, stroke2: any | null): boolean
  /**
   * Parses the given `string` into a transform and puts it in
   * `out_transform`.
   *
   * Strings printed via [method`Gsk`.Transform.to_string]
   * can be read in again successfully using this function.
   *
   * If `string` does not describe a valid transform, %FALSE is
   * returned and %NULL is put in `out_transform`.
   * @param string the string to parse
   * @returns %TRUE if @string described a valid transform.
   */
  function transformParse(
    string: string
  ): [/* returnType */ boolean, /* outTransform */ Transform]
  /**
   * Retrieves the `GskRenderNode` stored inside the given `value`, and acquires
   * a reference to it.
   * @param value a [struct`GObject`.Value] initialized with type `GSK_TYPE_RENDER_NODE`
   * @returns a `GskRenderNode`
   */
  function valueDupRenderNode(value: any): RenderNode | null
  /**
   * Retrieves the `GskRenderNode` stored inside the given `value`.
   * @param value a `GValue` initialized with type `GSK_TYPE_RENDER_NODE`
   * @returns a `GskRenderNode`
   */
  function valueGetRenderNode(value: any): RenderNode | null
  /**
   * Stores the given `GskRenderNode` inside `value`.
   *
   * The [struct`GObject`.Value] will acquire a reference to the `node`.
   * @param value a [struct`GObject`.Value] initialized with type `GSK_TYPE_RENDER_NODE`
   * @param node a `GskRenderNode`
   */
  function valueSetRenderNode(value: any, node: RenderNode): void
  /**
   * Stores the given `GskRenderNode` inside `value`.
   *
   * This function transfers the ownership of the `node` to the `GValue`.
   * @param value a [struct`GObject`.Value] initialized with type `GSK_TYPE_RENDER_NODE`
   * @param node a `GskRenderNode`
   */
  function valueTakeRenderNode(value: any, node: RenderNode | null): void
  /**
   * Type of callback that is called when an error occurs
   * during node deserialization.
   * @callback
   * @param start start of the error location
   * @param end end of the error location
   * @param error the error
   */
  interface ParseErrorFunc {
    (start: ParseLocation, end: ParseLocation, error: GLib.Error): void
  }
  /**
   * Prototype of the callback to iterate through the operations of
   * a path.
   *
   * For each operation, the callback is given the `op` itself, the points
   * that the operation is applied to in `pts,` and a `weight` for conic
   * curves. The `n_pts` argument is somewhat redundant, since the number
   * of points can be inferred from the operation.
   *
   * Each contour of the path starts with a `GSK_PATH_MOVE` operation.
   * Closed contours end with a `GSK_PATH_CLOSE` operation.
   * @callback
   * @param op The operation
   * @param pts The points of the operation
   * @param nPts The number of points
   * @param weight The weight for conic curves, or unused if not a conic curve
   * @returns %TRUE to continue iterating the path, %FALSE to   immediately abort and not call the function again.
   */
  interface PathForeachFunc {
    (
      op: PathOperation,
      pts: Graphene.Point,
      nPts: number,
      weight: number
    ): boolean
  }
  interface BlendNode {
    // Owm methods of Gsk-4.0.Gsk.BlendNode

    /**
     * Retrieves the blend mode used by `node`.
     * @returns the blend mode
     */
    getBlendMode(): BlendMode
    /**
     * Retrieves the bottom `GskRenderNode` child of the `node`.
     * @returns the bottom child node
     */
    getBottomChild(): RenderNode
    /**
     * Retrieves the top `GskRenderNode` child of the `node`.
     * @returns the top child node
     */
    getTopChild(): RenderNode
  }

  /**
   * A render node applying a blending function between its two child nodes.
   * @class
   */
  class BlendNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.BlendNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.BlendNode

    /**
     * Creates a `GskRenderNode` that will use `blend_mode` to blend the `top`
     * node onto the `bottom` node.
     * @constructor
     * @param bottom The bottom node to be drawn
     * @param top The node to be blended onto the `bottom` node
     * @param blendMode The blend mode to use
     * @returns A new `GskRenderNode`
     */
    constructor(bottom: RenderNode, top: RenderNode, blendMode: BlendMode)
    /**
     * Creates a `GskRenderNode` that will use `blend_mode` to blend the `top`
     * node onto the `bottom` node.
     * @constructor
     * @param bottom The bottom node to be drawn
     * @param top The node to be blended onto the `bottom` node
     * @param blendMode The blend mode to use
     * @returns A new `GskRenderNode`
     */
    static new(
      bottom: RenderNode,
      top: RenderNode,
      blendMode: BlendMode
    ): BlendNode
  }

  interface BlurNode {
    // Owm methods of Gsk-4.0.Gsk.BlurNode

    /**
     * Retrieves the child `GskRenderNode` of the blur `node`.
     * @returns the blurred child node
     */
    getChild(): RenderNode
    /**
     * Retrieves the blur radius of the `node`.
     * @returns the blur radius
     */
    getRadius(): number
  }

  /**
   * A render node applying a blur effect to its single child.
   * @class
   */
  class BlurNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.BlurNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.BlurNode

    /**
     * Creates a render node that blurs the child.
     * @constructor
     * @param child the child node to blur
     * @param radius the blur radius. Must be positive
     * @returns a new `GskRenderNode`
     */
    constructor(child: RenderNode, radius: number)
    /**
     * Creates a render node that blurs the child.
     * @constructor
     * @param child the child node to blur
     * @param radius the blur radius. Must be positive
     * @returns a new `GskRenderNode`
     */
    static new(child: RenderNode, radius: number): BlurNode
  }

  interface BorderNode {
    // Owm methods of Gsk-4.0.Gsk.BorderNode

    /**
     * Retrieves the colors of the border.
     * @returns an array of 4 `GdkRGBA` structs     for the top, right, bottom and left color of the border
     */
    getColors(): Gdk.RGBA
    /**
     * Retrieves the outline of the border.
     * @returns the outline of the border
     */
    getOutline(): RoundedRect
    /**
     * Retrieves the stroke widths of the border.
     * @returns an array of 4 floats   for the top, right, bottom and left stroke width of the border,   respectively
     */
    getWidths(): number[]
  }

  /**
   * A render node for a border.
   * @class
   */
  class BorderNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.BorderNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.BorderNode

    /**
     * Creates a `GskRenderNode` that will stroke a border rectangle inside the
     * given `outline`.
     *
     * The 4 sides of the border can have different widths and colors.
     * @constructor
     * @param outline a `GskRoundedRect` describing the outline of the border
     * @param borderWidth the stroke width of the border on     the top, right, bottom and left side respectively.
     * @param borderColor the color used on the top, right,     bottom and left side.
     * @returns A new `GskRenderNode`
     */
    constructor(
      outline: RoundedRect,
      borderWidth: number[],
      borderColor: Gdk.RGBA[]
    )
    /**
     * Creates a `GskRenderNode` that will stroke a border rectangle inside the
     * given `outline`.
     *
     * The 4 sides of the border can have different widths and colors.
     * @constructor
     * @param outline a `GskRoundedRect` describing the outline of the border
     * @param borderWidth the stroke width of the border on     the top, right, bottom and left side respectively.
     * @param borderColor the color used on the top, right,     bottom and left side.
     * @returns A new `GskRenderNode`
     */
    static new(
      outline: RoundedRect,
      borderWidth: number[],
      borderColor: Gdk.RGBA[]
    ): BorderNode
  }

  module BroadwayRenderer {
    // Constructor properties interface

    interface ConstructorProperties extends Renderer.ConstructorProperties {}
  }

  interface BroadwayRenderer {
    // Own properties of Gsk-4.0.Gsk.BroadwayRenderer

    __gtype__: number

    // Class property signals of Gsk-4.0.Gsk.BroadwayRenderer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::realized", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  class BroadwayRenderer extends Renderer {
    // Own properties of Gsk-4.0.Gsk.BroadwayRenderer

    static name: string

    // Constructors of Gsk-4.0.Gsk.BroadwayRenderer

    constructor(config?: BroadwayRenderer.ConstructorProperties)
    /**
     * Creates a new Broadway renderer.
     *
     * The Broadway renderer is the default renderer for the broadway backend.
     * It will only work with broadway surfaces, otherwise it will fail the
     * call to gsk_renderer_realize().
     *
     * This function is only available when GTK was compiled with Broadway
     * support.
     * @constructor
     * @returns a new Broadway renderer.
     */
    constructor()
    /**
     * Creates a new Broadway renderer.
     *
     * The Broadway renderer is the default renderer for the broadway backend.
     * It will only work with broadway surfaces, otherwise it will fail the
     * call to gsk_renderer_realize().
     *
     * This function is only available when GTK was compiled with Broadway
     * support.
     * @constructor
     * @returns a new Broadway renderer.
     */
    static new(): BroadwayRenderer
    _init(config?: BroadwayRenderer.ConstructorProperties): void
  }

  interface CairoNode {
    // Owm methods of Gsk-4.0.Gsk.CairoNode

    /**
     * Creates a Cairo context for drawing using the surface associated
     * to the render node.
     *
     * If no surface exists yet, a surface will be created optimized for
     * rendering to `renderer`.
     * @returns a Cairo context used for drawing; use   cairo_destroy() when done drawing
     */
    getDrawContext(): cairo.Context
    /**
     * Retrieves the Cairo surface used by the render node.
     * @returns a Cairo surface
     */
    getSurface(): cairo.Surface
  }

  /**
   * A render node for a Cairo surface.
   * @class
   */
  class CairoNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.CairoNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.CairoNode

    /**
     * Creates a `GskRenderNode` that will render a cairo surface
     * into the area given by `bounds`.
     *
     * You can draw to the cairo surface using [method`Gsk`.CairoNode.get_draw_context].
     * @constructor
     * @param bounds the rectangle to render to
     * @returns A new `GskRenderNode`
     */
    constructor(bounds: Graphene.Rect)
    /**
     * Creates a `GskRenderNode` that will render a cairo surface
     * into the area given by `bounds`.
     *
     * You can draw to the cairo surface using [method`Gsk`.CairoNode.get_draw_context].
     * @constructor
     * @param bounds the rectangle to render to
     * @returns A new `GskRenderNode`
     */
    static new(bounds: Graphene.Rect): CairoNode
  }

  module CairoRenderer {
    // Constructor properties interface

    interface ConstructorProperties extends Renderer.ConstructorProperties {}
  }

  interface CairoRenderer {
    // Own properties of Gsk-4.0.Gsk.CairoRenderer

    __gtype__: number

    // Class property signals of Gsk-4.0.Gsk.CairoRenderer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::realized", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A GSK renderer that is using cairo.
   *
   * Since it is using cairo, this renderer cannot support
   * 3D transformations.
   * @class
   */
  class CairoRenderer extends Renderer {
    // Own properties of Gsk-4.0.Gsk.CairoRenderer

    static name: string

    // Constructors of Gsk-4.0.Gsk.CairoRenderer

    constructor(config?: CairoRenderer.ConstructorProperties)
    /**
     * Creates a new Cairo renderer.
     *
     * The Cairo renderer is the fallback renderer drawing in ways similar
     * to how GTK 3 drew its content. Its primary use is as comparison tool.
     *
     * The Cairo renderer is incomplete. It cannot render 3D transformed
     * content and will instead render an error marker. Its usage should be
     * avoided.
     * @constructor
     * @returns a new Cairo renderer.
     */
    constructor()
    /**
     * Creates a new Cairo renderer.
     *
     * The Cairo renderer is the fallback renderer drawing in ways similar
     * to how GTK 3 drew its content. Its primary use is as comparison tool.
     *
     * The Cairo renderer is incomplete. It cannot render 3D transformed
     * content and will instead render an error marker. Its usage should be
     * avoided.
     * @constructor
     * @returns a new Cairo renderer.
     */
    static new(): CairoRenderer
    _init(config?: CairoRenderer.ConstructorProperties): void
  }

  interface ClipNode {
    // Owm methods of Gsk-4.0.Gsk.ClipNode

    /**
     * Gets the child node that is getting clipped by the given `node`.
     * @returns The child that is getting clipped
     */
    getChild(): RenderNode
    /**
     * Retrieves the clip rectangle for `node`.
     * @returns a clip rectangle
     */
    getClip(): Graphene.Rect
  }

  /**
   * A render node applying a rectangular clip to its single child node.
   * @class
   */
  class ClipNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ClipNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.ClipNode

    /**
     * Creates a `GskRenderNode` that will clip the `child` to the area
     * given by `clip`.
     * @constructor
     * @param child The node to draw
     * @param clip The clip to apply
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, clip: Graphene.Rect)
    /**
     * Creates a `GskRenderNode` that will clip the `child` to the area
     * given by `clip`.
     * @constructor
     * @param child The node to draw
     * @param clip The clip to apply
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, clip: Graphene.Rect): ClipNode
  }

  interface ColorMatrixNode {
    // Owm methods of Gsk-4.0.Gsk.ColorMatrixNode

    /**
     * Gets the child node that is getting its colors modified by the given `node`.
     * @returns The child that is getting its colors modified
     */
    getChild(): RenderNode
    /**
     * Retrieves the color matrix used by the `node`.
     * @returns a 4x4 color matrix
     */
    getColorMatrix(): Graphene.Matrix
    /**
     * Retrieves the color offset used by the `node`.
     * @returns a color vector
     */
    getColorOffset(): Graphene.Vec4
  }

  /**
   * A render node controlling the color matrix of its single child node.
   * @class
   */
  class ColorMatrixNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ColorMatrixNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.ColorMatrixNode

    /**
     * Creates a `GskRenderNode` that will drawn the `child` with
     * `color_matrix`.
     *
     * In particular, the node will transform colors by applying
     *
     *     pixel = transpose(color_matrix) * pixel + color_offset
     *
     * for every pixel. The transformation operates on unpremultiplied
     * colors, with color components ordered R, G, B, A.
     * @constructor
     * @param child The node to draw
     * @param colorMatrix The matrix to apply
     * @param colorOffset Values to add to the color
     * @returns A new `GskRenderNode`
     */
    constructor(
      child: RenderNode,
      colorMatrix: Graphene.Matrix,
      colorOffset: Graphene.Vec4
    )
    /**
     * Creates a `GskRenderNode` that will drawn the `child` with
     * `color_matrix`.
     *
     * In particular, the node will transform colors by applying
     *
     *     pixel = transpose(color_matrix) * pixel + color_offset
     *
     * for every pixel. The transformation operates on unpremultiplied
     * colors, with color components ordered R, G, B, A.
     * @constructor
     * @param child The node to draw
     * @param colorMatrix The matrix to apply
     * @param colorOffset Values to add to the color
     * @returns A new `GskRenderNode`
     */
    static new(
      child: RenderNode,
      colorMatrix: Graphene.Matrix,
      colorOffset: Graphene.Vec4
    ): ColorMatrixNode
  }

  interface ColorNode {
    // Owm methods of Gsk-4.0.Gsk.ColorNode

    /**
     * Retrieves the color of the given `node`.
     * @returns the color of the node
     */
    getColor(): Gdk.RGBA
  }

  /**
   * A render node for a solid color.
   * @class
   */
  class ColorNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ColorNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.ColorNode

    /**
     * Creates a `GskRenderNode` that will render the color specified by `rgba` into
     * the area given by `bounds`.
     * @constructor
     * @param rgba a `GdkRGBA` specifying a color
     * @param bounds the rectangle to render the color into
     * @returns A new `GskRenderNode`
     */
    constructor(rgba: Gdk.RGBA, bounds: Graphene.Rect)
    /**
     * Creates a `GskRenderNode` that will render the color specified by `rgba` into
     * the area given by `bounds`.
     * @constructor
     * @param rgba a `GdkRGBA` specifying a color
     * @param bounds the rectangle to render the color into
     * @returns A new `GskRenderNode`
     */
    static new(rgba: Gdk.RGBA, bounds: Graphene.Rect): ColorNode
  }

  interface ConicGradientNode {
    // Owm methods of Gsk-4.0.Gsk.ConicGradientNode

    /**
     * Retrieves the angle for the gradient in radians, normalized in [0, 2 * PI].
     *
     * The angle is starting at the top and going clockwise, as expressed
     * in the css specification:
     *
     *     angle = 90 - gsk_conic_gradient_node_get_rotation()
     * @returns the angle for the gradient
     */
    getAngle(): number
    /**
     * Retrieves the center pointer for the gradient.
     * @returns the center point for the gradient
     */
    getCenter(): Graphene.Point
    /**
     * Retrieves the color stops in the gradient.
     * @returns the color stops in the gradient
     */
    getColorStops(): ColorStop[]
    /**
     * Retrieves the number of color stops in the gradient.
     * @returns the number of color stops
     */
    getNColorStops(): number
    /**
     * Retrieves the rotation for the gradient in degrees.
     * @returns the rotation for the gradient
     */
    getRotation(): number
  }

  /**
   * A render node for a conic gradient.
   * @class
   */
  class ConicGradientNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ConicGradientNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.ConicGradientNode

    /**
     * Creates a `GskRenderNode` that draws a conic gradient.
     *
     * The conic gradient
     * starts around `center` in the direction of `rotation`. A rotation of 0 means
     * that the gradient points up. Color stops are then added clockwise.
     * @constructor
     * @param bounds the bounds of the node
     * @param center the center of the gradient
     * @param rotation the rotation of the gradient in degrees
     * @param colorStops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    constructor(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      rotation: number,
      colorStops: ColorStop[]
    )
    /**
     * Creates a `GskRenderNode` that draws a conic gradient.
     *
     * The conic gradient
     * starts around `center` in the direction of `rotation`. A rotation of 0 means
     * that the gradient points up. Color stops are then added clockwise.
     * @constructor
     * @param bounds the bounds of the node
     * @param center the center of the gradient
     * @param rotation the rotation of the gradient in degrees
     * @param colorStops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    static new(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      rotation: number,
      colorStops: ColorStop[]
    ): ConicGradientNode
  }

  interface ContainerNode {
    // Owm methods of Gsk-4.0.Gsk.ContainerNode

    /**
     * Gets one of the children of `container`.
     * @param idx the position of the child to get
     * @returns the @idx'th child of @container
     */
    getChild(idx: number): RenderNode
    /**
     * Retrieves the number of direct children of `node`.
     * @returns the number of children of the `GskRenderNode`
     */
    getNChildren(): number
  }

  /**
   * A render node that can contain other render nodes.
   * @class
   */
  class ContainerNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ContainerNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.ContainerNode

    /**
     * Creates a new `GskRenderNode` instance for holding the given `children`.
     *
     * The new node will acquire a reference to each of the children.
     * @constructor
     * @param children The children of the node
     * @returns the new `GskRenderNode`
     */
    constructor(children: RenderNode[])
    /**
     * Creates a new `GskRenderNode` instance for holding the given `children`.
     *
     * The new node will acquire a reference to each of the children.
     * @constructor
     * @param children The children of the node
     * @returns the new `GskRenderNode`
     */
    static new(children: RenderNode[]): ContainerNode
  }

  interface CrossFadeNode {
    // Owm methods of Gsk-4.0.Gsk.CrossFadeNode

    /**
     * Retrieves the child `GskRenderNode` at the end of the cross-fade.
     * @returns a `GskRenderNode`
     */
    getEndChild(): RenderNode
    /**
     * Retrieves the progress value of the cross fade.
     * @returns the progress value, between 0 and 1
     */
    getProgress(): number
    /**
     * Retrieves the child `GskRenderNode` at the beginning of the cross-fade.
     * @returns a `GskRenderNode`
     */
    getStartChild(): RenderNode
  }

  /**
   * A render node cross fading between two child nodes.
   * @class
   */
  class CrossFadeNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.CrossFadeNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.CrossFadeNode

    /**
     * Creates a `GskRenderNode` that will do a cross-fade between `start` and `end`.
     * @constructor
     * @param start The start node to be drawn
     * @param end The node to be cross_fadeed onto the `start` node
     * @param progress How far the fade has progressed from start to end. The value will     be clamped to the range [0 ... 1]
     * @returns A new `GskRenderNode`
     */
    constructor(start: RenderNode, end: RenderNode, progress: number)
    /**
     * Creates a `GskRenderNode` that will do a cross-fade between `start` and `end`.
     * @constructor
     * @param start The start node to be drawn
     * @param end The node to be cross_fadeed onto the `start` node
     * @param progress How far the fade has progressed from start to end. The value will     be clamped to the range [0 ... 1]
     * @returns A new `GskRenderNode`
     */
    static new(
      start: RenderNode,
      end: RenderNode,
      progress: number
    ): CrossFadeNode
  }

  interface DebugNode {
    // Owm methods of Gsk-4.0.Gsk.DebugNode

    /**
     * Gets the child node that is getting drawn by the given `node`.
     * @returns the child `GskRenderNode`
     */
    getChild(): RenderNode
    /**
     * Gets the debug message that was set on this node
     * @returns The debug message
     */
    getMessage(): string
  }

  /**
   * A render node that emits a debugging message when drawing its
   * child node.
   * @class
   */
  class DebugNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.DebugNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.DebugNode

    /**
     * Creates a `GskRenderNode` that will add debug information about
     * the given `child`.
     *
     * Adding this node has no visual effect.
     * @constructor
     * @param child The child to add debug info for
     * @param message The debug message
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, message: string | null)
    /**
     * Creates a `GskRenderNode` that will add debug information about
     * the given `child`.
     *
     * Adding this node has no visual effect.
     * @constructor
     * @param child The child to add debug info for
     * @param message The debug message
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, message: string | null): DebugNode
  }

  interface FillNode {
    // Owm methods of Gsk-4.0.Gsk.FillNode

    /**
     * Gets the child node that is getting drawn by the given `node`.
     * @returns The child that is getting drawn
     */
    getChild(): RenderNode
    /**
     * Retrieves the fill rule used to determine how the path is filled.
     * @returns a `GskFillRule`
     */
    getFillRule(): FillRule
    /**
     * Retrieves the path used to describe the area filled with the contents of
     * the `node`.
     * @returns a `GskPath`
     */
    getPath(): Path
  }

  /**
   * A render node filling the area given by [struct`Gsk`.Path]
   * and [enum`Gsk`.FillRule] with the child node.
   * @class
   */
  class FillNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.FillNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.FillNode

    /**
     * Creates a `GskRenderNode` that will fill the `child` in the area
     * given by `path` and `fill_rule`.
     * @constructor
     * @param child The node to fill the area with
     * @param path The path describing the area to fill
     * @param fillRule The fill rule to use
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, path: Path, fillRule: FillRule)
    /**
     * Creates a `GskRenderNode` that will fill the `child` in the area
     * given by `path` and `fill_rule`.
     * @constructor
     * @param child The node to fill the area with
     * @param path The path describing the area to fill
     * @param fillRule The fill rule to use
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, path: Path, fillRule: FillRule): FillNode
  }

  module GLRenderer {
    // Constructor properties interface

    interface ConstructorProperties extends Renderer.ConstructorProperties {}
  }

  interface GLRenderer {
    // Own properties of Gsk-4.0.Gsk.GLRenderer

    __gtype__: number

    // Class property signals of Gsk-4.0.Gsk.GLRenderer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::realized", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  class GLRenderer extends Renderer {
    // Own properties of Gsk-4.0.Gsk.GLRenderer

    static name: string

    // Constructors of Gsk-4.0.Gsk.GLRenderer

    constructor(config?: GLRenderer.ConstructorProperties)
    /**
     * Creates a new `GskRenderer` using the new OpenGL renderer.
     * @constructor
     * @returns a new GL renderer
     */
    constructor()
    /**
     * Creates a new `GskRenderer` using the new OpenGL renderer.
     * @constructor
     * @returns a new GL renderer
     */
    static new(): GLRenderer
    _init(config?: GLRenderer.ConstructorProperties): void
  }

  module GLShader {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gsk-4.0.Gsk.GLShader

      /**
       * Resource containing the source code for the shader.
       *
       * If the shader source is not coming from a resource, this
       * will be %NULL.
       */
      resource?: string | null
      source?: any | null
    }
  }

  interface GLShader {
    // Own properties of Gsk-4.0.Gsk.GLShader

    /**
     * Resource containing the source code for the shader.
     *
     * If the shader source is not coming from a resource, this
     * will be %NULL.
     */
    readonly resource: string | null
    readonly source: any
    __gtype__: number

    // Owm methods of Gsk-4.0.Gsk.GLShader

    /**
     * Tries to compile the `shader` for the given `renderer`.
     *
     * If there is a problem, this function returns %FALSE and reports
     * an error. You should use this function before relying on the shader
     * for rendering and use a fallback with a simpler shader or without
     * shaders if it fails.
     *
     * Note that this will modify the rendering state (for example
     * change the current GL context) and requires the renderer to be
     * set up. This means that the widget has to be realized. Commonly you
     * want to call this from the realize signal of a widget, or during
     * widget snapshot.
     * @param renderer a `GskRenderer`
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    compile(renderer: Renderer): boolean
    /**
     * Looks for a uniform by the name `name,` and returns the index
     * of the uniform, or -1 if it was not found.
     * @param name uniform name
     * @returns The index of the uniform, or -1
     */
    findUniformByName(name: string): number
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of bool type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @returns The value
     */
    getArgBool(args: any, idx: number): boolean
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of float type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @returns The value
     */
    getArgFloat(args: any, idx: number): number
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of int type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @returns The value
     */
    getArgInt(args: any, idx: number): number
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of uint type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @returns The value
     */
    getArgUint(args: any, idx: number): number
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of vec2 type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @param outValue location to store the uniform value in
     */
    getArgVec2(args: any, idx: number, outValue: Graphene.Vec2): void
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of vec3 type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @param outValue location to store the uniform value in
     */
    getArgVec3(args: any, idx: number, outValue: Graphene.Vec3): void
    /**
     * Gets the value of the uniform `idx` in the `args` block.
     *
     * The uniform must be of vec4 type.
     * @param args uniform arguments
     * @param idx index of the uniform
     * @param outValue location to store set the uniform value in
     */
    getArgVec4(args: any, idx: number, outValue: Graphene.Vec4): void
    /**
     * Get the size of the data block used to specify arguments for this shader.
     * @returns The size of the data block
     */
    getArgsSize(): number
    /**
     * Returns the number of textures that the shader requires.
     *
     * This can be used to check that the a passed shader works
     * in your usecase. It is determined by looking at the highest
     * u_textureN value that the shader defines.
     * @returns The number of texture inputs required by @shader
     */
    getNTextures(): number
    /**
     * Get the number of declared uniforms for this shader.
     * @returns The number of declared uniforms
     */
    getNUniforms(): number
    /**
     * Gets the resource path for the GLSL sourcecode being used
     * to render this shader.
     * @returns The resource path for the shader
     */
    getResource(): string | null
    /**
     * Gets the GLSL sourcecode being used to render this shader.
     * @returns The source code for the shader
     */
    getSource(): any
    /**
     * Get the name of the declared uniform for this shader at index `idx`.
     * @param idx index of the uniform
     * @returns The name of the declared uniform
     */
    getUniformName(idx: number): string
    /**
     * Get the offset into the data block where data for this uniforms is stored.
     * @param idx index of the uniform
     * @returns The data offset
     */
    getUniformOffset(idx: number): number
    /**
     * Get the type of the declared uniform for this shader at index `idx`.
     * @param idx index of the uniform
     * @returns The type of the declared uniform
     */
    getUniformType(idx: number): GLUniformType

    // Class property signals of Gsk-4.0.Gsk.GLShader

    connect(
      sigName: "notify::resource",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resource",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resource",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resource",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resource", ...args: any[]): void
    connect(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::source", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GskGLShader` is a snippet of GLSL that is meant to run in the
   * fragment shader of the rendering pipeline.
   *
   * A fragment shader gets the coordinates being rendered as input and
   * produces the pixel values for that particular pixel. Additionally,
   * the shader can declare a set of other input arguments, called
   * uniforms (as they are uniform over all the calls to your shader in
   * each instance of use). A shader can also receive up to 4
   * textures that it can use as input when producing the pixel data.
   *
   * `GskGLShader` is usually used with gtk_snapshot_push_gl_shader()
   * to produce a [class`Gsk`.GLShaderNode] in the rendering hierarchy,
   * and then its input textures are constructed by rendering the child
   * nodes to textures before rendering the shader node itself. (You can
   * pass texture nodes as children if you want to directly use a texture
   * as input).
   *
   * The actual shader code is GLSL code that gets combined with
   * some other code into the fragment shader. Since the exact
   * capabilities of the GPU driver differs between different OpenGL
   * drivers and hardware, GTK adds some defines that you can use
   * to ensure your GLSL code runs on as many drivers as it can.
   *
   * If the OpenGL driver is GLES, then the shader language version
   * is set to 100, and GSK_GLES will be defined in the shader.
   *
   * Otherwise, if the OpenGL driver does not support the 3.2 core profile,
   * then the shader will run with language version 110 for GL2 and 130 for GL3,
   * and GSK_LEGACY will be defined in the shader.
   *
   * If the OpenGL driver supports the 3.2 code profile, it will be used,
   * the shader language version is set to 150, and GSK_GL3 will be defined
   * in the shader.
   *
   * The main function the shader must implement is:
   *
   * ```glsl
   *  void mainImage(out vec4 fragColor,
   *                 in vec2 fragCoord,
   *                 in vec2 resolution,
   *                 in vec2 uv)
   * ```
   *
   * Where the input `fragCoord` is the coordinate of the pixel we're
   * currently rendering, relative to the boundary rectangle that was
   * specified in the `GskGLShaderNode`, and `resolution` is the width and
   * height of that rectangle. This is in the typical GTK coordinate
   * system with the origin in the top left. `uv` contains the u and v
   * coordinates that can be used to index a texture at the
   * corresponding point. These coordinates are in the [0..1]x[0..1]
   * region, with 0, 0 being in the lower left corder (which is typical
   * for OpenGL).
   *
   * The output `fragColor` should be a RGBA color (with
   * premultiplied alpha) that will be used as the output for the
   * specified pixel location. Note that this output will be
   * automatically clipped to the clip region of the glshader node.
   *
   * In addition to the function arguments the shader can define
   * up to 4 uniforms for textures which must be called u_textureN
   * (i.e. u_texture1 to u_texture4) as well as any custom uniforms
   * you want of types int, uint, bool, float, vec2, vec3 or vec4.
   *
   * All textures sources contain premultiplied alpha colors, but if some
   * there are outer sources of colors there is a gsk_premultiply() helper
   * to compute premultiplication when needed.
   *
   * Note that GTK parses the uniform declarations, so each uniform has to
   * be on a line by itself with no other code, like so:
   *
   * ```glsl
   * uniform float u_time;
   * uniform vec3 u_color;
   * uniform sampler2D u_texture1;
   * uniform sampler2D u_texture2;
   * ```
   *
   * GTK uses the "gsk" namespace in the symbols it uses in the
   * shader, so your code should not use any symbols with the prefix gsk
   * or GSK. There are some helper functions declared that you can use:
   *
   * ```glsl
   * vec4 GskTexture(sampler2D sampler, vec2 texCoords);
   * ```
   *
   * This samples a texture (e.g. u_texture1) at the specified
   * coordinates, and contains some helper ifdefs to ensure that
   * it works on all OpenGL versions.
   *
   * You can compile the shader yourself using [method`Gsk`.GLShader.compile],
   * otherwise the GSK renderer will do it when it handling the glshader
   * node. If errors occurs, the returned `error` will include the glsl
   * sources, so you can see what GSK was passing to the compiler. You
   * can also set GSK_DEBUG=shaders in the environment to see the sources
   * and other relevant information about all shaders that GSK is handling.
   *
   * # An example shader
   *
   * ```glsl
   * uniform float position;
   * uniform sampler2D u_texture1;
   * uniform sampler2D u_texture2;
   *
   * void mainImage(out vec4 fragColor,
   *                in vec2 fragCoord,
   *                in vec2 resolution,
   *                in vec2 uv) {
   *   vec4 source1 = GskTexture(u_texture1, uv);
   *   vec4 source2 = GskTexture(u_texture2, uv);
   *
   *   fragColor = position * source1 + (1.0 - position) * source2;
   * }
   * ```
   * @class
   */
  class GLShader extends GObject.Object {
    // Own properties of Gsk-4.0.Gsk.GLShader

    static name: string

    // Constructors of Gsk-4.0.Gsk.GLShader

    constructor(config?: GLShader.ConstructorProperties)
    /**
     * Creates a `GskGLShader` that will render pixels using the specified code.
     * @constructor
     * @param sourcecode GLSL sourcecode for the shader, as a `GBytes`
     * @returns A new `GskGLShader`
     */
    static newFromBytes(sourcecode: any): GLShader
    /**
     * Creates a `GskGLShader` that will render pixels using the specified code.
     * @constructor
     * @param resourcePath path to a resource that contains the GLSL sourcecode for     the shader
     * @returns A new `GskGLShader`
     */
    static newFromResource(resourcePath: string): GLShader
    _init(config?: GLShader.ConstructorProperties): void
  }

  interface GLShaderNode {
    // Owm methods of Gsk-4.0.Gsk.GLShaderNode

    /**
     * Gets args for the node.
     * @returns A `GBytes` with the uniform arguments
     */
    getArgs(): any
    /**
     * Gets one of the children.
     * @param idx the position of the child to get
     * @returns the @idx'th child of @node
     */
    getChild(idx: number): RenderNode
    /**
     * Returns the number of children
     * @returns The number of children
     */
    getNChildren(): number
    /**
     * Gets shader code for the node.
     * @returns the `GskGLShader` shader
     */
    getShader(): GLShader
  }

  /**
   * A render node using a GL shader when drawing its children nodes.
   * @class
   */
  class GLShaderNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.GLShaderNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.GLShaderNode

    /**
     * Creates a `GskRenderNode` that will render the given `shader` into the
     * area given by `bounds`.
     *
     * The `args` is a block of data to use for uniform input, as per types and
     * offsets defined by the `shader`. Normally this is generated by
     * [method`Gsk`.GLShader.format_args] or [struct`Gsk`.ShaderArgsBuilder].
     *
     * See [class`Gsk`.GLShader] for details about how the shader should be written.
     *
     * All the children will be rendered into textures (if they aren't already
     * `GskTextureNodes`, which will be used directly). These textures will be
     * sent as input to the shader.
     *
     * If the renderer doesn't support GL shaders, or if there is any problem
     * when compiling the shader, then the node will draw pink. You should use
     * [method`Gsk`.GLShader.compile] to ensure the `shader` will work for the
     * renderer before using it.
     * @constructor
     * @param shader the `GskGLShader`
     * @param bounds the rectangle to render the shader into
     * @param args Arguments for the uniforms
     * @param children array of child nodes,   these will be rendered to textures and used as input.
     * @returns A new `GskRenderNode`
     */
    constructor(
      shader: GLShader,
      bounds: Graphene.Rect,
      args: any,
      children: RenderNode[] | null
    )
    /**
     * Creates a `GskRenderNode` that will render the given `shader` into the
     * area given by `bounds`.
     *
     * The `args` is a block of data to use for uniform input, as per types and
     * offsets defined by the `shader`. Normally this is generated by
     * [method`Gsk`.GLShader.format_args] or [struct`Gsk`.ShaderArgsBuilder].
     *
     * See [class`Gsk`.GLShader] for details about how the shader should be written.
     *
     * All the children will be rendered into textures (if they aren't already
     * `GskTextureNodes`, which will be used directly). These textures will be
     * sent as input to the shader.
     *
     * If the renderer doesn't support GL shaders, or if there is any problem
     * when compiling the shader, then the node will draw pink. You should use
     * [method`Gsk`.GLShader.compile] to ensure the `shader` will work for the
     * renderer before using it.
     * @constructor
     * @param shader the `GskGLShader`
     * @param bounds the rectangle to render the shader into
     * @param args Arguments for the uniforms
     * @param children array of child nodes,   these will be rendered to textures and used as input.
     * @returns A new `GskRenderNode`
     */
    static new(
      shader: GLShader,
      bounds: Graphene.Rect,
      args: any,
      children: RenderNode[] | null
    ): GLShaderNode
  }

  interface InsetShadowNode {
    // Owm methods of Gsk-4.0.Gsk.InsetShadowNode

    /**
     * Retrieves the blur radius to apply to the shadow.
     * @returns the blur radius, in pixels
     */
    getBlurRadius(): number
    /**
     * Retrieves the color of the inset shadow.
     * @returns the color of the shadow
     */
    getColor(): Gdk.RGBA
    /**
     * Retrieves the horizontal offset of the inset shadow.
     * @returns an offset, in pixels
     */
    getDx(): number
    /**
     * Retrieves the vertical offset of the inset shadow.
     * @returns an offset, in pixels
     */
    getDy(): number
    /**
     * Retrieves the outline rectangle of the inset shadow.
     * @returns a rounded rectangle
     */
    getOutline(): RoundedRect
    /**
     * Retrieves how much the shadow spreads inwards.
     * @returns the size of the shadow, in pixels
     */
    getSpread(): number
  }

  /**
   * A render node for an inset shadow.
   * @class
   */
  class InsetShadowNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.InsetShadowNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.InsetShadowNode

    /**
     * Creates a `GskRenderNode` that will render an inset shadow
     * into the box given by `outline`.
     * @constructor
     * @param outline outline of the region containing the shadow
     * @param color color of the shadow
     * @param dx horizontal offset of shadow
     * @param dy vertical offset of shadow
     * @param spread how far the shadow spreads towards the inside
     * @param blurRadius how much blur to apply to the shadow
     * @returns A new `GskRenderNode`
     */
    constructor(
      outline: RoundedRect,
      color: Gdk.RGBA,
      dx: number,
      dy: number,
      spread: number,
      blurRadius: number
    )
    /**
     * Creates a `GskRenderNode` that will render an inset shadow
     * into the box given by `outline`.
     * @constructor
     * @param outline outline of the region containing the shadow
     * @param color color of the shadow
     * @param dx horizontal offset of shadow
     * @param dy vertical offset of shadow
     * @param spread how far the shadow spreads towards the inside
     * @param blurRadius how much blur to apply to the shadow
     * @returns A new `GskRenderNode`
     */
    static new(
      outline: RoundedRect,
      color: Gdk.RGBA,
      dx: number,
      dy: number,
      spread: number,
      blurRadius: number
    ): InsetShadowNode
  }

  interface LinearGradientNode {
    // Owm methods of Gsk-4.0.Gsk.LinearGradientNode

    /**
     * Retrieves the color stops in the gradient.
     * @returns the color stops in the gradient
     */
    getColorStops(): ColorStop[]
    /**
     * Retrieves the final point of the linear gradient.
     * @returns the final point
     */
    getEnd(): Graphene.Point
    /**
     * Retrieves the number of color stops in the gradient.
     * @returns the number of color stops
     */
    getNColorStops(): number
    /**
     * Retrieves the initial point of the linear gradient.
     * @returns the initial point
     */
    getStart(): Graphene.Point
  }

  /**
   * A render node for a linear gradient.
   * @class
   */
  class LinearGradientNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.LinearGradientNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.LinearGradientNode

    /**
     * Creates a `GskRenderNode` that will create a linear gradient from the given
     * points and color stops, and render that into the area given by `bounds`.
     * @constructor
     * @param bounds the rectangle to render the linear gradient into
     * @param start the point at which the linear gradient will begin
     * @param end the point at which the linear gradient will finish
     * @param colorStops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    constructor(
      bounds: Graphene.Rect,
      start: Graphene.Point,
      end: Graphene.Point,
      colorStops: ColorStop[]
    )
    /**
     * Creates a `GskRenderNode` that will create a linear gradient from the given
     * points and color stops, and render that into the area given by `bounds`.
     * @constructor
     * @param bounds the rectangle to render the linear gradient into
     * @param start the point at which the linear gradient will begin
     * @param end the point at which the linear gradient will finish
     * @param colorStops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    static new(
      bounds: Graphene.Rect,
      start: Graphene.Point,
      end: Graphene.Point,
      colorStops: ColorStop[]
    ): LinearGradientNode
  }

  interface MaskNode {
    // Owm methods of Gsk-4.0.Gsk.MaskNode

    /**
     * Retrieves the mask `GskRenderNode` child of the `node`.
     * @returns the mask child node
     */
    getMask(): RenderNode
    /**
     * Retrieves the mask mode used by `node`.
     * @returns the mask mode
     */
    getMaskMode(): MaskMode
    /**
     * Retrieves the source `GskRenderNode` child of the `node`.
     * @returns the source child node
     */
    getSource(): RenderNode
  }

  /**
   * A render node masking one child node with another.
   * @class
   */
  class MaskNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.MaskNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.MaskNode

    /**
     * Creates a `GskRenderNode` that will mask a given node by another.
     *
     * The `mask_mode` determines how the 'mask values' are derived from
     * the colors of the `mask`. Applying the mask consists of multiplying
     * the 'mask value' with the alpha of the source.
     * @constructor
     * @param source The source node to be drawn
     * @param mask The node to be used as mask
     * @param maskMode The mask mode to use
     * @returns A new `GskRenderNode`
     */
    constructor(source: RenderNode, mask: RenderNode, maskMode: MaskMode)
    /**
     * Creates a `GskRenderNode` that will mask a given node by another.
     *
     * The `mask_mode` determines how the 'mask values' are derived from
     * the colors of the `mask`. Applying the mask consists of multiplying
     * the 'mask value' with the alpha of the source.
     * @constructor
     * @param source The source node to be drawn
     * @param mask The node to be used as mask
     * @param maskMode The mask mode to use
     * @returns A new `GskRenderNode`
     */
    static new(
      source: RenderNode,
      mask: RenderNode,
      maskMode: MaskMode
    ): MaskNode
  }

  module NglRenderer {
    // Constructor properties interface

    interface ConstructorProperties extends Renderer.ConstructorProperties {}
  }

  interface NglRenderer {
    // Own properties of Gsk-4.0.Gsk.NglRenderer

    __gtype__: number

    // Class property signals of Gsk-4.0.Gsk.NglRenderer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::realized", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  class NglRenderer extends Renderer {
    // Own properties of Gsk-4.0.Gsk.NglRenderer

    static name: string

    // Constructors of Gsk-4.0.Gsk.NglRenderer

    constructor(config?: NglRenderer.ConstructorProperties)
    constructor()
    static new(): NglRenderer
    _init(config?: NglRenderer.ConstructorProperties): void
  }

  interface OpacityNode {
    // Owm methods of Gsk-4.0.Gsk.OpacityNode

    /**
     * Gets the child node that is getting opacityed by the given `node`.
     * @returns The child that is getting opacityed
     */
    getChild(): RenderNode
    /**
     * Gets the transparency factor for an opacity node.
     * @returns the opacity factor
     */
    getOpacity(): number
  }

  /**
   * A render node controlling the opacity of its single child node.
   * @class
   */
  class OpacityNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.OpacityNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.OpacityNode

    /**
     * Creates a `GskRenderNode` that will drawn the `child` with reduced
     * `opacity`.
     * @constructor
     * @param child The node to draw
     * @param opacity The opacity to apply
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, opacity: number)
    /**
     * Creates a `GskRenderNode` that will drawn the `child` with reduced
     * `opacity`.
     * @constructor
     * @param child The node to draw
     * @param opacity The opacity to apply
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, opacity: number): OpacityNode
  }

  interface OutsetShadowNode {
    // Owm methods of Gsk-4.0.Gsk.OutsetShadowNode

    /**
     * Retrieves the blur radius of the shadow.
     * @returns the blur radius, in pixels
     */
    getBlurRadius(): number
    /**
     * Retrieves the color of the outset shadow.
     * @returns a color
     */
    getColor(): Gdk.RGBA
    /**
     * Retrieves the horizontal offset of the outset shadow.
     * @returns an offset, in pixels
     */
    getDx(): number
    /**
     * Retrieves the vertical offset of the outset shadow.
     * @returns an offset, in pixels
     */
    getDy(): number
    /**
     * Retrieves the outline rectangle of the outset shadow.
     * @returns a rounded rectangle
     */
    getOutline(): RoundedRect
    /**
     * Retrieves how much the shadow spreads outwards.
     * @returns the size of the shadow, in pixels
     */
    getSpread(): number
  }

  /**
   * A render node for an outset shadow.
   * @class
   */
  class OutsetShadowNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.OutsetShadowNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.OutsetShadowNode

    /**
     * Creates a `GskRenderNode` that will render an outset shadow
     * around the box given by `outline`.
     * @constructor
     * @param outline outline of the region surrounded by shadow
     * @param color color of the shadow
     * @param dx horizontal offset of shadow
     * @param dy vertical offset of shadow
     * @param spread how far the shadow spreads towards the inside
     * @param blurRadius how much blur to apply to the shadow
     * @returns A new `GskRenderNode`
     */
    constructor(
      outline: RoundedRect,
      color: Gdk.RGBA,
      dx: number,
      dy: number,
      spread: number,
      blurRadius: number
    )
    /**
     * Creates a `GskRenderNode` that will render an outset shadow
     * around the box given by `outline`.
     * @constructor
     * @param outline outline of the region surrounded by shadow
     * @param color color of the shadow
     * @param dx horizontal offset of shadow
     * @param dy vertical offset of shadow
     * @param spread how far the shadow spreads towards the inside
     * @param blurRadius how much blur to apply to the shadow
     * @returns A new `GskRenderNode`
     */
    static new(
      outline: RoundedRect,
      color: Gdk.RGBA,
      dx: number,
      dy: number,
      spread: number,
      blurRadius: number
    ): OutsetShadowNode
  }

  interface RadialGradientNode {
    // Owm methods of Gsk-4.0.Gsk.RadialGradientNode

    /**
     * Retrieves the center pointer for the gradient.
     * @returns the center point for the gradient
     */
    getCenter(): Graphene.Point
    /**
     * Retrieves the color stops in the gradient.
     * @returns the color stops in the gradient
     */
    getColorStops(): ColorStop[]
    /**
     * Retrieves the end value for the gradient.
     * @returns the end value for the gradient
     */
    getEnd(): number
    /**
     * Retrieves the horizontal radius for the gradient.
     * @returns the horizontal radius for the gradient
     */
    getHradius(): number
    /**
     * Retrieves the number of color stops in the gradient.
     * @returns the number of color stops
     */
    getNColorStops(): number
    /**
     * Retrieves the start value for the gradient.
     * @returns the start value for the gradient
     */
    getStart(): number
    /**
     * Retrieves the vertical radius for the gradient.
     * @returns the vertical radius for the gradient
     */
    getVradius(): number
  }

  /**
   * A render node for a radial gradient.
   * @class
   */
  class RadialGradientNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.RadialGradientNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.RadialGradientNode

    /**
     * Creates a `GskRenderNode` that draws a radial gradient.
     *
     * The radial gradient
     * starts around `center`. The size of the gradient is dictated by `hradius`
     * in horizontal orientation and by `vradius` in vertical orientation.
     * @constructor
     * @param bounds the bounds of the node
     * @param center the center of the gradient
     * @param hradius the horizontal radius
     * @param vradius the vertical radius
     * @param start a percentage >= 0 that defines the start of the gradient around `center`
     * @param end a percentage >= 0 that defines the end of the gradient around `center`
     * @param colorStops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    constructor(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      hradius: number,
      vradius: number,
      start: number,
      end: number,
      colorStops: ColorStop[]
    )
    /**
     * Creates a `GskRenderNode` that draws a radial gradient.
     *
     * The radial gradient
     * starts around `center`. The size of the gradient is dictated by `hradius`
     * in horizontal orientation and by `vradius` in vertical orientation.
     * @constructor
     * @param bounds the bounds of the node
     * @param center the center of the gradient
     * @param hradius the horizontal radius
     * @param vradius the vertical radius
     * @param start a percentage >= 0 that defines the start of the gradient around `center`
     * @param end a percentage >= 0 that defines the end of the gradient around `center`
     * @param colorStops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    static new(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      hradius: number,
      vradius: number,
      start: number,
      end: number,
      colorStops: ColorStop[]
    ): RadialGradientNode
  }

  interface RenderNode {
    // Owm methods of Gsk-4.0.Gsk.RenderNode

    /**
     * Draw the contents of `node` to the given cairo context.
     *
     * Typically, you'll use this function to implement fallback rendering
     * of `GskRenderNode`s on an intermediate Cairo context, instead of using
     * the drawing context associated to a [class`Gdk`.Surface]'s rendering buffer.
     *
     * For advanced nodes that cannot be supported using Cairo, in particular
     * for nodes doing 3D operations, this function may fail.
     * @param cr cairo context to draw to
     */
    draw(cr: cairo.Context): void
    /**
     * Retrieves the boundaries of the `node`.
     *
     * The node will not draw outside of its boundaries.
     */
    getBounds(): /* bounds */ Graphene.Rect
    /**
     * Returns the type of the `node`.
     * @returns the type of the `GskRenderNode`
     */
    getNodeType(): RenderNodeType
    /**
     * Acquires a reference on the given `GskRenderNode`.
     * @returns the `GskRenderNode` with an additional reference
     */
    ref(): RenderNode
    /**
     * Serializes the `node` for later deserialization via
     * gsk_render_node_deserialize(). No guarantees are made about the format
     * used other than that the same version of GTK will be able to deserialize
     * the result of a call to gsk_render_node_serialize() and
     * gsk_render_node_deserialize() will correctly reject files it cannot open
     * that were created with previous versions of GTK.
     *
     * The intended use of this functions is testing, benchmarking and debugging.
     * The format is not meant as a permanent storage format.
     * @returns a `GBytes` representing the node.
     */
    serialize(): any
    /**
     * Releases a reference on the given `GskRenderNode`.
     *
     * If the reference was the last, the resources associated to the `node` are
     * freed.
     */
    unref(): void
    /**
     * This function is equivalent to calling [method`Gsk`.RenderNode.serialize]
     * followed by [func`GLib`.file_set_contents].
     *
     * See those two functions for details on the arguments.
     *
     * It is mostly intended for use inside a debugger to quickly dump a render
     * node to a file for later inspection.
     * @param filename the file to save it to.
     * @returns %TRUE if saving was successful
     */
    writeToFile(filename: string): boolean
  }

  /**
   * `GskRenderNode` is the basic block in a scene graph to be
   * rendered using [class`Gsk`.Renderer].
   *
   * Each node has a parent, except the top-level node; each node may have
   * children nodes.
   *
   * Each node has an associated drawing surface, which has the size of
   * the rectangle set when creating it.
   *
   * Render nodes are meant to be transient; once they have been associated
   * to a [class`Gsk`.Renderer] it's safe to release any reference you have on
   * them. All [class`Gsk`.RenderNode]s are immutable, you can only specify their
   * properties during construction.
   * @class
   */
  class RenderNode {
    // Own properties of Gsk-4.0.Gsk.RenderNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.RenderNode

    /**
     * Loads data previously created via [method`Gsk`.RenderNode.serialize].
     *
     * For a discussion of the supported format, see that function.
     * @param bytes the bytes containing the data
     * @returns a new `GskRenderNode`
     */
    static deserialize(bytes: any): RenderNode | null
  }

  module Renderer {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Renderer {
    // Own properties of Gsk-4.0.Gsk.Renderer

    /**
     * Whether the renderer has been associated with a surface or draw context.
     */
    readonly realized: boolean
    /**
     * The surface associated with renderer.
     */
    readonly surface: Gdk.Surface
    __gtype__: number

    // Owm methods of Gsk-4.0.Gsk.Renderer

    /**
     * Retrieves the `GdkSurface` set using gsk_enderer_realize().
     *
     * If the renderer has not been realized yet, %NULL will be returned.
     * @returns a `GdkSurface`
     */
    getSurface(): Gdk.Surface | null
    /**
     * Checks whether the `renderer` is realized or not.
     * @returns %TRUE if the `GskRenderer` was realized, and %FALSE otherwise
     */
    isRealized(): boolean
    /**
     * Creates the resources needed by the `renderer` to render the scene
     * graph.
     *
     * Since GTK 4.6, the surface may be `NULL`, which allows using
     * renderers without having to create a surface.
     * Since GTK 4.14, it is recommended to use [method`Gsk`.Renderer.realize_for_display]
     * instead.
     *
     * Note that it is mandatory to call [method`Gsk`.Renderer.unrealize] before
     * destroying the renderer.
     * @param surface the `GdkSurface` renderer will be used on
     * @returns Whether the renderer was successfully realized
     */
    realize(surface: Gdk.Surface | null): boolean
    /**
     * Creates the resources needed by the `renderer` to render the scene
     * graph.
     *
     * Note that it is mandatory to call [method`Gsk`.Renderer.unrealize] before
     * destroying the renderer.
     * @param display the `GdkDisplay` renderer will be used on
     * @returns Whether the renderer was successfully realized
     */
    realizeForDisplay(display: Gdk.Display): boolean
    /**
     * Renders the scene graph, described by a tree of `GskRenderNode` instances
     * to the renderer's surface,  ensuring that the given `region` gets redrawn.
     *
     * If the renderer has no associated surface, this function does nothing.
     *
     * Renderers must ensure that changes of the contents given by the `root`
     * node as well as the area given by `region` are redrawn. They are however
     * free to not redraw any pixel outside of `region` if they can guarantee that
     * it didn't change.
     *
     * The `renderer` will acquire a reference on the `GskRenderNode` tree while
     * the rendering is in progress.
     * @param root a `GskRenderNode`
     * @param region the `cairo_region_t` that must be redrawn or %NULL   for the whole window
     */
    render(root: RenderNode, region: cairo.Region | null): void
    /**
     * Renders the scene graph, described by a tree of `GskRenderNode` instances,
     * to a `GdkTexture`.
     *
     * The `renderer` will acquire a reference on the `GskRenderNode` tree while
     * the rendering is in progress.
     *
     * If you want to apply any transformations to `root,` you should put it into a
     * transform node and pass that node instead.
     * @param root a `GskRenderNode`
     * @param viewport the section to draw or %NULL to use `root'`s bounds
     * @returns a `GdkTexture` with the rendered contents of @root.
     */
    renderTexture(root: RenderNode, viewport: Graphene.Rect | null): Gdk.Texture
    /**
     * Releases all the resources created by gsk_renderer_realize().
     */
    unrealize(): void

    // Class property signals of Gsk-4.0.Gsk.Renderer

    connect(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::realized", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GskRenderer` is a class that renders a scene graph defined via a
   * tree of [class`Gsk`.RenderNode] instances.
   *
   * Typically you will use a `GskRenderer` instance to repeatedly call
   * [method`Gsk`.Renderer.render] to update the contents of its associated
   * [class`Gdk`.Surface].
   *
   * It is necessary to realize a `GskRenderer` instance using
   * [method`Gsk`.Renderer.realize] before calling [method`Gsk`.Renderer.render],
   * in order to create the appropriate windowing system resources needed
   * to render the scene.
   * @class
   */
  class Renderer extends GObject.Object {
    // Own properties of Gsk-4.0.Gsk.Renderer

    static name: string

    // Constructors of Gsk-4.0.Gsk.Renderer

    constructor(config?: Renderer.ConstructorProperties)
    /**
     * Creates an appropriate `GskRenderer` instance for the given `surface`.
     *
     * If the `GSK_RENDERER` environment variable is set, GSK will
     * try that renderer first, before trying the backend-specific
     * default. The ultimate fallback is the cairo renderer.
     *
     * The renderer will be realized before it is returned.
     * @constructor
     * @param surface a `GdkSurface`
     * @returns a `GskRenderer`
     */
    static newForSurface(surface: Gdk.Surface): Renderer
    _init(config?: Renderer.ConstructorProperties): void
  }

  interface RepeatNode {
    // Owm methods of Gsk-4.0.Gsk.RepeatNode

    /**
     * Retrieves the child of `node`.
     * @returns a `GskRenderNode`
     */
    getChild(): RenderNode
    /**
     * Retrieves the bounding rectangle of the child of `node`.
     * @returns a bounding rectangle
     */
    getChildBounds(): Graphene.Rect
  }

  /**
   * A render node repeating its single child node.
   * @class
   */
  class RepeatNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.RepeatNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.RepeatNode

    /**
     * Creates a `GskRenderNode` that will repeat the drawing of `child` across
     * the given `bounds`.
     * @constructor
     * @param bounds The bounds of the area to be painted
     * @param child The child to repeat
     * @param childBounds The area of the child to repeat or %NULL to     use the child's bounds
     * @returns A new `GskRenderNode`
     */
    constructor(
      bounds: Graphene.Rect,
      child: RenderNode,
      childBounds: Graphene.Rect | null
    )
    /**
     * Creates a `GskRenderNode` that will repeat the drawing of `child` across
     * the given `bounds`.
     * @constructor
     * @param bounds The bounds of the area to be painted
     * @param child The child to repeat
     * @param childBounds The area of the child to repeat or %NULL to     use the child's bounds
     * @returns A new `GskRenderNode`
     */
    static new(
      bounds: Graphene.Rect,
      child: RenderNode,
      childBounds: Graphene.Rect | null
    ): RepeatNode
  }

  interface RepeatingLinearGradientNode {}

  /**
   * A render node for a repeating linear gradient.
   * @class
   */
  class RepeatingLinearGradientNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.RepeatingLinearGradientNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.RepeatingLinearGradientNode

    /**
     * Creates a `GskRenderNode` that will create a repeating linear gradient
     * from the given points and color stops, and render that into the area
     * given by `bounds`.
     * @constructor
     * @param bounds the rectangle to render the linear gradient into
     * @param start the point at which the linear gradient will begin
     * @param end the point at which the linear gradient will finish
     * @param colorStops a pointer to an array of `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    constructor(
      bounds: Graphene.Rect,
      start: Graphene.Point,
      end: Graphene.Point,
      colorStops: ColorStop[]
    )
    /**
     * Creates a `GskRenderNode` that will create a repeating linear gradient
     * from the given points and color stops, and render that into the area
     * given by `bounds`.
     * @constructor
     * @param bounds the rectangle to render the linear gradient into
     * @param start the point at which the linear gradient will begin
     * @param end the point at which the linear gradient will finish
     * @param colorStops a pointer to an array of `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    static new(
      bounds: Graphene.Rect,
      start: Graphene.Point,
      end: Graphene.Point,
      colorStops: ColorStop[]
    ): RepeatingLinearGradientNode
  }

  interface RepeatingRadialGradientNode {}

  /**
   * A render node for a repeating radial gradient.
   * @class
   */
  class RepeatingRadialGradientNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.RepeatingRadialGradientNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.RepeatingRadialGradientNode

    /**
     * Creates a `GskRenderNode` that draws a repeating radial gradient.
     *
     * The radial gradient starts around `center`. The size of the gradient
     * is dictated by `hradius` in horizontal orientation and by `vradius`
     * in vertical orientation.
     * @constructor
     * @param bounds the bounds of the node
     * @param center the center of the gradient
     * @param hradius the horizontal radius
     * @param vradius the vertical radius
     * @param start a percentage >= 0 that defines the start of the gradient around `center`
     * @param end a percentage >= 0 that defines the end of the gradient around `center`
     * @param colorStops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    constructor(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      hradius: number,
      vradius: number,
      start: number,
      end: number,
      colorStops: ColorStop[]
    )
    /**
     * Creates a `GskRenderNode` that draws a repeating radial gradient.
     *
     * The radial gradient starts around `center`. The size of the gradient
     * is dictated by `hradius` in horizontal orientation and by `vradius`
     * in vertical orientation.
     * @constructor
     * @param bounds the bounds of the node
     * @param center the center of the gradient
     * @param hradius the horizontal radius
     * @param vradius the vertical radius
     * @param start a percentage >= 0 that defines the start of the gradient around `center`
     * @param end a percentage >= 0 that defines the end of the gradient around `center`
     * @param colorStops a pointer to an array of   `GskColorStop` defining the gradient. The offsets of all color stops   must be increasing. The first stop's offset must be >= 0 and the last   stop's offset must be <= 1.
     * @returns A new `GskRenderNode`
     */
    static new(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      hradius: number,
      vradius: number,
      start: number,
      end: number,
      colorStops: ColorStop[]
    ): RepeatingRadialGradientNode
  }

  interface RoundedClipNode {
    // Owm methods of Gsk-4.0.Gsk.RoundedClipNode

    /**
     * Gets the child node that is getting clipped by the given `node`.
     * @returns The child that is getting clipped
     */
    getChild(): RenderNode
    /**
     * Retrieves the rounded rectangle used to clip the contents of the `node`.
     * @returns a rounded rectangle
     */
    getClip(): RoundedRect
  }

  /**
   * A render node applying a rounded rectangle clip to its single child.
   * @class
   */
  class RoundedClipNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.RoundedClipNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.RoundedClipNode

    /**
     * Creates a `GskRenderNode` that will clip the `child` to the area
     * given by `clip`.
     * @constructor
     * @param child The node to draw
     * @param clip The clip to apply
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, clip: RoundedRect)
    /**
     * Creates a `GskRenderNode` that will clip the `child` to the area
     * given by `clip`.
     * @constructor
     * @param child The node to draw
     * @param clip The clip to apply
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, clip: RoundedRect): RoundedClipNode
  }

  interface ShadowNode {
    // Owm methods of Gsk-4.0.Gsk.ShadowNode

    /**
     * Retrieves the child `GskRenderNode` of the shadow `node`.
     * @returns the child render node
     */
    getChild(): RenderNode
    /**
     * Retrieves the number of shadows in the `node`.
     * @returns the number of shadows.
     */
    getNShadows(): number
    /**
     * Retrieves the shadow data at the given index `i`.
     * @param i the given index
     * @returns the shadow data
     */
    getShadow(i: number): Shadow
  }

  /**
   * A render node drawing one or more shadows behind its single child node.
   * @class
   */
  class ShadowNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.ShadowNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.ShadowNode

    /**
     * Creates a `GskRenderNode` that will draw a `child` with the given
     * `shadows` below it.
     * @constructor
     * @param child The node to draw
     * @param shadows The shadows to apply
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, shadows: Shadow[])
    /**
     * Creates a `GskRenderNode` that will draw a `child` with the given
     * `shadows` below it.
     * @constructor
     * @param child The node to draw
     * @param shadows The shadows to apply
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, shadows: Shadow[]): ShadowNode
  }

  interface StrokeNode {
    // Owm methods of Gsk-4.0.Gsk.StrokeNode

    /**
     * Gets the child node that is getting drawn by the given `node`.
     * @returns The child that is getting drawn
     */
    getChild(): RenderNode
    /**
     * Retrieves the path that will be stroked with the contents of
     * the `node`.
     * @returns a #GskPath
     */
    getPath(): Path
    /**
     * Retrieves the stroke attributes used in this `node`.
     * @returns a #GskStroke
     */
    getStroke(): Stroke
  }

  /**
   * A render node that will fill the area determined by stroking the the given
   * [struct`Gsk`.Path] using the [struct`Gsk`.Stroke] attributes.
   * @class
   */
  class StrokeNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.StrokeNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.StrokeNode

    /**
     * Creates a #GskRenderNode that will fill the outline generated by stroking
     * the given `path` using the attributes defined in `stroke`.
     *
     * The area is filled with `child`.
     * @constructor
     * @param child The node to stroke the area with
     * @param path The path describing the area to stroke
     * @param stroke The stroke attributes to use
     * @returns A new #GskRenderNode
     */
    constructor(child: RenderNode, path: Path, stroke: Stroke)
    /**
     * Creates a #GskRenderNode that will fill the outline generated by stroking
     * the given `path` using the attributes defined in `stroke`.
     *
     * The area is filled with `child`.
     * @constructor
     * @param child The node to stroke the area with
     * @param path The path describing the area to stroke
     * @param stroke The stroke attributes to use
     * @returns A new #GskRenderNode
     */
    static new(child: RenderNode, path: Path, stroke: Stroke): StrokeNode
  }

  interface SubsurfaceNode {
    // Owm methods of Gsk-4.0.Gsk.SubsurfaceNode

    /**
     * Gets the child node that is getting drawn by the given `node`.
     * @returns the child `GskRenderNode`
     */
    getChild(): RenderNode
  }

  /**
   * A render node that potentially diverts a part of the scene graph to a subsurface.
   * @class
   */
  class SubsurfaceNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.SubsurfaceNode

    static name: string
  }

  interface TextNode {
    // Owm methods of Gsk-4.0.Gsk.TextNode

    /**
     * Retrieves the color used by the text `node`.
     * @returns the text color
     */
    getColor(): Gdk.RGBA
    /**
     * Returns the font used by the text `node`.
     * @returns the font
     */
    getFont(): Pango.Font
    /**
     * Retrieves the glyph information in the `node`.
     * @returns the glyph information
     */
    getGlyphs(): Pango.GlyphInfo[]
    /**
     * Retrieves the number of glyphs in the text node.
     * @returns the number of glyphs
     */
    getNumGlyphs(): number
    /**
     * Retrieves the offset applied to the text.
     * @returns a point with the horizontal and vertical offsets
     */
    getOffset(): Graphene.Point
    /**
     * Checks whether the text `node` has color glyphs.
     * @returns %TRUE if the text node has color glyphs
     */
    hasColorGlyphs(): boolean
  }

  /**
   * A render node drawing a set of glyphs.
   * @class
   */
  class TextNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.TextNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.TextNode

    /**
     * Creates a render node that renders the given glyphs.
     *
     * Note that `color` may not be used if the font contains
     * color glyphs.
     * @constructor
     * @param font the `PangoFont` containing the glyphs
     * @param glyphs the `PangoGlyphString` to render
     * @param color the foreground color to render with
     * @param offset offset of the baseline
     * @returns a new `GskRenderNode`
     */
    constructor(
      font: Pango.Font,
      glyphs: Pango.GlyphString,
      color: Gdk.RGBA,
      offset: Graphene.Point
    )
    /**
     * Creates a render node that renders the given glyphs.
     *
     * Note that `color` may not be used if the font contains
     * color glyphs.
     * @constructor
     * @param font the `PangoFont` containing the glyphs
     * @param glyphs the `PangoGlyphString` to render
     * @param color the foreground color to render with
     * @param offset offset of the baseline
     * @returns a new `GskRenderNode`
     */
    static new(
      font: Pango.Font,
      glyphs: Pango.GlyphString,
      color: Gdk.RGBA,
      offset: Graphene.Point
    ): TextNode
  }

  interface TextureNode {
    // Owm methods of Gsk-4.0.Gsk.TextureNode

    /**
     * Retrieves the `GdkTexture` used when creating this `GskRenderNode`.
     * @returns the `GdkTexture`
     */
    getTexture(): Gdk.Texture
  }

  /**
   * A render node for a `GdkTexture`.
   * @class
   */
  class TextureNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.TextureNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.TextureNode

    /**
     * Creates a `GskRenderNode` that will render the given
     * `texture` into the area given by `bounds`.
     *
     * Note that GSK applies linear filtering when textures are
     * scaled and transformed. See [class`Gsk`.TextureScaleNode]
     * for a way to influence filtering.
     * @constructor
     * @param texture the `GdkTexture`
     * @param bounds the rectangle to render the texture into
     * @returns A new `GskRenderNode`
     */
    constructor(texture: Gdk.Texture, bounds: Graphene.Rect)
    /**
     * Creates a `GskRenderNode` that will render the given
     * `texture` into the area given by `bounds`.
     *
     * Note that GSK applies linear filtering when textures are
     * scaled and transformed. See [class`Gsk`.TextureScaleNode]
     * for a way to influence filtering.
     * @constructor
     * @param texture the `GdkTexture`
     * @param bounds the rectangle to render the texture into
     * @returns A new `GskRenderNode`
     */
    static new(texture: Gdk.Texture, bounds: Graphene.Rect): TextureNode
  }

  interface TextureScaleNode {
    // Owm methods of Gsk-4.0.Gsk.TextureScaleNode

    /**
     * Retrieves the `GskScalingFilter` used when creating this `GskRenderNode`.
     * @returns the `GskScalingFilter`
     */
    getFilter(): ScalingFilter
    /**
     * Retrieves the `GdkTexture` used when creating this `GskRenderNode`.
     * @returns the `GdkTexture`
     */
    getTexture(): Gdk.Texture
  }

  /**
   * A render node for a `GdkTexture`.
   * @class
   */
  class TextureScaleNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.TextureScaleNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.TextureScaleNode

    /**
     * Creates a node that scales the texture to the size given by the
     * bounds using the filter and then places it at the bounds' position.
     *
     * Note that further scaling and other transformations which are
     * applied to the node will apply linear filtering to the resulting
     * texture, as usual.
     *
     * This node is intended for tight control over scaling applied
     * to a texture, such as in image editors and requires the
     * application to be aware of the whole render tree as further
     * transforms may be applied that conflict with the desired effect
     * of this node.
     * @constructor
     * @param texture the texture to scale
     * @param bounds the size of the texture to scale to
     * @param filter how to scale the texture
     * @returns A new `GskRenderNode`
     */
    constructor(
      texture: Gdk.Texture,
      bounds: Graphene.Rect,
      filter: ScalingFilter
    )
    /**
     * Creates a node that scales the texture to the size given by the
     * bounds using the filter and then places it at the bounds' position.
     *
     * Note that further scaling and other transformations which are
     * applied to the node will apply linear filtering to the resulting
     * texture, as usual.
     *
     * This node is intended for tight control over scaling applied
     * to a texture, such as in image editors and requires the
     * application to be aware of the whole render tree as further
     * transforms may be applied that conflict with the desired effect
     * of this node.
     * @constructor
     * @param texture the texture to scale
     * @param bounds the size of the texture to scale to
     * @param filter how to scale the texture
     * @returns A new `GskRenderNode`
     */
    static new(
      texture: Gdk.Texture,
      bounds: Graphene.Rect,
      filter: ScalingFilter
    ): TextureScaleNode
  }

  interface TransformNode {
    // Owm methods of Gsk-4.0.Gsk.TransformNode

    /**
     * Gets the child node that is getting transformed by the given `node`.
     * @returns The child that is getting transformed
     */
    getChild(): RenderNode
    /**
     * Retrieves the `GskTransform` used by the `node`.
     * @returns a `GskTransform`
     */
    getTransform(): Transform
  }

  /**
   * A render node applying a `GskTransform` to its single child node.
   * @class
   */
  class TransformNode extends RenderNode {
    // Own properties of Gsk-4.0.Gsk.TransformNode

    static name: string

    // Constructors of Gsk-4.0.Gsk.TransformNode

    /**
     * Creates a `GskRenderNode` that will transform the given `child`
     * with the given `transform`.
     * @constructor
     * @param child The node to transform
     * @param transform The transform to apply
     * @returns A new `GskRenderNode`
     */
    constructor(child: RenderNode, transform: Transform)
    /**
     * Creates a `GskRenderNode` that will transform the given `child`
     * with the given `transform`.
     * @constructor
     * @param child The node to transform
     * @param transform The transform to apply
     * @returns A new `GskRenderNode`
     */
    static new(child: RenderNode, transform: Transform): TransformNode
  }

  module VulkanRenderer {
    // Constructor properties interface

    interface ConstructorProperties extends Renderer.ConstructorProperties {}
  }

  interface VulkanRenderer {
    // Own properties of Gsk-4.0.Gsk.VulkanRenderer

    __gtype__: number

    // Class property signals of Gsk-4.0.Gsk.VulkanRenderer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::realized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::realized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::realized", ...args: any[]): void
    connect(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::surface",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::surface",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::surface", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A GSK renderer that is using Vulkan.
   *
   * This renderer will fail to realize if Vulkan is not supported.
   * @class
   */
  class VulkanRenderer extends Renderer {
    // Own properties of Gsk-4.0.Gsk.VulkanRenderer

    static name: string

    // Constructors of Gsk-4.0.Gsk.VulkanRenderer

    constructor(config?: VulkanRenderer.ConstructorProperties)
    constructor()
    static new(): VulkanRenderer
    _init(config?: VulkanRenderer.ConstructorProperties): void
  }

  interface BroadwayRendererClass {}

  abstract class BroadwayRendererClass {
    // Own properties of Gsk-4.0.Gsk.BroadwayRendererClass

    static name: string
  }

  interface CairoRendererClass {}

  abstract class CairoRendererClass {
    // Own properties of Gsk-4.0.Gsk.CairoRendererClass

    static name: string
  }

  interface ColorStop {
    // Own fields of Gsk-4.0.Gsk.ColorStop

    /**
     * the offset of the color stop
     * @field
     */
    offset: number
    /**
     * the color at the given offset
     * @field
     */
    color: Gdk.RGBA
  }

  /**
   * A color stop in a gradient node.
   * @record
   */
  class ColorStop {
    // Own properties of Gsk-4.0.Gsk.ColorStop

    static name: string
  }

  interface GLRendererClass {}

  abstract class GLRendererClass {
    // Own properties of Gsk-4.0.Gsk.GLRendererClass

    static name: string
  }

  interface GLShaderClass {
    // Own fields of Gsk-4.0.Gsk.GLShaderClass

    parentClass: GObject.ObjectClass
  }

  abstract class GLShaderClass {
    // Own properties of Gsk-4.0.Gsk.GLShaderClass

    static name: string
  }

  interface ParseLocation {
    // Own fields of Gsk-4.0.Gsk.ParseLocation

    /**
     * the offset of the location in the parse buffer, as bytes
     * @field
     */
    bytes: number
    /**
     * the offset of the location in the parse buffer, as characters
     * @field
     */
    chars: number
    /**
     * the line of the location in the parse buffer
     * @field
     */
    lines: number
    /**
     * the position in the line, as bytes
     * @field
     */
    lineBytes: number
    /**
     * the position in the line, as characters
     * @field
     */
    lineChars: number
  }

  /**
   * A location in a parse buffer.
   * @record
   */
  class ParseLocation {
    // Own properties of Gsk-4.0.Gsk.ParseLocation

    static name: string
  }

  interface Path {
    // Owm methods of Gsk-4.0.Gsk.Path

    /**
     * Calls `func` for every operation of the path.
     *
     * Note that this may only approximate `self,` because paths can contain
     * optimizations for various specialized contours, and depending on the
     * `flags,` the path may be decomposed into simpler curves than the ones
     * that it contained originally.
     *
     * This function serves two purposes:
     *
     * - When the `flags` allow everything, it provides access to the raw,
     *   unmodified data of the path.
     * - When the `flags` disallow certain operations, it provides
     *   an approximation of the path using just the allowed operations.
     * @param flags flags to pass to the foreach function. See [flags`Gsk`.PathForeachFlags]   for details about flags
     * @param func the function to call for operations
     * @returns `FALSE` if @func returned FALSE`, `TRUE` otherwise.
     */
    foreach(flags: PathForeachFlags, func: PathForeachFunc): boolean
    /**
     * Computes the bounds of the given path.
     *
     * The returned bounds may be larger than necessary, because this
     * function aims to be fast, not accurate. The bounds are guaranteed
     * to contain the path.
     *
     * It is possible that the returned rectangle has 0 width and/or height.
     * This can happen when the path only describes a point or an
     * axis-aligned line.
     *
     * If the path is empty, `FALSE` is returned and `bounds` are set to
     * graphene_rect_zero(). This is different from the case where the path
     * is a single point at the origin, where the `bounds` will also be set to
     * the zero rectangle but `TRUE` will be returned.
     * @returns `TRUE` if the path has bounds, `FALSE` if the path is known   to be empty and have no bounds.
     */
    getBounds(): [/* returnType */ boolean, /* bounds */ Graphene.Rect]
    /**
     * Computes the closest point on the path to the given point
     * and sets the `result` to it.
     *
     * If there is no point closer than the given threshold,
     * `FALSE` is returned.
     * @param point the point
     * @param threshold maximum allowed distance
     * @returns `TRUE` if @point was set to the closest point   on @self, `FALSE` if no point is closer than @threshold
     */
    getClosestPoint(
      point: Graphene.Point,
      threshold: number
    ): [/* returnType */ boolean, /* result */ PathPoint, /* distance */ number]
    /**
     * Gets the end point of the path.
     *
     * An empty path has no points, so `FALSE`
     * is returned in this case.
     * @returns `TRUE` if @result was filled
     */
    getEndPoint(): [/* returnType */ boolean, /* result */ PathPoint]
    /**
     * Gets the start point of the path.
     *
     * An empty path has no points, so `FALSE`
     * is returned in this case.
     * @returns `TRUE` if @result was filled
     */
    getStartPoint(): [/* returnType */ boolean, /* result */ PathPoint]
    /**
     * Computes the bounds for stroking the given path with the
     * parameters in `stroke`.
     *
     * The returned bounds may be larger than necessary, because this
     * function aims to be fast, not accurate. The bounds are guaranteed
     * to contain the area affected by the stroke, including protrusions
     * like miters.
     * @param stroke stroke parameters
     * @returns `TRUE` if the path has bounds, `FALSE` if the path is known   to be empty and have no bounds.
     */
    getStrokeBounds(
      stroke: Stroke
    ): [/* returnType */ boolean, /* bounds */ Graphene.Rect]
    /**
     * Returns whether the given point is inside the area
     * that would be affected if the path was filled according
     * to `fill_rule`.
     *
     * Note that this function assumes that filling a contour
     * implicitly closes it.
     * @param point the point to test
     * @param fillRule the fill rule to follow
     * @returns `TRUE` if @point is inside
     */
    inFill(point: Graphene.Point, fillRule: FillRule): boolean
    /**
     * Returns if the path represents a single closed
     * contour.
     * @returns `TRUE` if the path is closed
     */
    isClosed(): boolean
    /**
     * Checks if the path is empty, i.e. contains no lines or curves.
     * @returns `TRUE` if the path is empty
     */
    isEmpty(): boolean
    /**
     * Converts `self` into a human-readable string representation suitable
     * for printing.
     *
     * The string is compatible with (a superset of)
     * [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData),
     * see [func`Gsk`.Path.parse] for a summary of the syntax.
     * @param string The string to print into
     */
    print(string: GLib.String): void
    /**
     * Increases the reference count of a `GskPath` by one.
     * @returns the passed in `GskPath`.
     */
    ref(): Path
    /**
     * Appends the given `path` to the given cairo context for drawing
     * with Cairo.
     *
     * This may cause some suboptimal conversions to be performed as
     * Cairo does not support all features of `GskPath`.
     *
     * This function does not clear the existing Cairo path. Call
     * cairo_new_path() if you want this.
     * @param cr a cairo context
     */
    toCairo(cr: cairo.Context): void
    /**
     * Converts the path into a string that is suitable for printing.
     *
     * You can use this function in a debugger to get a quick overview
     * of the path.
     *
     * This is a wrapper around [method`Gsk`.Path.print], see that function
     * for details.
     * @returns A new string for @self
     */
    toString(): string | null
    /**
     * Decreases the reference count of a `GskPath` by one.
     *
     * If the resulting reference count is zero, frees the path.
     */
    unref(): void
  }

  /**
   * A `GskPath` describes lines and curves that are more complex
   * than simple rectangles.
   *
   * Paths can used for rendering (filling or stroking) and for animations
   * (e.g. as trajectories).
   *
   * `GskPath` is an immutable, opaque, reference-counted struct.
   * After creation, you cannot change the types it represents. Instead,
   * new `GskPath` objects have to be created. The [struct`Gsk`.PathBuilder]
   * structure is meant to help in this endeavor.
   *
   * Conceptually, a path consists of zero or more contours (continuous, connected
   * curves), each of which may or may not be closed. Contours are typically
   * constructed from Bézier segments.
   *
   * <picture>
   *   <source srcset="path-dark.png" media="(prefers-color-scheme: dark)">
   *   <img alt="A Path" src="path-light.png">
   * </picture>
   * @record
   */
  class Path {
    // Own properties of Gsk-4.0.Gsk.Path

    static name: string

    // Constructors of Gsk-4.0.Gsk.Path

    /**
     * This is a convenience function that constructs a `GskPath`
     * from a serialized form.
     *
     * The string is expected to be in (a superset of)
     * [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData),
     * as e.g. produced by [method`Gsk`.Path.to_string].
     *
     * A high-level summary of the syntax:
     *
     * - `M x y` Move to `(x, y)`
     * - `L x y` Add a line from the current point to `(x, y)`
     * - `Q x1 y1 x2 y2` Add a quadratic Bézier from the current point to `(x2, y2)`, with control point `(x1, y1)`
     * - `C x1 y1 x2 y2 x3 y3` Add a cubic Bézier from the current point to `(x3, y3)`, with control points `(x1, y1)` and `(x2, y2)`
     * - `Z` Close the contour by drawing a line back to the start point
     * - `H x` Add a horizontal line from the current point to the given x value
     * - `V y` Add a vertical line from the current point to the given y value
     * - `T x2 y2` Add a quadratic Bézier, using the reflection of the previous segments' control point as control point
     * - `S x2 y2 x3 y3` Add a cubic Bézier, using the reflection of the previous segments' second control point as first control point
     * - `A rx ry r l s x y` Add an elliptical arc from the current point to `(x, y)` with radii rx and ry. See the SVG documentation for how the other parameters influence the arc.
     * - `O x1 y1 x2 y2 w` Add a rational quadratic Bézier from the current point to `(x2, y2)` with control point `(x1, y1)` and weight `w`.
     *
     * All the commands have lowercase variants that interpret coordinates
     * relative to the current point.
     *
     * The `O` command is an extension that is not supported in SVG.
     * @param string a string
     * @returns a new `GskPath`, or `NULL` if @string could not be parsed
     */
    static parse(string: string): Path | null
  }

  interface PathBuilder {
    // Owm methods of Gsk-4.0.Gsk.PathBuilder

    /**
     * Adds a Cairo path to the builder.
     *
     * You can use cairo_copy_path() to access the path
     * from a Cairo context.
     * @param path
     */
    addCairoPath(path: cairo.Path): void
    /**
     * Adds a circle with the `center` and `radius`.
     *
     * The path is going around the circle in clockwise direction.
     *
     * If `radius` is zero, the contour will be a closed point.
     * @param center the center of the circle
     * @param radius the radius of the circle
     */
    addCircle(center: Graphene.Point, radius: number): void
    /**
     * Adds the outlines for the glyphs in `layout` to the builder.
     * @param layout the pango layout to add
     */
    addLayout(layout: Pango.Layout): void
    /**
     * Appends all of `path` to the builder.
     * @param path the path to append
     */
    addPath(path: Path): void
    /**
     * Adds `rect` as a new contour to the path built by the builder.
     *
     * The path is going around the rectangle in clockwise direction.
     *
     * If the the width or height are 0, the path will be a closed
     * horizontal or vertical line. If both are 0, it'll be a closed dot.
     * @param rect The rectangle to create a path for
     */
    addRect(rect: Graphene.Rect): void
    /**
     * Appends all of `path` to the builder, in reverse order.
     * @param path the path to append
     */
    addReversePath(path: Path): void
    /**
     * Adds `rect` as a new contour to the path built in `self`.
     *
     * The path is going around the rectangle in clockwise direction.
     * @param rect the rounded rect
     */
    addRoundedRect(rect: RoundedRect): void
    /**
     * Adds to `self` the segment of `path` from `start` to `end`.
     *
     * If `start` is equal to or after `end,` the path will first add the
     * segment from `start` to the end of the path, and then add the segment
     * from the beginning to `end`. If the path is closed, these segments
     * will be connected.
     *
     * Note that this method always adds a path with the given start point
     * and end point. To add a closed path, use [method`Gsk`.PathBuilder.add_path].
     * @param path the `GskPath` to take the segment to
     * @param start the point on `path` to start at
     * @param end the point on `path` to end at
     */
    addSegment(path: Path, start: PathPoint, end: PathPoint): void
    /**
     * Adds an elliptical arc from the current point to `x3`, `y3`
     * with `x1`, `y1` determining the tangent directions.
     *
     * After this, `x3`, `y3` will be the new current point.
     *
     * Note: Two points and their tangents do not determine
     * a unique ellipse, so GSK just picks one. If you need more
     * precise control, use [method`Gsk`.PathBuilder.conic_to]
     * or [method`Gsk`.PathBuilder.svg_arc_to].
     *
     * <picture>
     *   <source srcset="arc-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Arc To" src="arc-light.png">
     * </picture>
     * @param x1 x coordinate of first control point
     * @param y1 y coordinate of first control point
     * @param x2 x coordinate of second control point
     * @param y2 y coordinate of second control point
     */
    arcTo(x1: number, y1: number, x2: number, y2: number): void
    /**
     * Ends the current contour with a line back to the start point.
     *
     * Note that this is different from calling [method`Gsk`.PathBuilder.line_to]
     * with the start point in that the contour will be closed. A closed
     * contour behaves differently from an open one. When stroking, its
     * start and end point are considered connected, so they will be
     * joined via the line join, and not ended with line caps.
     */
    close(): void
    /**
     * Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline)
     * from the current point to `x2`, `y2` with the given `weight` and `x1`, `y1` as the
     * control point.
     *
     * The weight determines how strongly the curve is pulled towards the control point.
     * A conic with weight 1 is identical to a quadratic Bézier curve with the same points.
     *
     * Conic curves can be used to draw ellipses and circles. They are also known as
     * rational quadratic Bézier curves.
     *
     * After this, `x2`, `y2` will be the new current point.
     *
     * <picture>
     *   <source srcset="conic-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Conic To" src="conic-light.png">
     * </picture>
     * @param x1 x coordinate of control point
     * @param y1 y coordinate of control point
     * @param x2 x coordinate of the end of the curve
     * @param y2 y coordinate of the end of the curve
     * @param weight weight of the control point, must be greater than zero
     */
    conicTo(
      x1: number,
      y1: number,
      x2: number,
      y2: number,
      weight: number
    ): void
    /**
     * Adds a [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
     * from the current point to `x3`, `y3` with `x1`, `y1` and `x2`, `y2` as the control
     * points.
     *
     * After this, `x3`, `y3` will be the new current point.
     *
     * <picture>
     *   <source srcset="cubic-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Cubic To" src="cubic-light.png">
     * </picture>
     * @param x1 x coordinate of first control point
     * @param y1 y coordinate of first control point
     * @param x2 x coordinate of second control point
     * @param y2 y coordinate of second control point
     * @param x3 x coordinate of the end of the curve
     * @param y3 y coordinate of the end of the curve
     */
    cubicTo(
      x1: number,
      y1: number,
      x2: number,
      y2: number,
      x3: number,
      y3: number
    ): void
    /**
     * Gets the current point.
     *
     * The current point is used for relative drawing commands and
     * updated after every operation.
     *
     * When the builder is created, the default current point is set
     * to `0, 0`. Note that this is different from cairo, which starts
     * out without a current point.
     * @returns The current point
     */
    getCurrentPoint(): Graphene.Point
    /**
     * Implements arc-to according to the HTML Canvas spec.
     *
     * A convenience function that implements the
     * [HTML arc_to](https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-arcto-dev)
     * functionality.
     *
     * After this, the current point will be the point where
     * the circle with the given radius touches the line from
     * `x1`, `y1` to `x2`, `y2`.
     * @param x1 X coordinate of first control point
     * @param y1 Y coordinate of first control point
     * @param x2 X coordinate of second control point
     * @param y2 Y coordinate of second control point
     * @param radius Radius of the circle
     */
    htmlArcTo(
      x1: number,
      y1: number,
      x2: number,
      y2: number,
      radius: number
    ): void
    /**
     * Draws a line from the current point to `x,` `y` and makes it
     * the new current point.
     *
     * <picture>
     *   <source srcset="line-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Line To" src="line-light.png">
     * </picture>
     * @param x x coordinate
     * @param y y coordinate
     */
    lineTo(x: number, y: number): void
    /**
     * Starts a new contour by placing the pen at `x,` `y`.
     *
     * If this function is called twice in succession, the first
     * call will result in a contour made up of a single point.
     * The second call will start a new contour.
     * @param x x coordinate
     * @param y y coordinate
     */
    moveTo(x: number, y: number): void
    /**
     * Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
     * from the current point to `x2`, `y2` with `x1`, `y1` as the control point.
     *
     * After this, `x2`, `y2` will be the new current point.
     *
     * <picture>
     *   <source srcset="quad-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Quad To" src="quad-light.png">
     * </picture>
     * @param x1 x coordinate of control point
     * @param y1 y coordinate of control point
     * @param x2 x coordinate of the end of the curve
     * @param y2 y coordinate of the end of the curve
     */
    quadTo(x1: number, y1: number, x2: number, y2: number): void
    /**
     * Acquires a reference on the given builder.
     *
     * This function is intended primarily for language bindings.
     * `GskPathBuilder` objects should not be kept around.
     * @returns the given `GskPathBuilder` with   its reference count increased
     */
    ref(): PathBuilder
    /**
     * Adds an elliptical arc from the current point to `x3`, `y3`
     * with `x1`, `y1` determining the tangent directions.
     *
     * All coordinates are given relative to the current point.
     *
     * This is the relative version of [method`Gsk`.PathBuilder.arc_to].
     * @param x1 x coordinate of first control point
     * @param y1 y coordinate of first control point
     * @param x2 x coordinate of second control point
     * @param y2 y coordinate of second control point
     */
    relArcTo(x1: number, y1: number, x2: number, y2: number): void
    /**
     * Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline)
     * from the current point to `x2`, `y2` with the given `weight` and `x1`, `y1` as the
     * control point.
     *
     * All coordinates are given relative to the current point.
     *
     * This is the relative version of [method`Gsk`.PathBuilder.conic_to].
     * @param x1 x offset of control point
     * @param y1 y offset of control point
     * @param x2 x offset of the end of the curve
     * @param y2 y offset of the end of the curve
     * @param weight weight of the curve, must be greater than zero
     */
    relConicTo(
      x1: number,
      y1: number,
      x2: number,
      y2: number,
      weight: number
    ): void
    /**
     * Adds a [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
     * from the current point to `x3`, `y3` with `x1`, `y1` and `x2`, `y2` as the control
     * points.
     *
     * All coordinates are given relative to the current point.
     *
     * This is the relative version of [method`Gsk`.PathBuilder.cubic_to].
     * @param x1 x offset of first control point
     * @param y1 y offset of first control point
     * @param x2 x offset of second control point
     * @param y2 y offset of second control point
     * @param x3 x offset of the end of the curve
     * @param y3 y offset of the end of the curve
     */
    relCubicTo(
      x1: number,
      y1: number,
      x2: number,
      y2: number,
      x3: number,
      y3: number
    ): void
    /**
     * Implements arc-to according to the HTML Canvas spec.
     *
     * All coordinates are given relative to the current point.
     *
     * This is the relative version of [method`Gsk`.PathBuilder.html_arc_to].
     * @param x1 X coordinate of first control point
     * @param y1 Y coordinate of first control point
     * @param x2 X coordinate of second control point
     * @param y2 Y coordinate of second control point
     * @param radius Radius of the circle
     */
    relHtmlArcTo(
      x1: number,
      y1: number,
      x2: number,
      y2: number,
      radius: number
    ): void
    /**
     * Draws a line from the current point to a point offset from it
     * by `x,` `y` and makes it the new current point.
     *
     * This is the relative version of [method`Gsk`.PathBuilder.line_to].
     * @param x x offset
     * @param y y offset
     */
    relLineTo(x: number, y: number): void
    /**
     * Starts a new contour by placing the pen at `x,` `y`
     * relative to the current point.
     *
     * This is the relative version of [method`Gsk`.PathBuilder.move_to].
     * @param x x offset
     * @param y y offset
     */
    relMoveTo(x: number, y: number): void
    /**
     * Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
     * from the current point to `x2`, `y2` with `x1`, `y1` the control point.
     *
     * All coordinates are given relative to the current point.
     *
     * This is the relative version of [method`Gsk`.PathBuilder.quad_to].
     * @param x1 x offset of control point
     * @param y1 y offset of control point
     * @param x2 x offset of the end of the curve
     * @param y2 y offset of the end of the curve
     */
    relQuadTo(x1: number, y1: number, x2: number, y2: number): void
    /**
     * Implements arc-to according to the SVG spec.
     *
     * All coordinates are given relative to the current point.
     *
     * This is the relative version of [method`Gsk`.PathBuilder.svg_arc_to].
     * @param rx X radius
     * @param ry Y radius
     * @param xAxisRotation the rotation of the ellipsis
     * @param largeArc whether to add the large arc
     * @param positiveSweep whether to sweep in the positive direction
     * @param x the X coordinate of the endpoint
     * @param y the Y coordinate of the endpoint
     */
    relSvgArcTo(
      rx: number,
      ry: number,
      xAxisRotation: number,
      largeArc: boolean,
      positiveSweep: boolean,
      x: number,
      y: number
    ): void
    /**
     * Implements arc-to according to the SVG spec.
     *
     * A convenience function that implements the
     * [SVG arc_to](https://www.w3.org/TR/SVG11/paths.html#PathDataEllipticalArcCommands)
     * functionality.
     *
     * After this, `x,` `y` will be the new current point.
     * @param rx X radius
     * @param ry Y radius
     * @param xAxisRotation the rotation of the ellipsis
     * @param largeArc whether to add the large arc
     * @param positiveSweep whether to sweep in the positive direction
     * @param x the X coordinate of the endpoint
     * @param y the Y coordinate of the endpoint
     */
    svgArcTo(
      rx: number,
      ry: number,
      xAxisRotation: number,
      largeArc: boolean,
      positiveSweep: boolean,
      x: number,
      y: number
    ): void
    /**
     * Creates a new `GskPath` from the given builder.
     *
     * The given `GskPathBuilder` is reset once this function returns;
     * you cannot call this function multiple times on the same builder
     * instance.
     *
     * This function is intended primarily for language bindings.
     * C code should use [method`Gsk`.PathBuilder.free_to_path].
     * @returns the newly created `GskPath`   with all the contours added to the builder
     */
    toPath(): Path
    /**
     * Releases a reference on the given builder.
     */
    unref(): void
  }

  /**
   * `GskPathBuilder` is an auxiliary object for constructing
   * `GskPath` objects.
   *
   * A path is constructed like this:
   *
   *
   * ```c
   * GskPath *
   * construct_path (void)
   * {
   *   GskPathBuilder *builder;
   *
   *   builder = gsk_path_builder_new ();
   *
   *   // add contours to the path here
   *
   *   return gsk_path_builder_free_to_path (builder);
   * ```
   *
   *
   * Adding contours to the path can be done in two ways.
   * The easiest option is to use the `gsk_path_builder_add_*` group
   * of functions that add predefined contours to the current path,
   * either common shapes like [method`Gsk`.PathBuilder.add_circle]
   * or by adding from other paths like [method`Gsk`.PathBuilder.add_path].
   *
   * The `gsk_path_builder_add_*` methods always add complete contours,
   * and do not use or modify the current point.
   *
   * The other option is to define each line and curve manually with
   * the `gsk_path_builder_*_to` group of functions. You start with
   * a call to [method`Gsk`.PathBuilder.move_to] to set the starting point
   * and then use multiple calls to any of the drawing functions to
   * move the pen along the plane. Once you are done, you can call
   * [method`Gsk`.PathBuilder.close] to close the path by connecting it
   * back with a line to the starting point.
   *
   * This is similar to how paths are drawn in Cairo.
   *
   * Note that `GskPathBuilder` will reduce the degree of added Bézier
   * curves as much as possible, to simplify rendering.
   * @record
   */
  class PathBuilder {
    // Own properties of Gsk-4.0.Gsk.PathBuilder

    static name: string

    // Constructors of Gsk-4.0.Gsk.PathBuilder

    /**
     * Create a new `GskPathBuilder` object.
     *
     * The resulting builder would create an empty `GskPath`.
     * Use addition functions to add types to it.
     * @constructor
     * @returns a new `GskPathBuilder`
     */
    constructor()
    /**
     * Create a new `GskPathBuilder` object.
     *
     * The resulting builder would create an empty `GskPath`.
     * Use addition functions to add types to it.
     * @constructor
     * @returns a new `GskPathBuilder`
     */
    static new(): PathBuilder
  }

  interface PathMeasure {
    // Owm methods of Gsk-4.0.Gsk.PathMeasure

    /**
     * Gets the length of the path being measured.
     *
     * The length is cached, so this function does not do any work.
     * @returns The length of the path measured by @self
     */
    getLength(): number
    /**
     * Returns the path that the measure was created for.
     * @returns the path of @self
     */
    getPath(): Path
    /**
     * Sets `result` to the point at the given distance into the path.
     *
     * An empty path has no points, so `FALSE` is returned in that case.
     * @param distance the distance
     * @returns `TRUE` if @result was set
     */
    getPoint(
      distance: number
    ): [/* returnType */ boolean, /* result */ PathPoint]
    /**
     * Returns the tolerance that the measure was created with.
     * @returns the tolerance of @self
     */
    getTolerance(): number
    /**
     * Increases the reference count of a `GskPathMeasure` by one.
     * @returns the passed in `GskPathMeasure`.
     */
    ref(): PathMeasure
    /**
     * Decreases the reference count of a `GskPathMeasure` by one.
     *
     * If the resulting reference count is zero, frees the object.
     */
    unref(): void
  }

  /**
   * `GskPathMeasure` is an object that allows measurements
   * on `GskPath`s such as determining the length of the path.
   *
   * Many measuring operations require sampling the path length
   * at intermediate points. Therefore, a `GskPathMeasure` has
   * a tolerance that determines what precision is required
   * for such approximations.
   *
   * A `GskPathMeasure` struct is a reference counted struct
   * and should be treated as opaque.
   * @record
   */
  class PathMeasure {
    // Own properties of Gsk-4.0.Gsk.PathMeasure

    static name: string

    // Constructors of Gsk-4.0.Gsk.PathMeasure

    /**
     * Creates a measure object for the given `path` with the
     * default tolerance.
     * @constructor
     * @param path the path to measure
     * @returns a new `GskPathMeasure` representing @path
     */
    constructor(path: Path)
    /**
     * Creates a measure object for the given `path` with the
     * default tolerance.
     * @constructor
     * @param path the path to measure
     * @returns a new `GskPathMeasure` representing @path
     */
    static new(path: Path): PathMeasure
    /**
     * Creates a measure object for the given `path` and `tolerance`.
     * @constructor
     * @param path the path to measure
     * @param tolerance the tolerance for measuring operations
     * @returns a new `GskPathMeasure` representing @path
     */
    static newWithTolerance(path: Path, tolerance: number): PathMeasure
  }

  interface PathPoint {
    // Owm methods of Gsk-4.0.Gsk.PathPoint

    /**
     * Returns whether `point1` is before or after `point2`.
     * @param point2 another `GskPathPoint`
     * @returns -1 if @point1 is before @point2,   1 if @point1 is after @point2,   0 if they are equal
     */
    compare(point2: PathPoint): number
    copy(): PathPoint
    /**
     * Returns whether the two path points refer to the same
     * location on all paths.
     *
     * Note that the start- and endpoint of a closed contour
     * will compare nonequal according to this definition.
     * Use [method`Gsk`.Path.is_closed] to find out if the
     * start- and endpoint of a concrete path refer to the
     * same location.
     * @param point2 another `GskPathPoint`
     * @returns `TRUE` if @point1 and @point2 are equal
     */
    equal(point2: PathPoint): boolean
    free(): void
    /**
     * Calculates the curvature of the path at the point.
     *
     * Optionally, returns the center of the osculating circle as well.
     * The curvature is the inverse of the radius of the osculating circle.
     *
     * Lines have a curvature of zero (indicating an osculating circle of
     * infinite radius. In this case, the `center` is not modified.
     *
     * Circles with a radius of zero have `INFINITY` as curvature
     *
     * Note that certain points on a path may not have a single curvature,
     * such as sharp turns. At such points, there are two curvatures --
     * the (limit of) the curvature of the path going into the point,
     * and the (limit of) the curvature of the path coming out of it.
     * The `direction` argument lets you choose which one to get.
     *
     * <picture>
     *   <source srcset="curvature-dark.png" media="(prefers-color-scheme: dark)">
     *   <img alt="Osculating circle" src="curvature-light.png">
     * </picture>
     * @param path the path that `point` is on
     * @param direction the direction for which to return the curvature
     * @returns The curvature of the path at the given point
     */
    getCurvature(
      path: Path,
      direction: PathDirection
    ): [/* returnType */ number, /* center */ Graphene.Point | null]
    /**
     * Returns the distance from the beginning of the path
     * to `point`.
     * @param measure a `GskPathMeasure` for the path
     * @returns the distance of @point
     */
    getDistance(measure: PathMeasure): number
    /**
     * Gets the position of the point.
     * @param path the path that `point` is on
     */
    getPosition(path: Path): /* position */ Graphene.Point
    /**
     * Gets the direction of the tangent at a given point.
     *
     * This is a convenience variant of [method`Gsk`.PathPoint.get_tangent]
     * that returns the angle between the tangent and the X axis. The angle
     * can e.g. be used in
     * [gtk_snapshot_rotate()](../gtk4/method.Snapshot.rotate.html).
     * @param path the path that `point` is on
     * @param direction the direction for which to return the rotation
     * @returns the angle between the tangent and the X axis, in degrees
     */
    getRotation(path: Path, direction: PathDirection): number
    /**
     * Gets the tangent of the path at the point.
     *
     * Note that certain points on a path may not have a single
     * tangent, such as sharp turns. At such points, there are
     * two tangents -- the direction of the path going into the
     * point, and the direction coming out of it. The `direction`
     * argument lets you choose which one to get.
     *
     * If the path is just a single point (e.g. a circle with
     * radius zero), then `tangent` is set to `0, 0`.
     *
     * If you want to orient something in the direction of the
     * path, [method`Gsk`.PathPoint.get_rotation] may be more
     * convenient to use.
     * @param path the path that `point` is on
     * @param direction the direction for which to return the tangent
     */
    getTangent(
      path: Path,
      direction: PathDirection
    ): /* tangent */ Graphene.Vec2
  }

  /**
   * `GskPathPoint` is an opaque type representing a point on a path.
   *
   * It can be queried for properties of the path at that point, such as
   * its tangent or its curvature.
   *
   * To obtain a `GskPathPoint`, use [method`Gsk`.Path.get_closest_point],
   * [method`Gsk`.Path.get_start_point], [method`Gsk`.Path.get_end_point]
   * or [method`Gsk`.PathMeasure.get_point].
   *
   * Note that `GskPathPoint` structs are meant to be stack-allocated,
   * and don't hold a reference to the path object they are obtained from.
   * It is the callers responsibility to keep a reference to the path
   * as long as the `GskPathPoint` is used.
   * @record
   */
  class PathPoint {
    // Own properties of Gsk-4.0.Gsk.PathPoint

    static name: string
  }

  interface RendererClass {}

  abstract class RendererClass {
    // Own properties of Gsk-4.0.Gsk.RendererClass

    static name: string
  }

  interface RoundedRect {
    // Own fields of Gsk-4.0.Gsk.RoundedRect

    /**
     * the bounds of the rectangle
     * @field
     */
    bounds: Graphene.Rect
    /**
     * the size of the 4 rounded corners
     * @field
     */
    corner: Graphene.Size[]

    // Owm methods of Gsk-4.0.Gsk.RoundedRect

    /**
     * Checks if the given `point` is inside the rounded rectangle.
     * @param point the point to check
     * @returns %TRUE if the @point is inside the rounded rectangle
     */
    containsPoint(point: Graphene.Point): boolean
    /**
     * Checks if the given `rect` is contained inside the rounded rectangle.
     * @param rect the rectangle to check
     * @returns %TRUE if the @rect is fully contained inside the rounded rectangle
     */
    containsRect(rect: Graphene.Rect): boolean
    /**
     * Initializes the given `GskRoundedRect` with the given values.
     *
     * This function will implicitly normalize the `GskRoundedRect`
     * before returning.
     * @param bounds a `graphene_rect_t` describing the bounds
     * @param topLeft the rounding radius of the top left corner
     * @param topRight the rounding radius of the top right corner
     * @param bottomRight the rounding radius of the bottom right corner
     * @param bottomLeft the rounding radius of the bottom left corner
     * @returns the initialized rectangle
     */
    init(
      bounds: Graphene.Rect,
      topLeft: Graphene.Size,
      topRight: Graphene.Size,
      bottomRight: Graphene.Size,
      bottomLeft: Graphene.Size
    ): RoundedRect
    /**
     * Initializes `self` using the given `src` rectangle.
     *
     * This function will not normalize the `GskRoundedRect`,
     * so make sure the source is normalized.
     * @param src a `GskRoundedRect`
     * @returns the initialized rectangle
     */
    initCopy(src: RoundedRect): RoundedRect
    /**
     * Initializes `self` to the given `bounds` and sets the radius
     * of all four corners to `radius`.
     * @param bounds a `graphene_rect_t`
     * @param radius the border radius
     * @returns the initialized rectangle
     */
    initFromRect(bounds: Graphene.Rect, radius: number): RoundedRect
    /**
     * Checks if part of the given `rect` is contained inside the rounded rectangle.
     * @param rect the rectangle to check
     * @returns %TRUE if the @rect intersects with the rounded rectangle
     */
    intersectsRect(rect: Graphene.Rect): boolean
    /**
     * Checks if all corners of `self` are right angles and the
     * rectangle covers all of its bounds.
     *
     * This information can be used to decide if [ctor`Gsk`.ClipNode.new]
     * or [ctor`Gsk`.RoundedClipNode.new] should be called.
     * @returns %TRUE if the rectangle is rectilinear
     */
    isRectilinear(): boolean
    /**
     * Normalizes the passed rectangle.
     *
     * This function will ensure that the bounds of the rectangle
     * are normalized and ensure that the corner values are positive
     * and the corners do not overlap.
     * @returns the normalized rectangle
     */
    normalize(): RoundedRect
    /**
     * Offsets the bound's origin by `dx` and `dy`.
     *
     * The size and corners of the rectangle are unchanged.
     * @param dx the horizontal offset
     * @param dy the vertical offset
     * @returns the offset rectangle
     */
    offset(dx: number, dy: number): RoundedRect
    /**
     * Shrinks (or grows) the given rectangle by moving the 4 sides
     * according to the offsets given.
     *
     * The corner radii will be changed in a way that tries to keep
     * the center of the corner circle intact. This emulates CSS behavior.
     *
     * This function also works for growing rectangles if you pass
     * negative values for the `top,` `right,` `bottom` or `left`.
     * @param top How far to move the top side downwards
     * @param right How far to move the right side to the left
     * @param bottom How far to move the bottom side upwards
     * @param left How far to move the left side to the right
     * @returns the resized `GskRoundedRect`
     */
    shrink(
      top: number,
      right: number,
      bottom: number,
      left: number
    ): RoundedRect
  }

  /**
   * A rectangular region with rounded corners.
   *
   * Application code should normalize rectangles using
   * [method`Gsk`.RoundedRect.normalize]; this function will ensure that
   * the bounds of the rectangle are normalized and ensure that the corner
   * values are positive and the corners do not overlap.
   *
   * All functions taking a `GskRoundedRect` as an argument will internally
   * operate on a normalized copy; all functions returning a `GskRoundedRect`
   * will always return a normalized one.
   *
   * The algorithm used for normalizing corner sizes is described in
   * [the CSS specification](https://drafts.csswg.org/css-backgrounds-3/#border-radius).
   * @record
   */
  class RoundedRect {
    // Own properties of Gsk-4.0.Gsk.RoundedRect

    static name: string
  }

  interface ShaderArgsBuilder {
    // Owm methods of Gsk-4.0.Gsk.ShaderArgsBuilder

    /**
     * Increases the reference count of a `GskShaderArgsBuilder` by one.
     * @returns the passed in `GskShaderArgsBuilder`
     */
    ref(): ShaderArgsBuilder
    /**
     * Sets the value of the uniform `idx`.
     *
     * The uniform must be of bool type.
     * @param idx index of the uniform
     * @param value value to set the uniform to
     */
    setBool(idx: number, value: boolean): void
    /**
     * Sets the value of the uniform `idx`.
     *
     * The uniform must be of float type.
     * @param idx index of the uniform
     * @param value value to set the uniform to
     */
    setFloat(idx: number, value: number): void
    /**
     * Sets the value of the uniform `idx`.
     *
     * The uniform must be of int type.
     * @param idx index of the uniform
     * @param value value to set the uniform to
     */
    setInt(idx: number, value: number): void
    /**
     * Sets the value of the uniform `idx`.
     *
     * The uniform must be of uint type.
     * @param idx index of the uniform
     * @param value value to set the uniform to
     */
    setUint(idx: number, value: number): void
    /**
     * Sets the value of the uniform `idx`.
     *
     * The uniform must be of vec2 type.
     * @param idx index of the uniform
     * @param value value to set the uniform too
     */
    setVec2(idx: number, value: Graphene.Vec2): void
    /**
     * Sets the value of the uniform `idx`.
     *
     * The uniform must be of vec3 type.
     * @param idx index of the uniform
     * @param value value to set the uniform too
     */
    setVec3(idx: number, value: Graphene.Vec3): void
    /**
     * Sets the value of the uniform `idx`.
     *
     * The uniform must be of vec4 type.
     * @param idx index of the uniform
     * @param value value to set the uniform too
     */
    setVec4(idx: number, value: Graphene.Vec4): void
    /**
     * Creates a new `GBytes` args from the current state of the
     * given `builder`.
     *
     * Any uniforms of the shader that have not been explicitly set on
     * the `builder` are zero-initialized.
     *
     * The given `GskShaderArgsBuilder` is reset once this function returns;
     * you cannot call this function multiple times on the same `builder` instance.
     *
     * This function is intended primarily for bindings. C code should use
     * [method`Gsk`.ShaderArgsBuilder.free_to_args].
     * @returns the newly allocated buffer with   all the args added to @builder
     */
    toArgs(): any
    /**
     * Decreases the reference count of a `GskShaderArgBuilder` by one.
     *
     * If the resulting reference count is zero, frees the builder.
     */
    unref(): void
  }

  /**
   * An object to build the uniforms data for a `GskGLShader`.
   * @record
   */
  class ShaderArgsBuilder {
    // Own properties of Gsk-4.0.Gsk.ShaderArgsBuilder

    static name: string

    // Constructors of Gsk-4.0.Gsk.ShaderArgsBuilder

    /**
     * Allocates a builder that can be used to construct a new uniform data
     * chunk.
     * @constructor
     * @param shader a `GskGLShader`
     * @param initialValues optional `GBytes` with initial values
     * @returns The newly allocated builder, free with     [method@Gsk.ShaderArgsBuilder.unref]
     */
    constructor(shader: GLShader, initialValues: any | null)
    /**
     * Allocates a builder that can be used to construct a new uniform data
     * chunk.
     * @constructor
     * @param shader a `GskGLShader`
     * @param initialValues optional `GBytes` with initial values
     * @returns The newly allocated builder, free with     [method@Gsk.ShaderArgsBuilder.unref]
     */
    static new(shader: GLShader, initialValues: any | null): ShaderArgsBuilder
  }

  interface Shadow {
    // Own fields of Gsk-4.0.Gsk.Shadow

    /**
     * the color of the shadow
     * @field
     */
    color: Gdk.RGBA
    /**
     * the horizontal offset of the shadow
     * @field
     */
    dx: number
    /**
     * the vertical offset of the shadow
     * @field
     */
    dy: number
    /**
     * the radius of the shadow
     * @field
     */
    radius: number
  }

  /**
   * The shadow parameters in a shadow node.
   * @record
   */
  class Shadow {
    // Own properties of Gsk-4.0.Gsk.Shadow

    static name: string
  }

  interface Stroke {
    // Owm methods of Gsk-4.0.Gsk.Stroke

    /**
     * Creates a copy of the given `other` stroke.
     * @returns a new `GskStroke`. Use [method@Gsk.Stroke.free] to free it
     */
    copy(): Stroke
    /**
     * Frees a `GskStroke`.
     */
    free(): void
    /**
     * Gets the dash array in use or `NULL` if dashing is disabled.
     * @returns The dash array or `NULL` if the dash array is empty.
     */
    getDash(): number[] | null
    /**
     * Returns the dash_offset of a `GskStroke`.
     */
    getDashOffset(): number
    /**
     * Gets the line cap used.
     *
     * See [enum`Gsk`.LineCap] for details.
     * @returns The line cap
     */
    getLineCap(): LineCap
    /**
     * Gets the line join used.
     *
     * See [enum`Gsk`.LineJoin] for details.
     * @returns The line join
     */
    getLineJoin(): LineJoin
    /**
     * Gets the line width used.
     * @returns The line width
     */
    getLineWidth(): number
    /**
     * Returns the miter limit of a `GskStroke`.
     */
    getMiterLimit(): number
    /**
     * Sets the dash pattern to use by this stroke.
     *
     * A dash pattern is specified by an array of alternating non-negative
     * values. Each value provides the length of alternate "on" and "off"
     * portions of the stroke.
     *
     * Each "on" segment will have caps applied as if the segment were a
     * separate contour. In particular, it is valid to use an "on" length
     * of 0 with `GSK_LINE_CAP_ROUND` or `GSK_LINE_CAP_SQUARE` to draw dots
     * or squares along a path.
     *
     * If `n_dash` is 0, if all elements in `dash` are 0, or if there are
     * negative values in `dash,` then dashing is disabled.
     *
     * If `n_dash` is 1, an alternating "on" and "off" pattern with the
     * single dash length provided is assumed.
     *
     * If `n_dash` is uneven, the dash array will be used with the first
     * element in `dash` defining an "on" or "off" in alternating passes
     * through the array.
     *
     * You can specify a starting offset into the dash with
     * [method`Gsk`.Stroke.set_dash_offset].
     * @param dash the array of dashes
     */
    setDash(dash: number[] | null): void
    /**
     * Sets the offset into the dash pattern where dashing should begin.
     *
     * This is an offset into the length of the path, not an index into
     * the array values of the dash array.
     *
     * See [method`Gsk`.Stroke.set_dash] for more details on dashing.
     * @param offset offset into the dash pattern
     */
    setDashOffset(offset: number): void
    /**
     * Sets the line cap to be used when stroking.
     *
     * See [enum`Gsk`.LineCap] for details.
     * @param lineCap the `GskLineCap`
     */
    setLineCap(lineCap: LineCap): void
    /**
     * Sets the line join to be used when stroking.
     *
     * See [enum`Gsk`.LineJoin] for details.
     * @param lineJoin The line join to use
     */
    setLineJoin(lineJoin: LineJoin): void
    /**
     * Sets the line width to be used when stroking.
     *
     * The line width must be > 0.
     * @param lineWidth width of the line in pixels
     */
    setLineWidth(lineWidth: number): void
    /**
     * Sets the limit for the distance from the corner where sharp
     * turns of joins get cut off.
     *
     * The miter limit is in units of line width and must be non-negative.
     *
     * For joins of type `GSK_LINE_JOIN_MITER` that exceed the miter
     * limit, the join gets rendered as if it was of type
     * `GSK_LINE_JOIN_BEVEL`.
     * @param limit the miter limit
     */
    setMiterLimit(limit: number): void
    /**
     * A helper function that sets the stroke parameters
     * of `cr` from the values found in `self`.
     * @param cr the cairo context to configure
     */
    toCairo(cr: cairo.Context): void
  }

  /**
   * A `GskStroke` struct collects the parameters that influence
   * the operation of stroking a path.
   * @record
   */
  class Stroke {
    // Own properties of Gsk-4.0.Gsk.Stroke

    static name: string

    // Constructors of Gsk-4.0.Gsk.Stroke

    /**
     * Creates a new `GskStroke` with the given `line_width`.
     * @constructor
     * @param lineWidth line width of the stroke. Must be > 0
     * @returns a new `GskStroke`
     */
    constructor(lineWidth: number)
    /**
     * Creates a new `GskStroke` with the given `line_width`.
     * @constructor
     * @param lineWidth line width of the stroke. Must be > 0
     * @returns a new `GskStroke`
     */
    static new(lineWidth: number): Stroke
    /**
     * Checks if 2 strokes are identical.
     * @param stroke1 the first `GskStroke`
     * @param stroke2 the second `GskStroke`
     * @returns `TRUE` if the 2 strokes are equal, `FALSE` otherwise
     */
    static equal(stroke1: any | null, stroke2: any | null): boolean
  }

  interface Transform {
    // Owm methods of Gsk-4.0.Gsk.Transform

    /**
     * Checks two transforms for equality.
     * @param second the second transform
     * @returns %TRUE if the two transforms perform the same operation
     */
    equal(second: Transform | null): boolean
    /**
     * Returns the category this transform belongs to.
     * @returns The category of the transform
     */
    getCategory(): TransformCategory
    /**
     * Inverts the given transform.
     *
     * If `self` is not invertible, %NULL is returned.
     * Note that inverting %NULL also returns %NULL, which is
     * the correct inverse of %NULL. If you need to differentiate
     * between those cases, you should check `self` is not %NULL
     * before calling this function.
     * @returns The inverted transform
     */
    invert(): Transform | null
    /**
     * Multiplies `next` with the given `matrix`.
     * @param matrix the matrix to multiply `next` with
     * @returns The new transform
     */
    matrix(matrix: Graphene.Matrix): Transform
    /**
     * Applies a perspective projection transform.
     *
     * This transform scales points in X and Y based on their Z value,
     * scaling points with positive Z values away from the origin, and
     * those with negative Z values towards the origin. Points
     * on the z=0 plane are unchanged.
     * @param depth distance of the z=0 plane. Lower values give a more   flattened pyramid and therefore a more pronounced   perspective effect.
     * @returns The new transform
     */
    perspective(depth: number): Transform
    /**
     * Converts `self` into a human-readable string representation suitable
     * for printing.
     *
     * The result of this function can later be parsed with
     * [func`Gsk`.Transform.parse].
     * @param string The string to print into
     */
    print(string: GLib.String): void
    /**
     * Acquires a reference on the given `GskTransform`.
     * @returns the `GskTransform` with an additional reference
     */
    ref(): Transform | null
    /**
     * Rotates `next` `angle` degrees in 2D - or in 3D-speak, around the Z axis.
     * The rotation happens around the origin point of (0, 0).
     * @param angle the rotation angle, in degrees (clockwise)
     * @returns The new transform
     */
    rotate(angle: number): Transform | null
    /**
     * Rotates `next` `angle` degrees around `axis`.
     *
     * For a rotation in 2D space, use [method`Gsk`.Transform.rotate]
     * @param angle the rotation angle, in degrees (clockwise)
     * @param axis The rotation axis
     * @returns The new transform
     */
    rotate3d(angle: number, axis: Graphene.Vec3): Transform | null
    /**
     * Scales `next` in 2-dimensional space by the given factors.
     *
     * Use [method`Gsk`.Transform.scale_3d] to scale in all 3 dimensions.
     * @param factorX scaling factor on the X axis
     * @param factorY scaling factor on the Y axis
     * @returns The new transform
     */
    scale(factorX: number, factorY: number): Transform | null
    /**
     * Scales `next` by the given factors.
     * @param factorX scaling factor on the X axis
     * @param factorY scaling factor on the Y axis
     * @param factorZ scaling factor on the Z axis
     * @returns The new transform
     */
    scale3d(factorX: number, factorY: number, factorZ: number): Transform | null
    /**
     * Applies a skew transform.
     * @param skewX skew factor, in degrees, on the X axis
     * @param skewY skew factor, in degrees, on the Y axis
     * @returns The new transform
     */
    skew(skewX: number, skewY: number): Transform | null
    /**
     * Converts a `GskTransform` to a 2D transformation matrix.
     *
     * `self` must be a 2D transformation. If you are not
     * sure, use gsk_transform_get_category() >=
     * %GSK_TRANSFORM_CATEGORY_2D to check.
     *
     * The returned values have the following layout:
     *
     * ```
     *   | xx yx |   |  a  b  0 |
     *   | xy yy | = |  c  d  0 |
     *   | dx dy |   | tx ty  1 |
     * ```
     *
     * This function can be used to convert between a `GskTransform`
     * and a matrix type from other 2D drawing libraries, in particular
     * Cairo.
     */
    to2d(): [
      /* outXx */ number,
      /* outYx */ number,
      /* outXy */ number,
      /* outYy */ number,
      /* outDx */ number,
      /* outDy */ number,
    ]
    /**
     * Converts a `GskTransform` to 2D transformation factors.
     *
     * To recreate an equivalent transform from the factors returned
     * by this function, use
     *
     *     gsk_transform_skew (
     *         gsk_transform_scale (
     *             gsk_transform_rotate (
     *                 gsk_transform_translate (NULL, &GRAPHENE_POINT_T (dx, dy)),
     *                 angle),
     *             scale_x, scale_y),
     *         skew_x, skew_y)
     *
     * `self` must be a 2D transformation. If you are not sure, use
     *
     *     gsk_transform_get_category() >= %GSK_TRANSFORM_CATEGORY_2D
     *
     * to check.
     */
    to2dComponents(): [
      /* outSkewX */ number,
      /* outSkewY */ number,
      /* outScaleX */ number,
      /* outScaleY */ number,
      /* outAngle */ number,
      /* outDx */ number,
      /* outDy */ number,
    ]
    /**
     * Converts a `GskTransform` to 2D affine transformation factors.
     *
     * To recreate an equivalent transform from the factors returned
     * by this function, use
     *
     *     gsk_transform_scale (gsk_transform_translate (NULL,
     *                                                   &GRAPHENE_POINT_T (dx, dy)),
     *                          sx, sy)
     *
     * `self` must be a 2D affine transformation. If you are not
     * sure, use
     *
     *     gsk_transform_get_category() >= %GSK_TRANSFORM_CATEGORY_2D_AFFINE
     *
     * to check.
     */
    toAffine(): [
      /* outScaleX */ number,
      /* outScaleY */ number,
      /* outDx */ number,
      /* outDy */ number,
    ]
    /**
     * Computes the actual value of `self` and stores it in `out_matrix`.
     *
     * The previous value of `out_matrix` will be ignored.
     */
    toMatrix(): /* outMatrix */ Graphene.Matrix
    /**
     * Converts a matrix into a string that is suitable for printing.
     *
     * The resulting string can be parsed with [func`Gsk`.Transform.parse].
     *
     * This is a wrapper around [method`Gsk`.Transform.print].
     * @returns A new string for @self
     */
    toString(): string | null
    /**
     * Converts a `GskTransform` to a translation operation.
     *
     * `self` must be a 2D transformation. If you are not
     * sure, use
     *
     *     gsk_transform_get_category() >= %GSK_TRANSFORM_CATEGORY_2D_TRANSLATE
     *
     * to check.
     */
    toTranslate(): [/* outDx */ number, /* outDy */ number]
    /**
     * Applies all the operations from `other` to `next`.
     * @param other Transform to apply
     * @returns The new transform
     */
    transform(other: Transform | null): Transform | null
    /**
     * Transforms a `graphene_rect_t` using the given transform `self`.
     *
     * The result is the bounding box containing the coplanar quad.
     * @param rect a `graphene_rect_t`
     */
    transformBounds(rect: Graphene.Rect): /* outRect */ Graphene.Rect
    /**
     * Transforms a `graphene_point_t` using the given transform `self`.
     * @param point a `graphene_point_t`
     */
    transformPoint(point: Graphene.Point): /* outPoint */ Graphene.Point
    /**
     * Translates `next` in 2-dimensional space by `point`.
     * @param point the point to translate the transform by
     * @returns The new transform
     */
    translate(point: Graphene.Point): Transform | null
    /**
     * Translates `next` by `point`.
     * @param point the point to translate the transform by
     * @returns The new transform
     */
    translate3d(point: Graphene.Point3D): Transform | null
    /**
     * Releases a reference on the given `GskTransform`.
     *
     * If the reference was the last, the resources associated to the `self` are
     * freed.
     */
    unref(): void
  }

  /**
   * `GskTransform` is an object to describe transform matrices.
   *
   * Unlike `graphene_matrix_t`, `GskTransform` retains the steps in how
   * a transform was constructed, and allows inspecting them. It is modeled
   * after the way CSS describes transforms.
   *
   * `GskTransform` objects are immutable and cannot be changed after creation.
   * This means code can safely expose them as properties of objects without
   * having to worry about others changing them.
   * @record
   */
  class Transform {
    // Own properties of Gsk-4.0.Gsk.Transform

    static name: string

    // Constructors of Gsk-4.0.Gsk.Transform

    constructor()
    static new(): Transform
    /**
     * Parses the given `string` into a transform and puts it in
     * `out_transform`.
     *
     * Strings printed via [method`Gsk`.Transform.to_string]
     * can be read in again successfully using this function.
     *
     * If `string` does not describe a valid transform, %FALSE is
     * returned and %NULL is put in `out_transform`.
     * @param string the string to parse
     * @returns %TRUE if @string described a valid transform.
     */
    static parse(
      string: string
    ): [/* returnType */ boolean, /* outTransform */ Transform]
  }

  interface VulkanRendererClass {}

  abstract class VulkanRendererClass {
    // Own properties of Gsk-4.0.Gsk.VulkanRendererClass

    static name: string
  }
}

/*
 * Type Definitions for node-gtk (https://github.com/romgrk/node-gtk)
 *
 * These type definitions are automatically generated, do not edit them by hand.
 * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
 */



declare namespace Gtk {
  /**
   * The priority of an accessibility announcement.
   */
  enum AccessibleAnnouncementPriority {
    LOW,
    MEDIUM,
    HIGH,
  }
  /**
   * The possible values for the %GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE
   * accessible property.
   */
  enum AccessibleAutocomplete {
    /**
     * Automatic suggestions are not displayed.
     */
    NONE,
    /**
     * When a user is providing input, text
     *    suggesting one way to complete the provided input may be dynamically
     *    inserted after the caret.
     */
    INLINE,
    /**
     * When a user is providing input, an element
     *    containing a collection of values that could complete the provided input
     *    may be displayed.
     */
    LIST,
    /**
     * When a user is providing input, an element
     *    containing a collection of values that could complete the provided input
     *    may be displayed. If displayed, one value in the collection is automatically
     *    selected, and the text needed to complete the automatically selected value
     *    appears after the caret in the input.
     */
    BOTH,
  }
  /**
   * The possible values for the %GTK_ACCESSIBLE_STATE_INVALID
   * accessible state.
   *
   * Note that the %GTK_ACCESSIBLE_INVALID_FALSE and
   * %GTK_ACCESSIBLE_INVALID_TRUE have the same values
   * as %FALSE and %TRUE.
   */
  enum AccessibleInvalidState {
    /**
     * There are no detected errors in the value
     */
    FALSE,
    /**
     * The value entered by the user has failed validation
     */
    TRUE,
    /**
     * A grammatical error was detected
     */
    GRAMMAR,
    /**
     * A spelling error was detected
     */
    SPELLING,
  }
  /**
   * The various platform states which can be queried
   * using [method`Gtk`.Accessible.get_platform_state].
   */
  enum AccessiblePlatformState {
    /**
     * whether the accessible can be focused
     */
    FOCUSABLE,
    /**
     * whether the accessible has focus
     */
    FOCUSED,
    /**
     * whether the accessible is active
     */
    ACTIVE,
  }
  /**
   * The possible accessible properties of a [iface`Accessible]`.
   */
  enum AccessibleProperty {
    /**
     * Indicates whether inputting text
     *    could trigger display of one or more predictions of the user's intended
     *    value for a combobox, searchbox, or textbox and specifies how predictions
     *    would be presented if they were made. Value type: [enum`AccessibleAutocomplete]`
     */
    AUTOCOMPLETE,
    /**
     * Defines a string value that describes
     *    or annotates the current element. Value type: string
     */
    DESCRIPTION,
    /**
     * Indicates the availability and type of
     *    interactive popup element, such as menu or dialog, that can be triggered
     *    by an element.
     */
    HAS_POPUP,
    /**
     * Indicates keyboard shortcuts that an
     *    author has implemented to activate or give focus to an element. Value type:
     *    string
     */
    KEY_SHORTCUTS,
    /**
     * Defines a string value that labels the current
     *    element. Value type: string
     */
    LABEL,
    /**
     * Defines the hierarchical level of an element
     *    within a structure. Value type: integer
     */
    LEVEL,
    /**
     * Indicates whether an element is modal when
     *    displayed. Value type: boolean
     */
    MODAL,
    /**
     * Indicates whether a text box accepts
     *    multiple lines of input or only a single line. Value type: boolean
     */
    MULTI_LINE,
    /**
     * Indicates that the user may select
     *    more than one item from the current selectable descendants. Value type:
     *    boolean
     */
    MULTI_SELECTABLE,
    /**
     * Indicates whether the element's
     *    orientation is horizontal, vertical, or unknown/ambiguous. Value type:
     *    [enum`Orientation]`
     */
    ORIENTATION,
    /**
     * Defines a short hint (a word or short
     *    phrase) intended to aid the user with data entry when the control has no
     *    value. A hint could be a sample value or a brief description of the expected
     *    format. Value type: string
     */
    PLACEHOLDER,
    /**
     * Indicates that the element is not editable,
     *    but is otherwise operable. Value type: boolean
     */
    READ_ONLY,
    /**
     * Indicates that user input is required on
     *    the element before a form may be submitted. Value type: boolean
     */
    REQUIRED,
    /**
     * Defines a human-readable,
     *    author-localized description for the role of an element. Value type: string
     */
    ROLE_DESCRIPTION,
    /**
     * Indicates if items in a table or grid are
     *    sorted in ascending or descending order. Value type: [enum`AccessibleSort]`
     */
    SORT,
    /**
     * Defines the maximum allowed value for a
     *    range widget. Value type: double
     */
    VALUE_MAX,
    /**
     * Defines the minimum allowed value for a
     *    range widget. Value type: double
     */
    VALUE_MIN,
    /**
     * Defines the current value for a range widget.
     *    Value type: double
     */
    VALUE_NOW,
    /**
     * Defines the human readable text alternative
     *    of aria-valuenow for a range widget. Value type: string
     */
    VALUE_TEXT,
  }
  /**
   * The possible accessible relations of a [iface`Accessible]`.
   *
   * Accessible relations can be references to other widgets,
   * integers or strings.
   */
  enum AccessibleRelation {
    /**
     * Identifies the currently active
     *    element when focus is on a composite widget, combobox, textbox, group,
     *    or application. Value type: reference
     */
    ACTIVE_DESCENDANT,
    /**
     * Defines the total number of columns
     *    in a table, grid, or treegrid. Value type: integer
     */
    COL_COUNT,
    /**
     * Defines an element's column index or
     *    position with respect to the total number of columns within a table,
     *    grid, or treegrid. Value type: integer
     */
    COL_INDEX,
    /**
     * Defines a human readable text
     *   alternative of %GTK_ACCESSIBLE_RELATION_COL_INDEX. Value type: string
     */
    COL_INDEX_TEXT,
    /**
     * Defines the number of columns spanned
     *   by a cell or gridcell within a table, grid, or treegrid. Value type: integer
     */
    COL_SPAN,
    /**
     * Identifies the element (or elements) whose
     *    contents or presence are controlled by the current element. Value type: reference
     */
    CONTROLS,
    /**
     * Identifies the element (or elements)
     *    that describes the object. Value type: reference
     */
    DESCRIBED_BY,
    /**
     * Identifies the element (or elements) that
     *    provide additional information related to the object. Value type: reference
     */
    DETAILS,
    /**
     * Identifies the element that provides
     *    an error message for an object. Value type: reference
     */
    ERROR_MESSAGE,
    /**
     * Identifies the next element (or elements)
     *    in an alternate reading order of content which, at the user's discretion,
     *    allows assistive technology to override the general default of reading in
     *    document source order. Value type: reference
     */
    FLOW_TO,
    /**
     * Identifies the element (or elements)
     *    that labels the current element. Value type: reference
     */
    LABELLED_BY,
    /**
     * Identifies an element (or elements) in order
     *    to define a visual, functional, or contextual parent/child relationship
     *    between elements where the widget hierarchy cannot be used to represent
     *    the relationship. Value type: reference
     */
    OWNS,
    /**
     * Defines an element's number or position
     *    in the current set of listitems or treeitems. Value type: integer
     */
    POS_IN_SET,
    /**
     * Defines the total number of rows in a table,
     *    grid, or treegrid. Value type: integer
     */
    ROW_COUNT,
    /**
     * Defines an element's row index or position
     *    with respect to the total number of rows within a table, grid, or treegrid.
     *    Value type: integer
     */
    ROW_INDEX,
    /**
     * Defines a human readable text
     *    alternative of aria-rowindex. Value type: string
     */
    ROW_INDEX_TEXT,
    /**
     * Defines the number of rows spanned by a
     *    cell or gridcell within a table, grid, or treegrid. Value type: integer
     */
    ROW_SPAN,
    /**
     * Defines the number of items in the current
     *    set of listitems or treeitems. Value type: integer
     */
    SET_SIZE,
  }
  /**
   * The accessible role for a [iface`Accessible]` implementation.
   *
   * Abstract roles are only used as part of the ontology; application
   * developers must not use abstract roles in their code.
   */
  enum AccessibleRole {
    /**
     * An element with important, and usually
     *   time-sensitive, information
     */
    ALERT,
    /**
     * A type of dialog that contains an
     *   alert message
     */
    ALERT_DIALOG,
    /**
     * Unused
     */
    BANNER,
    /**
     * An input element that allows for
     *   user-triggered actions when clicked or pressed
     */
    BUTTON,
    /**
     * Unused
     */
    CAPTION,
    /**
     * Unused
     */
    CELL,
    /**
     * A checkable input element that has
     *   three possible values: `true`, `false`, or `mixed`
     */
    CHECKBOX,
    /**
     * A header in a columned list.
     */
    COLUMN_HEADER,
    /**
     * An input that controls another element,
     *   such as a list or a grid, that can dynamically pop up to help the user
     *   set the value of the input
     */
    COMBO_BOX,
    /**
     * Abstract role.
     */
    COMMAND,
    /**
     * Abstract role.
     */
    COMPOSITE,
    /**
     * A dialog is a window that is designed to interrupt
     *   the current processing of an application in order to prompt the user to enter
     *   information or require a response.
     */
    DIALOG,
    /**
     * Content that assistive technology users may want to
     *   browse in a reading mode.
     */
    DOCUMENT,
    /**
     * Unused
     */
    FEED,
    /**
     * Unused
     */
    FORM,
    /**
     * A nameless container that has no semantic meaning
     *   of its own. This is the role that GTK uses by default for widgets.
     */
    GENERIC,
    /**
     * A grid of items.
     */
    GRID,
    /**
     * An item in a grid or tree grid.
     */
    GRID_CELL,
    /**
     * An element that groups multiple related widgets. GTK uses
     *   this role for various containers, like [class`Gtk`.HeaderBar] or [class`Gtk`.Notebook].
     */
    GROUP,
    /**
     * Unused
     */
    HEADING,
    /**
     * An image.
     */
    IMG,
    /**
     * Abstract role.
     */
    INPUT,
    /**
     * A visible name or caption for a user interface component.
     */
    LABEL,
    /**
     * Abstract role.
     */
    LANDMARK,
    /**
     * Unused
     */
    LEGEND,
    /**
     * A clickable link.
     */
    LINK,
    /**
     * A list of items.
     */
    LIST,
    /**
     * Unused.
     */
    LIST_BOX,
    /**
     * An item in a list.
     */
    LIST_ITEM,
    /**
     * Unused
     */
    LOG,
    /**
     * Unused
     */
    MAIN,
    /**
     * Unused
     */
    MARQUEE,
    /**
     * Unused
     */
    MATH,
    /**
     * An element that represents a value within a known range.
     */
    METER,
    /**
     * A menu.
     */
    MENU,
    /**
     * A menubar.
     */
    MENU_BAR,
    /**
     * An item in a menu.
     */
    MENU_ITEM,
    /**
     * A check item in a menu.
     */
    MENU_ITEM_CHECKBOX,
    /**
     * A radio item in a menu.
     */
    MENU_ITEM_RADIO,
    /**
     * Unused
     */
    NAVIGATION,
    /**
     * An element that is not represented to accessibility technologies.
     *   This role is synonymous to `GTK_ACCESSIBLE_ROLE_PRESENTATION`.
     */
    NONE,
    /**
     * Unused
     */
    NOTE,
    /**
     * Unused
     */
    OPTION,
    /**
     * An element that is not represented to accessibility technologies.
     *   This role is synonymous to `GTK_ACCESSIBLE_ROLE_NONE`.
     */
    PRESENTATION,
    /**
     * An element that displays the progress
     *   status for tasks that take a long time.
     */
    PROGRESS_BAR,
    /**
     * A checkable input in a group of radio roles,
     *   only one of which can be checked at a time.
     */
    RADIO,
    /**
     * Unused
     */
    RADIO_GROUP,
    /**
     * Abstract role.
     */
    RANGE,
    /**
     * Unused
     */
    REGION,
    /**
     * A row in a columned list.
     */
    ROW,
    /**
     * Unused
     */
    ROW_GROUP,
    /**
     * Unused
     */
    ROW_HEADER,
    /**
     * A graphical object that controls the scrolling
     *   of content within a viewing area, regardless of whether the content is fully
     *   displayed within the viewing area.
     */
    SCROLLBAR,
    /**
     * Unused
     */
    SEARCH,
    /**
     * A type of textbox intended for specifying
     *   search criteria.
     */
    SEARCH_BOX,
    /**
     * Abstract role.
     */
    SECTION,
    /**
     * Abstract role.
     */
    SECTION_HEAD,
    /**
     * Abstract role.
     */
    SELECT,
    /**
     * A divider that separates and distinguishes
     *   sections of content or groups of menuitems.
     */
    SEPARATOR,
    /**
     * A user input where the user selects a value
     *   from within a given range.
     */
    SLIDER,
    /**
     * A form of range that expects the user to
     *   select from among discrete choices.
     */
    SPIN_BUTTON,
    /**
     * Unused
     */
    STATUS,
    /**
     * Abstract role.
     */
    STRUCTURE,
    /**
     * A type of checkbox that represents on/off values,
     *   as opposed to checked/unchecked values.
     */
    SWITCH,
    /**
     * An item in a list of tab used for switching pages.
     */
    TAB,
    /**
     * Unused
     */
    TABLE,
    /**
     * A list of tabs for switching pages.
     */
    TAB_LIST,
    /**
     * A page in a notebook or stack.
     */
    TAB_PANEL,
    /**
     * A type of input that allows free-form text
     *   as its value.
     */
    TEXT_BOX,
    /**
     * Unused
     */
    TIME,
    /**
     * Unused
     */
    TIMER,
    /**
     * Unused
     */
    TOOLBAR,
    /**
     * Unused
     */
    TOOLTIP,
    /**
     * Unused
     */
    TREE,
    /**
     * A treeview-like, columned list.
     */
    TREE_GRID,
    /**
     * Unused
     */
    TREE_ITEM,
    /**
     * Abstract role for interactive components of a
     *   graphical user interface
     */
    WIDGET,
    /**
     * Abstract role for windows.
     */
    WINDOW,
    /**
     * A type of push button which stays pressed until depressed by a second
     * activation.
     */
    TOGGLE_BUTTON,
    /**
     * A toplevel element of a graphical user interface.
     *
     * This is the role that GTK uses by default for windows.
     */
    APPLICATION,
    /**
     * A paragraph of content.
     */
    PARAGRAPH,
    /**
     * A section of content that is quoted from another source.
     */
    BLOCK_QUOTE,
    /**
     * A section of a page that consists of a composition that forms an independent
     * part of a document, page, or site.
     */
    ARTICLE,
    /**
     * A comment contains content expressing reaction to other content.
     */
    COMMENT,
    /**
     * A virtual terminal.
     */
    TERMINAL,
  }
  /**
   * The possible values for the %GTK_ACCESSIBLE_PROPERTY_SORT
   * accessible property.
   */
  enum AccessibleSort {
    /**
     * There is no defined sort applied to the column.
     */
    NONE,
    /**
     * Items are sorted in ascending order by this column.
     */
    ASCENDING,
    /**
     * Items are sorted in descending order by this column.
     */
    DESCENDING,
    /**
     * A sort algorithm other than ascending or
     *    descending has been applied.
     */
    OTHER,
  }
  /**
   * The possible accessible states of a [iface`Accessible]`.
   */
  enum AccessibleState {
    /**
     * A “busy” state. This state has boolean values
     */
    BUSY,
    /**
     * A “checked” state; indicates the current
     *   state of a [class`CheckButton]`. Value type: [enum`AccessibleTristate]`
     */
    CHECKED,
    /**
     * A “disabled” state; corresponds to the
     *   [property`Widget:`sensitive] property. It indicates a UI element
     *   that is perceivable, but not editable or operable. Value type: boolean
     */
    DISABLED,
    /**
     * An “expanded” state; corresponds to the
     *   [property`Expander:`expanded] property. Value type: boolean
     *   or undefined
     */
    EXPANDED,
    /**
     * A “hidden” state; corresponds to the
     *   [property`Widget:`visible] property. You can use this state
     *   explicitly on UI elements that should not be exposed to an assistive
     *   technology. Value type: boolean
     *   See also: %GTK_ACCESSIBLE_STATE_DISABLED
     */
    HIDDEN,
    /**
     * An “invalid” state; set when a widget
     *   is showing an error. Value type: [enum`AccessibleInvalidState]`
     */
    INVALID,
    /**
     * A “pressed” state; indicates the current
     *   state of a [class`ToggleButton]`. Value type: [enum`AccessibleTristate]`
     *   enumeration
     */
    PRESSED,
    /**
     * A “selected” state; set when a widget
     *   is selected. Value type: boolean or undefined
     */
    SELECTED,
    /**
     * Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited.
     * Value type: boolean.
     */
    VISITED,
  }
  /**
   * The type of contents change operation.
   */
  enum AccessibleTextContentChange {
    /**
     * contents change as the result of
     *   an insert operation
     */
    INSERT,
    /**
     * contents change as the result of
     *   a remove operation
     */
    REMOVE,
  }
  /**
   * The granularity for queries about the text contents of a [iface`Gtk`.AccessibleText]
   * implementation.
   */
  enum AccessibleTextGranularity {
    /**
     * Use the boundary between
     *   characters (including non-printing characters)
     */
    CHARACTER,
    /**
     * Use the boundary between words,
     *   starting from the beginning of the current word and ending at the
     *   beginning of the next word
     */
    WORD,
    /**
     * Use the boundary between
     *   sentences, starting from the beginning of the current sentence and
     *   ending at the beginning of the next sentence
     */
    SENTENCE,
    /**
     * Use the boundary between lines,
     *   starting from the beginning of the current line and ending at the
     *   beginning of the next line
     */
    LINE,
    /**
     * Use the boundary between
     *   paragraphs, starting from the beginning of the current paragraph and
     *   ending at the beginning of the next paragraph
     */
    PARAGRAPH,
  }
  /**
   * The possible values for the %GTK_ACCESSIBLE_STATE_PRESSED
   * accessible state.
   *
   * Note that the %GTK_ACCESSIBLE_TRISTATE_FALSE and
   * %GTK_ACCESSIBLE_TRISTATE_TRUE have the same values
   * as %FALSE and %TRUE.
   */
  enum AccessibleTristate {
    /**
     * The state is `false`
     */
    FALSE,
    /**
     * The state is `true`
     */
    TRUE,
    /**
     * The state is `mixed`
     */
    MIXED,
  }
  /**
   * Controls how a widget deals with extra space in a single dimension.
   *
   * Alignment only matters if the widget receives a “too large” allocation,
   * for example if you packed the widget with the [property`Gtk`.Widget:hexpand]
   * property inside a [class`Box]`, then the widget might get extra space.
   * If you have for example a 16x16 icon inside a 32x32 space, the icon
   * could be scaled and stretched, it could be centered, or it could be
   * positioned to one side of the space.
   *
   * Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
   * are interpreted relative to text direction.
   *
   * Baseline support is optional for containers and widgets, and is only available
   * for vertical alignment. `GTK_ALIGN_BASELINE_CENTER and `GTK_ALIGN_BASELINE_FILL`
   * are treated similar to `GTK_ALIGN_CENTER` and `GTK_ALIGN_FILL`, except that it
   * positions the widget to line up the baselines, where that is supported.
   */
  enum Align {
    /**
     * stretch to fill all space if possible, center if
     *   no meaningful way to stretch
     */
    FILL,
    /**
     * snap to left or top side, leaving space on right or bottom
     */
    START,
    /**
     * snap to right or bottom side, leaving space on left or top
     */
    END,
    /**
     * center natural width of widget inside the allocation
     */
    CENTER,
    /**
     * a different name for `GTK_ALIGN_BASELINE`.
     */
    BASELINE_FILL,
    /**
     * align the widget according to the baseline.
     */
    BASELINE,
    /**
     * stretch to fill all space, but align the baseline.
     */
    BASELINE_CENTER,
  }
  /**
   * Used to indicate the direction in which an arrow should point.
   */
  enum ArrowType {
    /**
     * Represents an upward pointing arrow.
     */
    UP,
    /**
     * Represents a downward pointing arrow.
     */
    DOWN,
    /**
     * Represents a left pointing arrow.
     */
    LEFT,
    /**
     * Represents a right pointing arrow.
     */
    RIGHT,
    /**
     * No arrow.
     */
    NONE,
  }
  /**
   * Determines the page role inside a `GtkAssistant`.
   *
   * The role is used to handle buttons sensitivity and visibility.
   *
   * Note that an assistant needs to end its page flow with a page of type
   * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
   * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
   *
   * The Cancel button will only be shown if the page isn’t “committed”.
   * See gtk_assistant_commit() for details.
   */
  enum AssistantPageType {
    /**
     * The page has regular contents. Both the
     *  Back and forward buttons will be shown.
     */
    CONTENT,
    /**
     * The page contains an introduction to the
     *  assistant task. Only the Forward button will be shown if there is a
     *   next page.
     */
    INTRO,
    /**
     * The page lets the user confirm or deny the
     *  changes. The Back and Apply buttons will be shown.
     */
    CONFIRM,
    /**
     * The page informs the user of the changes
     *  done. Only the Close button will be shown.
     */
    SUMMARY,
    /**
     * Used for tasks that take a long time to
     *  complete, blocks the assistant until the page is marked as complete.
     *   Only the back button will be shown.
     */
    PROGRESS,
    /**
     * Used for when other page types are not
     *  appropriate. No buttons will be shown, and the application must
     *  add its own buttons through gtk_assistant_add_action_widget().
     */
    CUSTOM,
  }
  /**
   * Baseline position in a row of widgets.
   *
   * Whenever a container has some form of natural row it may align
   * children in that row along a common typographical baseline. If
   * the amount of vertical space in the row is taller than the total
   * requested height of the baseline-aligned children then it can use a
   * `GtkBaselinePosition` to select where to put the baseline inside the
   * extra available space.
   */
  enum BaselinePosition {
    /**
     * Align the baseline at the top
     */
    TOP,
    /**
     * Center the baseline
     */
    CENTER,
    /**
     * Align the baseline at the bottom
     */
    BOTTOM,
  }
  /**
   * Describes how the border of a UI element should be rendered.
   */
  enum BorderStyle {
    /**
     * No visible border
     */
    NONE,
    /**
     * Same as %GTK_BORDER_STYLE_NONE
     */
    HIDDEN,
    /**
     * A single line segment
     */
    SOLID,
    /**
     * Looks as if the content is sunken into the canvas
     */
    INSET,
    /**
     * Looks as if the content is coming out of the canvas
     */
    OUTSET,
    /**
     * A series of round dots
     */
    DOTTED,
    /**
     * A series of square-ended dashes
     */
    DASHED,
    /**
     * Two parallel lines with some space between them
     */
    DOUBLE,
    /**
     * Looks as if it were carved in the canvas
     */
    GROOVE,
    /**
     * Looks as if it were coming out of the canvas
     */
    RIDGE,
  }
  /**
   * Error codes that identify various errors that can occur while using
   * `GtkBuilder`.
   */
  enum BuilderError {
    /**
     * A type-func attribute didn’t name
     *  a function that returns a `GType`.
     */
    INVALID_TYPE_FUNCTION,
    /**
     * The input contained a tag that `GtkBuilder`
     *  can’t handle.
     */
    UNHANDLED_TAG,
    /**
     * An attribute that is required by
     *  `GtkBuilder` was missing.
     */
    MISSING_ATTRIBUTE,
    /**
     * `GtkBuilder` found an attribute that
     *  it doesn’t understand.
     */
    INVALID_ATTRIBUTE,
    /**
     * `GtkBuilder` found a tag that
     *  it doesn’t understand.
     */
    INVALID_TAG,
    /**
     * A required property value was
     *  missing.
     */
    MISSING_PROPERTY_VALUE,
    /**
     * `GtkBuilder` couldn’t parse
     *  some attribute value.
     */
    INVALID_VALUE,
    /**
     * The input file requires a newer version
     *  of GTK.
     */
    VERSION_MISMATCH,
    /**
     * An object id occurred twice.
     */
    DUPLICATE_ID,
    /**
     * A specified object type is of the same type or
     *  derived from the type of the composite class being extended with builder XML.
     */
    OBJECT_TYPE_REFUSED,
    /**
     * The wrong type was specified in a composite class’s template XML
     */
    TEMPLATE_MISMATCH,
    /**
     * The specified property is unknown for the object class.
     */
    INVALID_PROPERTY,
    /**
     * The specified signal is unknown for the object class.
     */
    INVALID_SIGNAL,
    /**
     * An object id is unknown.
     */
    INVALID_ID,
    /**
     * A function could not be found. This often happens
     *   when symbols are set to be kept private. Compiling code with -rdynamic or using the
     *   `gmodule-export-2.0` pkgconfig module can fix this problem.
     */
    INVALID_FUNCTION,
  }
  /**
   * Prebuilt sets of buttons for `GtkDialog`.
   *
   * If none of these choices are appropriate, simply use
   * %GTK_BUTTONS_NONE and call [method`Gtk`.Dialog.add_buttons].
   *
   * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
   * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
   * > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/).
   */
  enum ButtonsType {
    /**
     * no buttons at all
     */
    NONE,
    /**
     * an OK button
     */
    OK,
    /**
     * a Close button
     */
    CLOSE,
    /**
     * a Cancel button
     */
    CANCEL,
    /**
     * Yes and No buttons
     */
    YES_NO,
    /**
     * OK and Cancel buttons
     */
    OK_CANCEL,
  }
  /**
   * The available modes for [property`Gtk`.CellRendererAccel:accel-mode].
   */
  enum CellRendererAccelMode {
    /**
     * GTK accelerators mode
     */
    GTK,
    /**
     * Other accelerator mode
     */
    OTHER,
  }
  /**
   * Identifies how the user can interact with a particular cell.
   */
  enum CellRendererMode {
    /**
     * The cell is just for display
     *  and cannot be interacted with.  Note that this doesn’t mean that eg. the
     *  row being drawn can’t be selected -- just that a particular element of
     *  it cannot be individually modified.
     */
    INERT,
    /**
     * The cell can be clicked.
     */
    ACTIVATABLE,
    /**
     * The cell can be edited or otherwise modified.
     */
    EDITABLE,
  }
  /**
   * Describes how a [class`Gtk`.StringSorter] turns strings into sort keys to
   * compare them.
   *
   * Note that the result of sorting will in general depend on the current locale
   * unless the mode is `GTK_COLLATION_NONE`.
   */
  enum Collation {
    /**
     * Don't do any collation
     */
    NONE,
    /**
     * Use [func`GLib`.utf8_collate_key]
     */
    UNICODE,
    /**
     * Use [func`GLib`.utf8_collate_key_for_filename]
     */
    FILENAME,
  }
  /**
   * The widget attributes that can be used when creating a [class`Constraint]`.
   */
  enum ConstraintAttribute {
    /**
     * No attribute, used for constant
     *   relations
     */
    NONE,
    /**
     * The left edge of a widget, regardless of
     *   text direction
     */
    LEFT,
    /**
     * The right edge of a widget, regardless
     *   of text direction
     */
    RIGHT,
    /**
     * The top edge of a widget
     */
    TOP,
    /**
     * The bottom edge of a widget
     */
    BOTTOM,
    /**
     * The leading edge of a widget, depending
     *   on text direction; equivalent to %GTK_CONSTRAINT_ATTRIBUTE_LEFT for LTR
     *   languages, and %GTK_CONSTRAINT_ATTRIBUTE_RIGHT for RTL ones
     */
    START,
    /**
     * The trailing edge of a widget, depending
     *   on text direction; equivalent to %GTK_CONSTRAINT_ATTRIBUTE_RIGHT for LTR
     *   languages, and %GTK_CONSTRAINT_ATTRIBUTE_LEFT for RTL ones
     */
    END,
    /**
     * The width of a widget
     */
    WIDTH,
    /**
     * The height of a widget
     */
    HEIGHT,
    /**
     * The center of a widget, on the
     *   horizontal axis
     */
    CENTER_X,
    /**
     * The center of a widget, on the
     *   vertical axis
     */
    CENTER_Y,
    /**
     * The baseline of a widget
     */
    BASELINE,
  }
  /**
   * The relation between two terms of a constraint.
   */
  enum ConstraintRelation {
    /**
     * Less than, or equal
     */
    LE,
    /**
     * Equal
     */
    EQ,
    /**
     * Greater than, or equal
     */
    GE,
  }
  /**
   * The strength of a constraint, expressed as a symbolic constant.
   *
   * The strength of a [class`Constraint]` can be expressed with any positive
   * integer; the values of this enumeration can be used for readability.
   */
  enum ConstraintStrength {
    /**
     * The constraint is required towards solving the layout
     */
    REQUIRED,
    /**
     * A strong constraint
     */
    STRONG,
    /**
     * A medium constraint
     */
    MEDIUM,
    /**
     * A weak constraint
     */
    WEAK,
  }
  /**
   * Domain for VFL parsing errors.
   */
  enum ConstraintVflParserError {
    /**
     * Invalid or unknown symbol
     */
    SYMBOL,
    /**
     * Invalid or unknown attribute
     */
    ATTRIBUTE,
    /**
     * Invalid or unknown view
     */
    VIEW,
    /**
     * Invalid or unknown metric
     */
    METRIC,
    /**
     * Invalid or unknown priority
     */
    PRIORITY,
    /**
     * Invalid or unknown relation
     */
    RELATION,
  }
  /**
   * Controls how a content should be made to fit inside an allocation.
   */
  enum ContentFit {
    /**
     * Make the content fill the entire allocation,
     *   without taking its aspect ratio in consideration. The resulting
     *   content will appear as stretched if its aspect ratio is different
     *   from the allocation aspect ratio.
     */
    FILL,
    /**
     * Scale the content to fit the allocation,
     *   while taking its aspect ratio in consideration. The resulting
     *   content will appear as letterboxed if its aspect ratio is different
     *   from the allocation aspect ratio.
     */
    CONTAIN,
    /**
     * Cover the entire allocation, while taking
     *   the content aspect ratio in consideration. The resulting content
     *   will appear as clipped if its aspect ratio is different from the
     *   allocation aspect ratio.
     */
    COVER,
    /**
     * The content is scaled down to fit the
     *   allocation, if needed, otherwise its original size is used.
     */
    SCALE_DOWN,
  }
  /**
   * Specifies which corner a child widget should be placed in when packed into
   * a `GtkScrolledWindow.`
   *
   * This is effectively the opposite of where the scroll bars are placed.
   */
  enum CornerType {
    /**
     * Place the scrollbars on the right and bottom of the
     *   widget (default behaviour).
     */
    TOP_LEFT,
    /**
     * Place the scrollbars on the top and right of the
     *   widget.
     */
    BOTTOM_LEFT,
    /**
     * Place the scrollbars on the left and bottom of the
     *   widget.
     */
    TOP_RIGHT,
    /**
     * Place the scrollbars on the top and left of the
     *   widget.
     */
    BOTTOM_RIGHT,
  }
  /**
   * Errors that can occur while parsing CSS.
   *
   * These errors are unexpected and will cause parts of the given CSS
   * to be ignored.
   */
  enum CssParserError {
    /**
     * Unknown failure.
     */
    FAILED,
    /**
     * The given text does not form valid syntax
     */
    SYNTAX,
    /**
     * Failed to import a resource
     */
    IMPORT,
    /**
     * The given name has not been defined
     */
    NAME,
    /**
     * The given value is not correct
     */
    UNKNOWN_VALUE,
  }
  /**
   * Warnings that can occur while parsing CSS.
   *
   * Unlike `GtkCssParserError`s, warnings do not cause the parser to
   * skip any input, but they indicate issues that should be fixed.
   */
  enum CssParserWarning {
    /**
     * The given construct is
     *   deprecated and will be removed in a future version
     */
    DEPRECATED,
    /**
     * A syntax construct was used
     *   that should be avoided
     */
    SYNTAX,
    /**
     * A feature is not implemented
     */
    UNIMPLEMENTED,
  }
  /**
   * Passed to various keybinding signals for deleting text.
   */
  enum DeleteType {
    /**
     * Delete characters.
     */
    CHARS,
    /**
     * Delete only the portion of the word to the
     *   left/right of cursor if we’re in the middle of a word.
     */
    WORD_ENDS,
    /**
     * Delete words.
     */
    WORDS,
    /**
     * Delete display-lines. Display-lines
     *   refers to the visible lines, with respect to the current line
     *   breaks. As opposed to paragraphs, which are defined by line
     *   breaks in the input.
     */
    DISPLAY_LINES,
    /**
     * Delete only the portion of the
     *   display-line to the left/right of cursor.
     */
    DISPLAY_LINE_ENDS,
    /**
     * Delete to the end of the
     *   paragraph. Like C-k in Emacs (or its reverse).
     */
    PARAGRAPH_ENDS,
    /**
     * Delete entire line. Like C-k in pico.
     */
    PARAGRAPHS,
    /**
     * Delete only whitespace. Like M-\ in Emacs.
     */
    WHITESPACE,
  }
  /**
   * Error codes in the `GTK_DIALOG_ERROR` domain that can be returned
   * by async dialog functions.
   */
  enum DialogError {
    /**
     * Generic error condition for when
     *   an operation fails and no more specific code is applicable
     */
    FAILED,
    /**
     * The async function call was cancelled
     *   via its `GCancellable`
     */
    CANCELLED,
    /**
     * The operation was cancelled
     *   by the user (via a Cancel or Close button)
     */
    DISMISSED,
  }
  /**
   * Focus movement types.
   */
  enum DirectionType {
    /**
     * Move forward.
     */
    TAB_FORWARD,
    /**
     * Move backward.
     */
    TAB_BACKWARD,
    /**
     * Move up.
     */
    UP,
    /**
     * Move down.
     */
    DOWN,
    /**
     * Move left.
     */
    LEFT,
    /**
     * Move right.
     */
    RIGHT,
  }
  /**
   * The identifiers for [iface`Gtk`.Editable] properties.
   *
   * See [func`Gtk`.Editable.install_properties] for details on how to
   * implement the `GtkEditable` interface.
   */
  enum EditableProperties {
    /**
     * the property id for [property`Gtk`.Editable:text]
     */
    PROP_TEXT,
    /**
     * the property id for [property`Gtk`.Editable:cursor-position]
     */
    PROP_CURSOR_POSITION,
    /**
     * the property id for [property`Gtk`.Editable:selection-bound]
     */
    PROP_SELECTION_BOUND,
    /**
     * the property id for [property`Gtk`.Editable:editable]
     */
    PROP_EDITABLE,
    /**
     * the property id for [property`Gtk`.Editable:width-chars]
     */
    PROP_WIDTH_CHARS,
    /**
     * the property id for [property`Gtk`.Editable:max-width-chars]
     */
    PROP_MAX_WIDTH_CHARS,
    /**
     * the property id for [property`Gtk`.Editable:xalign]
     */
    PROP_XALIGN,
    /**
     * the property id for [property`Gtk`.Editable:enable-undo]
     */
    PROP_ENABLE_UNDO,
    /**
     * the number of properties
     */
    NUM_PROPERTIES,
  }
  /**
   * Specifies the side of the entry at which an icon is placed.
   */
  enum EntryIconPosition {
    /**
     * At the beginning of the entry (depending on the text direction).
     */
    PRIMARY,
    /**
     * At the end of the entry (depending on the text direction).
     */
    SECONDARY,
  }
  /**
   * Describes the state of a [struct`Gdk`.EventSequence] in a [class`Gesture]`.
   */
  enum EventSequenceState {
    /**
     * The sequence is handled, but not grabbed.
     */
    NONE,
    /**
     * The sequence is handled and grabbed.
     */
    CLAIMED,
    /**
     * The sequence is denied.
     */
    DENIED,
  }
  /**
   * Describes whether a `GtkFileChooser` is being used to open existing files
   * or to save to a possibly new file.
   */
  enum FileChooserAction {
    /**
     * Indicates open mode.  The file chooser
     *  will only let the user pick an existing file.
     */
    OPEN,
    /**
     * Indicates save mode.  The file chooser
     *  will let the user pick an existing file, or type in a new
     *  filename.
     */
    SAVE,
    /**
     * Indicates an Open mode for
     *  selecting folders.  The file chooser will let the user pick an
     *  existing folder.
     */
    SELECT_FOLDER,
  }
  /**
   * These identify the various errors that can occur while calling
   * `GtkFileChooser` functions.
   */
  enum FileChooserError {
    /**
     * Indicates that a file does not exist.
     */
    NONEXISTENT,
    /**
     * Indicates a malformed filename.
     */
    BAD_FILENAME,
    /**
     * Indicates a duplicate path (e.g. when
     *  adding a bookmark).
     */
    ALREADY_EXISTS,
    /**
     * Indicates an incomplete hostname
     *  (e.g. "http://foo" without a slash after that).
     */
    INCOMPLETE_HOSTNAME,
  }
  /**
   * Describes changes in a filter in more detail and allows objects
   * using the filter to optimize refiltering items.
   *
   * If you are writing an implementation and are not sure which
   * value to pass, %GTK_FILTER_CHANGE_DIFFERENT is always a correct
   * choice.
   */
  enum FilterChange {
    /**
     * The filter change cannot be
     *   described with any of the other enumeration values.
     */
    DIFFERENT,
    /**
     * The filter is less strict than
     *   it was before: All items that it used to return %TRUE for
     *   still return %TRUE, others now may, too.
     */
    LESS_STRICT,
    /**
     * The filter is more strict than
     *   it was before: All items that it used to return %FALSE for
     *   still return %FALSE, others now may, too.
     */
    MORE_STRICT,
  }
  /**
   * Describes the known strictness of a filter.
   *
   * Note that for filters where the strictness is not known,
   * %GTK_FILTER_MATCH_SOME is always an acceptable value,
   * even if a filter does match all or no items.
   */
  enum FilterMatch {
    /**
     * The filter matches some items,
     *   gtk_filter_match() may return %TRUE or %FALSE
     */
    SOME,
    /**
     * The filter does not match any item,
     *   gtk_filter_match() will always return %FALSE.
     */
    NONE,
    /**
     * The filter matches all items,
     *   gtk_filter_match() will alays return %TRUE.
     */
    ALL,
  }
  /**
   * The level of granularity for the font selection.
   *
   * Depending on this value, the `PangoFontDescription` that
   * is returned by [method`Gtk`.FontDialogButton.get_font_desc]
   * will have more or less fields set.
   */
  enum FontLevel {
    /**
     * Select a font family
     */
    FAMILY,
    /**
     * Select a font face (i.e. a family and a style)
     */
    FACE,
    /**
     * Select a font (i.e. a face with a size, and possibly font variations)
     */
    FONT,
    /**
     * Select a font and font features
     */
    FEATURES,
  }
  /**
   * Represents the state of graphics offlodading.
   */
  enum GraphicsOffloadEnabled {
    /**
     * Graphics offloading is enabled.
     */
    ENABLED,
    /**
     * Graphics offloading is disabled.
     */
    DISABLED,
  }
  /**
   * Built-in icon sizes.
   *
   * Icon sizes default to being inherited. Where they cannot be
   * inherited, text size is the default.
   *
   * All widgets which use `GtkIconSize` set the normal-icons or
   * large-icons style classes correspondingly, and let themes
   * determine the actual size to be used with the
   * `-gtk-icon-size` CSS property.
   */
  enum IconSize {
    /**
     * Keep the size of the parent element
     */
    INHERIT,
    /**
     * Size similar to text size
     */
    NORMAL,
    /**
     * Large size, for example in an icon view
     */
    LARGE,
  }
  /**
   * Error codes for `GtkIconTheme` operations.
   */
  enum IconThemeError {
    /**
     * The icon specified does not exist in the theme
     */
    NOT_FOUND,
    /**
     * An unspecified error occurred.
     */
    FAILED,
  }
  /**
   * An enum for determining where a dropped item goes.
   */
  enum IconViewDropPosition {
    /**
     * no drop possible
     */
    NO_DROP,
    /**
     * dropped item replaces the item
     */
    DROP_INTO,
    /**
     * dropped item is inserted to the left
     */
    DROP_LEFT,
    /**
     * dropped item is inserted to the right
     */
    DROP_RIGHT,
    /**
     * dropped item is inserted above
     */
    DROP_ABOVE,
    /**
     * dropped item is inserted below
     */
    DROP_BELOW,
  }
  /**
   * Describes the image data representation used by a [class`Gtk`.Image].
   *
   * If you want to get the image from the widget, you can only get the
   * currently-stored representation; for instance, if the gtk_image_get_storage_type()
   * returns %GTK_IMAGE_PAINTABLE, then you can call gtk_image_get_paintable().
   *
   * For empty images, you can request any storage type (call any of the "get"
   * functions), but they will all return %NULL values.
   */
  enum ImageType {
    /**
     * there is no image displayed by the widget
     */
    EMPTY,
    /**
     * the widget contains a named icon
     */
    ICON_NAME,
    /**
     * the widget contains a `GIcon`
     */
    GICON,
    /**
     * the widget contains a `GdkPaintable`
     */
    PAINTABLE,
  }
  /**
   * Describes primary purpose of the input widget.
   *
   * This information is useful for on-screen keyboards and similar input
   * methods to decide which keys should be presented to the user.
   *
   * Note that the purpose is not meant to impose a totally strict rule
   * about allowed characters, and does not replace input validation.
   * It is fine for an on-screen keyboard to let the user override the
   * character set restriction that is expressed by the purpose. The
   * application is expected to validate the entry contents, even if
   * it specified a purpose.
   *
   * The difference between %GTK_INPUT_PURPOSE_DIGITS and
   * %GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits
   * while the latter also some punctuation (like commas or points, plus,
   * minus) and “e” or “E” as in 3.14E+000.
   *
   * This enumeration may be extended in the future; input methods should
   * interpret unknown values as “free form”.
   */
  enum InputPurpose {
    /**
     * Allow any character
     */
    FREE_FORM,
    /**
     * Allow only alphabetic characters
     */
    ALPHA,
    /**
     * Allow only digits
     */
    DIGITS,
    /**
     * Edited field expects numbers
     */
    NUMBER,
    /**
     * Edited field expects phone number
     */
    PHONE,
    /**
     * Edited field expects URL
     */
    URL,
    /**
     * Edited field expects email address
     */
    EMAIL,
    /**
     * Edited field expects the name of a person
     */
    NAME,
    /**
     * Like %GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden
     */
    PASSWORD,
    /**
     * Like %GTK_INPUT_PURPOSE_DIGITS, but characters are hidden
     */
    PIN,
    /**
     * Allow any character, in addition to control codes
     */
    TERMINAL,
  }
  /**
   * The different methods to handle text in #GtkInscription when it doesn't
   * fit the available space.
   */
  enum InscriptionOverflow {
    /**
     * Clip the remaining text
     */
    CLIP,
    /**
     * Omit characters at the start of the text
     */
    ELLIPSIZE_START,
    /**
     * Omit characters at the middle of the text
     */
    ELLIPSIZE_MIDDLE,
    /**
     * Omit characters at the end of the text
     */
    ELLIPSIZE_END,
  }
  /**
   * Used for justifying the text inside a [class`Label]` widget.
   */
  enum Justification {
    /**
     * The text is placed at the left edge of the label.
     */
    LEFT,
    /**
     * The text is placed at the right edge of the label.
     */
    RIGHT,
    /**
     * The text is placed in the center of the label.
     */
    CENTER,
    /**
     * The text is placed is distributed across the label.
     */
    FILL,
  }
  /**
   * Describes how [class`LevelBar]` contents should be rendered.
   *
   * Note that this enumeration could be extended with additional modes
   * in the future.
   */
  enum LevelBarMode {
    /**
     * the bar has a continuous mode
     */
    CONTINUOUS,
    /**
     * the bar has a discrete mode
     */
    DISCRETE,
  }
  /**
   * The type of license for an application.
   *
   * This enumeration can be expanded at later date.
   */
  enum License {
    /**
     * No license specified
     */
    UNKNOWN,
    /**
     * A license text is going to be specified by the
     *   developer
     */
    CUSTOM,
    /**
     * The GNU General Public License, version 2.0 or later
     */
    GPL_2_0,
    /**
     * The GNU General Public License, version 3.0 or later
     */
    GPL_3_0,
    /**
     * The GNU Lesser General Public License, version 2.1 or later
     */
    LGPL_2_1,
    /**
     * The GNU Lesser General Public License, version 3.0 or later
     */
    LGPL_3_0,
    /**
     * The BSD standard license
     */
    BSD,
    /**
     * The MIT/X11 standard license
     */
    MIT_X11,
    /**
     * The Artistic License, version 2.0
     */
    ARTISTIC,
    /**
     * The GNU General Public License, version 2.0 only
     */
    GPL_2_0_ONLY,
    /**
     * The GNU General Public License, version 3.0 only
     */
    GPL_3_0_ONLY,
    /**
     * The GNU Lesser General Public License, version 2.1 only
     */
    LGPL_2_1_ONLY,
    /**
     * The GNU Lesser General Public License, version 3.0 only
     */
    LGPL_3_0_ONLY,
    /**
     * The GNU Affero General Public License, version 3.0 or later
     */
    AGPL_3_0,
    /**
     * The GNU Affero General Public License, version 3.0 only
     */
    AGPL_3_0_ONLY,
    /**
     * The 3-clause BSD licence
     */
    BSD_3,
    /**
     * The Apache License, version 2.0
     */
    APACHE_2_0,
    /**
     * The Mozilla Public License, version 2.0
     */
    MPL_2_0,
    /**
     * Zero-Clause BSD license
     */
    TODO_0BSD,
  }
  /**
   * Used to configure the focus behavior in the `GTK_DIR_TAB_FORWARD`
   * and `GTK_DIR_TAB_BACKWARD` direction, like the <kbd>Tab</kbd> key
   * in a [class`Gtk`.ListView].
   */
  enum ListTabBehavior {
    /**
     * Cycle through all focusable items of the list
     */
    ALL,
    /**
     * Cycle through a single list element, then move
     *   focus out of the list. Moving focus between items needs to be
     *   done with the arrow keys.
     */
    ITEM,
    /**
     * Cycle only through a single cell, then
     *   move focus out of the list. Moving focus between cells needs to
     *   be done with the arrow keys. This is only relevant for
     *   cell-based widgets like #GtkColumnView, otherwise it behaves
     *   like `GTK_LIST_TAB_ITEM`.
     */
    CELL,
  }
  /**
   * The type of message being displayed in a [class`MessageDialog]`.
   */
  enum MessageType {
    /**
     * Informational message
     */
    INFO,
    /**
     * Non-fatal warning message
     */
    WARNING,
    /**
     * Question requiring a choice
     */
    QUESTION,
    /**
     * Fatal error message
     */
    ERROR,
    /**
     * None of the above
     */
    OTHER,
  }
  /**
   * Passed as argument to various keybinding signals for moving the
   * cursor position.
   */
  enum MovementStep {
    /**
     * Move forward or back by graphemes
     */
    LOGICAL_POSITIONS,
    /**
     * Move left or right by graphemes
     */
    VISUAL_POSITIONS,
    /**
     * Move forward or back by words
     */
    WORDS,
    /**
     * Move up or down lines (wrapped lines)
     */
    DISPLAY_LINES,
    /**
     * Move to either end of a line
     */
    DISPLAY_LINE_ENDS,
    /**
     * Move up or down paragraphs (newline-ended lines)
     */
    PARAGRAPHS,
    /**
     * Move to either end of a paragraph
     */
    PARAGRAPH_ENDS,
    /**
     * Move by pages
     */
    PAGES,
    /**
     * Move to ends of the buffer
     */
    BUFFER_ENDS,
    /**
     * Move horizontally by pages
     */
    HORIZONTAL_PAGES,
  }
  /**
   * Options for selecting a different wrap mode for natural size
   * requests.
   *
   * See for example the [property`Gtk`.Label:natural-wrap-mode] property.
   */
  enum NaturalWrapMode {
    /**
     * Inherit the minimum size request.
     *   In particular, this should be used with %PANGO_WRAP_CHAR.
     */
    INHERIT,
    /**
     * Try not to wrap the text. This mode is the
     *   closest to GTK3's behavior but can lead to a wide label leaving
     *   lots of empty space below the text.
     */
    NONE,
    /**
     * Attempt to wrap at word boundaries. This
     *   is useful in particular when using %PANGO_WRAP_WORD_CHAR as the
     *   wrap mode.
     */
    WORD,
  }
  /**
   * The parameter used in the action signals of `GtkNotebook`.
   */
  enum NotebookTab {
    /**
     * the first tab in the notebook
     */
    FIRST,
    /**
     * the last tab in the notebook
     */
    LAST,
  }
  /**
   * Used to determine the layout of pages on a sheet when printing
   * multiple pages per sheet.
   */
  enum NumberUpLayout {
    /**
     * ![](layout-lrtb.png)
     */
    LRTB,
    /**
     * ![](layout-lrbt.png)
     */
    LRBT,
    /**
     * ![](layout-rltb.png)
     */
    RLTB,
    /**
     * ![](layout-rlbt.png)
     */
    RLBT,
    /**
     * ![](layout-tblr.png)
     */
    TBLR,
    /**
     * ![](layout-tbrl.png)
     */
    TBRL,
    /**
     * ![](layout-btlr.png)
     */
    BTLR,
    /**
     * ![](layout-btrl.png)
     */
    BTRL,
  }
  /**
   * Describes the way two values can be compared.
   *
   * These values can be used with a [callback`GLib`.CompareFunc]. However,
   * a `GCompareFunc` is allowed to return any integer values.
   * For converting such a value to a `GtkOrdering` value, use
   * [func`Gtk`.Ordering.from_cmpfunc].
   */
  enum Ordering {
    /**
     * the first value is smaller than the second
     */
    SMALLER,
    /**
     * the two values are equal
     */
    EQUAL,
    /**
     * the first value is larger than the second
     */
    LARGER,
  }
  /**
   * Represents the orientation of widgets and other objects.
   *
   * Typical examples are [class`Box]` or [class`GesturePan]`.
   */
  enum Orientation {
    /**
     * The element is in horizontal orientation.
     */
    HORIZONTAL,
    /**
     * The element is in vertical orientation.
     */
    VERTICAL,
  }
  /**
   * Defines how content overflowing a given area should be handled.
   *
   * This is used in [method`Gtk`.Widget.set_overflow]. The
   * [property`Gtk`.Widget:overflow] property is modeled after the
   * CSS overflow property, but implements it only partially.
   */
  enum Overflow {
    /**
     * No change is applied. Content is drawn at the specified
     *   position.
     */
    VISIBLE,
    /**
     * Content is clipped to the bounds of the area. Content
     *   outside the area is not drawn and cannot be interacted with.
     */
    HIDDEN,
  }
  /**
   * Represents the packing location of a children in its parent.
   *
   * See [class`WindowControls]` for example.
   */
  enum PackType {
    /**
     * The child is packed into the start of the widget
     */
    START,
    /**
     * The child is packed into the end of the widget
     */
    END,
  }
  /**
   * The type of a pad action.
   */
  enum PadActionType {
    /**
     * Action is triggered by a pad button
     */
    BUTTON,
    /**
     * Action is triggered by a pad ring
     */
    RING,
    /**
     * Action is triggered by a pad strip
     */
    STRIP,
  }
  /**
   * See also gtk_print_settings_set_orientation().
   */
  enum PageOrientation {
    /**
     * Portrait mode.
     */
    PORTRAIT,
    /**
     * Landscape mode.
     */
    LANDSCAPE,
    /**
     * Reverse portrait mode.
     */
    REVERSE_PORTRAIT,
    /**
     * Reverse landscape mode.
     */
    REVERSE_LANDSCAPE,
  }
  /**
   * See also gtk_print_job_set_page_set().
   */
  enum PageSet {
    /**
     * All pages.
     */
    ALL,
    /**
     * Even pages.
     */
    EVEN,
    /**
     * Odd pages.
     */
    ODD,
  }
  /**
   * Describes the panning direction of a [class`GesturePan]`.
   */
  enum PanDirection {
    /**
     * panned towards the left
     */
    LEFT,
    /**
     * panned towards the right
     */
    RIGHT,
    /**
     * panned upwards
     */
    UP,
    /**
     * panned downwards
     */
    DOWN,
  }
  /**
   * Determines how the size should be computed to achieve the one of the
   * visibility mode for the scrollbars.
   */
  enum PolicyType {
    /**
     * The scrollbar is always visible. The view size is
     *   independent of the content.
     */
    ALWAYS,
    /**
     * The scrollbar will appear and disappear as necessary.
     *   For example, when all of a `GtkTreeView` can not be seen.
     */
    AUTOMATIC,
    /**
     * The scrollbar should never appear. In this mode the
     *   content determines the size.
     */
    NEVER,
    /**
     * Don't show a scrollbar, but don't force the
     *   size to follow the content. This can be used e.g. to make multiple
     *   scrolled windows share a scrollbar.
     */
    EXTERNAL,
  }
  /**
   * Describes which edge of a widget a certain feature is positioned at.
   *
   * For examples, see the tabs of a [class`Notebook]`, or the label
   * of a [class`Scale]`.
   */
  enum PositionType {
    /**
     * The feature is at the left edge.
     */
    LEFT,
    /**
     * The feature is at the right edge.
     */
    RIGHT,
    /**
     * The feature is at the top edge.
     */
    TOP,
    /**
     * The feature is at the bottom edge.
     */
    BOTTOM,
  }
  /**
   * See also gtk_print_settings_set_duplex().
   */
  enum PrintDuplex {
    /**
     * No duplex.
     */
    SIMPLEX,
    /**
     * Horizontal duplex.
     */
    HORIZONTAL,
    /**
     * Vertical duplex.
     */
    VERTICAL,
  }
  /**
   * Error codes that identify various errors that can occur while
   * using the GTK printing support.
   */
  enum PrintError {
    /**
     * An unspecified error occurred.
     */
    GENERAL,
    /**
     * An internal error occurred.
     */
    INTERNAL_ERROR,
    /**
     * A memory allocation failed.
     */
    NOMEM,
    /**
     * An error occurred while loading a page setup
     *   or paper size from a key file.
     */
    INVALID_FILE,
  }
  /**
   * Determines what action the print operation should perform.
   *
   * A parameter of this typs is passed to [method`Gtk`.PrintOperation.run].
   */
  enum PrintOperationAction {
    /**
     * Show the print dialog.
     */
    PRINT_DIALOG,
    /**
     * Start to print without showing
     *   the print dialog, based on the current print settings.
     */
    PRINT,
    /**
     * Show the print preview.
     */
    PREVIEW,
    /**
     * Export to a file. This requires
     *   the export-filename property to be set.
     */
    EXPORT,
  }
  /**
   * The result of a print operation.
   *
   * A value of this type is returned by [method`Gtk`.PrintOperation.run].
   */
  enum PrintOperationResult {
    /**
     * An error has occurred.
     */
    ERROR,
    /**
     * The print settings should be stored.
     */
    APPLY,
    /**
     * The print operation has been canceled,
     *   the print settings should not be stored.
     */
    CANCEL,
    /**
     * The print operation is not complete
     *   yet. This value will only be returned when running asynchronously.
     */
    IN_PROGRESS,
  }
  /**
   * See also gtk_print_job_set_pages()
   */
  enum PrintPages {
    /**
     * All pages.
     */
    ALL,
    /**
     * Current page.
     */
    CURRENT,
    /**
     * Range of pages.
     */
    RANGES,
    /**
     * Selected pages.
     */
    SELECTION,
  }
  /**
   * See also gtk_print_settings_set_quality().
   */
  enum PrintQuality {
    /**
     * Low quality.
     */
    LOW,
    /**
     * Normal quality.
     */
    NORMAL,
    /**
     * High quality.
     */
    HIGH,
    /**
     * Draft quality.
     */
    DRAFT,
  }
  /**
   * The status gives a rough indication of the completion of a running
   * print operation.
   */
  enum PrintStatus {
    /**
     * The printing has not started yet; this
     *   status is set initially, and while the print dialog is shown.
     */
    INITIAL,
    /**
     * This status is set while the begin-print
     *   signal is emitted and during pagination.
     */
    PREPARING,
    /**
     * This status is set while the
     *   pages are being rendered.
     */
    GENERATING_DATA,
    /**
     * The print job is being sent off to the
     *   printer.
     */
    SENDING_DATA,
    /**
     * The print job has been sent to the printer,
     *   but is not printed for some reason, e.g. the printer may be stopped.
     */
    PENDING,
    /**
     * Some problem has occurred during
     *   printing, e.g. a paper jam.
     */
    PENDING_ISSUE,
    /**
     * The printer is processing the print job.
     */
    PRINTING,
    /**
     * The printing has been completed successfully.
     */
    FINISHED,
    /**
     * The printing has been aborted.
     */
    FINISHED_ABORTED,
  }
  /**
   * Describes limits of a [class`EventController]` for handling events
   * targeting other widgets.
   */
  enum PropagationLimit {
    /**
     * Events are handled regardless of what their
     *   target is.
     */
    NONE,
    /**
     * Events are only handled if their target
     *   is in the same [iface`Native]` as the event controllers widget. Note
     *   that some event types have two targets (origin and destination).
     */
    SAME_NATIVE,
  }
  /**
   * Describes the stage at which events are fed into a [class`EventController]`.
   */
  enum PropagationPhase {
    /**
     * Events are not delivered.
     */
    NONE,
    /**
     * Events are delivered in the capture phase. The
     *   capture phase happens before the bubble phase, runs from the toplevel down
     *   to the event widget. This option should only be used on containers that
     *   might possibly handle events before their children do.
     */
    CAPTURE,
    /**
     * Events are delivered in the bubble phase. The bubble
     *   phase happens after the capture phase, and before the default handlers
     *   are run. This phase runs from the event widget, up to the toplevel.
     */
    BUBBLE,
    /**
     * Events are delivered in the default widget event handlers,
     *   note that widget implementations must chain up on button, motion, touch and
     *   grab broken handlers for controllers in this phase to be run.
     */
    TARGET,
  }
  /**
   * Error codes for `GtkRecentManager` operations
   */
  enum RecentManagerError {
    /**
     * the URI specified does not exists in
     *   the recently used resources list.
     */
    NOT_FOUND,
    /**
     * the URI specified is not valid.
     */
    INVALID_URI,
    /**
     * the supplied string is not
     *   UTF-8 encoded.
     */
    INVALID_ENCODING,
    /**
     * no application has registered
     *   the specified item.
     */
    NOT_REGISTERED,
    /**
     * failure while reading the recently used
     *   resources file.
     */
    READ,
    /**
     * failure while writing the recently used
     *   resources file.
     */
    WRITE,
    /**
     * unspecified error.
     */
    UNKNOWN,
  }
  /**
   * Predefined values for use as response ids in gtk_dialog_add_button().
   *
   * All predefined values are negative; GTK leaves values of 0 or greater for
   * application-defined response ids.
   */
  enum ResponseType {
    /**
     * Returned if an action widget has no response id,
     *   or if the dialog gets programmatically hidden or destroyed
     */
    NONE,
    /**
     * Generic response id, not used by GTK dialogs
     */
    REJECT,
    /**
     * Generic response id, not used by GTK dialogs
     */
    ACCEPT,
    /**
     * Returned if the dialog is deleted
     */
    DELETE_EVENT,
    /**
     * Returned by OK buttons in GTK dialogs
     */
    OK,
    /**
     * Returned by Cancel buttons in GTK dialogs
     */
    CANCEL,
    /**
     * Returned by Close buttons in GTK dialogs
     */
    CLOSE,
    /**
     * Returned by Yes buttons in GTK dialogs
     */
    YES,
    /**
     * Returned by No buttons in GTK dialogs
     */
    NO,
    /**
     * Returned by Apply buttons in GTK dialogs
     */
    APPLY,
    /**
     * Returned by Help buttons in GTK dialogs
     */
    HELP,
  }
  /**
   * These enumeration values describe the possible transitions
   * when the child of a `GtkRevealer` widget is shown or hidden.
   */
  enum RevealerTransitionType {
    /**
     * No transition
     */
    NONE,
    /**
     * Fade in
     */
    CROSSFADE,
    /**
     * Slide in from the left
     */
    SLIDE_RIGHT,
    /**
     * Slide in from the right
     */
    SLIDE_LEFT,
    /**
     * Slide in from the bottom
     */
    SLIDE_UP,
    /**
     * Slide in from the top
     */
    SLIDE_DOWN,
    /**
     * Floop in from the left
     */
    SWING_RIGHT,
    /**
     * Floop in from the right
     */
    SWING_LEFT,
    /**
     * Floop in from the bottom
     */
    SWING_UP,
    /**
     * Floop in from the top
     */
    SWING_DOWN,
  }
  /**
   * Passed as argument to various keybinding signals.
   */
  enum ScrollStep {
    /**
     * Scroll in steps.
     */
    STEPS,
    /**
     * Scroll by pages.
     */
    PAGES,
    /**
     * Scroll to ends.
     */
    ENDS,
    /**
     * Scroll in horizontal steps.
     */
    HORIZONTAL_STEPS,
    /**
     * Scroll by horizontal pages.
     */
    HORIZONTAL_PAGES,
    /**
     * Scroll to the horizontal ends.
     */
    HORIZONTAL_ENDS,
  }
  /**
   * Scrolling types.
   */
  enum ScrollType {
    /**
     * No scrolling.
     */
    NONE,
    /**
     * Jump to new location.
     */
    JUMP,
    /**
     * Step backward.
     */
    STEP_BACKWARD,
    /**
     * Step forward.
     */
    STEP_FORWARD,
    /**
     * Page backward.
     */
    PAGE_BACKWARD,
    /**
     * Page forward.
     */
    PAGE_FORWARD,
    /**
     * Step up.
     */
    STEP_UP,
    /**
     * Step down.
     */
    STEP_DOWN,
    /**
     * Page up.
     */
    PAGE_UP,
    /**
     * Page down.
     */
    PAGE_DOWN,
    /**
     * Step to the left.
     */
    STEP_LEFT,
    /**
     * Step to the right.
     */
    STEP_RIGHT,
    /**
     * Page to the left.
     */
    PAGE_LEFT,
    /**
     * Page to the right.
     */
    PAGE_RIGHT,
    /**
     * Scroll to start.
     */
    START,
    /**
     * Scroll to end.
     */
    END,
  }
  /**
   * Defines the policy to be used in a scrollable widget when updating
   * the scrolled window adjustments in a given orientation.
   */
  enum ScrollablePolicy {
    /**
     * Scrollable adjustments are based on the minimum size
     */
    MINIMUM,
    /**
     * Scrollable adjustments are based on the natural size
     */
    NATURAL,
  }
  /**
   * Used to control what selections users are allowed to make.
   */
  enum SelectionMode {
    /**
     * No selection is possible.
     */
    NONE,
    /**
     * Zero or one element may be selected.
     */
    SINGLE,
    /**
     * Exactly one element is selected.
     *   In some circumstances, such as initially or during a search
     *   operation, it’s possible for no element to be selected with
     *   %GTK_SELECTION_BROWSE. What is really enforced is that the user
     *   can’t deselect a currently selected element except by selecting
     *   another element.
     */
    BROWSE,
    /**
     * Any number of elements may be selected.
     *   The Ctrl key may be used to enlarge the selection, and Shift
     *   key to select between the focus and the child pointed to.
     *   Some widgets may also allow Click-drag to select a range of elements.
     */
    MULTIPLE,
  }
  /**
   * Determines how GTK handles the sensitivity of various controls,
   * such as combo box buttons.
   */
  enum SensitivityType {
    /**
     * The control is made insensitive if no
     *   action can be triggered
     */
    AUTO,
    /**
     * The control is always sensitive
     */
    ON,
    /**
     * The control is always insensitive
     */
    OFF,
  }
  /**
   * Describes where [class`Shortcut]`s added to a
   * [class`ShortcutController]` get handled.
   */
  enum ShortcutScope {
    /**
     * Shortcuts are handled inside
     *   the widget the controller belongs to.
     */
    LOCAL,
    /**
     * Shortcuts are handled by
     *   the first ancestor that is a [iface`ShortcutManager]`
     */
    MANAGED,
    /**
     * Shortcuts are handled by
     *   the root widget.
     */
    GLOBAL,
  }
  /**
   * GtkShortcutType specifies the kind of shortcut that is being described.
   *
   * More values may be added to this enumeration over time.
   */
  enum ShortcutType {
    /**
     * The shortcut is a keyboard accelerator. The GtkShortcutsShortcut:accelerator
     *   property will be used.
     */
    ACCELERATOR,
    /**
     * The shortcut is a pinch gesture. GTK provides an icon and subtitle.
     */
    GESTURE_PINCH,
    /**
     * The shortcut is a stretch gesture. GTK provides an icon and subtitle.
     */
    GESTURE_STRETCH,
    /**
     * The shortcut is a clockwise rotation gesture. GTK provides an icon and subtitle.
     */
    GESTURE_ROTATE_CLOCKWISE,
    /**
     * The shortcut is a counterclockwise rotation gesture. GTK provides an icon and subtitle.
     */
    GESTURE_ROTATE_COUNTERCLOCKWISE,
    /**
     * The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
     */
    GESTURE_TWO_FINGER_SWIPE_LEFT,
    /**
     * The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
     */
    GESTURE_TWO_FINGER_SWIPE_RIGHT,
    /**
     * The shortcut is a gesture. The GtkShortcutsShortcut:icon property will be
     *   used.
     */
    GESTURE,
    /**
     * The shortcut is a swipe gesture. GTK provides an icon and subtitle.
     */
    GESTURE_SWIPE_LEFT,
    /**
     * The shortcut is a swipe gesture. GTK provides an icon and subtitle.
     */
    GESTURE_SWIPE_RIGHT,
  }
  /**
   * The mode of the size group determines the directions in which the size
   * group affects the requested sizes of its component widgets.
   */
  enum SizeGroupMode {
    /**
     * group has no effect
     */
    NONE,
    /**
     * group affects horizontal requisition
     */
    HORIZONTAL,
    /**
     * group affects vertical requisition
     */
    VERTICAL,
    /**
     * group affects both horizontal and vertical requisition
     */
    BOTH,
  }
  /**
   * Specifies a preference for height-for-width or
   * width-for-height geometry management.
   */
  enum SizeRequestMode {
    /**
     * Prefer height-for-width geometry management
     */
    HEIGHT_FOR_WIDTH,
    /**
     * Prefer width-for-height geometry management
     */
    WIDTH_FOR_HEIGHT,
    /**
     * Don’t trade height-for-width or width-for-height
     */
    CONSTANT_SIZE,
  }
  /**
   * Determines the direction of a sort.
   */
  enum SortType {
    /**
     * Sorting is in ascending order.
     */
    ASCENDING,
    /**
     * Sorting is in descending order.
     */
    DESCENDING,
  }
  /**
   * Describes changes in a sorter in more detail and allows users
   * to optimize resorting.
   */
  enum SorterChange {
    /**
     * The sorter change cannot be described
     *   by any of the other enumeration values
     */
    DIFFERENT,
    /**
     * The sort order was inverted. Comparisons
     *   that returned %GTK_ORDERING_SMALLER now return %GTK_ORDERING_LARGER
     *   and vice versa. Other comparisons return the same values as before.
     */
    INVERTED,
    /**
     * The sorter is less strict: Comparisons
     *   may now return %GTK_ORDERING_EQUAL that did not do so before.
     */
    LESS_STRICT,
    /**
     * The sorter is more strict: Comparisons
     *   that did return %GTK_ORDERING_EQUAL may not do so anymore.
     */
    MORE_STRICT,
  }
  /**
   * Describes the type of order that a `GtkSorter` may produce.
   */
  enum SorterOrder {
    /**
     * A partial order. Any `GtkOrdering` is possible.
     */
    PARTIAL,
    /**
     * No order, all elements are considered equal.
     *   gtk_sorter_compare() will only return %GTK_ORDERING_EQUAL.
     */
    NONE,
    /**
     * A total order. gtk_sorter_compare() will only
     *   return %GTK_ORDERING_EQUAL if an item is compared with itself. Two
     *   different items will never cause this value to be returned.
     */
    TOTAL,
  }
  /**
   * Determines whether the spin button displays values outside the adjustment
   * bounds.
   *
   * See [method`Gtk`.SpinButton.set_update_policy].
   */
  enum SpinButtonUpdatePolicy {
    /**
     * When refreshing your `GtkSpinButton`, the value is
     *   always displayed
     */
    ALWAYS,
    /**
     * When refreshing your `GtkSpinButton`, the value is
     *   only displayed if it is valid within the bounds of the spin button's
     *   adjustment
     */
    IF_VALID,
  }
  /**
   * The values of the GtkSpinType enumeration are used to specify the
   * change to make in gtk_spin_button_spin().
   */
  enum SpinType {
    /**
     * Increment by the adjustments step increment.
     */
    STEP_FORWARD,
    /**
     * Decrement by the adjustments step increment.
     */
    STEP_BACKWARD,
    /**
     * Increment by the adjustments page increment.
     */
    PAGE_FORWARD,
    /**
     * Decrement by the adjustments page increment.
     */
    PAGE_BACKWARD,
    /**
     * Go to the adjustments lower bound.
     */
    HOME,
    /**
     * Go to the adjustments upper bound.
     */
    END,
    /**
     * Change by a specified amount.
     */
    USER_DEFINED,
  }
  /**
   * Possible transitions between pages in a `GtkStack` widget.
   *
   * New values may be added to this enumeration over time.
   */
  enum StackTransitionType {
    /**
     * No transition
     */
    NONE,
    /**
     * A cross-fade
     */
    CROSSFADE,
    /**
     * Slide from left to right
     */
    SLIDE_RIGHT,
    /**
     * Slide from right to left
     */
    SLIDE_LEFT,
    /**
     * Slide from bottom up
     */
    SLIDE_UP,
    /**
     * Slide from top down
     */
    SLIDE_DOWN,
    /**
     * Slide from left or right according to the children order
     */
    SLIDE_LEFT_RIGHT,
    /**
     * Slide from top down or bottom up according to the order
     */
    SLIDE_UP_DOWN,
    /**
     * Cover the old page by sliding up
     */
    OVER_UP,
    /**
     * Cover the old page by sliding down
     */
    OVER_DOWN,
    /**
     * Cover the old page by sliding to the left
     */
    OVER_LEFT,
    /**
     * Cover the old page by sliding to the right
     */
    OVER_RIGHT,
    /**
     * Uncover the new page by sliding up
     */
    UNDER_UP,
    /**
     * Uncover the new page by sliding down
     */
    UNDER_DOWN,
    /**
     * Uncover the new page by sliding to the left
     */
    UNDER_LEFT,
    /**
     * Uncover the new page by sliding to the right
     */
    UNDER_RIGHT,
    /**
     * Cover the old page sliding up or uncover the new page sliding down, according to order
     */
    OVER_UP_DOWN,
    /**
     * Cover the old page sliding down or uncover the new page sliding up, according to order
     */
    OVER_DOWN_UP,
    /**
     * Cover the old page sliding left or uncover the new page sliding right, according to order
     */
    OVER_LEFT_RIGHT,
    /**
     * Cover the old page sliding right or uncover the new page sliding left, according to order
     */
    OVER_RIGHT_LEFT,
    /**
     * Pretend the pages are sides of a cube and rotate that cube to the left
     */
    ROTATE_LEFT,
    /**
     * Pretend the pages are sides of a cube and rotate that cube to the right
     */
    ROTATE_RIGHT,
    /**
     * Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
     */
    ROTATE_LEFT_RIGHT,
  }
  /**
   * Specifies how search strings are matched inside text.
   */
  enum StringFilterMatchMode {
    /**
     * The search string and
     *   text must match exactly.
     */
    EXACT,
    /**
     * The search string
     *   must be contained as a substring inside the text.
     */
    SUBSTRING,
    /**
     * The text must begin
     *   with the search string.
     */
    PREFIX,
  }
  /**
   * The indexes of colors passed to symbolic color rendering, such as
   * [vfunc`Gtk`.SymbolicPaintable.snapshot_symbolic].
   *
   * More values may be added over time.
   */
  enum SymbolicColor {
    /**
     * The default foreground color
     */
    FOREGROUND,
    /**
     * Indication color for errors
     */
    ERROR,
    /**
     * Indication color for warnings
     */
    WARNING,
    /**
     * Indication color for success
     */
    SUCCESS,
  }
  /**
   * Values that can be passed to the [vfunc`Gtk`.Widget.system_setting_changed]
   * vfunc.
   *
   * The values indicate which system setting has changed.
   * Widgets may need to drop caches, or react otherwise.
   *
   * Most of the values correspond to [class`Settings]` properties.
   *
   * More values may be added over time.
   */
  enum SystemSetting {
    /**
     * the [property`Gtk`.Settings:gtk-xft-dpi] setting has changed
     */
    DPI,
    /**
     * The [property`Gtk`.Settings:gtk-font-name] setting has changed
     */
    FONT_NAME,
    /**
     * The font configuration has changed in a way that
     *   requires text to be redrawn. This can be any of the
     *   [property`Gtk`.Settings:gtk-xft-antialias],
     *   [property`Gtk`.Settings:gtk-xft-hinting],
     *   [property`Gtk`.Settings:gtk-xft-hintstyle],
     *   [property`Gtk`.Settings:gtk-xft-rgba] or
     *   [property`Gtk`.Settings:gtk-fontconfig-timestamp] settings
     */
    FONT_CONFIG,
    /**
     * The display has changed
     */
    DISPLAY,
    /**
     * The icon theme has changed in a way that requires
     *   icons to be looked up again
     */
    ICON_THEME,
  }
  /**
   * Reading directions for text.
   */
  enum TextDirection {
    /**
     * No direction.
     */
    NONE,
    /**
     * Left to right text direction.
     */
    LTR,
    /**
     * Right to left text direction.
     */
    RTL,
  }
  /**
   * Granularity types that extend the text selection. Use the
   * `GtkTextView::extend-selection` signal to customize the selection.
   */
  enum TextExtendSelection {
    /**
     * Selects the current word. It is triggered by
     *   a double-click for example.
     */
    WORD,
    /**
     * Selects the current line. It is triggered by
     *   a triple-click for example.
     */
    LINE,
  }
  /**
   * Used to reference the layers of `GtkTextView` for the purpose of customized
   * drawing with the ::snapshot_layer vfunc.
   */
  enum TextViewLayer {
    /**
     * The layer rendered below the text (but above the background).
     */
    BELOW_TEXT,
    /**
     * The layer rendered above the text.
     */
    ABOVE_TEXT,
  }
  /**
   * Used to reference the parts of `GtkTextView`.
   */
  enum TextWindowType {
    /**
     * Window that floats over scrolling areas.
     */
    WIDGET,
    /**
     * Scrollable text window.
     */
    TEXT,
    /**
     * Left side border window.
     */
    LEFT,
    /**
     * Right side border window.
     */
    RIGHT,
    /**
     * Top border window.
     */
    TOP,
    /**
     * Bottom border window.
     */
    BOTTOM,
  }
  /**
   * The sizing method the column uses to determine its width.  Please note
   * that %GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
   * can make columns appear choppy.
   */
  enum TreeViewColumnSizing {
    /**
     * Columns only get bigger in reaction to changes in the model
     */
    GROW_ONLY,
    /**
     * Columns resize to be the optimal size every time the model changes.
     */
    AUTOSIZE,
    /**
     * Columns are a fixed numbers of pixels wide.
     */
    FIXED,
  }
  /**
   * An enum for determining where a dropped row goes.
   */
  enum TreeViewDropPosition {
    /**
     * dropped row is inserted before
     */
    BEFORE,
    /**
     * dropped row is inserted after
     */
    AFTER,
    /**
     * dropped row becomes a child or is inserted before
     */
    INTO_OR_BEFORE,
    /**
     * dropped row becomes a child or is inserted after
     */
    INTO_OR_AFTER,
  }
  /**
   * Used to indicate which grid lines to draw in a tree view.
   */
  enum TreeViewGridLines {
    /**
     * No grid lines.
     */
    NONE,
    /**
     * Horizontal grid lines.
     */
    HORIZONTAL,
    /**
     * Vertical grid lines.
     */
    VERTICAL,
    /**
     * Horizontal and vertical grid lines.
     */
    BOTH,
  }
  /**
   * See also gtk_print_settings_set_paper_width().
   */
  enum Unit {
    /**
     * No units.
     */
    NONE,
    /**
     * Dimensions in points.
     */
    POINTS,
    /**
     * Dimensions in inches.
     */
    INCH,
    /**
     * Dimensions in millimeters
     */
    MM,
  }
  /**
   * Describes a type of line wrapping.
   */
  enum WrapMode {
    /**
     * do not wrap lines; just make the text area wider
     */
    NONE,
    /**
     * wrap text, breaking lines anywhere the cursor can
     *   appear (between characters, usually - if you want to be technical,
     *   between graphemes, see pango_get_log_attrs())
     */
    CHAR,
    /**
     * wrap text, breaking lines in between words
     */
    WORD,
    /**
     * wrap text, breaking lines in between words, or if
     *   that is not enough, also between graphemes
     */
    WORD_CHAR,
  }
  /**
   * Types of user actions that may be blocked by `GtkApplication`.
   *
   * See [method`Gtk`.Application.inhibit].
   * @bitfield
   */
  enum ApplicationInhibitFlags {
    /**
     * Inhibit ending the user session
     *   by logging out or by shutting down the computer
     */
    LOGOUT,
    /**
     * Inhibit user switching
     */
    SWITCH,
    /**
     * Inhibit suspending the
     *   session or computer
     */
    SUSPEND,
    /**
     * Inhibit the session being
     *   marked as idle (and possibly locked)
     */
    IDLE,
  }
  /**
   * The list of flags that can be passed to gtk_builder_create_closure().
   *
   * New values may be added in the future for new features, so external
   * implementations of [iface`Gtk`.BuilderScope] should test the flags
   * for unknown values and raise a %GTK_BUILDER_ERROR_INVALID_ATTRIBUTE error
   * when they encounter one.
   * @bitfield
   */
  enum BuilderClosureFlags {
    /**
     * The closure should be created swapped. See
     *   g_cclosure_new_swap() for details.
     */
    SWAPPED,
  }
  /**
   * Tells how a cell is to be rendered.
   * @bitfield
   */
  enum CellRendererState {
    /**
     * The cell is currently selected, and
     *  probably has a selection colored background to render to.
     */
    SELECTED,
    /**
     * The mouse is hovering over the cell.
     */
    PRELIT,
    /**
     * The cell is drawn in an insensitive manner
     */
    INSENSITIVE,
    /**
     * The cell is in a sorted row
     */
    SORTED,
    /**
     * The cell is in the focus row.
     */
    FOCUSED,
    /**
     * The cell is in a row that can be expanded
     */
    EXPANDABLE,
    /**
     * The cell is in a row that is expanded
     */
    EXPANDED,
  }
  /**
   * Flags to use with gtk_set_debug_flags().
   *
   * Settings these flags causes GTK to print out different
   * types of debugging information. Some of these flags are
   * only available when GTK has been configured with `-Ddebug=true`.
   * @bitfield
   */
  enum DebugFlags {
    /**
     * Information about GtkTextView
     */
    TEXT,
    /**
     * Information about GtkTreeView
     */
    TREE,
    /**
     * Information about keyboard shortcuts
     */
    KEYBINDINGS,
    /**
     * Information about modules and extensions
     */
    MODULES,
    /**
     * Information about size allocation
     */
    GEOMETRY,
    /**
     * Information about icon themes
     */
    ICONTHEME,
    /**
     * Information about printing
     */
    PRINTING,
    /**
     * Trace GtkBuilder operation
     */
    BUILDER,
    /**
     * Information about size requests
     */
    SIZE_REQUEST,
    /**
     * Disable the style property cache
     */
    NO_CSS_CACHE,
    /**
     * Open the GTK inspector
     */
    INTERACTIVE,
    /**
     * Information about actions and menu models
     */
    ACTIONS,
    /**
     * Information from layout managers
     */
    LAYOUT,
    /**
     * Include debug render nodes in the generated snapshots
     */
    SNAPSHOT,
    /**
     * Information from the constraints solver
     */
    CONSTRAINTS,
    /**
     * Log unused GtkBuilder objects
     */
    BUILDER_OBJECTS,
    /**
     * Information about accessibility state changes
     */
    A11Y,
    /**
     * Information about icon fallback.
     */
    ICONFALLBACK,
    /**
     * Inverts the default text-direction.
     */
    INVERT_TEXT_DIR,
  }
  /**
   * Flags used to influence dialog construction.
   * @bitfield
   */
  enum DialogFlags {
    /**
     * Make the constructed dialog modal
     */
    MODAL,
    /**
     * Destroy the dialog when its parent is destroyed
     */
    DESTROY_WITH_PARENT,
    /**
     * Create dialog with actions in header
     *   bar instead of action area
     */
    USE_HEADER_BAR,
  }
  /**
   * Describes the behavior of a `GtkEventControllerScroll`.
   * @bitfield
   */
  enum EventControllerScrollFlags {
    /**
     * Don't emit scroll.
     */
    NONE,
    /**
     * Emit scroll with vertical deltas.
     */
    VERTICAL,
    /**
     * Emit scroll with horizontal deltas.
     */
    HORIZONTAL,
    /**
     * Only emit deltas that are multiples of 1.
     */
    DISCRETE,
    /**
     * Emit ::decelerate after continuous scroll finishes.
     */
    KINETIC,
    /**
     * Emit scroll on both axes.
     */
    BOTH_AXES,
  }
  /**
   * Specifies the granularity of font selection
   * that is desired in a `GtkFontChooser`.
   *
   * This enumeration may be extended in the future; applications should
   * ignore unknown values.
   * @bitfield
   */
  enum FontChooserLevel {
    /**
     * Allow selecting a font family
     */
    FAMILY,
    /**
     * Allow selecting a specific font face
     */
    STYLE,
    /**
     * Allow selecting a specific font size
     */
    SIZE,
    /**
     * Allow changing OpenType font variation axes
     */
    VARIATIONS,
    /**
     * Allow selecting specific OpenType font features
     */
    FEATURES,
  }
  /**
   * Used to specify options for gtk_icon_theme_lookup_icon().
   * @bitfield
   */
  enum IconLookupFlags {
    /**
     * Try to always load regular icons, even
     *   when symbolic icon names are given
     */
    FORCE_REGULAR,
    /**
     * Try to always load symbolic icons, even
     *   when regular icon names are given
     */
    FORCE_SYMBOLIC,
    /**
     * Starts loading the texture in the background
     *   so it is ready when later needed.
     */
    PRELOAD,
  }
  /**
   * Describes hints that might be taken into account by input methods
   * or applications.
   *
   * Note that input methods may already tailor their behaviour according
   * to the [enum`InputPurpose]` of the entry.
   *
   * Some common sense is expected when using these flags - mixing
   * %GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.
   *
   * This enumeration may be extended in the future; input methods should
   * ignore unknown values.
   * @bitfield
   */
  enum InputHints {
    /**
     * No special behaviour suggested
     */
    NONE,
    /**
     * Suggest checking for typos
     */
    SPELLCHECK,
    /**
     * Suggest not checking for typos
     */
    NO_SPELLCHECK,
    /**
     * Suggest word completion
     */
    WORD_COMPLETION,
    /**
     * Suggest to convert all text to lowercase
     */
    LOWERCASE,
    /**
     * Suggest to capitalize all text
     */
    UPPERCASE_CHARS,
    /**
     * Suggest to capitalize the first
     *   character of each word
     */
    UPPERCASE_WORDS,
    /**
     * Suggest to capitalize the
     *   first word of each sentence
     */
    UPPERCASE_SENTENCES,
    /**
     * Suggest to not show an onscreen keyboard
     *   (e.g for a calculator that already has all the keys).
     */
    INHIBIT_OSK,
    /**
     * The text is vertical
     */
    VERTICAL_WRITING,
    /**
     * Suggest offering Emoji support
     */
    EMOJI,
    /**
     * Suggest not offering Emoji support
     */
    NO_EMOJI,
    /**
     * Request that the input method should not
     *    update personalized data (like typing history)
     */
    PRIVATE,
  }
  /**
   * List of actions to perform when scrolling to items in
   * a list widget.
   * @bitfield
   */
  enum ListScrollFlags {
    /**
     * Don't do anything extra
     */
    NONE,
    /**
     * Focus the target item
     */
    FOCUS,
    /**
     * Select the target item and
     *   unselect all other items.
     */
    SELECT,
  }
  /**
   * Flags that influence the behavior of [method`Widget`.pick].
   * @bitfield
   */
  enum PickFlags {
    /**
     * The default behavior, include widgets that are receiving events
     */
    DEFAULT,
    /**
     * Include widgets that are insensitive
     */
    INSENSITIVE,
    /**
     * Include widgets that are marked as non-targetable. See [property`Widget:`can-target]
     */
    NON_TARGETABLE,
  }
  /**
   * Flags that affect how [class`Gtk`.PopoverMenu] widgets built from
   * a [class`Gio`.MenuModel] are created and displayed.
   * @bitfield
   */
  enum PopoverMenuFlags {
    /**
     * Submenus are presented as sliding submenus that replace the main menu.
     */
    SLIDING,
    /**
     * Submenus are presented as traditional, nested
     *   popovers.
     */
    NESTED,
  }
  /**
   * Specifies which features the print dialog should offer.
   *
   * If neither %GTK_PRINT_CAPABILITY_GENERATE_PDF nor
   * %GTK_PRINT_CAPABILITY_GENERATE_PS is specified, GTK assumes that all
   * formats are supported.
   * @bitfield
   */
  enum PrintCapabilities {
    /**
     * Print dialog will offer printing even/odd pages.
     */
    PAGE_SET,
    /**
     * Print dialog will allow to print multiple copies.
     */
    COPIES,
    /**
     * Print dialog will allow to collate multiple copies.
     */
    COLLATE,
    /**
     * Print dialog will allow to print pages in reverse order.
     */
    REVERSE,
    /**
     * Print dialog will allow to scale the output.
     */
    SCALE,
    /**
     * The program will send the document to
     *   the printer in PDF format
     */
    GENERATE_PDF,
    /**
     * The program will send the document to
     *   the printer in Postscript format
     */
    GENERATE_PS,
    /**
     * Print dialog will offer a preview
     */
    PREVIEW,
    /**
     * Print dialog will offer printing multiple
     *   pages per sheet
     */
    NUMBER_UP,
    /**
     * Print dialog will allow to rearrange
     *   pages when printing multiple pages per sheet
     */
    NUMBER_UP_LAYOUT,
  }
  /**
   * List of flags that can be passed to action activation.
   *
   * More flags may be added in the future.
   * @bitfield
   */
  enum ShortcutActionFlags {
    /**
     * The action is the only
     *   action that can be activated. If this flag is not set,
     *   a future activation may select a different action.
     */
    EXCLUSIVE,
  }
  /**
   * Describes a widget state.
   *
   * Widget states are used to match the widget against CSS pseudo-classes.
   * Note that GTK extends the regular CSS classes and sometimes uses
   * different names.
   * @bitfield
   */
  enum StateFlags {
    /**
     * State during normal operation
     */
    NORMAL,
    /**
     * Widget is active
     */
    ACTIVE,
    /**
     * Widget has a mouse pointer over it
     */
    PRELIGHT,
    /**
     * Widget is selected
     */
    SELECTED,
    /**
     * Widget is insensitive
     */
    INSENSITIVE,
    /**
     * Widget is inconsistent
     */
    INCONSISTENT,
    /**
     * Widget has the keyboard focus
     */
    FOCUSED,
    /**
     * Widget is in a background toplevel window
     */
    BACKDROP,
    /**
     * Widget is in left-to-right text direction
     */
    DIR_LTR,
    /**
     * Widget is in right-to-left text direction
     */
    DIR_RTL,
    /**
     * Widget is a link
     */
    LINK,
    /**
     * The location the widget points to has already been visited
     */
    VISITED,
    /**
     * Widget is checked
     */
    CHECKED,
    /**
     * Widget is highlighted as a drop target for DND
     */
    DROP_ACTIVE,
    /**
     * Widget has the visible focus
     */
    FOCUS_VISIBLE,
    /**
     * Widget contains the keyboard focus
     */
    FOCUS_WITHIN,
  }
  /**
   * Flags that modify the behavior of gtk_style_context_to_string().
   *
   * New values may be added to this enumeration.
   * @bitfield
   */
  enum StyleContextPrintFlags {
    /**
     * Default value.
     */
    NONE,
    /**
     * Print the entire tree of
     *   CSS nodes starting at the style context's node
     */
    RECURSE,
    /**
     * Show the values of the
     *   CSS properties for each node
     */
    SHOW_STYLE,
    /**
     * Show information about
     *   what changes affect the styles
     */
    SHOW_CHANGE,
  }
  /**
   * Flags affecting how a search is done.
   *
   * If neither %GTK_TEXT_SEARCH_VISIBLE_ONLY nor %GTK_TEXT_SEARCH_TEXT_ONLY are
   * enabled, the match must be exact; the special 0xFFFC character will match
   * embedded paintables or child widgets.
   * @bitfield
   */
  enum TextSearchFlags {
    /**
     * Search only visible data. A search match may
     * have invisible text interspersed.
     */
    VISIBLE_ONLY,
    /**
     * Search only text. A match may have paintables or
     * child widgets mixed inside the matched range.
     */
    TEXT_ONLY,
    /**
     * The text will be matched regardless of
     * what case it is in.
     */
    CASE_INSENSITIVE,
  }
  /**
   * These flags indicate various properties of a `GtkTreeModel`.
   *
   * They are returned by [method`Gtk`.TreeModel.get_flags], and must be
   * static for the lifetime of the object. A more complete description
   * of %GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
   * this section.
   * @bitfield
   */
  enum TreeModelFlags {
    /**
     * iterators survive all signals
     *   emitted by the tree
     */
    ITERS_PERSIST,
    /**
     * the model is a list only, and never
     *   has children
     */
    LIST_ONLY,
  }
  /**
   * An attribute for the background color, expressed as an RGB value
   * encoded in a string using the format: `{r8},{g8},{b8}`.
   */
  const ACCESSIBLE_ATTRIBUTE_BACKGROUND: string
  /**
   * An attribute for the font family name.
   */
  const ACCESSIBLE_ATTRIBUTE_FAMILY: string
  /**
   * An attribute for the foreground color, expressed as an RGB value
   * encoded in a string using the format: `{r8},{g8},{b8}`.
   */
  const ACCESSIBLE_ATTRIBUTE_FOREGROUND: string
  /**
   * An attribute for the overline style.
   *
   * Possible values are:
   *
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE]
   */
  const ACCESSIBLE_ATTRIBUTE_OVERLINE: string
  /**
   * The "none" overline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE].
   */
  const ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE: string
  /**
   * The "single" overline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE].
   */
  const ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE: string
  /**
   * An attribute for the font size, expressed in points.
   */
  const ACCESSIBLE_ATTRIBUTE_SIZE: string
  /**
   * An attribute for the font stretch type.
   *
   * Possible values are:
   *
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED]
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH: string
  /**
   * The "condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED: string
  /**
   * The "expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_EXPANDED: string
  /**
   * The "extra condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED: string
  /**
   * The "extra expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_EXPANDED: string
  /**
   * The "normal" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_NORMAL: string
  /**
   * The "semi condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED: string
  /**
   * The "semi expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_EXPANDED: string
  /**
   * The "ultra condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED: string
  /**
   * The "ultra expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
   */
  const ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_EXPANDED: string
  /**
   * An attribute for strikethrough text.
   *
   * Possible values are `true` or `false`.
   */
  const ACCESSIBLE_ATTRIBUTE_STRIKETHROUGH: string
  /**
   * An attribute for the font style.
   *
   * Possible values are:
   *
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC]
   */
  const ACCESSIBLE_ATTRIBUTE_STYLE: string
  /**
   * The "italic" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
   */
  const ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC: string
  /**
   * The "normal" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
   */
  const ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL: string
  /**
   * The "oblique" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
   */
  const ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE: string
  /**
   * An attribute for the underline style.
   *
   * Possible values are:
   *
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR]
   */
  const ACCESSIBLE_ATTRIBUTE_UNDERLINE: string
  /**
   * The "double" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
   */
  const ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE: string
  /**
   * The "error" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
   */
  const ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR: string
  /**
   * The "none" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
   */
  const ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE: string
  /**
   * The "single" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
   */
  const ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE: string
  /**
   * An attribute for the font variant.
   *
   * Possible values are:
   *
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE]
   * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS]
   */
  const ACCESSIBLE_ATTRIBUTE_VARIANT: string
  /**
   * The "all petite caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
   */
  const ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS: string
  /**
   * The "all small caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
   */
  const ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS: string
  /**
   * The "petite caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
   */
  const ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS: string
  /**
   * The "small caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
   */
  const ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS: string
  /**
   * The "title caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
   */
  const ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS: string
  /**
   * The "unicase" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
   */
  const ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE: string
  /**
   * An attribute for the font weight.
   */
  const ACCESSIBLE_ATTRIBUTE_WEIGHT: string
  /**
   * An undefined value. The accessible attribute is either unset, or its
   * value is undefined.
   */
  const ACCESSIBLE_VALUE_UNDEFINED: number
  /**
   * Like [func`get_binary_age]`, but from the headers used at
   * application compile time, rather than from the library linked
   * against at application run time.
   */
  const BINARY_AGE: number
  const IM_MODULE_EXTENSION_POINT_NAME: string
  /**
   * Constant to return from a signal handler for the ::input
   * signal in case of conversion failure.
   *
   * See [signal`Gtk`.SpinButton::input].
   */
  const INPUT_ERROR: number
  /**
   * Like [func`get_interface_age]`, but from the headers used at
   * application compile time, rather than from the library linked
   * against at application run time.
   */
  const INTERFACE_AGE: number
  /**
   * The value used to refer to a guaranteed invalid position
   * in a `GListModel`.
   *
   * This value may be returned from some functions, others may
   * accept it as input. Its interpretation may differ for different
   * functions.
   *
   * Refer to each function's documentation for if this value is
   * allowed and what it does.
   */
  const INVALID_LIST_POSITION: number
  /**
   * The name used for the stock full offset included by `GtkLevelBar`.
   */
  const LEVEL_BAR_OFFSET_FULL: string
  /**
   * The name used for the stock high offset included by `GtkLevelBar`.
   */
  const LEVEL_BAR_OFFSET_HIGH: string
  /**
   * The name used for the stock low offset included by `GtkLevelBar`.
   */
  const LEVEL_BAR_OFFSET_LOW: string
  /**
   * Like [func`get_major_version]`, but from the headers used at
   * application compile time, rather than from the library linked
   * against at application run time.
   */
  const MAJOR_VERSION: number
  const MAX_COMPOSE_LEN: number
  const MEDIA_FILE_EXTENSION_POINT_NAME: string
  /**
   * Like [func`get_micro_version]`, but from the headers used at
   * application compile time, rather than from the library linked
   * against at application run time.
   */
  const MICRO_VERSION: number
  /**
   * Like [func`get_minor_version]`, but from the headers used at
   * application compile time, rather than from the library linked
   * against at application run time.
   */
  const MINOR_VERSION: number
  /**
   * Name for the A3 paper size.
   */
  const PAPER_NAME_A3: string
  /**
   * Name for the A4 paper size.
   */
  const PAPER_NAME_A4: string
  /**
   * Name for the A5 paper size.
   */
  const PAPER_NAME_A5: string
  /**
   * Name for the B5 paper size.
   */
  const PAPER_NAME_B5: string
  /**
   * Name for the Executive paper size.
   */
  const PAPER_NAME_EXECUTIVE: string
  /**
   * Name for the Legal paper size.
   */
  const PAPER_NAME_LEGAL: string
  /**
   * Name for the Letter paper size.
   */
  const PAPER_NAME_LETTER: string
  const PRINT_SETTINGS_COLLATE: string
  const PRINT_SETTINGS_DEFAULT_SOURCE: string
  const PRINT_SETTINGS_DITHER: string
  const PRINT_SETTINGS_DUPLEX: string
  const PRINT_SETTINGS_FINISHINGS: string
  const PRINT_SETTINGS_MEDIA_TYPE: string
  const PRINT_SETTINGS_NUMBER_UP: string
  const PRINT_SETTINGS_NUMBER_UP_LAYOUT: string
  const PRINT_SETTINGS_N_COPIES: string
  const PRINT_SETTINGS_ORIENTATION: string
  /**
   * The key used by the “Print to file” printer to store the file
   * name of the output without the path to the directory and the
   * file extension.
   */
  const PRINT_SETTINGS_OUTPUT_BASENAME: string
  const PRINT_SETTINGS_OUTPUT_BIN: string
  /**
   * The key used by the “Print to file” printer to store the
   * directory to which the output should be written.
   */
  const PRINT_SETTINGS_OUTPUT_DIR: string
  /**
   * The key used by the “Print to file” printer to store the format
   * of the output. The supported values are “PS” and “PDF”.
   */
  const PRINT_SETTINGS_OUTPUT_FILE_FORMAT: string
  /**
   * The key used by the “Print to file” printer to store the URI
   * to which the output should be written. GTK itself supports
   * only “file://” URIs.
   */
  const PRINT_SETTINGS_OUTPUT_URI: string
  const PRINT_SETTINGS_PAGE_RANGES: string
  const PRINT_SETTINGS_PAGE_SET: string
  const PRINT_SETTINGS_PAPER_FORMAT: string
  const PRINT_SETTINGS_PAPER_HEIGHT: string
  const PRINT_SETTINGS_PAPER_WIDTH: string
  const PRINT_SETTINGS_PRINTER: string
  const PRINT_SETTINGS_PRINTER_LPI: string
  const PRINT_SETTINGS_PRINT_PAGES: string
  const PRINT_SETTINGS_QUALITY: string
  const PRINT_SETTINGS_RESOLUTION: string
  const PRINT_SETTINGS_RESOLUTION_X: string
  const PRINT_SETTINGS_RESOLUTION_Y: string
  const PRINT_SETTINGS_REVERSE: string
  const PRINT_SETTINGS_SCALE: string
  const PRINT_SETTINGS_USE_COLOR: string
  const PRINT_SETTINGS_WIN32_DRIVER_EXTRA: string
  const PRINT_SETTINGS_WIN32_DRIVER_VERSION: string
  /**
   * Use this priority for functionality related to size allocation.
   *
   * It is used internally by GTK+ to compute the sizes of widgets.
   * This priority is higher than %GDK_PRIORITY_REDRAW to avoid
   * resizing a widget which was just redrawn.
   */
  const PRIORITY_RESIZE: number
  /**
   * A priority that can be used when adding a `GtkStyleProvider`
   * for application-specific style information.
   */
  const STYLE_PROVIDER_PRIORITY_APPLICATION: number
  /**
   * The priority used for default style information
   * that is used in the absence of themes.
   *
   * Note that this is not very useful for providing default
   * styling for custom style classes - themes are likely to
   * override styling provided at this priority with
   * catch-all `* {...}` rules.
   */
  const STYLE_PROVIDER_PRIORITY_FALLBACK: number
  /**
   * The priority used for style information provided
   * via `GtkSettings`.
   *
   * This priority is higher than %GTK_STYLE_PROVIDER_PRIORITY_THEME
   * to let settings override themes.
   */
  const STYLE_PROVIDER_PRIORITY_SETTINGS: number
  /**
   * The priority used for style information provided
   * by themes.
   */
  const STYLE_PROVIDER_PRIORITY_THEME: number
  /**
   * The priority used for the style information from
   * `$XDG_CONFIG_HOME/gtk-4.0/gtk.css`.
   *
   * You should not use priorities higher than this, to
   * give the user the last word.
   */
  const STYLE_PROVIDER_PRIORITY_USER: number
  /**
   * The priority at which the text view validates onscreen lines
   * in an idle job in the background.
   */
  const TEXT_VIEW_PRIORITY_VALIDATE: number
  /**
   * Uses the default sort function in a [iface`Gtk`.TreeSortable].
   *
   * See also: [method`Gtk`.TreeSortable.set_sort_column_id]
   */
  const TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: number
  /**
   * Disables sorting in a [iface`Gtk`.TreeSortable].
   *
   * See also: [method`Gtk`.TreeSortable.set_sort_column_id]
   */
  const TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: number
  /**
   * Gets the modifier mask.
   *
   * The modifier mask determines which modifiers are considered significant
   * for keyboard accelerators. This includes all keyboard modifiers except
   * for %GDK_LOCK_MASK.
   * @returns the modifier mask for accelerators
   */
  function acceleratorGetDefaultModMask(): Gdk.ModifierType
  /**
   * Converts an accelerator keyval and modifier mask into a string
   * which can be used to represent the accelerator to the user.
   * @param acceleratorKey accelerator keyval
   * @param acceleratorMods accelerator modifier mask
   * @returns a newly-allocated string representing the accelerator
   */
  function acceleratorGetLabel(
    acceleratorKey: number,
    acceleratorMods: Gdk.ModifierType
  ): string | null
  /**
   * Converts an accelerator keyval and modifier mask
   * into a string that can be displayed to the user.
   *
   * The string may be translated.
   *
   * This function is similar to [func`Gtk`.accelerator_get_label],
   * but handling keycodes. This is only useful for system-level
   * components, applications should use [func`Gtk`.accelerator_get_label]
   * instead.
   * @param display a `GdkDisplay` or %NULL to use the default display
   * @param acceleratorKey accelerator keyval
   * @param keycode accelerator keycode
   * @param acceleratorMods accelerator modifier mask
   * @returns a newly-allocated string representing the accelerator
   */
  function acceleratorGetLabelWithKeycode(
    display: Gdk.Display | null,
    acceleratorKey: number,
    keycode: number,
    acceleratorMods: Gdk.ModifierType
  ): string | null
  /**
   * Converts an accelerator keyval and modifier mask into a string
   * parseable by gtk_accelerator_parse().
   *
   * For example, if you pass in %GDK_KEY_q and %GDK_CONTROL_MASK,
   * this function returns `<Control>q`.
   *
   * If you need to display accelerators in the user interface,
   * see [func`Gtk`.accelerator_get_label].
   * @param acceleratorKey accelerator keyval
   * @param acceleratorMods accelerator modifier mask
   * @returns a newly-allocated accelerator name
   */
  function acceleratorName(
    acceleratorKey: number,
    acceleratorMods: Gdk.ModifierType
  ): string | null
  /**
   * Converts an accelerator keyval and modifier mask
   * into a string parseable by gtk_accelerator_parse_with_keycode().
   *
   * This is similar to [func`Gtk`.accelerator_name] but handling keycodes.
   * This is only useful for system-level components, applications
   * should use [func`Gtk`.accelerator_name] instead.
   * @param display a `GdkDisplay` or %NULL to use the default display
   * @param acceleratorKey accelerator keyval
   * @param keycode accelerator keycode
   * @param acceleratorMods accelerator modifier mask
   * @returns a newly allocated accelerator name.
   */
  function acceleratorNameWithKeycode(
    display: Gdk.Display | null,
    acceleratorKey: number,
    keycode: number,
    acceleratorMods: Gdk.ModifierType
  ): string | null
  /**
   * Parses a string representing an accelerator.
   *
   * The format looks like “`<Control>a`” or “`<Shift><Alt>F1`”.
   *
   * The parser is fairly liberal and allows lower or upper case, and also
   * abbreviations such as “`<Ctl>`” and “`<Ctrl>`”.
   *
   * Key names are parsed using [func`Gdk`.keyval_from_name]. For character keys
   * the name is not the symbol, but the lowercase name, e.g. one would use
   * “`<Ctrl>minus`” instead of “`<Ctrl>-`”.
   *
   * Modifiers are enclosed in angular brackets `<>`, and match the
   * [flags`Gdk`.ModifierType] mask:
   *
   * - `<Shift>` for `GDK_SHIFT_MASK`
   * - `<Ctrl>` for `GDK_CONTROL_MASK`
   * - `<Alt>` for `GDK_ALT_MASK`
   * - `<Meta>` for `GDK_META_MASK`
   * - `<Super>` for `GDK_SUPER_MASK`
   * - `<Hyper>` for `GDK_HYPER_MASK`
   *
   * If the parse operation fails, `accelerator_key` and `accelerator_mods` will
   * be set to 0 (zero).
   * @param accelerator string representing an accelerator
   */
  function acceleratorParse(
    accelerator: string
  ): [
    /* returnType */ boolean,
    /* acceleratorKey */ number,
    /* acceleratorMods */ Gdk.ModifierType,
  ]
  /**
   * Parses a string representing an accelerator.
   *
   * This is similar to [func`Gtk`.accelerator_parse] but handles keycodes as
   * well. This is only useful for system-level components, applications should
   * use [func`Gtk`.accelerator_parse] instead.
   *
   * If `accelerator_codes` is given and the result stored in it is non-%NULL,
   * the result must be freed with g_free().
   *
   * If a keycode is present in the accelerator and no `accelerator_codes`
   * is given, the parse will fail.
   *
   * If the parse fails, `accelerator_key,` `accelerator_mods` and
   * `accelerator_codes` will be set to 0 (zero).
   * @param accelerator string representing an accelerator
   * @param display the `GdkDisplay` to look up `accelerator_codes` in
   * @returns %TRUE if parsing succeeded
   */
  function acceleratorParseWithKeycode(
    accelerator: string,
    display: Gdk.Display | null
  ): [
    /* returnType */ boolean,
    /* acceleratorKey */ number,
    /* acceleratorCodes */ number[],
    /* acceleratorMods */ Gdk.ModifierType,
  ]
  /**
   * Determines whether a given keyval and modifier mask constitute
   * a valid keyboard accelerator.
   *
   * For example, the %GDK_KEY_a keyval plus %GDK_CONTROL_MASK mark is valid,
   * and matches the “Ctrl+a” accelerator. But, you can't, for instance, use
   * the %GDK_KEY_Control_L keyval as an accelerator.
   * @param keyval a GDK keyval
   * @param modifiers modifier mask
   * @returns %TRUE if the accelerator is valid
   */
  function acceleratorValid(
    keyval: number,
    modifiers: Gdk.ModifierType
  ): boolean
  function accessiblePropertyInitValue(
    property: AccessibleProperty,
    value: any
  ): void
  function accessibleRelationInitValue(
    relation: AccessibleRelation,
    value: any
  ): void
  function accessibleStateInitValue(state: AccessibleState, value: any): void
  /**
   * Initializes `iter` to point to `target`.
   *
   * If `target` is not found, finds the next value after it.
   * If no value >= `target` exists in `set,` this function returns %FALSE.
   * @param set a `GtkBitset`
   * @param target target value to start iterating at
   * @returns %TRUE if a value was found.
   */
  function bitsetIterInitAt(
    set: Bitset,
    target: number
  ): [/* returnType */ boolean, /* iter */ BitsetIter, /* value */ number]
  /**
   * Initializes an iterator for `set` and points it to the first
   * value in `set`.
   *
   * If `set` is empty, %FALSE is returned and `value` is set to %G_MAXUINT.
   * @param set a `GtkBitset`
   * @returns %TRUE if @set isn't empty.
   */
  function bitsetIterInitFirst(
    set: Bitset
  ): [/* returnType */ boolean, /* iter */ BitsetIter, /* value */ number]
  /**
   * Initializes an iterator for `set` and points it to the last
   * value in `set`.
   *
   * If `set` is empty, %FALSE is returned.
   * @param set a `GtkBitset`
   * @returns %TRUE if @set isn't empty.
   */
  function bitsetIterInitLast(
    set: Bitset
  ): [/* returnType */ boolean, /* iter */ BitsetIter, /* value */ number]
  function builderErrorQuark(): GLib.Quark
  /**
   * Checks that the GTK library in use is compatible with the
   * given version.
   *
   * Generally you would pass in the constants %GTK_MAJOR_VERSION,
   * %GTK_MINOR_VERSION, %GTK_MICRO_VERSION as the three arguments
   * to this function; that produces a check that the library in
   * use is compatible with the version of GTK the application or
   * module was compiled against.
   *
   * Compatibility is defined by two things: first the version
   * of the running library is newer than the version
   * `required_major`.required_minor.`required_micro`. Second
   * the running library must be binary compatible with the
   * version `required_major`.required_minor.`required_micro`
   * (same major version.)
   *
   * This function is primarily for GTK modules; the module
   * can call this function to check that it wasn’t loaded
   * into an incompatible version of GTK. However, such a
   * check isn’t completely reliable, since the module may be
   * linked against an old version of GTK and calling the
   * old version of gtk_check_version(), but still get loaded
   * into an application using a newer version of GTK.
   * @param requiredMajor the required major version
   * @param requiredMinor the required minor version
   * @param requiredMicro the required micro version
   * @returns %NULL if the GTK library is compatible with the   given version, or a string describing the version mismatch.   The returned string is owned by GTK and should not be modified   or freed.
   */
  function checkVersion(
    requiredMajor: number,
    requiredMinor: number,
    requiredMicro: number
  ): string | null
  function constraintVflParserErrorQuark(): GLib.Quark
  function cssParserErrorQuark(): GLib.Quark
  function cssParserWarningQuark(): GLib.Quark
  function dialogErrorQuark(): GLib.Quark
  /**
   * Prevents [func`Gtk`.init] and [func`Gtk`.init_check] from automatically calling
   * `setlocale (LC_ALL, "")`.
   *
   * You would want to use this function if you wanted to set the locale for
   * your program to something other than the user’s locale, or if
   * you wanted to set different values for different locale categories.
   *
   * Most programs should not need to call this function.
   */
  function disableSetlocale(): void
  /**
   * Distributes `extra_space` to child `sizes` by bringing smaller
   * children up to natural size first.
   *
   * The remaining space will be added to the `minimum_size` member of the
   * `GtkRequestedSize` struct. If all sizes reach their natural size then
   * the remaining space is returned.
   * @param extraSpace Extra space to redistribute among children after subtracting   minimum sizes and any child padding from the overall allocation
   * @param sizes An array of structs with a client pointer and a minimum/natural size  in the orientation of the allocation.
   * @returns The remainder of @extra_space after redistributing space to @sizes.
   */
  function distributeNaturalAllocation(
    extraSpace: number,
    sizes: RequestedSize[]
  ): number
  /**
   * Gets a property of the `GtkEditable` delegate for `object`.
   *
   * This is helper function that should be called in the `get_property`
   * function of your `GtkEditable` implementation, before handling your
   * own properties.
   * @param object a `GObject`
   * @param propId a property ID
   * @param value value to set
   * @param pspec the `GParamSpec` for the property
   * @returns %TRUE if the property was found
   */
  function editableDelegateGetProperty(
    object: GObject.Object,
    propId: number,
    value: any,
    pspec: GObject.ParamSpec
  ): boolean
  /**
   * Sets a property on the `GtkEditable` delegate for `object`.
   *
   * This is a helper function that should be called in the `set_property`
   * function of your `GtkEditable` implementation, before handling your
   * own properties.
   * @param object a `GObject`
   * @param propId a property ID
   * @param value value to set
   * @param pspec the `GParamSpec` for the property
   * @returns %TRUE if the property was found
   */
  function editableDelegateSetProperty(
    object: GObject.Object,
    propId: number,
    value: any,
    pspec: GObject.ParamSpec
  ): boolean
  /**
   * Overrides the `GtkEditable` properties for `class`.
   *
   * This is a helper function that should be called in class_init,
   * after installing your own properties.
   *
   * Note that your class must have "text", "cursor-position",
   * "selection-bound", "editable", "width-chars", "max-width-chars",
   * "xalign" and "enable-undo" properties for this function to work.
   *
   * To handle the properties in your set_property and get_property
   * functions, you can either use [func`Gtk`.Editable.delegate_set_property]
   * and [func`Gtk`.Editable.delegate_get_property] (if you are using
   * a delegate), or remember the `first_prop` offset and add it to the
   * values in the [enum`Gtk`.EditableProperties] enumeration to get the
   * property IDs for these properties.
   * @param objectClass a `GObjectClass`
   * @param firstProp property ID to use for the first property
   * @returns the number of properties that were installed
   */
  function editableInstallProperties(
    objectClass: GObject.ObjectClass,
    firstProp: number
  ): number
  /**
   * Calls a function for all `GtkPrinter`s.
   *
   * If `func` returns %TRUE, the enumeration is stopped.
   * @param func a function to call for each printer
   * @param wait if %TRUE, wait in a recursive mainloop until    all printers are enumerated; otherwise return early
   */
  function enumeratePrinters(func: PrinterFunc, wait: boolean): void
  /**
   * Registers an error quark for `GtkFileChooser` errors.
   * @returns The error quark used for `GtkFileChooser` errors.
   */
  function fileChooserErrorQuark(): GLib.Quark
  /**
   * Returns the binary age as passed to `libtool`.
   *
   * If `libtool` means nothing to you, don't worry about it.
   * @returns the binary age of the GTK library
   */
  function getBinaryAge(): number
  /**
   * Returns the GTK debug flags that are currently active.
   *
   * This function is intended for GTK modules that want
   * to adjust their debug output based on GTK debug flags.
   * @returns the GTK debug flags.
   */
  function getDebugFlags(): DebugFlags
  /**
   * Returns the `PangoLanguage` for the default language
   * currently in effect.
   *
   * Note that this can change over the life of an
   * application.
   *
   * The default language is derived from the current
   * locale. It determines, for example, whether GTK uses
   * the right-to-left or left-to-right text direction.
   *
   * This function is equivalent to [func`Pango`.Language.get_default].
   * See that function for details.
   * @returns the default language
   */
  function getDefaultLanguage(): Pango.Language
  /**
   * Returns the interface age as passed to `libtool`.
   *
   * If `libtool` means nothing to you, don't worry about it.
   * @returns the interface age of the GTK library
   */
  function getInterfaceAge(): number
  /**
   * Get the direction of the current locale. This is the expected
   * reading direction for text and UI.
   *
   * This function depends on the current locale being set with
   * setlocale() and will default to setting the %GTK_TEXT_DIR_LTR
   * direction otherwise. %GTK_TEXT_DIR_NONE will never be returned.
   *
   * GTK sets the default text direction according to the locale
   * during gtk_init(), and you should normally use
   * gtk_widget_get_direction() or gtk_widget_get_default_direction()
   * to obtain the current direction.
   *
   * This function is only needed rare cases when the locale is
   * changed after GTK has already been initialized. In this case,
   * you can use it to update the default text direction as follows:
   *
   *
   * ```c
   * #include <locale.h>
   *
   * static void
   * update_locale (const char *new_locale)
   * {
   *   setlocale (LC_ALL, new_locale);
   *   gtk_widget_set_default_direction (gtk_get_locale_direction ());
   * }
   * ```
   *
   * @returns the direction of the current locale
   */
  function getLocaleDirection(): TextDirection
  /**
   * Returns the major version number of the GTK library.
   *
   * For example, in GTK version 3.1.5 this is 3.
   *
   * This function is in the library, so it represents the GTK library
   * your code is running against. Contrast with the %GTK_MAJOR_VERSION
   * macro, which represents the major version of the GTK headers you
   * have included when compiling your code.
   * @returns the major version number of the GTK library
   */
  function getMajorVersion(): number
  /**
   * Returns the micro version number of the GTK library.
   *
   * For example, in GTK version 3.1.5 this is 5.
   *
   * This function is in the library, so it represents the GTK library
   * your code is are running against. Contrast with the
   * %GTK_MICRO_VERSION macro, which represents the micro version of the
   * GTK headers you have included when compiling your code.
   * @returns the micro version number of the GTK library
   */
  function getMicroVersion(): number
  /**
   * Returns the minor version number of the GTK library.
   *
   * For example, in GTK version 3.1.5 this is 1.
   *
   * This function is in the library, so it represents the GTK library
   * your code is are running against. Contrast with the
   * %GTK_MINOR_VERSION macro, which represents the minor version of the
   * GTK headers you have included when compiling your code.
   * @returns the minor version number of the GTK library
   */
  function getMinorVersion(): number
  /**
   * Converts a color from HSV space to RGB.
   *
   * Input values must be in the [0.0, 1.0] range;
   * output values will be in the same range.
   * @param h Hue
   * @param s Saturation
   * @param v Value
   */
  function hsvToRgb(
    h: number,
    s: number,
    v: number
  ): [/* r */ number, /* g */ number, /* b */ number]
  function iconThemeErrorQuark(): GLib.Quark
  /**
   * Call this function before using any other GTK functions in your GUI
   * applications. It will initialize everything needed to operate the
   * toolkit.
   *
   * If you are using `GtkApplication`, you usually don't have to call this
   * function; the `GApplication::startup` handler does it for you. Though,
   * if you are using GApplication methods that will be invoked before `startup`,
   * such as `local_command_line`, you may need to initialize stuff explicitly.
   *
   * This function will terminate your program if it was unable to
   * initialize the windowing system for some reason. If you want
   * your program to fall back to a textual interface, call
   * [func`Gtk`.init_check] instead.
   *
   * GTK calls `signal (SIGPIPE, SIG_IGN)` during initialization, to ignore
   * SIGPIPE signals, since these are almost never wanted in graphical
   * applications. If you do need to handle SIGPIPE for some reason, reset
   * the handler after gtk_init(), but notice that other libraries (e.g.
   * libdbus or gvfs) might do similar things.
   */
  function init(): void
  /**
   * This function does the same work as gtk_init() with only a single
   * change: It does not terminate the program if the windowing system
   * can’t be initialized. Instead it returns %FALSE on failure.
   *
   * This way the application can fall back to some other means of
   * communication with the user - for example a curses or command line
   * interface.
   * @returns %TRUE if the windowing system has been successfully   initialized, %FALSE otherwise
   */
  function initCheck(): boolean
  /**
   * Use this function to check if GTK has been initialized.
   *
   * See [func`Gtk`.init].
   * @returns the initialization status
   */
  function isInitialized(): boolean
  /**
   * Finds the `GtkNative` associated with the surface.
   * @param surface a `GdkSurface`
   * @returns the `GtkNative` that is associated with @surface
   */
  function nativeGetForSurface(surface: Gdk.Surface): Native | null
  /**
   * Returns the name of the default paper size, which
   * depends on the current locale.
   * @returns the name of the default paper size. The string is owned by GTK and should not be modified.
   */
  function paperSizeGetDefault(): string
  /**
   * Creates a list of known paper sizes.
   * @param includeCustom whether to include custom paper sizes   as defined in the page setup dialog
   * @returns a newly allocated list of newly    allocated `GtkPaperSize` objects
   */
  function paperSizeGetPaperSizes(includeCustom: boolean): PaperSize[]
  /**
   * Creates a new `GParamSpec` instance for a property holding a `GtkExpression`.
   *
   * See `g_param_spec_internal()` for details on the property strings.
   * @param name canonical name of the property
   * @param nick a user-readable name for the property
   * @param blurb a user-readable description of the property
   * @param flags flags for the property
   * @returns a newly created property specification
   */
  function paramSpecExpression(
    name: string,
    nick: string,
    blurb: string,
    flags: GObject.ParamFlags
  ): GObject.ParamSpec
  /**
   * Registers an error quark for `GtkPrintOperation` if necessary.
   * @returns The error quark used for `GtkPrintOperation` errors.
   */
  function printErrorQuark(): GLib.Quark
  /**
   * Runs a page setup dialog, letting the user modify the values from
   * `page_setup`. If the user cancels the dialog, the returned `GtkPageSetup`
   * is identical to the passed in `page_setup,` otherwise it contains the
   * modifications done in the dialog.
   *
   * Note that this function may use a recursive mainloop to show the page
   * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
   * a problem.
   * @param parent transient parent
   * @param pageSetup an existing `GtkPageSetup`
   * @param settings a `GtkPrintSettings`
   * @returns a new `GtkPageSetup`
   */
  function printRunPageSetupDialog(
    parent: Window | null,
    pageSetup: PageSetup | null,
    settings: PrintSettings
  ): PageSetup
  /**
   * Runs a page setup dialog, letting the user modify the values from `page_setup`.
   *
   * In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
   * showing the page setup dialog on platforms that support this, and calls `done_cb`
   * from a signal handler for the ::response signal of the dialog.
   * @param parent transient parent
   * @param pageSetup an existing `GtkPageSetup`
   * @param settings a `GtkPrintSettings`
   * @param doneCb a function to call when the user saves    the modified page setup
   */
  function printRunPageSetupDialogAsync(
    parent: Window | null,
    pageSetup: PageSetup | null,
    settings: PrintSettings,
    doneCb: PageSetupDoneFunc
  ): void
  function recentManagerErrorQuark(): GLib.Quark
  /**
   * Renders an activity indicator (such as in `GtkSpinner`).
   * The state %GTK_STATE_FLAG_CHECKED determines whether there is
   * activity going on.
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin of the rectangle
   * @param y Y origin of the rectangle
   * @param width rectangle width
   * @param height rectangle height
   */
  function renderActivity(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Renders an arrow pointing to `angle`.
   *
   * Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
   *
   * ![](arrows.png)
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param angle arrow angle from 0 to 2 * %G_PI, being 0 the arrow pointing to the north
   * @param x X origin of the render area
   * @param y Y origin of the render area
   * @param size square side for render area
   */
  function renderArrow(
    context: StyleContext,
    cr: cairo.Context,
    angle: number,
    x: number,
    y: number,
    size: number
  ): void
  /**
   * Renders the background of an element.
   *
   * Typical background rendering, showing the effect of
   * `background-image`, `border-width` and `border-radius`:
   *
   * ![](background.png)
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin of the rectangle
   * @param y Y origin of the rectangle
   * @param width rectangle width
   * @param height rectangle height
   */
  function renderBackground(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Renders a checkmark (as in a `GtkCheckButton`).
   *
   * The %GTK_STATE_FLAG_CHECKED state determines whether the check is
   * on or off, and %GTK_STATE_FLAG_INCONSISTENT determines whether it
   * should be marked as undefined.
   *
   * Typical checkmark rendering:
   *
   * ![](checks.png)
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin of the rectangle
   * @param y Y origin of the rectangle
   * @param width rectangle width
   * @param height rectangle height
   */
  function renderCheck(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Renders an expander (as used in `GtkTreeView` and `GtkExpander`) in the area
   * defined by `x,` `y,` `width,` `height`. The state %GTK_STATE_FLAG_CHECKED
   * determines whether the expander is collapsed or expanded.
   *
   * Typical expander rendering:
   *
   * ![](expanders.png)
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin of the rectangle
   * @param y Y origin of the rectangle
   * @param width rectangle width
   * @param height rectangle height
   */
  function renderExpander(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Renders a focus indicator on the rectangle determined by `x,` `y,` `width,` `height`.
   *
   * Typical focus rendering:
   *
   * ![](focus.png)
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin of the rectangle
   * @param y Y origin of the rectangle
   * @param width rectangle width
   * @param height rectangle height
   */
  function renderFocus(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Renders a frame around the rectangle defined by `x,` `y,` `width,` `height`.
   *
   * Examples of frame rendering, showing the effect of `border-image`,
   * `border-color`, `border-width`, `border-radius` and junctions:
   *
   * ![](frames.png)
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin of the rectangle
   * @param y Y origin of the rectangle
   * @param width rectangle width
   * @param height rectangle height
   */
  function renderFrame(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Renders a handle (as in `GtkPaned` and `GtkWindow`’s resize grip),
   * in the rectangle determined by `x,` `y,` `width,` `height`.
   *
   * Handles rendered for the paned and grip classes:
   *
   * ![](handles.png)
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin of the rectangle
   * @param y Y origin of the rectangle
   * @param width rectangle width
   * @param height rectangle height
   */
  function renderHandle(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Renders the icon in `texture` at the specified `x` and `y` coordinates.
   *
   * This function will render the icon in `texture` at exactly its size,
   * regardless of scaling factors, which may not be appropriate when
   * drawing on displays with high pixel densities.
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param texture a `GdkTexture` containing the icon to draw
   * @param x X position for the `texture`
   * @param y Y position for the `texture`
   */
  function renderIcon(
    context: StyleContext,
    cr: cairo.Context,
    texture: Gdk.Texture,
    x: number,
    y: number
  ): void
  /**
   * Renders `layout` on the coordinates `x,` `y`
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin
   * @param y Y origin
   * @param layout the `PangoLayout` to render
   */
  function renderLayout(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    layout: Pango.Layout
  ): void
  /**
   * Renders a line from (x0, y0) to (x1, y1).
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x0 X coordinate for the origin of the line
   * @param y0 Y coordinate for the origin of the line
   * @param x1 X coordinate for the end of the line
   * @param y1 Y coordinate for the end of the line
   */
  function renderLine(
    context: StyleContext,
    cr: cairo.Context,
    x0: number,
    y0: number,
    x1: number,
    y1: number
  ): void
  /**
   * Renders an option mark (as in a radio button), the %GTK_STATE_FLAG_CHECKED
   * state will determine whether the option is on or off, and
   * %GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined.
   *
   * Typical option mark rendering:
   *
   * ![](options.png)
   * @param context a `GtkStyleContext`
   * @param cr a `cairo_t`
   * @param x X origin of the rectangle
   * @param y Y origin of the rectangle
   * @param width rectangle width
   * @param height rectangle height
   */
  function renderOption(
    context: StyleContext,
    cr: cairo.Context,
    x: number,
    y: number,
    width: number,
    height: number
  ): void
  /**
   * Converts a color from RGB space to HSV.
   *
   * Input values must be in the [0.0, 1.0] range;
   * output values will be in the same range.
   * @param r Red
   * @param g Green
   * @param b Blue
   */
  function rgbToHsv(
    r: number,
    g: number,
    b: number
  ): [/* h */ number, /* s */ number, /* v */ number]
  /**
   * Sets the GTK debug flags.
   * @param flags the debug flags to set
   */
  function setDebugFlags(flags: DebugFlags): void
  /**
   * This function launches the default application for showing
   * a given uri, or shows an error dialog if that fails.
   * @param parent parent window
   * @param uri the uri to show
   * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
   */
  function showUri(parent: Window | null, uri: string, timestamp: number): void
  /**
   * This function launches the default application for showing
   * a given uri.
   *
   * The `callback` will be called when the launch is completed.
   * It should call gtk_show_uri_full_finish() to obtain the result.
   *
   * This is the recommended call to be used as it passes information
   * necessary for sandbox helpers to parent their dialogs properly.
   * @param parent parent window
   * @param uri the uri to show
   * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
   * @param cancellable a `GCancellable` to cancel the launch
   * @param callback a callback to call when the action is complete
   */
  function showUriFull(
    parent: Window | null,
    uri: string,
    timestamp: number,
    cancellable: Gio.Cancellable | null,
    callback: Gio.AsyncReadyCallback | null
  ): void
  /**
   * Finishes the gtk_show_uri() call and returns the result
   * of the operation.
   * @param parent the `GtkWindow` passed to gtk_show_uri()
   * @param result `GAsyncResult` that was passed to `callback`
   * @returns %TRUE if the URI was shown successfully.   Otherwise, %FALSE is returned and @error is set
   */
  function showUriFullFinish(parent: Window, result: Gio.AsyncResult): boolean
  function testAccessibleAssertionMessageRole(
    domain: string,
    file: string,
    line: number,
    func: string,
    expr: string,
    accessible: Accessible,
    expectedRole: AccessibleRole,
    actualRole: AccessibleRole
  ): void
  /**
   * Checks whether the `GtkAccessible` has `property` set.
   * @param accessible a `GtkAccessible`
   * @param property a `GtkAccessibleProperty`
   * @returns %TRUE if the @property is set in the @accessible
   */
  function testAccessibleHasProperty(
    accessible: Accessible,
    property: AccessibleProperty
  ): boolean
  /**
   * Checks whether the `GtkAccessible` has `relation` set.
   * @param accessible a `GtkAccessible`
   * @param relation a `GtkAccessibleRelation`
   * @returns %TRUE if the @relation is set in the @accessible
   */
  function testAccessibleHasRelation(
    accessible: Accessible,
    relation: AccessibleRelation
  ): boolean
  /**
   * Checks whether the `GtkAccessible:accessible-role` of the accessible
   * is `role`.
   * @param accessible a `GtkAccessible`
   * @param role a `GtkAccessibleRole`
   * @returns %TRUE if the role matches
   */
  function testAccessibleHasRole(
    accessible: Accessible,
    role: AccessibleRole
  ): boolean
  /**
   * Checks whether the `GtkAccessible` has `state` set.
   * @param accessible a `GtkAccessible`
   * @param state a `GtkAccessibleState`
   * @returns %TRUE if the @state is set in the @accessible
   */
  function testAccessibleHasState(
    accessible: Accessible,
    state: AccessibleState
  ): boolean
  /**
   * Return the type ids that have been registered after
   * calling gtk_test_register_all_types().
   * @returns 0-terminated array of type ids
   */
  function testListAllTypes(): GObject.GType[]
  /**
   * Force registration of all core GTK object types.
   *
   * This allows to refer to any of those object types via
   * g_type_from_name() after calling this function.
   */
  function testRegisterAllTypes(): void
  /**
   * Enters the main loop and waits for `widget` to be “drawn”.
   *
   * In this context that means it waits for the frame clock of
   * `widget` to have run a full styling, layout and drawing cycle.
   *
   * This function is intended to be used for syncing with actions that
   * depend on `widget` relayouting or on interaction with the display
   * server.
   * @param widget the widget to wait for
   */
  function testWidgetWaitForDraw(widget: Widget): void
  /**
   * Creates a content provider for dragging `path` from `tree_model`.
   * @param treeModel a `GtkTreeModel`
   * @param path a row in `tree_model`
   * @returns a new `GdkContentProvider`
   */
  function treeCreateRowDragContent(
    treeModel: TreeModel,
    path: TreePath
  ): Gdk.ContentProvider
  /**
   * Obtains a `tree_model` and `path` from value of target type
   * %GTK_TYPE_TREE_ROW_DATA.
   *
   * The returned path must be freed with gtk_tree_path_free().
   * @param value a `GValue`
   * @returns %TRUE if @selection_data had target type %GTK_TYPE_TREE_ROW_DATA  is otherwise valid
   */
  function treeGetRowDragData(
    value: any
  ): [
    /* returnType */ boolean,
    /* treeModel */ TreeModel | null,
    /* path */ TreePath | null,
  ]
  /**
   * Lets a set of row reference created by
   * gtk_tree_row_reference_new_proxy() know that the
   * model emitted the ::row-deleted signal.
   * @param proxy a `GObject`
   * @param path the path position that was deleted
   */
  function treeRowReferenceDeleted(proxy: GObject.Object, path: TreePath): void
  /**
   * Lets a set of row reference created by
   * gtk_tree_row_reference_new_proxy() know that the
   * model emitted the ::row-inserted signal.
   * @param proxy a `GObject`
   * @param path the row position that was inserted
   */
  function treeRowReferenceInserted(proxy: GObject.Object, path: TreePath): void
  /**
   * Retrieves the `GtkExpression` stored inside the given `value`, and acquires
   * a reference to it.
   * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
   * @returns a `GtkExpression`
   */
  function valueDupExpression(value: any): Expression | null
  /**
   * Retrieves the `GtkExpression` stored inside the given `value`.
   * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
   * @returns a `GtkExpression`
   */
  function valueGetExpression(value: any): Expression | null
  /**
   * Stores the given `GtkExpression` inside `value`.
   *
   * The `GValue` will acquire a reference to the `expression`.
   * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
   * @param expression a `GtkExpression`
   */
  function valueSetExpression(value: any, expression: Expression): void
  /**
   * Stores the given `GtkExpression` inside `value`.
   *
   * This function transfers the ownership of the `expression` to the `GValue`.
   * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
   * @param expression a `GtkExpression`
   */
  function valueTakeExpression(value: any, expression: Expression | null): void
  /**
   * Type of callback used to calculate the next page in a `GtkAssistant`.
   *
   * It’s called both for computing the next page when the user presses the
   * “forward” button and for handling the behavior of the “last” button.
   *
   * See [method`Gtk`.Assistant.set_forward_page_func].
   * @callback
   * @param currentPage The page number used to calculate the next page.
   * @returns The next page number
   */
  interface AssistantPageFunc {
    (currentPage: number): number
  }
  /**
   * The type of the callback functions used for iterating over the
   * cell renderers and their allocated areas inside a `GtkCellArea`,
   * see gtk_cell_area_foreach_alloc().
   * @callback
   * @param renderer the cell renderer to operate on
   * @param cellArea the area allocated to `renderer` inside the rectangle   provided to gtk_cell_area_foreach_alloc().
   * @param cellBackground the background area for `renderer` inside the   background area provided to gtk_cell_area_foreach_alloc().
   * @returns %TRUE to stop iterating over cells.
   */
  interface CellAllocCallback {
    (
      renderer: CellRenderer,
      cellArea: Gdk.Rectangle,
      cellBackground: Gdk.Rectangle
    ): boolean
  }
  /**
   * The type of the callback functions used for iterating over
   * the cell renderers of a `GtkCellArea`, see gtk_cell_area_foreach().
   * @callback
   * @param renderer the cell renderer to operate on
   * @returns %TRUE to stop iterating over cells.
   */
  interface CellCallback {
    (renderer: CellRenderer): boolean
  }
  /**
   * A function which should set the value of `cell_layout’`s cell renderer(s)
   * as appropriate.
   * @callback
   * @param cellLayout a `GtkCellLayout`
   * @param cell the cell renderer whose value is to be set
   * @param treeModel the model
   * @param iter a `GtkTreeIter` indicating the row to set the value for
   */
  interface CellLayoutDataFunc {
    (
      cellLayout: CellLayout,
      cell: CellRenderer,
      treeModel: TreeModel,
      iter: TreeIter
    ): void
  }
  /**
   * A function to be used by `GtkCustomLayout` to allocate a widget.
   * @callback
   * @param widget the widget to allocate
   * @param width the new width of the widget
   * @param height the new height of the widget
   * @param baseline the new baseline of the widget, or -1
   */
  interface CustomAllocateFunc {
    (widget: Widget, width: number, height: number, baseline: number): void
  }
  /**
   * User function that is called to determine if the `item` should be matched.
   *
   * If the filter matches the item, this function must return %TRUE. If the
   * item should be filtered out, %FALSE must be returned.
   * @callback
   * @param item The item to be matched
   * @returns %TRUE to keep the item around
   */
  interface CustomFilterFunc {
    (item: GObject.Object): boolean
  }
  /**
   * A function to be used by `GtkCustomLayout` to measure a widget.
   * @callback
   * @param widget the widget to be measured
   * @param orientation the direction to be measured
   * @param forSize the size to be measured for
   */
  interface CustomMeasureFunc {
    (widget: Widget, orientation: Orientation, forSize: number): void
  }
  /**
   * Queries a widget for its preferred size request mode.
   * @callback
   * @param widget the widget to be queried
   * @returns the size request mode
   */
  interface CustomRequestModeFunc {
    (widget: Widget): SizeRequestMode
  }
  /**
   * Whenever `drawing_area` needs to redraw, this function will be called.
   *
   * This function should exclusively redraw the contents of the drawing area
   * and must not call any widget functions that cause changes.
   * @callback
   * @param drawingArea the `GtkDrawingArea` to redraw
   * @param cr the context to draw to
   * @param width the actual width of the contents. This value will be at least   as wide as GtkDrawingArea:width.
   * @param height the actual height of the contents. This value will be at least   as wide as GtkDrawingArea:height.
   */
  interface DrawingAreaDrawFunc {
    (
      drawingArea: DrawingArea,
      cr: cairo.Context,
      width: number,
      height: number
    ): void
  }
  /**
   * A function which decides whether the row indicated by `iter` matches
   * a given `key,` and should be displayed as a possible completion for `key`.
   *
   * Note that `key` is normalized and case-folded (see g_utf8_normalize()
   * and g_utf8_casefold()). If this is not appropriate, match functions
   * have access to the unmodified key via
   * `gtk_editable_get_text (GTK_EDITABLE (gtk_entry_completion_get_entry ()))`.
   * @callback
   * @param completion the `GtkEntryCompletion`
   * @param key the string to match, normalized and case-folded
   * @param iter a `GtkTreeIter` indicating the row to match
   * @returns %TRUE if @iter should be displayed as a possible completion   for @key
   */
  interface EntryCompletionMatchFunc {
    (completion: EntryCompletion, key: string, iter: TreeIter): boolean
  }
  /**
   * Callback called by gtk_expression_watch() when the
   * expression value changes.
   * @callback
   */
  interface ExpressionNotify {
    (): void
  }
  /**
   * Called for flow boxes that are bound to a `GListModel`.
   *
   * This function is called for each item that gets added to the model.
   * @callback
   * @param item the item from the model for which to create a widget for
   * @returns a `GtkWidget` that represents @item
   */
  interface FlowBoxCreateWidgetFunc {
    (item: GObject.Object): Widget
  }
  /**
   * A function that will be called whenever a child changes
   * or is added.
   *
   * It lets you control if the child should be visible or not.
   * @callback
   * @param child a `GtkFlowBoxChild` that may be filtered
   * @returns %TRUE if the row should be visible, %FALSE otherwise
   */
  interface FlowBoxFilterFunc {
    (child: FlowBoxChild): boolean
  }
  /**
   * A function used by gtk_flow_box_selected_foreach().
   *
   * It will be called on every selected child of the `box`.
   * @callback
   * @param box a `GtkFlowBox`
   * @param child a `GtkFlowBoxChild`
   */
  interface FlowBoxForeachFunc {
    (box: FlowBox, child: FlowBoxChild): void
  }
  /**
   * A function to compare two children to determine which
   * should come first.
   * @callback
   * @param child1 the first child
   * @param child2 the second child
   * @returns < 0 if @child1 should be before @child2, 0 if   they are equal, and > 0 otherwise
   */
  interface FlowBoxSortFunc {
    (child1: FlowBoxChild, child2: FlowBoxChild): number
  }
  /**
   * The type of function that is used for deciding what fonts get
   * shown in a `GtkFontChooser`.
   *
   * See [method`Gtk`.FontChooser.set_filter_func].
   * @callback
   * @param family a `PangoFontFamily`
   * @param face a `PangoFontFace` belonging to `family`
   * @returns %TRUE if the font should be displayed
   */
  interface FontFilterFunc {
    (family: Pango.FontFamily, face: Pango.FontFace): boolean
  }
  /**
   * A function used by gtk_icon_view_selected_foreach() to map all
   * selected rows.
   *
   * It will be called on every selected row in the view.
   * @callback
   * @param iconView a `GtkIconView`
   * @param path The `GtkTreePath` of a selected row
   */
  interface IconViewForeachFunc {
    (iconView: IconView, path: TreePath): void
  }
  /**
   * Called for list boxes that are bound to a `GListModel` with
   * gtk_list_box_bind_model() for each item that gets added to the model.
   *
   * If the widget returned is not a #GtkListBoxRow widget, then the widget
   * will be inserted as the child of an intermediate #GtkListBoxRow.
   * @callback
   * @param item the item from the model for which to create a widget for
   * @returns a `GtkWidget` that represents @item
   */
  interface ListBoxCreateWidgetFunc {
    (item: GObject.Object): Widget
  }
  /**
   * Will be called whenever the row changes or is added and lets you control
   * if the row should be visible or not.
   * @callback
   * @param row the row that may be filtered
   * @returns %TRUE if the row should be visible, %FALSE otherwise
   */
  interface ListBoxFilterFunc {
    (row: ListBoxRow): boolean
  }
  /**
   * A function used by gtk_list_box_selected_foreach().
   *
   * It will be called on every selected child of the `box`.
   * @callback
   * @param box a `GtkListBox`
   * @param row a `GtkListBoxRow`
   */
  interface ListBoxForeachFunc {
    (box: ListBox, row: ListBoxRow): void
  }
  /**
   * Compare two rows to determine which should be first.
   * @callback
   * @param row1 the first row
   * @param row2 the second row
   * @returns < 0 if @row1 should be before @row2, 0 if they are   equal and > 0 otherwise
   */
  interface ListBoxSortFunc {
    (row1: ListBoxRow, row2: ListBoxRow): number
  }
  /**
   * Whenever `row` changes or which row is before `row` changes this
   * is called, which lets you update the header on `row`.
   *
   * You may remove or set a new one via [method`Gtk`.ListBoxRow.set_header]
   * or just change the state of the current header widget.
   * @callback
   * @param row the row to update
   * @param before the row before `row,` or %NULL if it is first
   */
  interface ListBoxUpdateHeaderFunc {
    (row: ListBoxRow, before: ListBoxRow | null): void
  }
  /**
   * User function that is called to map an `item` of the original model to
   * an item expected by the map model.
   *
   * The returned items must conform to the item type of the model they are
   * used with.
   * @callback
   * @param item The item to map
   * @returns The item to map to
   */
  interface MapListModelMapFunc {
    (item: GObject.Object): GObject.Object
  }
  /**
   * User-provided callback function to create a popup for a
   * `GtkMenuButton` on demand.
   *
   * This function is called when the popup of `menu_button` is shown,
   * but none has been provided via [method`Gtk`.MenuButton.set_popover]
   * or [method`Gtk`.MenuButton.set_menu_model].
   * @callback
   * @param menuButton the `GtkMenuButton`
   */
  interface MenuButtonCreatePopupFunc {
    (menuButton: MenuButton): void
  }
  /**
   * The type of function that is passed to
   * gtk_print_run_page_setup_dialog_async().
   *
   * This function will be called when the page setup dialog
   * is dismissed, and also serves as destroy notify for `data`.
   * @callback
   * @param pageSetup the `GtkPageSetup` that has been passed to   gtk_print_run_page_setup_dialog_async()
   */
  interface PageSetupDoneFunc {
    (pageSetup: PageSetup): void
  }
  /**
   * The type of callback that is passed to gtk_print_job_send().
   *
   * It is called when the print job has been completely sent.
   * @callback
   * @param printJob the `GtkPrintJob`
   * @param error a `GError` that contains error information if the sending   of the print job failed, otherwise %NULL
   */
  interface PrintJobCompleteFunc {
    (printJob: PrintJob, error: GLib.Error): void
  }
  interface PrintSettingsFunc {
    (key: string, value: string): void
  }
  /**
   * The type of function passed to gtk_enumerate_printers().
   *
   * Note that you need to ref `printer,` if you want to keep
   * a reference to it after the function has returned.
   * @callback
   * @param printer a `GtkPrinter`
   * @returns %TRUE to stop the enumeration, %FALSE to continue
   */
  interface PrinterFunc {
    (printer: Printer): boolean
  }
  interface ScaleFormatValueFunc {
    (scale: Scale, value: number): string | null
  }
  /**
   * Prototype for shortcuts based on user callbacks.
   * @callback
   * @param widget The widget passed to the activation
   * @param args The arguments passed to the activation
   * @returns %TRUE if the action was successful.
   */
  interface ShortcutFunc {
    (widget: Widget, args: GLib.Variant | null): boolean
  }
  /**
   * The predicate function used by gtk_text_iter_forward_find_char() and
   * gtk_text_iter_backward_find_char().
   * @callback
   * @param ch a Unicode code point
   * @returns %TRUE if the predicate is satisfied, and the iteration should   stop, and %FALSE otherwise
   */
  interface TextCharPredicate {
    (ch: string): boolean
  }
  /**
   * A function used with gtk_text_tag_table_foreach(),
   * to iterate over every `GtkTextTag` inside a `GtkTextTagTable`.
   * @callback
   * @param tag the `GtkTextTag`
   */
  interface TextTagTableForeach {
    (tag: TextTag): void
  }
  /**
   * Callback type for adding a function to update animations. See gtk_widget_add_tick_callback().
   * @callback
   * @param widget the widget
   * @param frameClock the frame clock for the widget (same as calling gtk_widget_get_frame_clock())
   * @returns %G_SOURCE_CONTINUE if the tick callback should continue to be called,  %G_SOURCE_REMOVE if the tick callback should be removed.
   */
  interface TickCallback {
    (widget: Widget, frameClock: Gdk.FrameClock): boolean
  }
  /**
   * A function to set the properties of a cell instead of just using the
   * straight mapping between the cell and the model.
   *
   * This function is useful for customizing the cell renderer. For example,
   * a function might get an* integer from the `tree_model,` and render it to
   * the “text” attribute of “cell” by converting it to its written equivalent.
   *
   * See also: gtk_tree_view_column_set_cell_data_func()
   * @callback
   * @param treeColumn A `GtkTreeViewColumn`
   * @param cell The `GtkCellRenderer` that is being rendered by `tree_column`
   * @param treeModel The `GtkTreeModel` being rendered
   * @param iter A `GtkTreeIter` of the current row rendered
   */
  interface TreeCellDataFunc {
    (
      treeColumn: TreeViewColumn,
      cell: CellRenderer,
      treeModel: TreeModel,
      iter: TreeIter
    ): void
  }
  /**
   * A GtkTreeIterCompareFunc should return a negative integer, zero, or a positive
   * integer if `a` sorts before `b,` `a` sorts with `b,` or `a` sorts after `b`
   * respectively.
   *
   * If two iters compare as equal, their order in the sorted model
   * is undefined. In order to ensure that the `GtkTreeSortable` behaves as
   * expected, the GtkTreeIterCompareFunc must define a partial order on
   * the model, i.e. it must be reflexive, antisymmetric and transitive.
   *
   * For example, if `model` is a product catalogue, then a compare function
   * for the “price” column could be one which returns
   * `price_of(`a)` - price_of(`b)``.
   * @callback
   * @param model The `GtkTreeModel` the comparison is within
   * @param a A `GtkTreeIter` in `model`
   * @param b Another `GtkTreeIter` in `model`
   * @returns a negative integer, zero or a positive integer depending on whether   @a sorts before, with or after @b
   */
  interface TreeIterCompareFunc {
    (model: TreeModel, a: TreeIter, b: TreeIter): number
  }
  /**
   * Prototype of the function called to create new child models when
   * gtk_tree_list_row_set_expanded() is called.
   *
   * This function can return %NULL to indicate that `item` is guaranteed to be
   * a leaf node and will never have children. If it does not have children but
   * may get children later, it should return an empty model that is filled once
   * children arrive.
   * @callback
   * @param item The item that is being expanded
   * @returns The model tracking the children of   @item or %NULL if @item can never have children
   */
  interface TreeListModelCreateModelFunc {
    (item: GObject.Object): Gio.ListModel | null
  }
  /**
   * A function which calculates display values from raw values in the model.
   * It must fill `value` with the display value for the column `column` in the
   * row indicated by `iter`.
   *
   * Since this function is called for each data access, it’s not a
   * particularly efficient operation.
   * @callback
   * @param model the `GtkTreeModelFilter`
   * @param iter a `GtkTreeIter` pointing to the row whose display values are determined
   * @param column the column whose display value is determined
   */
  interface TreeModelFilterModifyFunc {
    (model: TreeModel, iter: TreeIter, column: number): void
  }
  /**
   * A function which decides whether the row indicated by `iter` is visible.
   * @callback
   * @param model the child model of the `GtkTreeModelFilter`
   * @param iter a `GtkTreeIter` pointing to the row in `model` whose visibility   is determined
   * @returns Whether the row indicated by @iter is visible.
   */
  interface TreeModelFilterVisibleFunc {
    (model: TreeModel, iter: TreeIter): boolean
  }
  /**
   * Type of the callback passed to gtk_tree_model_foreach() to
   * iterate over the rows in a tree model.
   * @callback
   * @param model the `GtkTreeModel` being iterated
   * @param path the current `GtkTreePath`
   * @param iter the current `GtkTreeIter`
   * @returns %TRUE to stop iterating, %FALSE to continue
   */
  interface TreeModelForeachFunc {
    (model: TreeModel, path: TreePath, iter: TreeIter): boolean
  }
  /**
   * A function used by gtk_tree_selection_selected_foreach() to map all
   * selected rows.  It will be called on every selected row in the view.
   * @callback
   * @param model The `GtkTreeModel` being viewed
   * @param path The `GtkTreePath` of a selected row
   * @param iter A `GtkTreeIter` pointing to a selected row
   */
  interface TreeSelectionForeachFunc {
    (model: TreeModel, path: TreePath, iter: TreeIter): void
  }
  /**
   * A function used by gtk_tree_selection_set_select_function() to filter
   * whether or not a row may be selected. It is called whenever a row's
   * state might change.
   *
   * A return value of %TRUE indicates to `selection` that it is okay to
   * change the selection.
   * @callback
   * @param selection A `GtkTreeSelection`
   * @param model A `GtkTreeModel` being viewed
   * @param path The `GtkTreePath` of the row in question
   * @param pathCurrentlySelected %TRUE, if the path is currently selected
   * @returns %TRUE, if the selection state of the row can be toggled
   */
  interface TreeSelectionFunc {
    (
      selection: TreeSelection,
      model: TreeModel,
      path: TreePath,
      pathCurrentlySelected: boolean
    ): boolean
  }
  /**
   * Function type for determining whether `column` can be dropped in a
   * particular spot (as determined by `prev_column` and `next_column)`.  In
   * left to right locales, `prev_column` is on the left of the potential drop
   * spot, and `next_column` is on the right.  In right to left mode, this is
   * reversed.  This function should return %TRUE if the spot is a valid drop
   * spot.  Please note that returning %TRUE does not actually indicate that
   * the column drop was made, but is meant only to indicate a possible drop
   * spot to the user.
   * @callback
   * @param treeView A `GtkTreeView`
   * @param column The `GtkTreeViewColumn` being dragged
   * @param prevColumn A `GtkTreeViewColumn` on one side of `column`
   * @param nextColumn A `GtkTreeViewColumn` on the other side of `column`
   * @returns %TRUE, if @column can be dropped in this spot
   */
  interface TreeViewColumnDropFunc {
    (
      treeView: TreeView,
      column: TreeViewColumn,
      prevColumn: TreeViewColumn,
      nextColumn: TreeViewColumn
    ): boolean
  }
  /**
   * Function used for gtk_tree_view_map_expanded_rows().
   * @callback
   * @param treeView A `GtkTreeView`
   * @param path The path that’s expanded
   */
  interface TreeViewMappingFunc {
    (treeView: TreeView, path: TreePath): void
  }
  /**
   * Function type for determining whether the row pointed to by `iter` should
   * be rendered as a separator. A common way to implement this is to have a
   * boolean column in the model, whose values the `GtkTreeViewRowSeparatorFunc`
   * returns.
   * @callback
   * @param model the `GtkTreeModel`
   * @param iter a `GtkTreeIter` pointing at a row in `model`
   * @returns %TRUE if the row is a separator
   */
  interface TreeViewRowSeparatorFunc {
    (model: TreeModel, iter: TreeIter): boolean
  }
  /**
   * A function used for checking whether a row in `model` matches
   * a search key string entered by the user. Note the return value
   * is reversed from what you would normally expect, though it
   * has some similarity to strcmp() returning 0 for equal strings.
   * @callback
   * @param model the `GtkTreeModel` being searched
   * @param column the search column set by gtk_tree_view_set_search_column()
   * @param key the key string to compare with
   * @param iter a `GtkTreeIter` pointing the row of `model` that should be compared  with `key`.
   * @returns %FALSE if the row matches, %TRUE otherwise.
   */
  interface TreeViewSearchEqualFunc {
    (model: TreeModel, column: number, key: string, iter: TreeIter): boolean
  }
  /**
   * The type of the callback functions used for activating
   * actions installed with gtk_widget_class_install_action().
   *
   * The `parameter` must match the `parameter_type` of the action.
   * @callback
   * @param widget the widget to which the action belongs
   * @param actionName the action name
   * @param parameter parameter for activation
   */
  interface WidgetActionActivateFunc {
    (widget: Widget, actionName: string, parameter: GLib.Variant | null): void
  }
  module Accessible {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Accessible

      /**
       * The accessible role of the given `GtkAccessible` implementation.
       *
       * The accessible role cannot be changed once set.
       */
      accessible_role?: AccessibleRole | null
    }
  }

  interface Accessible {
    // Own properties of Gtk-4.0.Gtk.Accessible

    /**
     * The accessible role of the given `GtkAccessible` implementation.
     *
     * The accessible role cannot be changed once set.
     */
    accessibleRole: AccessibleRole
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Accessible

    /**
     * Requests the user's screen reader to announce the given message.
     *
     * This kind of notification is useful for messages that
     * either have only a visual representation or that are not
     * exposed visually at all, e.g. a notification about a
     * successful operation.
     *
     * Also, by using this API, you can ensure that the message
     * does not interrupts the user's current screen reader output.
     * @param message the string to announce
     * @param priority the priority of the announcement
     */
    announce(message: string, priority: AccessibleAnnouncementPriority): void
    // Has conflict: getAccessibleParent(): Accessible | null
    /**
     * Retrieves the accessible role of an accessible object.
     * @returns the accessible role
     */
    getAccessibleRole(): AccessibleRole
    // Has conflict: getAtContext(): ATContext
    // Has conflict: getBounds(): [ /* returnType */ boolean, /* x */ number, /* y */ number, /* width */ number, /* height */ number ]
    // Has conflict: getFirstAccessibleChild(): Accessible | null
    // Has conflict: getNextAccessibleSibling(): Accessible | null
    // Has conflict: getPlatformState(state: AccessiblePlatformState): boolean
    /**
     * Resets the accessible `property` to its default value.
     * @param property a `GtkAccessibleProperty`
     */
    resetProperty(property: AccessibleProperty): void
    /**
     * Resets the accessible `relation` to its default value.
     * @param relation a `GtkAccessibleRelation`
     */
    resetRelation(relation: AccessibleRelation): void
    /**
     * Resets the accessible `state` to its default value.
     * @param state a `GtkAccessibleState`
     */
    resetState(state: AccessibleState): void
    /**
     * Sets the parent and sibling of an accessible object.
     *
     * This function is meant to be used by accessible implementations that are
     * not part of the widget hierarchy, and but act as a logical bridge between
     * widgets. For instance, if a widget creates an object that holds metadata
     * for each child, and you want that object to implement the `GtkAccessible`
     * interface, you will use this function to ensure that the parent of each
     * child widget is the metadata object, and the parent of each metadata
     * object is the container widget.
     * @param parent the parent accessible object
     * @param nextSibling the sibling accessible object
     */
    setAccessibleParent(
      parent: Accessible | null,
      nextSibling: Accessible | null
    ): void
    /**
     * Updates the next accessible sibling of `self`.
     *
     * That might be useful when a new child of a custom `GtkAccessible`
     * is created, and it needs to be linked to a previous child.
     * @param newSibling the new next accessible sibling to set
     */
    updateNextAccessibleSibling(newSibling: Accessible | null): void
    /**
     * Updates an array of accessible properties.
     *
     * This function should be called by `GtkWidget` types whenever an accessible
     * property change must be communicated to assistive technologies.
     *
     * This function is meant to be used by language bindings.
     * @param properties an array of `GtkAccessibleProperty`
     * @param values an array of `GValues`, one for each property
     */
    updateProperty(properties: AccessibleProperty[], values: any[]): void
    /**
     * Updates an array of accessible relations.
     *
     * This function should be called by `GtkWidget` types whenever an accessible
     * relation change must be communicated to assistive technologies.
     *
     * This function is meant to be used by language bindings.
     * @param relations an array of `GtkAccessibleRelation`
     * @param values an array of `GValues`, one for each relation
     */
    updateRelation(relations: AccessibleRelation[], values: any[]): void
    /**
     * Updates an array of accessible states.
     *
     * This function should be called by `GtkWidget` types whenever an accessible
     * state change must be communicated to assistive technologies.
     *
     * This function is meant to be used by language bindings.
     * @param states an array of `GtkAccessibleState`
     * @param values an array of `GValues`, one for each state
     */
    updateState(states: AccessibleState[], values: any[]): void

    // Own virtual methods of Gtk-4.0.Gtk.Accessible

    /**
     * Retrieves the accessible parent for an accessible object.
     *
     * This function returns `NULL` for top level widgets.
     * @virtual
     * @returns the accessible parent
     */
    getAccessibleParent(): Accessible | null
    /**
     * Retrieves the accessible implementation for the given `GtkAccessible`.
     * @virtual
     * @returns the accessible implementation object
     */
    getAtContext(): ATContext | null
    /**
     * Queries the coordinates and dimensions of this accessible
     *
     * This functionality can be overridden by `GtkAccessible`
     * implementations, e.g. to get the bounds from an ignored
     * child widget.
     * @virtual
     * @returns true if the bounds are valid, and false otherwise
     */
    getBounds(): [
      /* returnType */ boolean,
      /* x */ number,
      /* y */ number,
      /* width */ number,
      /* height */ number,
    ]
    /**
     * Retrieves the first accessible child of an accessible object.
     * @virtual
     * @returns the first accessible child
     */
    getFirstAccessibleChild(): Accessible | null
    /**
     * Retrieves the next accessible sibling of an accessible object
     * @virtual
     * @returns the next accessible sibling
     */
    getNextAccessibleSibling(): Accessible | null
    /**
     * Query a platform state, such as focus.
     *
     * See gtk_accessible_platform_changed().
     *
     * This functionality can be overridden by `GtkAccessible`
     * implementations, e.g. to get platform state from an ignored
     * child widget, as is the case for `GtkText` wrappers.
     * @virtual
     * @param state platform state to query
     * @returns the value of @state for the accessible
     */
    getPlatformState(state: AccessiblePlatformState): boolean

    // Class property signals of Gtk-4.0.Gtk.Accessible

    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAccessible` is an interface for describing UI elements for
   * Assistive Technologies.
   *
   * Every accessible implementation has:
   *
   *  - a “role”, represented by a value of the [enum`Gtk`.AccessibleRole] enumeration
   *  - an “attribute”, represented by a set of [enum`Gtk`.AccessibleState],
   *    [enum`Gtk`.AccessibleProperty] and [enum`Gtk`.AccessibleRelation] values
   *
   * The role cannot be changed after instantiating a `GtkAccessible`
   * implementation.
   *
   * The attributes are updated every time a UI element's state changes in
   * a way that should be reflected by assistive technologies. For instance,
   * if a `GtkWidget` visibility changes, the %GTK_ACCESSIBLE_STATE_HIDDEN
   * state will also change to reflect the [property`Gtk`.Widget:visible] property.
   *
   * Every accessible implementation is part of a tree of accessible objects.
   * Normally, this tree corresponds to the widget tree, but can be customized
   * by reimplementing the [vfunc`Gtk`.Accessible.get_accessible_parent],
   * [vfunc`Gtk`.Accessible.get_first_accessible_child] and
   * [vfunc`Gtk`.Accessible.get_next_accessible_sibling] virtual functions.
   * Note that you can not create a top-level accessible object as of now,
   * which means that you must always have a parent accessible object.
   * Also note that when an accessible object does not correspond to a widget,
   * and it has children, whose implementation you don't control,
   * it is necessary to ensure the correct shape of the a11y tree
   * by calling [method`Gtk`.Accessible.set_accessible_parent] and
   * updating the sibling by [method`Gtk`.Accessible.update_next_accessible_sibling].
   * @interface
   */
  class Accessible extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Accessible

    static name: string

    // Constructors of Gtk-4.0.Gtk.Accessible

    constructor(config?: Accessible.ConstructorProperties)
    _init(config?: Accessible.ConstructorProperties): void
  }

  module AccessibleRange {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface AccessibleRange extends Accessible {
    // Own properties of Gtk-4.0.Gtk.AccessibleRange

    __gtype__: number

    // Own virtual methods of Gtk-4.0.Gtk.AccessibleRange

    /**
     * Sets the current value of the accessible range.
     *
     * This operation should behave similarly as if the user performed the
     * action.
     * @virtual
     * @param value the value to set
     * @returns true if the operation was performed, false otherwise
     */
    setCurrentValue(value: number): boolean

    // Class property signals of Gtk-4.0.Gtk.AccessibleRange

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * This interface describes ranged controls, e.g. controls which have a single
   * value within an allowed range and that can optionally be changed by the user.
   *
   * This interface is expected to be implemented by controls using the following
   * roles:
   *
   * - `GTK_ACCESSIBLE_ROLE_METER`
   * - `GTK_ACCESSIBLE_ROLE_PROGRESS_BAR`
   * - `GTK_ACCESSIBLE_ROLE_SCROLLBAR`
   * - `GTK_ACCESSIBLE_ROLE_SLIDER`
   * - `GTK_ACCESSIBLE_ROLE_SPIN_BUTTON`
   *
   * If that is not the case, a warning will be issued at run time.
   *
   * In addition to this interface, its implementers are expected to provide the
   * correct values for the following properties:
   *
   * - `GTK_ACCESSIBLE_PROPERTY_VALUE_MAX`
   * - `GTK_ACCESSIBLE_PROPERTY_VALUE_MIN`
   * - `GTK_ACCESSIBLE_PROPERTY_VALUE_NOW`
   * - `GTK_ACCESSIBLE_PROPERTY_VALUE_TEXT`
   * @interface
   */
  class AccessibleRange extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.AccessibleRange

    static name: string

    // Constructors of Gtk-4.0.Gtk.AccessibleRange

    constructor(config?: AccessibleRange.ConstructorProperties)
    _init(config?: AccessibleRange.ConstructorProperties): void
  }

  module AccessibleText {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface AccessibleText extends Accessible {
    // Own properties of Gtk-4.0.Gtk.AccessibleText

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.AccessibleText

    /**
     * Updates the position of the caret.
     *
     * Implementations of the `GtkAccessibleText` interface should call this
     * function every time the caret has moved, in order to notify assistive
     * technologies.
     */
    updateCaretPosition(): void
    /**
     * Notifies assistive technologies of a change in contents.
     *
     * Implementations of the `GtkAccessibleText` interface should call this
     * function every time their contents change as the result of an operation,
     * like an insertion or a removal.
     *
     * Note: If the change is a deletion, this function must be called *before*
     * removing the contents, if it is an insertion, it must be called *after*
     * inserting the new contents.
     * @param change the type of change in the contents
     * @param start the starting offset of the change, in characters
     * @param end the end offset of the change, in characters
     */
    updateContents(
      change: AccessibleTextContentChange,
      start: number,
      end: number
    ): void
    /**
     * Updates the boundary of the selection.
     *
     * Implementations of the `GtkAccessibleText` interface should call this
     * function every time the selection has moved, in order to notify assistive
     * technologies.
     */
    updateSelectionBound(): void

    // Own virtual methods of Gtk-4.0.Gtk.AccessibleText

    /**
     * Retrieves the text attributes inside the accessible object.
     *
     * Each attribute is composed by:
     *
     * - a range
     * - a name
     * - a value
     *
     * It is left to the implementation to determine the serialization format
     * of the value to a string.
     *
     * GTK provides support for various text attribute names and values, but
     * implementations of this interface are free to add their own attributes.
     *
     * If this function returns true, `n_ranges` will be set to a value
     * greater than or equal to one, `ranges` will be set to a newly
     * allocated array of [struct#Gtk.AccessibleTextRange].
     * @virtual
     * @param offset the offset, in characters
     * @returns true if the accessible object has at least an attribute,   and false otherwise
     */
    getAttributes(
      offset: number
    ): [
      /* returnType */ boolean,
      /* ranges */ AccessibleTextRange[],
      /* attributeNames */ string[],
      /* attributeValues */ string[],
    ]
    /**
     * Retrieves the position of the caret inside the accessible object.
     * @virtual
     * @returns the position of the caret, in characters
     */
    getCaretPosition(): number
    /**
     * Retrieve the current contents of the accessible object within
     * the given range.
     *
     * If `end` is `G_MAXUINT`, the end of the range is the full content
     * of the accessible object.
     * @virtual
     * @param start the beginning of the range, in characters
     * @param end the end of the range, in characters
     * @returns the requested slice of the contents of the   accessible object, as UTF-8. Note that the slice does not have to   be NUL-terminated
     */
    getContents(start: number, end: number): any
    /**
     * Retrieve the current contents of the accessible object starting
     * from the given offset, and using the given granularity.
     *
     * The `start` and `end` values contain the boundaries of the text.
     * @virtual
     * @param offset the offset, in characters
     * @param granularity the granularity of the query
     * @returns the requested slice of the contents of the   accessible object, as UTF-8. Note that the slice does not have to   be NUL-terminated
     */
    getContentsAt(
      offset: number,
      granularity: AccessibleTextGranularity
    ): [/* returnType */ any, /* start */ number, /* end */ number]
    /**
     * Retrieves the default text attributes inside the accessible object.
     *
     * Each attribute is composed by:
     *
     * - a name
     * - a value
     *
     * It is left to the implementation to determine the serialization format
     * of the value to a string.
     *
     * GTK provides support for various text attribute names and values, but
     * implementations of this interface are free to add their own attributes.
     * @virtual
     */
    getDefaultAttributes(): [
      /* attributeNames */ string[],
      /* attributeValues */ string[],
    ]
    /**
     * Retrieves the selection ranges in the accessible object.
     *
     * If this function returns true, `n_ranges` will be set to a value
     * greater than or equal to one, and `ranges` will be set to a newly
     * allocated array of [struct#Gtk.AccessibleTextRange].
     * @virtual
     * @returns true if there is at least a selection inside the   accessible object, and false otherwise
     */
    getSelection(): [
      /* returnType */ boolean,
      /* ranges */ AccessibleTextRange[],
    ]

    // Class property signals of Gtk-4.0.Gtk.AccessibleText

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An interface for accessible objects containing formatted text.
   *
   * The `GtkAccessibleText` interfaces is meant to be implemented by accessible
   * objects that have text formatted with attributes, or non-trivial text contents.
   *
   * You should use the [enum`Gtk`.AccessibleProperty.LABEL] or the
   * [enum`Gtk`.AccessibleProperty.DESCRIPTION] properties for accessible
   * objects containing simple, unformatted text.
   * @interface
   */
  class AccessibleText extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.AccessibleText

    static name: string

    // Constructors of Gtk-4.0.Gtk.AccessibleText

    constructor(config?: AccessibleText.ConstructorProperties)
    _init(config?: AccessibleText.ConstructorProperties): void
  }

  module Actionable {
    // Constructor properties interface

    interface ConstructorProperties
      extends Widget.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Actionable

      action_name?: string | null
      action_target?: GLib.Variant | null
    }
  }

  interface Actionable extends Widget {
    // Own properties of Gtk-4.0.Gtk.Actionable

    actionName: string | null
    actionTarget: GLib.Variant
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Actionable

    // Has conflict: getActionName(): string | null
    // Has conflict: getActionTargetValue(): GLib.Variant | null
    // Has conflict: setActionName(actionName: string | null): void
    // Has conflict: setActionTargetValue(targetValue: GLib.Variant | null): void
    /**
     * Sets the action-name and associated string target value of an
     * actionable widget.
     *
     * `detailed_action_name` is a string in the format accepted by
     * [func`Gio`.Action.parse_detailed_name].
     * @param detailedActionName the detailed action name
     */
    setDetailedActionName(detailedActionName: string): void

    // Own virtual methods of Gtk-4.0.Gtk.Actionable

    /**
     * Gets the action name for `actionable`.
     * @virtual
     * @returns the action name
     */
    getActionName(): string | null
    /**
     * Gets the current target value of `actionable`.
     * @virtual
     * @returns the current target value
     */
    getActionTargetValue(): GLib.Variant | null
    /**
     * Specifies the name of the action with which this widget should be
     * associated.
     *
     * If `action_name` is %NULL then the widget will be unassociated from
     * any previous action.
     *
     * Usually this function is used when the widget is located (or will be
     * located) within the hierarchy of a `GtkApplicationWindow`.
     *
     * Names are of the form “win.save” or “app.quit” for actions on the
     * containing [class`ApplicationWindow]` or its associated [class`Application]`,
     * respectively. This is the same form used for actions in the [class`Gio`.Menu]
     * associated with the window.
     * @virtual
     * @param actionName an action name
     */
    setActionName(actionName: string | null): void
    /**
     * Sets the target value of an actionable widget.
     *
     * If `target_value` is %NULL then the target value is unset.
     *
     * The target value has two purposes. First, it is used as the parameter
     * to activation of the action associated with the `GtkActionable` widget.
     * Second, it is used to determine if the widget should be rendered as
     * “active” — the widget is active if the state is equal to the given target.
     *
     * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
     * with string state in a typical “radio button” situation. Each button
     * will be associated with the same action, but with a different target
     * value for that action. Clicking on a particular button will activate
     * the action with the target of that button, which will typically cause
     * the action’s state to change to that value. Since the action’s state
     * is now equal to the target value of the button, the button will now
     * be rendered as active (and the other buttons, with different targets,
     * rendered inactive).
     * @virtual
     * @param targetValue a [struct`GLib`.Variant] to set as the target value
     */
    setActionTargetValue(targetValue: GLib.Variant | null): void

    // Class property signals of Gtk-4.0.Gtk.Actionable

    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-target", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkActionable` interface provides a convenient way of associating
   * widgets with actions.
   *
   * It primarily consists of two properties: [property`Gtk`.Actionable:action-name]
   * and [property`Gtk`.Actionable:action-target]. There are also some convenience
   * APIs for setting these properties.
   *
   * The action will be looked up in action groups that are found among
   * the widgets ancestors. Most commonly, these will be the actions with
   * the “win.” or “app.” prefix that are associated with the
   * `GtkApplicationWindow` or `GtkApplication`, but other action groups that
   * are added with [method`Gtk`.Widget.insert_action_group] will be consulted
   * as well.
   * @interface
   */
  class Actionable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Actionable

    static name: string

    // Constructors of Gtk-4.0.Gtk.Actionable

    constructor(config?: Actionable.ConstructorProperties)
    _init(config?: Actionable.ConstructorProperties): void
  }

  module AppChooser {
    // Constructor properties interface

    interface ConstructorProperties
      extends Widget.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AppChooser

      /**
       * The content type of the `GtkAppChooser` object.
       *
       * See `GContentType` for more information about content types.
       */
      content_type?: string | null
    }
  }

  interface AppChooser extends Widget {
    // Own properties of Gtk-4.0.Gtk.AppChooser

    /**
     * The content type of the `GtkAppChooser` object.
     *
     * See `GContentType` for more information about content types.
     */
    readonly contentType: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.AppChooser

    /**
     * Returns the currently selected application.
     * @returns a `GAppInfo` for the   currently selected application
     */
    getAppInfo(): Gio.AppInfo | null
    /**
     * Returns the content type for which the `GtkAppChooser`
     * shows applications.
     * @returns the content type of @self. Free with g_free()
     */
    getContentType(): string | null
    /**
     * Reloads the list of applications.
     */
    refresh(): void

    // Class property signals of Gtk-4.0.Gtk.AppChooser

    connect(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content-type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAppChooser` is an interface for widgets which allow the user to
   * choose an application.
   *
   * The main objects that implement this interface are
   * [class`Gtk`.AppChooserWidget],
   * [class`Gtk`.AppChooserDialog] and [class`Gtk`.AppChooserButton].
   *
   * Applications are represented by GIO `GAppInfo` objects here.
   * GIO has a concept of recommended and fallback applications for a
   * given content type. Recommended applications are those that claim
   * to handle the content type itself, while fallback also includes
   * applications that handle a more generic content type. GIO also
   * knows the default and last-used application for a given content
   * type. The `GtkAppChooserWidget` provides detailed control over
   * whether the shown list of applications should include default,
   * recommended or fallback applications.
   *
   * To obtain the application that has been selected in a `GtkAppChooser`,
   * use [method`Gtk`.AppChooser.get_app_info].
   * @interface
   */
  class AppChooser extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.AppChooser

    static name: string

    // Constructors of Gtk-4.0.Gtk.AppChooser

    constructor(config?: AppChooser.ConstructorProperties)
    _init(config?: AppChooser.ConstructorProperties): void
  }

  module Buildable {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Buildable {
    // Own properties of Gtk-4.0.Gtk.Buildable

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Buildable

    /**
     * Gets the ID of the `buildable` object.
     *
     * `GtkBuilder` sets the name based on the ID attribute
     * of the `<object>` tag used to construct the `buildable`.
     * @returns the ID of the buildable object
     */
    getBuildableId(): string | null

    // Own virtual methods of Gtk-4.0.Gtk.Buildable

    /**
     * Adds a child to `buildable`. `type` is an optional string
     * describing how the child should be added.
     * @virtual
     * @param builder a `GtkBuilder`
     * @param child child to add
     * @param type kind of child or %NULL
     */
    addChild(builder: Builder, child: GObject.Object, type: string | null): void
    /**
     * Similar to gtk_buildable_parser_finished() but is
     * called once for each custom tag handled by the `buildable`.
     * @virtual
     * @param builder a `GtkBuilder`
     * @param child child object or %NULL for non-child tags
     * @param tagname the name of the tag
     * @param data user data created in custom_tag_start
     */
    customFinished(
      builder: Builder,
      child: GObject.Object | null,
      tagname: string,
      data: any | null
    ): void
    /**
     * Called at the end of each custom element handled by
     * the buildable.
     * @virtual
     * @param builder `GtkBuilder` used to construct this object
     * @param child child object or %NULL for non-child tags
     * @param tagname name of tag
     * @param data user data that will be passed in to parser functions
     */
    customTagEnd(
      builder: Builder,
      child: GObject.Object | null,
      tagname: string,
      data: any | null
    ): void
    /**
     * Called for each unknown element under `<child>`.
     * @virtual
     * @param builder a `GtkBuilder` used to construct this object
     * @param child child object or %NULL for non-child tags
     * @param tagname name of tag
     * @returns %TRUE if an object has a custom implementation, %FALSE   if it doesn't.
     */
    customTagStart(
      builder: Builder,
      child: GObject.Object | null,
      tagname: string
    ): [
      /* returnType */ boolean,
      /* parser */ BuildableParser,
      /* data */ any | null,
    ]
    /**
     * The getter corresponding to `set_id`. Implement this
     *   if you implement `set_id`.
     * @virtual
     */
    getId(): string
    /**
     * Retrieves the internal child called `childname` of the `buildable` object.
     * @virtual
     * @param builder a `GtkBuilder`
     * @param childname name of child
     * @returns the internal child of the buildable object
     */
    getInternalChild(builder: Builder, childname: string): GObject.Object
    /**
     * Called when a builder finishes the parsing
     *  of a UI definition. It is normally not necessary to implement this,
     *  unless you need to perform special cleanup actions. `GtkWindow` sets
     *  the `GtkWidget:visible` property here.
     * @virtual
     * @param builder
     */
    parserFinished(builder: Builder): void
    /**
     * Sets a property of a buildable object.
     *  It is normally not necessary to implement this, g_object_set_property()
     *  is used by default. `GtkWindow` implements this to delay showing itself
     *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
     *  interface is created.
     * @virtual
     * @param builder
     * @param name
     * @param value
     */
    setBuildableProperty(builder: Builder, name: string, value: any): void
    /**
     * Stores the id attribute given in the `GtkBuilder` UI definition.
     *   `GtkWidget` stores the name as object data. Implement this method if your
     *   object has some notion of “ID” and it makes sense to map the XML id
     *   attribute to it.
     * @virtual
     * @param id
     */
    setId(id: string): void

    // Class property signals of Gtk-4.0.Gtk.Buildable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkBuildable` allows objects to extend and customize their deserialization
   * from ui files.
   *
   * The interface includes methods for setting names and properties of objects,
   * parsing custom tags and constructing child objects.
   *
   * The `GtkBuildable` interface is implemented by all widgets and
   * many of the non-widget objects that are provided by GTK. The
   * main user of this interface is [class`Gtk`.Builder]. There should be
   * very little need for applications to call any of these functions directly.
   *
   * An object only needs to implement this interface if it needs to extend the
   * `GtkBuilder` XML format or run any extra routines at deserialization time.
   * @interface
   */
  class Buildable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Buildable

    static name: string

    // Constructors of Gtk-4.0.Gtk.Buildable

    constructor(config?: Buildable.ConstructorProperties)
    _init(config?: Buildable.ConstructorProperties): void
  }

  module BuilderScope {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface BuilderScope {
    // Own properties of Gtk-4.0.Gtk.BuilderScope

    __gtype__: number

    // Own virtual methods of Gtk-4.0.Gtk.BuilderScope

    /**
     * Create a closure with the given arguments. See gtk_builder_create_closure()
     *   for more details on those.
     *   The C implementation will try to use dlsym() to locate the function name and then
     *   g_cclosure_new() to create a closure for the symbol.
     *   The default implementation just fails and returns %NULL.
     * @virtual
     * @param builder
     * @param functionName
     * @param flags
     * @param object
     */
    createClosure(
      builder: Builder,
      functionName: string,
      flags: BuilderClosureFlags,
      object: GObject.Object
    ): GObject.TClosure
    /**
     * Try to lookup a `GType` via the given function name, specified
     *   explicitly in a GtkBuilder file, like via the "type-func" attribute in the `<object>` tag.
     *   This function is very rarely used.
     *   The C implementation will use dlsym() and call the resulting function as a `GTypeFunc`.
     *   The default implementation will fail and just return %G_TYPE_INVALID.
     * @virtual
     * @param builder
     * @param functionName
     */
    getTypeFromFunction(builder: Builder, functionName: string): GObject.GType
    /**
     * Try to lookup a `GType` via the its name. See
     *   gtk_builder_get_type_from_name() for more details.
     *   The C implementation will use g_type_from_name() and if that fails try to guess the
     *   correct function name for registering the type and then use dlsym() to load it.
     *   The default implementation just tries g_type_from_name() and otherwise fails.
     * @virtual
     * @param builder
     * @param typeName
     */
    getTypeFromName(builder: Builder, typeName: string): GObject.GType

    // Class property signals of Gtk-4.0.Gtk.BuilderScope

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkBuilderScope` is an interface to provide language binding support
   * to `GtkBuilder`.
   *
   * The goal of `GtkBuilderScope` is to look up programming-language-specific
   * values for strings that are given in a `GtkBuilder` UI file.
   *
   * The primary intended audience is bindings that want to provide deeper
   * integration of `GtkBuilder` into the language.
   *
   * A `GtkBuilderScope` instance may be used with multiple `GtkBuilder` objects,
   * even at once.
   *
   * By default, GTK will use its own implementation of `GtkBuilderScope`
   * for the C language which can be created via [ctor`Gtk`.BuilderCScope.new].
   *
   * If you implement `GtkBuilderScope` for a language binding, you
   * may want to (partially) derive from or fall back to a [class`Gtk`.BuilderCScope],
   * as that class implements support for automatic lookups from C symbols.
   * @interface
   */
  class BuilderScope extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.BuilderScope

    static name: string

    // Constructors of Gtk-4.0.Gtk.BuilderScope

    constructor(config?: BuilderScope.ConstructorProperties)
    _init(config?: BuilderScope.ConstructorProperties): void
  }

  module CellEditable {
    // Signal callback interfaces

    /**
     * Signal callback interface for `editing-done`
     */
    interface EditingDoneSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `remove-widget`
     */
    interface RemoveWidgetSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Widget.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellEditable

      /**
       * Indicates whether editing on the cell has been canceled.
       */
      editing_canceled?: boolean | null
    }
  }

  interface CellEditable extends Widget {
    // Own properties of Gtk-4.0.Gtk.CellEditable

    /**
     * Indicates whether editing on the cell has been canceled.
     */
    editingCanceled: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CellEditable

    // Has conflict: editingDone(): void
    // Has conflict: removeWidget(): void
    // Has conflict: startEditing(event: Gdk.Event | null): void

    // Own virtual methods of Gtk-4.0.Gtk.CellEditable

    /**
     * Emits the `GtkCellEditable::editing-done` signal.
     * @virtual
     */
    editingDone(): void
    /**
     * Emits the `GtkCellEditable::remove-widget` signal.
     * @virtual
     */
    removeWidget(): void
    /**
     * Begins editing on a `cell_editable`.
     *
     * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
     * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
     *
     * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
     * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
     *
     * Note that the `cell_editable` is created on-demand for the current edit; its
     * lifetime is temporary and does not persist across other edits and/or cells.
     * @virtual
     * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
     */
    startEditing(event: Gdk.Event | null): void

    // Own signals of Gtk-4.0.Gtk.CellEditable

    connect(
      sigName: "editing-done",
      callback: CellEditable.EditingDoneSignalCallback
    ): number
    on(
      sigName: "editing-done",
      callback: CellEditable.EditingDoneSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "editing-done",
      callback: CellEditable.EditingDoneSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "editing-done",
      callback: CellEditable.EditingDoneSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "editing-done", ...args: any[]): void
    connect(
      sigName: "remove-widget",
      callback: CellEditable.RemoveWidgetSignalCallback
    ): number
    on(
      sigName: "remove-widget",
      callback: CellEditable.RemoveWidgetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "remove-widget",
      callback: CellEditable.RemoveWidgetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "remove-widget",
      callback: CellEditable.RemoveWidgetSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "remove-widget", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.CellEditable

    connect(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing-canceled", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Interface for widgets that can be used for editing cells
   *
   * The `GtkCellEditable` interface must be implemented for widgets to be usable
   * to edit the contents of a `GtkTreeView` cell. It provides a way to specify how
   * temporary widgets should be configured for editing, get the new value, etc.
   * @interface
   */
  class CellEditable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.CellEditable

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellEditable

    constructor(config?: CellEditable.ConstructorProperties)
    _init(config?: CellEditable.ConstructorProperties): void
  }

  module CellLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface CellLayout {
    // Own properties of Gtk-4.0.Gtk.CellLayout

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CellLayout

    // Has conflict: addAttribute(cell: CellRenderer, attribute: string, column: number): void
    // Has conflict: clear(): void
    // Has conflict: clearAttributes(cell: CellRenderer): void
    // Has conflict: getArea(): CellArea | null
    // Has conflict: getCells(): CellRenderer[]
    // Has conflict: packEnd(cell: CellRenderer, expand: boolean): void
    // Has conflict: packStart(cell: CellRenderer, expand: boolean): void
    // Has conflict: reorder(cell: CellRenderer, position: number): void
    // Has conflict: setCellDataFunc(cell: CellRenderer, func: CellLayoutDataFunc | null): void

    // Own virtual methods of Gtk-4.0.Gtk.CellLayout

    /**
     * Adds an attribute mapping to the list in `cell_layout`.
     *
     * The `column` is the column of the model to get a value from, and the
     * `attribute` is the property on `cell` to be set from that value. So for
     * example if column 2 of the model contains strings, you could have the
     * “text” attribute of a `GtkCellRendererText` get its values from column 2.
     * In this context "attribute" and "property" are used interchangeably.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param attribute a property on the renderer
     * @param column the column position on the model to get the attribute from
     */
    addAttribute(cell: CellRenderer, attribute: string, column: number): void
    /**
     * Unsets all the mappings on all renderers on `cell_layout` and
     * removes all renderers from `cell_layout`.
     * @virtual
     */
    clear(): void
    /**
     * Clears all existing attributes previously set with
     * gtk_cell_layout_set_attributes().
     * @virtual
     * @param cell a `GtkCellRenderer` to clear the attribute mapping on
     */
    clearAttributes(cell: CellRenderer): void
    /**
     * Returns the underlying `GtkCellArea` which might be `cell_layout`
     * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
     * is used by `cell_layout`.
     * @virtual
     * @returns the cell area used by @cell_layout
     */
    getArea(): CellArea | null
    /**
     * Returns the cell renderers which have been added to `cell_layout`.
     * @virtual
     * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
     */
    getCells(): CellRenderer[]
    /**
     * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
     * `cell` is allocated no more space than it needs. Any unused space is
     * divided evenly between cells for which `expand` is %TRUE.
     *
     * Note that reusing the same cell renderer is not supported.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param expand %TRUE if `cell` is to be given extra space allocated to `cell_layout`
     */
    packEnd(cell: CellRenderer, expand: boolean): void
    /**
     * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
     * then the `cell` is allocated no more space than it needs. Any unused space
     * is divided evenly between cells for which `expand` is %TRUE.
     *
     * Note that reusing the same cell renderer is not supported.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param expand %TRUE if `cell` is to be given extra space allocated to `cell_layout`
     */
    packStart(cell: CellRenderer, expand: boolean): void
    /**
     * Re-inserts `cell` at `position`.
     *
     * Note that `cell` has already to be packed into `cell_layout`
     * for this to function properly.
     * @virtual
     * @param cell a `GtkCellRenderer` to reorder
     * @param position new position to insert `cell` at
     */
    reorder(cell: CellRenderer, position: number): void
    /**
     * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
     *
     * This function is used instead of the standard attributes mapping
     * for setting the column value, and should set the value of `cell_layout’`s
     * cell renderer(s) as appropriate.
     *
     * `func` may be %NULL to remove a previously set function.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param func the `GtkCellLayout`DataFunc to use
     */
    setCellDataFunc(cell: CellRenderer, func: CellLayoutDataFunc | null): void

    // Class property signals of Gtk-4.0.Gtk.CellLayout

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An interface for packing cells
   *
   * `GtkCellLayout` is an interface to be implemented by all objects which
   * want to provide a `GtkTreeViewColumn` like API for packing cells,
   * setting attributes and data funcs.
   *
   * One of the notable features provided by implementations of
   * `GtkCellLayout` are attributes. Attributes let you set the properties
   * in flexible ways. They can just be set to constant values like regular
   * properties. But they can also be mapped to a column of the underlying
   * tree model with gtk_cell_layout_set_attributes(), which means that the value
   * of the attribute can change from cell to cell as they are rendered by
   * the cell renderer. Finally, it is possible to specify a function with
   * gtk_cell_layout_set_cell_data_func() that is called to determine the
   * value of the attribute for each cell that is rendered.
   *
   * ## GtkCellLayouts as GtkBuildable
   *
   * Implementations of GtkCellLayout which also implement the GtkBuildable
   * interface (`GtkCellView`, `GtkIconView`, `GtkComboBox`,
   * `GtkEntryCompletion`, `GtkTreeViewColumn`) accept `GtkCellRenderer` objects
   * as `<child>` elements in UI definitions. They support a custom `<attributes>`
   * element for their children, which can contain multiple `<attribute>`
   * elements. Each `<attribute>` element has a name attribute which specifies
   * a property of the cell renderer; the content of the element is the
   * attribute value.
   *
   * This is an example of a UI definition fragment specifying attributes:
   *
   * ```xml
   * <object class="GtkCellView">
   *   <child>
   *     <object class="GtkCellRendererText"/>
   *     <attributes>
   *       <attribute name="text">0</attribute>
   *     </attributes>
   *   </child>
   * </object>
   * ```
   *
   * Furthermore for implementations of `GtkCellLayout` that use a `GtkCellArea`
   * to lay out cells (all `GtkCellLayout`s in GTK use a `GtkCellArea`)
   * [cell properties](class.CellArea.html#cell-properties) can also be defined
   * in the format by specifying the custom `<cell-packing>` attribute which can
   * contain multiple `<property>` elements.
   *
   * Here is a UI definition fragment specifying cell properties:
   *
   * ```xml
   * <object class="GtkTreeViewColumn">
   *   <child>
   *     <object class="GtkCellRendererText"/>
   *     <cell-packing>
   *       <property name="align">True</property>
   *       <property name="expand">False</property>
   *     </cell-packing>
   *   </child>
   * </object>
   * ```
   *
   * ## Subclassing GtkCellLayout implementations
   *
   * When subclassing a widget that implements `GtkCellLayout` like
   * `GtkIconView` or `GtkComboBox`, there are some considerations related
   * to the fact that these widgets internally use a `GtkCellArea`.
   * The cell area is exposed as a construct-only property by these
   * widgets. This means that it is possible to e.g. do
   *
   * ```c
   * GtkWIdget *combo =
   *   g_object_new (GTK_TYPE_COMBO_BOX, "cell-area", my_cell_area, NULL);
   * ```
   *
   * to use a custom cell area with a combo box. But construct properties
   * are only initialized after instance `init()`
   * functions have run, which means that using functions which rely on
   * the existence of the cell area in your subclass `init()` function will
   * cause the default cell area to be instantiated. In this case, a provided
   * construct property value will be ignored (with a warning, to alert
   * you to the problem).
   *
   * ```c
   * static void
   * my_combo_box_init (MyComboBox *b)
   * {
   *   GtkCellRenderer *cell;
   *
   *   cell = gtk_cell_renderer_pixbuf_new ();
   *
   *   // The following call causes the default cell area for combo boxes,
   *   // a GtkCellAreaBox, to be instantiated
   *   gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (b), cell, FALSE);
   *   ...
   * }
   *
   * GtkWidget *
   * my_combo_box_new (GtkCellArea *area)
   * {
   *   // This call is going to cause a warning about area being ignored
   *   return g_object_new (MY_TYPE_COMBO_BOX, "cell-area", area, NULL);
   * }
   * ```
   *
   * If supporting alternative cell areas with your derived widget is
   * not important, then this does not have to concern you. If you want
   * to support alternative cell areas, you can do so by moving the
   * problematic calls out of `init()` and into a `constructor()`
   * for your class.
   * @interface
   */
  class CellLayout extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.CellLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellLayout

    constructor(config?: CellLayout.ConstructorProperties)
    _init(config?: CellLayout.ConstructorProperties): void
  }

  module ColorChooser {
    // Signal callback interfaces

    /**
     * Signal callback interface for `color-activated`
     */
    interface ColorActivatedSignalCallback {
      (color: Gdk.RGBA): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColorChooser

      /**
       * The currently selected color, as a `GdkRGBA` struct.
       *
       * The property can be set to change the current selection
       * programmatically.
       */
      rgba?: Gdk.RGBA | null
      /**
       * Whether colors may have alpha (translucency).
       *
       * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
       * via the [property`Gtk`.ColorChooser:rgba] property will be
       * forced to have alpha == 1.
       *
       * Implementations are expected to show alpha by rendering the color
       * over a non-uniform background (like a checkerboard pattern).
       */
      use_alpha?: boolean | null
    }
  }

  interface ColorChooser {
    // Own properties of Gtk-4.0.Gtk.ColorChooser

    /**
     * The currently selected color, as a `GdkRGBA` struct.
     *
     * The property can be set to change the current selection
     * programmatically.
     */
    rgba: Gdk.RGBA
    /**
     * Whether colors may have alpha (translucency).
     *
     * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
     * via the [property`Gtk`.ColorChooser:rgba] property will be
     * forced to have alpha == 1.
     *
     * Implementations are expected to show alpha by rendering the color
     * over a non-uniform background (like a checkerboard pattern).
     */
    useAlpha: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColorChooser

    // Has conflict: addPalette(orientation: Orientation, colorsPerLine: number, colors: Gdk.RGBA[] | null): void
    // Has conflict: getRgba(): /* color */ Gdk.RGBA
    /**
     * Returns whether the color chooser shows the alpha channel.
     * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
     */
    getUseAlpha(): boolean
    // Has conflict: setRgba(color: Gdk.RGBA): void
    /**
     * Sets whether or not the color chooser should use the alpha channel.
     * @param useAlpha %TRUE if color chooser should use alpha channel, %FALSE if not
     */
    setUseAlpha(useAlpha: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.ColorChooser

    /**
     * Adds a palette to the color chooser.
     *
     * If `orientation` is horizontal, the colors are grouped in rows,
     * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
     * the colors are grouped in columns instead.
     *
     * The default color palette of [class`Gtk`.ColorChooserWidget] has
     * 45 colors, organized in columns of 5 colors (this includes some
     * grays).
     *
     * The layout of the color chooser widget works best when the
     * palettes have 9-10 columns.
     *
     * Calling this function for the first time has the side effect
     * of removing the default color palette from the color chooser.
     *
     * If `colors` is %NULL, removes all previously added palettes.
     * @virtual
     * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
     * @param colorsPerLine the number of colors to show in each row/column
     * @param colors the colors of the palette
     */
    addPalette(
      orientation: Orientation,
      colorsPerLine: number,
      colors: Gdk.RGBA[] | null
    ): void
    colorActivated(color: Gdk.RGBA): void
    /**
     * Gets the currently-selected color.
     * @virtual
     */
    getRgba(): /* color */ Gdk.RGBA
    /**
     * Sets the color.
     * @virtual
     * @param color the new color
     */
    setRgba(color: Gdk.RGBA): void

    // Own signals of Gtk-4.0.Gtk.ColorChooser

    connect(
      sigName: "color-activated",
      callback: ColorChooser.ColorActivatedSignalCallback
    ): number
    on(
      sigName: "color-activated",
      callback: ColorChooser.ColorActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "color-activated",
      callback: ColorChooser.ColorActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "color-activated",
      callback: ColorChooser.ColorActivatedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "color-activated", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ColorChooser

    connect(sigName: "notify::rgba", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rgba", ...args: any[]): void
    connect(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-alpha", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkColorChooser` is an interface that is implemented by widgets
   * for choosing colors.
   *
   * Depending on the situation, colors may be allowed to have alpha (translucency).
   *
   * In GTK, the main widgets that implement this interface are
   * [class`Gtk`.ColorChooserWidget], [class`Gtk`.ColorChooserDialog] and
   * [class`Gtk`.ColorButton].
   * @interface
   */
  class ColorChooser extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ColorChooser

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColorChooser

    constructor(config?: ColorChooser.ConstructorProperties)
    _init(config?: ColorChooser.ConstructorProperties): void
  }

  module ConstraintTarget {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ConstraintTarget

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.ConstraintTarget

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkConstraintTarget` interface is implemented by objects that
   * can be used as source or target in `GtkConstraint`s.
   *
   * Besides `GtkWidget`, it is also implemented by `GtkConstraintGuide`.
   * @interface
   */
  class ConstraintTarget extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ConstraintTarget

    static name: string

    // Constructors of Gtk-4.0.Gtk.ConstraintTarget

    constructor(config?: ConstraintTarget.ConstructorProperties)
    _init(config?: ConstraintTarget.ConstructorProperties): void
  }

  module Editable {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `delete-text`
     */
    interface DeleteTextSignalCallback {
      (startPos: number, endPos: number): void
    }

    /**
     * Signal callback interface for `insert-text`
     */
    interface InsertTextSignalCallback {
      (text: string | null, length: number, position: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Widget.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Editable

      /**
       * Whether the entry contents can be edited.
       */
      editable?: boolean | null
      /**
       * If undo/redo should be enabled for the editable.
       */
      enable_undo?: boolean | null
      /**
       * The desired maximum width of the entry, in characters.
       */
      max_width_chars?: number | null
      /**
       * The contents of the entry.
       */
      text?: string | null
      /**
       * Number of characters to leave space for in the entry.
       */
      width_chars?: number | null
      /**
       * The horizontal alignment, from 0 (left) to 1 (right).
       *
       * Reversed for RTL layouts.
       */
      xalign?: number | null
    }
  }

  interface Editable extends Widget {
    // Own properties of Gtk-4.0.Gtk.Editable

    /**
     * The current position of the insertion cursor in chars.
     */
    readonly cursorPosition: number
    /**
     * Whether the entry contents can be edited.
     */
    editable: boolean
    /**
     * If undo/redo should be enabled for the editable.
     */
    enableUndo: boolean
    /**
     * The desired maximum width of the entry, in characters.
     */
    maxWidthChars: number
    /**
     * The position of the opposite end of the selection from the cursor in chars.
     */
    readonly selectionBound: number
    /**
     * The contents of the entry.
     */
    text: string | null
    /**
     * Number of characters to leave space for in the entry.
     */
    widthChars: number
    /**
     * The horizontal alignment, from 0 (left) to 1 (right).
     *
     * Reversed for RTL layouts.
     */
    xalign: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Editable

    /**
     * Retrieves the accessible platform state from the editable delegate.
     *
     * This is an helper function to retrieve the accessible state for
     * `GtkEditable` interface implementations using a delegate pattern.
     *
     * You should call this function in your editable widget implementation
     * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
     * instance:
     *
     * ```c
     * static void
     * accessible_interface_init (GtkAccessibleInterface *iface)
     * {
     *   iface->get_platform_state = your_editable_get_accessible_platform_state;
     * }
     *
     * static gboolean
     * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
     *                                              GtkAccessiblePlatformState state)
     * {
     *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
     * }
     * ```
     * @param state what kind of accessible state to retrieve
     */
    delegateGetAccessiblePlatformState(state: AccessiblePlatformState): boolean
    /**
     * Deletes the currently selected text of the editable.
     *
     * This call doesn’t do anything if there is no selected text.
     */
    deleteSelection(): void
    // Has conflict: deleteText(startPos: number, endPos: number): void
    /**
     * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
     *
     * This is a helper function that should be called from dispose,
     * before removing the delegate object.
     */
    finishDelegate(): void
    /**
     * Gets the alignment of the editable.
     * @returns the alignment
     */
    getAlignment(): number
    /**
     * Retrieves a sequence of characters.
     *
     * The characters that are retrieved are those characters at positions
     * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
     * then the characters retrieved are those characters from `start_pos` to
     * the end of the text.
     *
     * Note that positions are specified in characters, not bytes.
     * @param startPos start of text
     * @param endPos end of text
     * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
     */
    getChars(startPos: number, endPos: number): string | null
    // Has conflict: getDelegate(): Editable | null
    /**
     * Retrieves whether `editable` is editable.
     * @returns %TRUE if @editable is editable.
     */
    getEditable(): boolean
    /**
     * Gets if undo/redo actions are enabled for `editable`
     * @returns %TRUE if undo is enabled
     */
    getEnableUndo(): boolean
    /**
     * Retrieves the desired maximum width of `editable,` in characters.
     * @returns the maximum width of the entry, in characters
     */
    getMaxWidthChars(): number
    /**
     * Retrieves the current position of the cursor relative
     * to the start of the content of the editable.
     *
     * Note that this position is in characters, not in bytes.
     * @returns the cursor position
     */
    getPosition(): number
    // Has conflict: getSelectionBounds(): [ /* returnType */ boolean, /* startPos */ number, /* endPos */ number ]
    // Has conflict: getText(): string
    /**
     * Gets the number of characters of space reserved
     * for the contents of the editable.
     * @returns number of chars to request space for, or negative if unset
     */
    getWidthChars(): number
    /**
     * Sets up a delegate for `GtkEditable`.
     *
     * This is assuming that the get_delegate vfunc in the `GtkEditable`
     * interface has been set up for the `editable'`s type.
     *
     * This is a helper function that should be called in instance init,
     * after creating the delegate object.
     */
    initDelegate(): void
    // Has conflict: insertText(text: string, length: number, position: number): /* position */ number
    /**
     * Selects a region of text.
     *
     * The characters that are selected are those characters at positions
     * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
     * negative, then the characters selected are those characters from
     * `start_pos` to  the end of the text.
     *
     * Note that positions are specified in characters, not bytes.
     * @param startPos start of region
     * @param endPos end of region
     */
    selectRegion(startPos: number, endPos: number): void
    /**
     * Sets the alignment for the contents of the editable.
     *
     * This controls the horizontal positioning of the contents when
     * the displayed text is shorter than the width of the editable.
     * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
     */
    setAlignment(xalign: number): void
    /**
     * Determines if the user can edit the text in the editable widget.
     * @param isEditable %TRUE if the user is allowed to edit the text   in the widget
     */
    setEditable(isEditable: boolean): void
    /**
     * If enabled, changes to `editable` will be saved for undo/redo
     * actions.
     *
     * This results in an additional copy of text changes and are not
     * stored in secure memory. As such, undo is forcefully disabled
     * when [property`Gtk`.Text:visibility] is set to %FALSE.
     * @param enableUndo if undo/redo should be enabled
     */
    setEnableUndo(enableUndo: boolean): void
    /**
     * Sets the desired maximum width in characters of `editable`.
     * @param nChars the new desired maximum width, in characters
     */
    setMaxWidthChars(nChars: number): void
    /**
     * Sets the cursor position in the editable to the given value.
     *
     * The cursor is displayed before the character with the given (base 0)
     * index in the contents of the editable. The value must be less than
     * or equal to the number of characters in the editable. A value of -1
     * indicates that the position should be set after the last character
     * of the editable. Note that `position` is in characters, not in bytes.
     * @param position the position of the cursor
     */
    setPosition(position: number): void
    /**
     * Sets the text in the editable to the given value.
     *
     * This is replacing the current contents.
     * @param text the text to set
     */
    setText(text: string): void
    /**
     * Changes the size request of the editable to be about the
     * right size for `n_chars` characters.
     *
     * Note that it changes the size request, the size can still
     * be affected by how you pack the widget into containers.
     * If `n_chars` is -1, the size reverts to the default size.
     * @param nChars width in chars
     */
    setWidthChars(nChars: number): void

    // Own virtual methods of Gtk-4.0.Gtk.Editable

    changed(): void
    /**
     * Deletes a sequence of characters.
     *
     * The characters that are deleted are those characters at positions
     * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
     * negative, then the characters deleted are those from `start_pos` to
     * the end of the text.
     *
     * Note that the positions are specified in characters, not bytes.
     * @virtual
     * @param startPos start position
     * @param endPos end position
     */
    deleteText(startPos: number, endPos: number): void
    /**
     * Deletes a sequence of characters.
     *
     * The characters that are deleted are those characters at positions
     * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
     * negative, then the characters deleted are those from `start_pos` to
     * the end of the text.
     *
     * Note that the positions are specified in characters, not bytes.
     * @virtual
     * @param startPos start position
     * @param endPos end position
     */
    doDeleteText(startPos: number, endPos: number): void
    /**
     * Inserts `length` bytes of `text` into the contents of the
     * widget, at position `position`.
     *
     * Note that the position is in characters, not in bytes.
     * The function updates `position` to point after the newly
     * inserted text.
     * @virtual
     * @param text the text to insert
     * @param length the length of the text in bytes, or -1
     * @param position location of the position text will be inserted at
     */
    doInsertText(
      text: string,
      length: number,
      position: number
    ): /* position */ number
    /**
     * Gets the `GtkEditable` that `editable` is delegating its
     * implementation to.
     *
     * Typically, the delegate is a [class`Gtk`.Text] widget.
     * @virtual
     * @returns the delegate `GtkEditable`
     */
    getDelegate(): Editable | null
    /**
     * Retrieves the selection bound of the editable.
     *
     * `start_pos` will be filled with the start of the selection and
     * `end_pos` with end. If no text was selected both will be identical
     * and %FALSE will be returned.
     *
     * Note that positions are specified in characters, not bytes.
     * @virtual
     * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
     */
    getSelectionBounds(): [
      /* returnType */ boolean,
      /* startPos */ number,
      /* endPos */ number,
    ]
    /**
     * Retrieves the contents of `editable`.
     *
     * The returned string is owned by GTK and must not be modified or freed.
     * @virtual
     * @returns a pointer to the contents of the editable
     */
    getText(): string
    /**
     * Inserts `length` bytes of `text` into the contents of the
     * widget, at position `position`.
     *
     * Note that the position is in characters, not in bytes.
     * The function updates `position` to point after the newly
     * inserted text.
     * @virtual
     * @param text the text to insert
     * @param length the length of the text in bytes, or -1
     * @param position location of the position text will be inserted at
     */
    insertText(
      text: string,
      length: number,
      position: number
    ): /* position */ number
    /**
     * Selects a region of text.
     *
     * The characters that are selected are those characters at positions
     * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
     * negative, then the characters selected are those characters from
     * `start_pos` to  the end of the text.
     *
     * Note that positions are specified in characters, not bytes.
     * @virtual
     * @param startPos start of region
     * @param endPos end of region
     */
    setSelectionBounds(startPos: number, endPos: number): void

    // Own signals of Gtk-4.0.Gtk.Editable

    connect(
      sigName: "changed",
      callback: Editable.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: Editable.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Editable.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Editable.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "delete-text",
      callback: Editable.DeleteTextSignalCallback
    ): number
    on(
      sigName: "delete-text",
      callback: Editable.DeleteTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "delete-text",
      callback: Editable.DeleteTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "delete-text",
      callback: Editable.DeleteTextSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "delete-text", endPos: number, ...args: any[]): void
    connect(
      sigName: "insert-text",
      callback: Editable.InsertTextSignalCallback
    ): number
    on(
      sigName: "insert-text",
      callback: Editable.InsertTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-text",
      callback: Editable.InsertTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-text",
      callback: Editable.InsertTextSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "insert-text",
      length: number,
      position: number,
      ...args: any[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.Editable

    connect(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-position", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-undo", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-bound", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEditable` is an interface for text editing widgets.
   *
   * Typical examples of editable widgets are [class`Gtk`.Entry] and
   * [class`Gtk`.SpinButton]. It contains functions for generically manipulating
   * an editable widget, a large number of action signals used for key bindings,
   * and several signals that an application can connect to modify the behavior
   * of a widget.
   *
   * As an example of the latter usage, by connecting the following handler to
   * [signal`Gtk`.Editable::insert-text], an application can convert all entry
   * into a widget into uppercase.
   *
   * ## Forcing entry to uppercase.
   *
   * ```c
   * #include <ctype.h>
   *
   * void
   * insert_text_handler (GtkEditable *editable,
   *                      const char  *text,
   *                      int          length,
   *                      int         *position,
   *                      gpointer     data)
   * {
   *   char *result = g_utf8_strup (text, length);
   *
   *   g_signal_handlers_block_by_func (editable,
   *                                (gpointer) insert_text_handler, data);
   *   gtk_editable_insert_text (editable, result, length, position);
   *   g_signal_handlers_unblock_by_func (editable,
   *                                      (gpointer) insert_text_handler, data);
   *
   *   g_signal_stop_emission_by_name (editable, "insert_text");
   *
   *   g_free (result);
   * }
   * ```
   *
   * ## Implementing GtkEditable
   *
   * The most likely scenario for implementing `GtkEditable` on your own widget
   * is that you will embed a `GtkText` inside a complex widget, and want to
   * delegate the editable functionality to that text widget. `GtkEditable`
   * provides some utility functions to make this easy.
   *
   * In your class_init function, call [func`Gtk`.Editable.install_properties],
   * passing the first available property ID:
   *
   * ```c
   * static void
   * my_class_init (MyClass *class)
   * {
   *   ...
   *   g_object_class_install_properties (object_class, NUM_PROPERTIES, props);
   *   gtk_editable_install_properties (object_clas, NUM_PROPERTIES);
   *   ...
   * }
   * ```
   *
   * In your interface_init function for the `GtkEditable` interface, provide
   * an implementation for the get_delegate vfunc that returns your text widget:
   *
   * ```c
   * GtkEditable *
   * get_editable_delegate (GtkEditable *editable)
   * {
   *   return GTK_EDITABLE (MY_WIDGET (editable)->text_widget);
   * }
   *
   * static void
   * my_editable_init (GtkEditableInterface *iface)
   * {
   *   iface->get_delegate = get_editable_delegate;
   * }
   * ```
   *
   * You don't need to provide any other vfuncs. The default implementations
   * work by forwarding to the delegate that the GtkEditableInterface.get_delegate()
   * vfunc returns.
   *
   * In your instance_init function, create your text widget, and then call
   * [method`Gtk`.Editable.init_delegate]:
   *
   * ```c
   * static void
   * my_widget_init (MyWidget *self)
   * {
   *   ...
   *   self->text_widget = gtk_text_new ();
   *   gtk_editable_init_delegate (GTK_EDITABLE (self));
   *   ...
   * }
   * ```
   *
   * In your dispose function, call [method`Gtk`.Editable.finish_delegate] before
   * destroying your text widget:
   *
   * ```c
   * static void
   * my_widget_dispose (GObject *object)
   * {
   *   ...
   *   gtk_editable_finish_delegate (GTK_EDITABLE (self));
   *   g_clear_pointer (&self->text_widget, gtk_widget_unparent);
   *   ...
   * }
   * ```
   *
   * Finally, use [func`Gtk`.Editable.delegate_set_property] in your `set_property`
   * function (and similar for `get_property`), to set the editable properties:
   *
   * ```c
   *   ...
   *   if (gtk_editable_delegate_set_property (object, prop_id, value, pspec))
   *     return;
   *
   *   switch (prop_id)
   *   ...
   * ```
   *
   * It is important to note that if you create a `GtkEditable` that uses
   * a delegate, the low level [signal`Gtk`.Editable::insert-text] and
   * [signal`Gtk`.Editable::delete-text] signals will be propagated from the
   * "wrapper" editable to the delegate, but they will not be propagated from
   * the delegate to the "wrapper" editable, as they would cause an infinite
   * recursion. If you wish to connect to the [signal`Gtk`.Editable::insert-text]
   * and [signal`Gtk`.Editable::delete-text] signals, you will need to connect
   * to them on the delegate obtained via [method`Gtk`.Editable.get_delegate].
   * @interface
   */
  class Editable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Editable

    static name: string

    // Constructors of Gtk-4.0.Gtk.Editable

    constructor(config?: Editable.ConstructorProperties)
    _init(config?: Editable.ConstructorProperties): void
    /**
     * Gets a property of the `GtkEditable` delegate for `object`.
     *
     * This is helper function that should be called in the `get_property`
     * function of your `GtkEditable` implementation, before handling your
     * own properties.
     * @param object a `GObject`
     * @param propId a property ID
     * @param value value to set
     * @param pspec the `GParamSpec` for the property
     * @returns %TRUE if the property was found
     */
    static delegateGetProperty(
      object: GObject.Object,
      propId: number,
      value: any,
      pspec: GObject.ParamSpec
    ): boolean
    /**
     * Sets a property on the `GtkEditable` delegate for `object`.
     *
     * This is a helper function that should be called in the `set_property`
     * function of your `GtkEditable` implementation, before handling your
     * own properties.
     * @param object a `GObject`
     * @param propId a property ID
     * @param value value to set
     * @param pspec the `GParamSpec` for the property
     * @returns %TRUE if the property was found
     */
    static delegateSetProperty(
      object: GObject.Object,
      propId: number,
      value: any,
      pspec: GObject.ParamSpec
    ): boolean
    /**
     * Overrides the `GtkEditable` properties for `class`.
     *
     * This is a helper function that should be called in class_init,
     * after installing your own properties.
     *
     * Note that your class must have "text", "cursor-position",
     * "selection-bound", "editable", "width-chars", "max-width-chars",
     * "xalign" and "enable-undo" properties for this function to work.
     *
     * To handle the properties in your set_property and get_property
     * functions, you can either use [func`Gtk`.Editable.delegate_set_property]
     * and [func`Gtk`.Editable.delegate_get_property] (if you are using
     * a delegate), or remember the `first_prop` offset and add it to the
     * values in the [enum`Gtk`.EditableProperties] enumeration to get the
     * property IDs for these properties.
     * @param objectClass a `GObjectClass`
     * @param firstProp property ID to use for the first property
     * @returns the number of properties that were installed
     */
    static installProperties(
      objectClass: GObject.ObjectClass,
      firstProp: number
    ): number
  }

  module FileChooser {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FileChooser

      /**
       * The type of operation that the file chooser is performing.
       */
      action?: FileChooserAction | null
      /**
       * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
       * will offer the user to create new folders.
       */
      create_folders?: boolean | null
      /**
       * The current filter for selecting files that are displayed.
       */
      filter?: FileFilter | null
      /**
       * Whether to allow multiple files to be selected.
       */
      select_multiple?: boolean | null
    }
  }

  interface FileChooser {
    // Own properties of Gtk-4.0.Gtk.FileChooser

    /**
     * The type of operation that the file chooser is performing.
     */
    action: FileChooserAction
    /**
     * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
     * will offer the user to create new folders.
     */
    createFolders: boolean
    /**
     * The current filter for selecting files that are displayed.
     */
    filter: FileFilter
    /**
     * A `GListModel` containing the filters that have been
     * added with gtk_file_chooser_add_filter().
     *
     * The returned object should not be modified. It may
     * or may not be updated for later changes.
     */
    readonly filters: Gio.ListModel
    /**
     * Whether to allow multiple files to be selected.
     */
    selectMultiple: boolean
    /**
     * A `GListModel` containing the shortcut folders that have been
     * added with gtk_file_chooser_add_shortcut_folder().
     *
     * The returned object should not be modified. It may
     * or may not be updated for later changes.
     */
    readonly shortcutFolders: Gio.ListModel
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FileChooser

    /**
     * Adds a 'choice' to the file chooser.
     *
     * This is typically implemented as a combobox or, for boolean choices,
     * as a checkbutton. You can select a value using
     * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
     * and you can obtain the user-selected value in the
     * [signal`Gtk`.Dialog::response] signal handler using
     * [method`Gtk`.FileChooser.get_choice].
     * @param id id for the added choice
     * @param label user-visible label for the added choice
     * @param options ids for the options of the choice, or %NULL for a boolean choice
     * @param optionLabels user-visible labels for the options, must be the same length as `options`
     */
    addChoice(
      id: string,
      label: string,
      options: string[] | null,
      optionLabels: string[] | null
    ): void
    /**
     * Adds `filter` to the list of filters that the user can select between.
     *
     * When a filter is selected, only files that are passed by that
     * filter are displayed.
     *
     * Note that the `chooser` takes ownership of the filter if it is floating,
     * so you have to ref and sink it if you want to keep a reference.
     * @param filter a `GtkFileFilter`
     */
    addFilter(filter: FileFilter): void
    /**
     * Adds a folder to be displayed with the shortcut folders
     * in a file chooser.
     * @param folder a `GFile` for the folder to add
     * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
     */
    addShortcutFolder(folder: Gio.File): boolean
    /**
     * Gets the type of operation that the file chooser is performing.
     * @returns the action that the file selector is performing
     */
    getAction(): FileChooserAction
    /**
     * Gets the currently selected option in the 'choice' with the given ID.
     * @param id the ID of the choice to get
     * @returns the ID of the currently selected option
     */
    getChoice(id: string): string | null
    /**
     * Gets whether file chooser will offer to create new folders.
     * @returns %TRUE if the Create Folder button should be displayed.
     */
    getCreateFolders(): boolean
    /**
     * Gets the current folder of `chooser` as `GFile`.
     * @returns the `GFile` for the current folder.
     */
    getCurrentFolder(): Gio.File | null
    /**
     * Gets the current name in the file selector, as entered by the user.
     *
     * This is meant to be used in save dialogs, to get the currently typed
     * filename when the file itself does not exist yet.
     * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
     */
    getCurrentName(): string | null
    /**
     * Gets the `GFile` for the currently selected file in
     * the file selector.
     *
     * If multiple files are selected, one of the files will be
     * returned at random.
     *
     * If the file chooser is in folder mode, this function returns
     * the selected folder.
     * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
     */
    getFile(): Gio.File | null
    /**
     * Lists all the selected files and subfolders in the current folder
     * of `chooser` as `GFile`.
     * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
     */
    getFiles(): Gio.ListModel
    /**
     * Gets the current filter.
     * @returns the current filter
     */
    getFilter(): FileFilter | null
    /**
     * Gets the current set of user-selectable filters, as a list model.
     *
     * See [method`Gtk`.FileChooser.add_filter] and
     * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
     *
     * You should not modify the returned list model. Future changes to
     * `chooser` may or may not affect the returned model.
     * @returns a `GListModel` containing the current set   of user-selectable filters.
     */
    getFilters(): Gio.ListModel
    /**
     * Gets whether multiple files can be selected in the file
     * chooser.
     * @returns %TRUE if multiple files can be selected.
     */
    getSelectMultiple(): boolean
    /**
     * Queries the list of shortcut folders in the file chooser.
     *
     * You should not modify the returned list model. Future changes to
     * `chooser` may or may not affect the returned model.
     * @returns A list model of `GFile`s
     */
    getShortcutFolders(): Gio.ListModel
    /**
     * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
     * @param id the ID of the choice to remove
     */
    removeChoice(id: string): void
    /**
     * Removes `filter` from the list of filters that the user can select between.
     * @param filter a `GtkFileFilter`
     */
    removeFilter(filter: FileFilter): void
    /**
     * Removes a folder from the shortcut folders in a file chooser.
     * @param folder a `GFile` for the folder to remove
     * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
     */
    removeShortcutFolder(folder: Gio.File): boolean
    /**
     * Sets the type of operation that the chooser is performing.
     *
     * The user interface is adapted to suit the selected action.
     *
     * For example, an option to create a new folder might be shown
     * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
     * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
     * @param action the action that the file selector is performing
     */
    setAction(action: FileChooserAction): void
    /**
     * Selects an option in a 'choice' that has been added with
     * gtk_file_chooser_add_choice().
     *
     * For a boolean choice, the possible options are "true" and "false".
     * @param id the ID of the choice to set
     * @param option the ID of the option to select
     */
    setChoice(id: string, option: string): void
    /**
     * Sets whether file chooser will offer to create new folders.
     *
     * This is only relevant if the action is not set to be
     * %GTK_FILE_CHOOSER_ACTION_OPEN.
     * @param createFolders %TRUE if the Create Folder button should be displayed
     */
    setCreateFolders(createFolders: boolean): void
    /**
     * Sets the current folder for `chooser` from a `GFile`.
     * @param file the `GFile` for the new folder
     * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
     */
    setCurrentFolder(file: Gio.File | null): boolean
    /**
     * Sets the current name in the file selector, as if entered
     * by the user.
     *
     * Note that the name passed in here is a UTF-8 string rather
     * than a filename. This function is meant for such uses as a
     * suggested name in a “Save As...” dialog.  You can pass
     * “Untitled.doc” or a similarly suitable suggestion for the `name`.
     *
     * If you want to preselect a particular existing file, you should
     * use [method`Gtk`.FileChooser.set_file] instead.
     *
     * Please see the documentation for those functions for an example
     * of using [method`Gtk`.FileChooser.set_current_name] as well.
     * @param name the filename to use, as a UTF-8 string
     */
    setCurrentName(name: string): void
    /**
     * Sets `file` as the current filename for the file chooser.
     *
     * This includes changing to the file’s parent folder and actually selecting
     * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
     * the file’s base name will also appear in the dialog’s file name entry.
     *
     * If the file name isn’t in the current folder of `chooser,` then the current
     * folder of `chooser` will be changed to the folder containing `file`.
     *
     * Note that the file must exist, or nothing will be done except
     * for the directory change.
     *
     * If you are implementing a save dialog, you should use this function if
     * you already have a file name to which the user may save; for example,
     * when the user opens an existing file and then does “Save As…”. If you
     * don’t have a file name already — for example, if the user just created
     * a new file and is saving it for the first time, do not call this function.
     *
     * Instead, use something similar to this:
     *
     * ```c
     * static void
     * prepare_file_chooser (GtkFileChooser *chooser,
     *                       GFile          *existing_file)
     * {
     *   gboolean document_is_new = (existing_file == NULL);
     *
     *   if (document_is_new)
     *     {
     *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
     *       // the user just created a new document
     *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
     *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
     *       g_object_unref (default_file_for_saving);
     *     }
     *   else
     *     {
     *       // the user edited an existing document
     *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
     *     }
     * }
     * ```
     * @param file the `GFile` to set as current
     * @returns Not useful
     */
    setFile(file: Gio.File): boolean
    /**
     * Sets the current filter.
     *
     * Only the files that pass the filter will be displayed.
     * If the user-selectable list of filters is non-empty, then
     * the filter should be one of the filters in that list.
     *
     * Setting the current filter when the list of filters is
     * empty is useful if you want to restrict the displayed
     * set of files without letting the user change it.
     * @param filter a `GtkFileFilter`
     */
    setFilter(filter: FileFilter): void
    /**
     * Sets whether multiple files can be selected in the file chooser.
     *
     * This is only relevant if the action is set to be
     * %GTK_FILE_CHOOSER_ACTION_OPEN or
     * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
     * @param selectMultiple %TRUE if multiple files can be selected.
     */
    setSelectMultiple(selectMultiple: boolean): void

    // Class property signals of Gtk-4.0.Gtk.FileChooser

    connect(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action", ...args: any[]): void
    connect(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::create-folders", ...args: any[]): void
    connect(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filter", ...args: any[]): void
    connect(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filters", ...args: any[]): void
    connect(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::select-multiple", ...args: any[]): void
    connect(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shortcut-folders", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFileChooser` is an interface that can be implemented by file
   * selection widgets.
   *
   * In GTK, the main objects that implement this interface are
   * [class`Gtk`.FileChooserWidget] and [class`Gtk`.FileChooserDialog].
   *
   * You do not need to write an object that implements the `GtkFileChooser`
   * interface unless you are trying to adapt an existing file selector to
   * expose a standard programming interface.
   *
   * `GtkFileChooser` allows for shortcuts to various places in the filesystem.
   * In the default implementation these are displayed in the left pane. It
   * may be a bit confusing at first that these shortcuts come from various
   * sources and in various flavours, so lets explain the terminology here:
   *
   * - Bookmarks: are created by the user, by dragging folders from the
   *   right pane to the left pane, or by using the “Add”. Bookmarks
   *   can be renamed and deleted by the user.
   *
   * - Shortcuts: can be provided by the application. For example, a Paint
   *   program may want to add a shortcut for a Clipart folder. Shortcuts
   *   cannot be modified by the user.
   *
   * - Volumes: are provided by the underlying filesystem abstraction. They are
   *   the “roots” of the filesystem.
   *
   * # File Names and Encodings
   *
   * When the user is finished selecting files in a `GtkFileChooser`, your
   * program can get the selected filenames as `GFile`s.
   *
   * # Adding options
   *
   * You can add extra widgets to a file chooser to provide options
   * that are not present in the default design, by using
   * [method`Gtk`.FileChooser.add_choice]. Each choice has an identifier and
   * a user visible label; additionally, each choice can have multiple
   * options. If a choice has no option, it will be rendered as a
   * check button with the given label; if a choice has options, it will
   * be rendered as a combo box.
   * @interface
   */
  class FileChooser extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.FileChooser

    static name: string

    // Constructors of Gtk-4.0.Gtk.FileChooser

    constructor(config?: FileChooser.ConstructorProperties)
    _init(config?: FileChooser.ConstructorProperties): void
  }

  module FontChooser {
    // Signal callback interfaces

    /**
     * Signal callback interface for `font-activated`
     */
    interface FontActivatedSignalCallback {
      (fontname: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FontChooser

      /**
       * The font description as a string, e.g. "Sans Italic 12".
       */
      font?: string | null
      /**
       * The font description as a `PangoFontDescription`.
       */
      font_desc?: Pango.FontDescription | null
      /**
       * The language for which the font features were selected.
       */
      language?: string | null
      /**
       * The level of granularity to offer for selecting fonts.
       */
      level?: FontChooserLevel | null
      /**
       * The string with which to preview the font.
       */
      preview_text?: string | null
      /**
       * Whether to show an entry to change the preview text.
       */
      show_preview_entry?: boolean | null
    }
  }

  interface FontChooser {
    // Own properties of Gtk-4.0.Gtk.FontChooser

    /**
     * The font description as a string, e.g. "Sans Italic 12".
     */
    font: string | null
    /**
     * The font description as a `PangoFontDescription`.
     */
    fontDesc: Pango.FontDescription
    /**
     * The selected font features.
     *
     * The format of the string is compatible with
     * CSS and with Pango attributes.
     */
    readonly fontFeatures: string | null
    /**
     * The language for which the font features were selected.
     */
    language: string | null
    /**
     * The level of granularity to offer for selecting fonts.
     */
    level: FontChooserLevel
    /**
     * The string with which to preview the font.
     */
    previewText: string | null
    /**
     * Whether to show an entry to change the preview text.
     */
    showPreviewEntry: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FontChooser

    /**
     * Gets the currently-selected font name.
     *
     * Note that this can be a different string than what you set with
     * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
     * normalize font names and thus return a string with a different
     * structure. For example, “Helvetica Italic Bold 12” could be
     * normalized to “Helvetica Bold Italic 12”.
     *
     * Use [method`Pango`.FontDescription.equal] if you want to compare two
     * font descriptions.
     * @returns A string with the name   of the current font
     */
    getFont(): string | null
    /**
     * Gets the currently-selected font.
     *
     * Note that this can be a different string than what you set with
     * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
     * normalize font names and thus return a string with a different
     * structure. For example, “Helvetica Italic Bold 12” could be
     * normalized to “Helvetica Bold Italic 12”.
     *
     * Use [method`Pango`.FontDescription.equal] if you want to compare two
     * font descriptions.
     * @returns A `PangoFontDescription` for the   current font
     */
    getFontDesc(): Pango.FontDescription | null
    // Has conflict: getFontFace(): Pango.FontFace | null
    // Has conflict: getFontFamily(): Pango.FontFamily | null
    /**
     * Gets the currently-selected font features.
     *
     * The format of the returned string is compatible with the
     * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
     * It can be passed to [func`Pango`.AttrFontFeatures.new].
     * @returns the currently selected font features
     */
    getFontFeatures(): string | null
    // Has conflict: getFontMap(): Pango.FontMap | null
    // Has conflict: getFontSize(): number
    /**
     * Gets the language that is used for font features.
     * @returns the currently selected language
     */
    getLanguage(): string | null
    /**
     * Returns the current level of granularity for selecting fonts.
     * @returns the current granularity level
     */
    getLevel(): FontChooserLevel
    /**
     * Gets the text displayed in the preview area.
     * @returns the text displayed in the preview area
     */
    getPreviewText(): string | null
    /**
     * Returns whether the preview entry is shown or not.
     * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
     */
    getShowPreviewEntry(): boolean
    // Has conflict: setFilterFunc(filter: FontFilterFunc | null): void
    /**
     * Sets the currently-selected font.
     * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
     */
    setFont(fontname: string): void
    /**
     * Sets the currently-selected font from `font_desc`.
     * @param fontDesc a `PangoFontDescription`
     */
    setFontDesc(fontDesc: Pango.FontDescription): void
    // Has conflict: setFontMap(fontmap: Pango.FontMap | null): void
    /**
     * Sets the language to use for font features.
     * @param language a language
     */
    setLanguage(language: string): void
    /**
     * Sets the desired level of granularity for selecting fonts.
     * @param level the desired level of granularity
     */
    setLevel(level: FontChooserLevel): void
    /**
     * Sets the text displayed in the preview area.
     *
     * The `text` is used to show how the selected font looks.
     * @param text the text to display in the preview area
     */
    setPreviewText(text: string): void
    /**
     * Shows or hides the editable preview entry.
     * @param showPreviewEntry whether to show the editable preview entry or not
     */
    setShowPreviewEntry(showPreviewEntry: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.FontChooser

    fontActivated(fontname: string): void
    /**
     * Gets the `PangoFontFace` representing the selected font group
     * details (i.e. family, slant, weight, width, etc).
     *
     * If the selected font is not installed, returns %NULL.
     * @virtual
     * @returns A `PangoFontFace` representing the   selected font group details
     */
    getFontFace(): Pango.FontFace | null
    /**
     * Gets the `PangoFontFamily` representing the selected font family.
     *
     * Font families are a collection of font faces.
     *
     * If the selected font is not installed, returns %NULL.
     * @virtual
     * @returns A `PangoFontFamily` representing the   selected font family
     */
    getFontFamily(): Pango.FontFamily | null
    /**
     * Gets the custom font map of this font chooser widget,
     * or %NULL if it does not have one.
     * @virtual
     * @returns a `PangoFontMap`
     */
    getFontMap(): Pango.FontMap | null
    /**
     * The selected font size.
     * @virtual
     * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
     */
    getFontSize(): number
    /**
     * Adds a filter function that decides which fonts to display
     * in the font chooser.
     * @virtual
     * @param filter a `GtkFontFilterFunc`
     */
    setFilterFunc(filter: FontFilterFunc | null): void
    /**
     * Sets a custom font map to use for this font chooser widget.
     *
     * A custom font map can be used to present application-specific
     * fonts instead of or in addition to the normal system fonts.
     *
     * ```c
     * FcConfig *config;
     * PangoFontMap *fontmap;
     *
     * config = FcInitLoadConfigAndFonts ();
     * FcConfigAppFontAddFile (config, my_app_font_file);
     *
     * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
     * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
     *
     * gtk_font_chooser_set_font_map (font_chooser, fontmap);
     * ```
     *
     * Note that other GTK widgets will only be able to use the
     * application-specific font if it is present in the font map they use:
     *
     * ```c
     * context = gtk_widget_get_pango_context (label);
     * pango_context_set_font_map (context, fontmap);
     * ```
     * @virtual
     * @param fontmap a `PangoFontMap`
     */
    setFontMap(fontmap: Pango.FontMap | null): void

    // Own signals of Gtk-4.0.Gtk.FontChooser

    connect(
      sigName: "font-activated",
      callback: FontChooser.FontActivatedSignalCallback
    ): number
    on(
      sigName: "font-activated",
      callback: FontChooser.FontActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "font-activated",
      callback: FontChooser.FontActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "font-activated",
      callback: FontChooser.FontActivatedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "font-activated", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.FontChooser

    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-features", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::level", ...args: any[]): void
    connect(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::preview-text", ...args: any[]): void
    connect(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-preview-entry", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFontChooser` is an interface that can be implemented by widgets
   * for choosing fonts.
   *
   * In GTK, the main objects that implement this interface are
   * [class`Gtk`.FontChooserWidget], [class`Gtk`.FontChooserDialog] and
   * [class`Gtk`.FontButton].
   * @interface
   */
  class FontChooser extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.FontChooser

    static name: string

    // Constructors of Gtk-4.0.Gtk.FontChooser

    constructor(config?: FontChooser.ConstructorProperties)
    _init(config?: FontChooser.ConstructorProperties): void
  }

  module Native {
    // Constructor properties interface

    interface ConstructorProperties
      extends Widget.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface Native extends Widget {
    // Own properties of Gtk-4.0.Gtk.Native

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Native

    /**
     * Returns the renderer that is used for this `GtkNative`.
     * @returns the renderer for @self
     */
    getRenderer(): Gsk.Renderer | null
    /**
     * Returns the surface of this `GtkNative`.
     * @returns the surface of @self
     */
    getSurface(): Gdk.Surface | null
    /**
     * Retrieves the surface transform of `self`.
     *
     * This is the translation from `self'`s surface coordinates into
     * `self'`s widget coordinates.
     */
    getSurfaceTransform(): [/* x */ number, /* y */ number]
    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void

    // Class property signals of Gtk-4.0.Gtk.Native

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkNative` is the interface implemented by all widgets that have
   * their own `GdkSurface`.
   *
   * The obvious example of a `GtkNative` is `GtkWindow`.
   *
   * Every widget that is not itself a `GtkNative` is contained in one,
   * and you can get it with [method`Gtk`.Widget.get_native].
   *
   * To get the surface of a `GtkNative`, use [method`Gtk`.Native.get_surface].
   * It is also possible to find the `GtkNative` to which a surface
   * belongs, with [func`Gtk`.Native.get_for_surface].
   *
   * In addition to a [class`Gdk`.Surface], a `GtkNative` also provides
   * a [class`Gsk`.Renderer] for rendering on that surface. To get the
   * renderer, use [method`Gtk`.Native.get_renderer].
   * @interface
   */
  class Native extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Native

    static name: string

    // Constructors of Gtk-4.0.Gtk.Native

    constructor(config?: Native.ConstructorProperties)
    _init(config?: Native.ConstructorProperties): void
    /**
     * Finds the `GtkNative` associated with the surface.
     * @param surface a `GdkSurface`
     * @returns the `GtkNative` that is associated with @surface
     */
    static getForSurface(surface: Gdk.Surface): Native | null
  }

  module Orientable {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Orientable

      /**
       * The orientation of the orientable.
       */
      orientation?: Orientation | null
    }
  }

  interface Orientable {
    // Own properties of Gtk-4.0.Gtk.Orientable

    /**
     * The orientation of the orientable.
     */
    orientation: Orientation
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Orientable

    /**
     * Retrieves the orientation of the `orientable`.
     * @returns the orientation of the @orientable
     */
    getOrientation(): Orientation
    /**
     * Sets the orientation of the `orientable`.
     * @param orientation the orientable’s new orientation
     */
    setOrientation(orientation: Orientation): void

    // Class property signals of Gtk-4.0.Gtk.Orientable

    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkOrientable` interface is implemented by all widgets that can be
   * oriented horizontally or vertically.
   *
   * `GtkOrientable` is more flexible in that it allows the orientation to be
   * changed at runtime, allowing the widgets to “flip”.
   *
   * ## CSS nodes
   *
   * `GtkWidget` types implementing the `GtkOrientable` interface will
   * automatically acquire the `horizontal` or `vertical` CSS class depending on
   * the value of the [property`Gtk`.Orientable:orientation] property.
   * @interface
   */
  class Orientable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Orientable

    static name: string

    // Constructors of Gtk-4.0.Gtk.Orientable

    constructor(config?: Orientable.ConstructorProperties)
    _init(config?: Orientable.ConstructorProperties): void
  }

  module PrintOperationPreview {
    // Signal callback interfaces

    /**
     * Signal callback interface for `got-page-size`
     */
    interface GotPageSizeSignalCallback {
      (context: PrintContext, pageSetup: PageSetup): void
    }

    /**
     * Signal callback interface for `ready`
     */
    interface ReadySignalCallback {
      (context: PrintContext): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface PrintOperationPreview {
    // Own properties of Gtk-4.0.Gtk.PrintOperationPreview

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PrintOperationPreview

    // Has conflict: endPreview(): void
    // Has conflict: isSelected(pageNr: number): boolean
    // Has conflict: renderPage(pageNr: number): void

    // Own virtual methods of Gtk-4.0.Gtk.PrintOperationPreview

    /**
     * Ends a preview.
     *
     * This function must be called to finish a custom print preview.
     * @virtual
     */
    endPreview(): void
    gotPageSize(context: PrintContext, pageSetup: PageSetup): void
    /**
     * Returns whether the given page is included in the set of pages that
     * have been selected for printing.
     * @virtual
     * @param pageNr a page number
     * @returns %TRUE if the page has been selected for printing
     */
    isSelected(pageNr: number): boolean
    ready(context: PrintContext): void
    /**
     * Renders a page to the preview.
     *
     * This is using the print context that was passed to the
     * [signal`Gtk`.PrintOperation::preview] handler together
     * with `preview`.
     *
     * A custom print preview should use this function to render
     * the currently selected page.
     *
     * Note that this function requires a suitable cairo context to
     * be associated with the print context.
     * @virtual
     * @param pageNr the page to render
     */
    renderPage(pageNr: number): void

    // Own signals of Gtk-4.0.Gtk.PrintOperationPreview

    connect(
      sigName: "got-page-size",
      callback: PrintOperationPreview.GotPageSizeSignalCallback
    ): number
    on(
      sigName: "got-page-size",
      callback: PrintOperationPreview.GotPageSizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "got-page-size",
      callback: PrintOperationPreview.GotPageSizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "got-page-size",
      callback: PrintOperationPreview.GotPageSizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "got-page-size", pageSetup: PageSetup, ...args: any[]): void
    connect(
      sigName: "ready",
      callback: PrintOperationPreview.ReadySignalCallback
    ): number
    on(
      sigName: "ready",
      callback: PrintOperationPreview.ReadySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "ready",
      callback: PrintOperationPreview.ReadySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "ready",
      callback: PrintOperationPreview.ReadySignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "ready", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.PrintOperationPreview

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPrintOperationPreview` is the interface that is used to
   * implement print preview.
   *
   * A `GtkPrintOperationPreview` object is passed to the
   * [signal`Gtk`.PrintOperation::preview] signal by
   * [class`Gtk`.PrintOperation].
   * @interface
   */
  class PrintOperationPreview extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.PrintOperationPreview

    static name: string

    // Constructors of Gtk-4.0.Gtk.PrintOperationPreview

    constructor(config?: PrintOperationPreview.ConstructorProperties)
    _init(config?: PrintOperationPreview.ConstructorProperties): void
  }

  module Root {
    // Constructor properties interface

    interface ConstructorProperties
      extends Native.ConstructorProperties,
        Widget.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface Root extends Native, Widget {
    // Own properties of Gtk-4.0.Gtk.Root

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Root

    /**
     * Returns the display that this `GtkRoot` is on.
     * @returns the display of @root
     */
    getDisplay(): Gdk.Display
    /**
     * Retrieves the current focused widget within the root.
     *
     * Note that this is the widget that would have the focus
     * if the root is active; if the root is not focused then
     * `gtk_widget_has_focus (widget)` will be %FALSE for the
     * widget.
     * @returns the currently focused widget
     */
    getFocus(): Widget | null
    /**
     * If `focus` is not the current focus widget, and is focusable, sets
     * it as the focus widget for the root.
     *
     * If `focus` is %NULL, unsets the focus widget for the root.
     *
     * To set the focus to a particular widget in the root, it is usually
     * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
     * this function.
     * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
     */
    setFocus(focus: Widget | null): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void

    // Class property signals of Gtk-4.0.Gtk.Root

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkRoot` is the interface implemented by all widgets that can act as a toplevel
   * widget.
   *
   * The root widget takes care of providing the connection to the windowing system
   * and manages layout, drawing and event delivery for its widget hierarchy.
   *
   * The obvious example of a `GtkRoot` is `GtkWindow`.
   *
   * To get the display to which a `GtkRoot` belongs, use
   * [method`Gtk`.Root.get_display].
   *
   * `GtkRoot` also maintains the location of keyboard focus inside its widget
   * hierarchy, with [method`Gtk`.Root.set_focus] and [method`Gtk`.Root.get_focus].
   * @interface
   */
  class Root extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Root

    static name: string

    // Constructors of Gtk-4.0.Gtk.Root

    constructor(config?: Root.ConstructorProperties)
    _init(config?: Root.ConstructorProperties): void
  }

  module Scrollable {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Scrollable

      /**
       * Horizontal `GtkAdjustment` of the scrollable widget.
       *
       * This adjustment is shared between the scrollable widget and its parent.
       */
      hadjustment?: Adjustment | null
      /**
       * Determines when horizontal scrolling should start.
       */
      hscroll_policy?: ScrollablePolicy | null
      /**
       * Vertical `GtkAdjustment` of the scrollable widget.
       *
       * This adjustment is shared between the scrollable widget and its parent.
       */
      vadjustment?: Adjustment | null
      /**
       * Determines when vertical scrolling should start.
       */
      vscroll_policy?: ScrollablePolicy | null
    }
  }

  interface Scrollable {
    // Own properties of Gtk-4.0.Gtk.Scrollable

    /**
     * Horizontal `GtkAdjustment` of the scrollable widget.
     *
     * This adjustment is shared between the scrollable widget and its parent.
     */
    hadjustment: Adjustment
    /**
     * Determines when horizontal scrolling should start.
     */
    hscrollPolicy: ScrollablePolicy
    /**
     * Vertical `GtkAdjustment` of the scrollable widget.
     *
     * This adjustment is shared between the scrollable widget and its parent.
     */
    vadjustment: Adjustment
    /**
     * Determines when vertical scrolling should start.
     */
    vscrollPolicy: ScrollablePolicy
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Scrollable

    // Has conflict: getBorder(): [ /* returnType */ boolean, /* border */ Border ]
    /**
     * Retrieves the `GtkAdjustment` used for horizontal scrolling.
     * @returns horizontal `GtkAdjustment`.
     */
    getHadjustment(): Adjustment | null
    /**
     * Gets the horizontal `GtkScrollablePolicy`.
     * @returns The horizontal `GtkScrollablePolicy`.
     */
    getHscrollPolicy(): ScrollablePolicy
    /**
     * Retrieves the `GtkAdjustment` used for vertical scrolling.
     * @returns vertical `GtkAdjustment`.
     */
    getVadjustment(): Adjustment | null
    /**
     * Gets the vertical `GtkScrollablePolicy`.
     * @returns The vertical `GtkScrollablePolicy`.
     */
    getVscrollPolicy(): ScrollablePolicy
    /**
     * Sets the horizontal adjustment of the `GtkScrollable`.
     * @param hadjustment a `GtkAdjustment`
     */
    setHadjustment(hadjustment: Adjustment | null): void
    /**
     * Sets the `GtkScrollablePolicy`.
     *
     * The policy determines whether horizontal scrolling should start
     * below the minimum width or below the natural width.
     * @param policy the horizontal `GtkScrollablePolicy`
     */
    setHscrollPolicy(policy: ScrollablePolicy): void
    /**
     * Sets the vertical adjustment of the `GtkScrollable`.
     * @param vadjustment a `GtkAdjustment`
     */
    setVadjustment(vadjustment: Adjustment | null): void
    /**
     * Sets the `GtkScrollablePolicy`.
     *
     * The policy determines whether vertical scrolling should start
     * below the minimum height or below the natural height.
     * @param policy the vertical `GtkScrollablePolicy`
     */
    setVscrollPolicy(policy: ScrollablePolicy): void

    // Own virtual methods of Gtk-4.0.Gtk.Scrollable

    /**
     * Returns the size of a non-scrolling border around the
     * outside of the scrollable.
     *
     * An example for this would be treeview headers. GTK can use
     * this information to display overlaid graphics, like the
     * overshoot indication, at the right position.
     * @virtual
     * @returns %TRUE if @border has been set
     */
    getBorder(): [/* returnType */ boolean, /* border */ Border]

    // Class property signals of Gtk-4.0.Gtk.Scrollable

    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkScrollable` is an interface for widgets with native scrolling ability.
   *
   * To implement this interface you should override the
   * [property`Gtk`.Scrollable:hadjustment] and
   * [property`Gtk`.Scrollable:vadjustment] properties.
   *
   * ## Creating a scrollable widget
   *
   * All scrollable widgets should do the following.
   *
   * - When a parent widget sets the scrollable child widget’s adjustments,
   *   the widget should connect to the [signal`Gtk`.Adjustment::value-changed]
   *   signal. The child widget should then populate the adjustments’ properties
   *   as soon as possible, which usually means queueing an allocation right away
   *   and populating the properties in the [vfunc`Gtk`.Widget.size_allocate]
   *   implementation.
   *
   * - Because its preferred size is the size for a fully expanded widget,
   *   the scrollable widget must be able to cope with underallocations.
   *   This means that it must accept any value passed to its
   *   [vfunc`Gtk`.Widget.size_allocate] implementation.
   *
   * - When the parent allocates space to the scrollable child widget,
   *   the widget must ensure the adjustments’ property values are correct and up
   *   to date, for example using [method`Gtk`.Adjustment.configure].
   *
   * - When any of the adjustments emits the [signal`Gtk`.Adjustment::value-changed]
   *   signal, the scrollable widget should scroll its contents.
   * @interface
   */
  class Scrollable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Scrollable

    static name: string

    // Constructors of Gtk-4.0.Gtk.Scrollable

    constructor(config?: Scrollable.ConstructorProperties)
    _init(config?: Scrollable.ConstructorProperties): void
  }

  module SectionModel {
    // Signal callback interfaces

    /**
     * Signal callback interface for `sections-changed`
     */
    interface SectionsChangedSignalCallback {
      (position: number, nItems: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface SectionModel extends Gio.ListModel {
    // Own properties of Gtk-4.0.Gtk.SectionModel

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SectionModel

    // Has conflict: getSection(position: number): [ /* outStart */ number, /* outEnd */ number ]
    sectionsChanged(position: number, nItems: number): void

    // Own virtual methods of Gtk-4.0.Gtk.SectionModel

    /**
     * Query the section that covers the given position. The number of
     * items in the section can be computed by `out_end - out_start`.
     *
     * If the position is larger than the number of items, a single
     * range from n_items to G_MAXUINT will be returned.
     * @virtual
     * @param position the position of the item to query
     */
    getSection(position: number): [/* outStart */ number, /* outEnd */ number]

    // Own signals of Gtk-4.0.Gtk.SectionModel

    connect(
      sigName: "sections-changed",
      callback: SectionModel.SectionsChangedSignalCallback
    ): number
    on(
      sigName: "sections-changed",
      callback: SectionModel.SectionsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "sections-changed",
      callback: SectionModel.SectionsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "sections-changed",
      callback: SectionModel.SectionsChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "sections-changed", nItems: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.SectionModel

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSectionModel` is an interface that adds support for sections to list models.
   *
   * A `GtkSectionModel` groups successive items into so-called sections. List widgets
   * like `GtkListView` and `GtkGridView` then allow displaying section headers for
   * these sections by installing a header factory.
   *
   * Many GTK list models support sections inherently, or they pass through the sections
   * of a model they are wrapping.
   *
   * When the section groupings of a model change, the model will emit the
   * [signal`Gtk`.SectionModel::sections-changed] signal by calling the
   * [method`Gtk`.SectionModel.sections_changed] function. All sections in the given range
   * then need to be queried again.
   * The [signal`Gio`.ListModel::items-changed] signal has the same effect, all sections in
   * that range are invalidated, too.
   * @interface
   */
  class SectionModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.SectionModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.SectionModel

    constructor(config?: SectionModel.ConstructorProperties)
    _init(config?: SectionModel.ConstructorProperties): void
  }

  module SelectionModel {
    // Signal callback interfaces

    /**
     * Signal callback interface for `selection-changed`
     */
    interface SelectionChangedSignalCallback {
      (position: number, nItems: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface SelectionModel extends Gio.ListModel {
    // Own properties of Gtk-4.0.Gtk.SelectionModel

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SelectionModel

    /**
     * Gets the set containing all currently selected items in the model.
     *
     * This function may be slow, so if you are only interested in single item,
     * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
     * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
     * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
     */
    getSelection(): Bitset
    // Has conflict: getSelectionInRange(position: number, nItems: number): Bitset
    // Has conflict: isSelected(position: number): boolean
    // Has conflict: selectAll(): boolean
    // Has conflict: selectItem(position: number, unselectRest: boolean): boolean
    // Has conflict: selectRange(position: number, nItems: number, unselectRest: boolean): boolean
    /**
     * Helper function for implementations of `GtkSelectionModel`.
     *
     * Call this when the selection changes to emit the
     * [signal`Gtk`.SelectionModel::selection-changed] signal.
     * @param position the first changed item
     * @param nItems the number of changed items
     */
    selectionChanged(position: number, nItems: number): void
    // Has conflict: setSelection(selected: Bitset, mask: Bitset): boolean
    // Has conflict: unselectAll(): boolean
    // Has conflict: unselectItem(position: number): boolean
    // Has conflict: unselectRange(position: number, nItems: number): boolean

    // Own virtual methods of Gtk-4.0.Gtk.SelectionModel

    /**
     * Gets the set of selected items in a range.
     *
     * This function is an optimization for
     * [method`Gtk`.SelectionModel.get_selection] when you are only
     * interested in part of the model's selected state. A common use
     * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
     * signal.
     * @virtual
     * @param position start of the queried range
     * @param nItems number of items in the queried range
     * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
     */
    getSelectionInRange(position: number, nItems: number): Bitset
    /**
     * Checks if the given item is selected.
     * @virtual
     * @param position the position of the item to query
     * @returns %TRUE if the item is selected
     */
    isSelected(position: number): boolean
    /**
     * Requests to select all items in the model.
     * @virtual
     * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
     */
    selectAll(): boolean
    /**
     * Requests to select an item in the model.
     * @virtual
     * @param position the position of the item to select
     * @param unselectRest whether previously selected items should be unselected
     * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
     */
    selectItem(position: number, unselectRest: boolean): boolean
    /**
     * Requests to select a range of items in the model.
     * @virtual
     * @param position the first item to select
     * @param nItems the number of items to select
     * @param unselectRest whether previously selected items should be unselected
     * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
     */
    selectRange(
      position: number,
      nItems: number,
      unselectRest: boolean
    ): boolean
    /**
     * Make selection changes.
     *
     * This is the most advanced selection updating method that allows
     * the most fine-grained control over selection changes. If you can,
     * you should try the simpler versions, as implementations are more
     * likely to implement support for those.
     *
     * Requests that the selection state of all positions set in `mask`
     * be updated to the respective value in the `selected` bitmask.
     *
     * In pseudocode, it would look something like this:
     *
     * ```c
     * for (i = 0; i < n_items; i++)
     *   {
     *     // don't change values not in the mask
     *     if (!gtk_bitset_contains (mask, i))
     *       continue;
     *
     *     if (gtk_bitset_contains (selected, i))
     *       select_item (i);
     *     else
     *       unselect_item (i);
     *   }
     *
     * gtk_selection_model_selection_changed (model,
     *                                        first_changed_item,
     *                                        n_changed_items);
     * ```
     *
     * `mask` and `selected` must not be modified. They may refer to the
     * same bitset, which would mean that every item in the set should
     * be selected.
     * @virtual
     * @param selected bitmask specifying if items should be selected or unselected
     * @param mask bitmask specifying which items should be updated
     * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
     */
    setSelection(selected: Bitset, mask: Bitset): boolean
    /**
     * Requests to unselect all items in the model.
     * @virtual
     * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
     */
    unselectAll(): boolean
    /**
     * Requests to unselect an item in the model.
     * @virtual
     * @param position the position of the item to unselect
     * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
     */
    unselectItem(position: number): boolean
    /**
     * Requests to unselect a range of items in the model.
     * @virtual
     * @param position the first item to unselect
     * @param nItems the number of items to unselect
     * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
     */
    unselectRange(position: number, nItems: number): boolean

    // Own signals of Gtk-4.0.Gtk.SelectionModel

    connect(
      sigName: "selection-changed",
      callback: SelectionModel.SelectionChangedSignalCallback
    ): number
    on(
      sigName: "selection-changed",
      callback: SelectionModel.SelectionChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "selection-changed",
      callback: SelectionModel.SelectionChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "selection-changed",
      callback: SelectionModel.SelectionChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "selection-changed", nItems: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.SelectionModel

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSelectionModel` is an interface that add support for selection to list models.
   *
   * This support is then used by widgets using list models to add the ability
   * to select and unselect various items.
   *
   * GTK provides default implementations of the most common selection modes such
   * as [class`Gtk`.SingleSelection], so you will only need to implement this
   * interface if you want detailed control about how selections should be handled.
   *
   * A `GtkSelectionModel` supports a single boolean per item indicating if an item is
   * selected or not. This can be queried via [method`Gtk`.SelectionModel.is_selected].
   * When the selected state of one or more items changes, the model will emit the
   * [signal`Gtk`.SelectionModel::selection-changed] signal by calling the
   * [method`Gtk`.SelectionModel.selection_changed] function. The positions given
   * in that signal may have their selection state changed, though that is not a
   * requirement. If new items added to the model via the
   * [signal`Gio`.ListModel::items-changed] signal are selected or not is up to the
   * implementation.
   *
   * Note that items added via [signal`Gio`.ListModel::items-changed] may already
   * be selected and no [signal`Gtk`.SelectionModel::selection-changed] will be
   * emitted for them. So to track which items are selected, it is necessary to
   * listen to both signals.
   *
   * Additionally, the interface can expose functionality to select and unselect
   * items. If these functions are implemented, GTK's list widgets will allow users
   * to select and unselect items. However, `GtkSelectionModel`s are free to only
   * implement them partially or not at all. In that case the widgets will not
   * support the unimplemented operations.
   *
   * When selecting or unselecting is supported by a model, the return values of
   * the selection functions do *not* indicate if selection or unselection happened.
   * They are only meant to indicate complete failure, like when this mode of
   * selecting is not supported by the model.
   *
   * Selections may happen asynchronously, so the only reliable way to find out
   * when an item was selected is to listen to the signals that indicate selection.
   * @interface
   */
  class SelectionModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.SelectionModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.SelectionModel

    constructor(config?: SelectionModel.ConstructorProperties)
    _init(config?: SelectionModel.ConstructorProperties): void
  }

  module ShortcutManager {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.ShortcutManager

    __gtype__: number

    // Own virtual methods of Gtk-4.0.Gtk.ShortcutManager

    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void

    // Class property signals of Gtk-4.0.Gtk.ShortcutManager

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkShortcutManager` interface is used to implement
   * shortcut scopes.
   *
   * This is important for [iface`Gtk`.Native] widgets that have their
   * own surface, since the event controllers that are used to implement
   * managed and global scopes are limited to the same native.
   *
   * Examples for widgets implementing `GtkShortcutManager` are
   * [class`Gtk`.Window] and [class`Gtk`.Popover].
   *
   * Every widget that implements `GtkShortcutManager` will be used as a
   * %GTK_SHORTCUT_SCOPE_MANAGED.
   * @interface
   */
  class ShortcutManager extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ShortcutManager

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutManager

    constructor(config?: ShortcutManager.ConstructorProperties)
    _init(config?: ShortcutManager.ConstructorProperties): void
  }

  module StyleProvider {
    // Signal callback interfaces

    /**
     * Signal callback interface for `gtk-private-changed`
     */
    interface GtkPrivateChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface StyleProvider {
    // Own properties of Gtk-4.0.Gtk.StyleProvider

    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.StyleProvider

    connect(
      sigName: "gtk-private-changed",
      callback: StyleProvider.GtkPrivateChangedSignalCallback
    ): number
    on(
      sigName: "gtk-private-changed",
      callback: StyleProvider.GtkPrivateChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "gtk-private-changed",
      callback: StyleProvider.GtkPrivateChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "gtk-private-changed",
      callback: StyleProvider.GtkPrivateChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "gtk-private-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.StyleProvider

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkStyleProvider` is an interface for style information used by
   * `GtkStyleContext`.
   *
   * See [method`Gtk`.StyleContext.add_provider] and
   * [func`Gtk`.StyleContext.add_provider_for_display] for
   * adding `GtkStyleProviders`.
   *
   * GTK uses the `GtkStyleProvider` implementation for CSS in
   * [class`Gtk`.CssProvider].
   * @interface
   */
  class StyleProvider extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.StyleProvider

    static name: string

    // Constructors of Gtk-4.0.Gtk.StyleProvider

    constructor(config?: StyleProvider.ConstructorProperties)
    _init(config?: StyleProvider.ConstructorProperties): void
  }

  module SymbolicPaintable {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gdk.Paintable.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface SymbolicPaintable extends Gdk.Paintable {
    // Own properties of Gtk-4.0.Gtk.SymbolicPaintable

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SymbolicPaintable

    // Has conflict: snapshotSymbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void

    // Own virtual methods of Gtk-4.0.Gtk.SymbolicPaintable

    /**
     * Snapshots the paintable with the given colors.
     *
     * If less than 4 colors are provided, GTK will pad the array with default
     * colors.
     * @virtual
     * @param snapshot a `GdkSnapshot` to snapshot to
     * @param width width to snapshot in
     * @param height height to snapshot in
     * @param colors a pointer to an array of colors
     */
    snapshotSymbolic(
      snapshot: Gdk.Snapshot,
      width: number,
      height: number,
      colors: Gdk.RGBA[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.SymbolicPaintable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSymbolicPaintable` is an interface that support symbolic colors in
   * paintables.
   *
   * `GdkPaintable`s implementing the interface will have the
   * [vfunc`Gtk`.SymbolicPaintable.snapshot_symbolic] function called and
   * have the colors for drawing symbolic icons passed. At least 4 colors are guaranteed
   * to be passed every time.
   *
   * These 4 colors are the foreground color, and the colors to use for errors, warnings
   * and success information in that order.
   *
   * More colors may be added in the future.
   * @interface
   */
  class SymbolicPaintable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.SymbolicPaintable

    static name: string

    // Constructors of Gtk-4.0.Gtk.SymbolicPaintable

    constructor(config?: SymbolicPaintable.ConstructorProperties)
    _init(config?: SymbolicPaintable.ConstructorProperties): void
  }

  module TreeDragDest {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface TreeDragDest {
    // Own properties of Gtk-4.0.Gtk.TreeDragDest

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeDragDest

    // Has conflict: dragDataReceived(dest: TreePath, value: any): boolean
    // Has conflict: rowDropPossible(destPath: TreePath, value: any): boolean

    // Own virtual methods of Gtk-4.0.Gtk.TreeDragDest

    /**
     * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
     * deriving the contents of the row from `value`. If `dest` is
     * outside the tree so that inserting before it is impossible, %FALSE
     * will be returned. Also, %FALSE may be returned if the new row is
     * not created for some model-specific reason.  Should robustly handle
     * a `dest` no longer found in the model!
     * @virtual
     * @param dest row to drop in front of
     * @param value data to drop
     * @returns whether a new row was created before position @dest
     */
    dragDataReceived(dest: TreePath, value: any): boolean
    /**
     * Determines whether a drop is possible before the given `dest_path,`
     * at the same depth as `dest_path`. i.e., can we drop the data in
     * `value` at that location. `dest_path` does not have to
     * exist; the return value will almost certainly be %FALSE if the
     * parent of `dest_path` doesn’t exist, though.
     * @virtual
     * @param destPath destination row
     * @param value the data being dropped
     * @returns %TRUE if a drop is possible before @dest_path
     */
    rowDropPossible(destPath: TreePath, value: any): boolean

    // Class property signals of Gtk-4.0.Gtk.TreeDragDest

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Interface for Drag-and-Drop destinations in `GtkTreeView`.
   * @interface
   */
  class TreeDragDest extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeDragDest

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeDragDest

    constructor(config?: TreeDragDest.ConstructorProperties)
    _init(config?: TreeDragDest.ConstructorProperties): void
  }

  module TreeDragSource {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface TreeDragSource {
    // Own properties of Gtk-4.0.Gtk.TreeDragSource

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeDragSource

    // Has conflict: dragDataDelete(path: TreePath): boolean
    // Has conflict: dragDataGet(path: TreePath): Gdk.ContentProvider | null
    // Has conflict: rowDraggable(path: TreePath): boolean

    // Own virtual methods of Gtk-4.0.Gtk.TreeDragSource

    /**
     * Asks the `GtkTreeDragSource` to delete the row at `path,` because
     * it was moved somewhere else via drag-and-drop. Returns %FALSE
     * if the deletion fails because `path` no longer exists, or for
     * some model-specific reason. Should robustly handle a `path` no
     * longer found in the model!
     * @virtual
     * @param path row that was being dragged
     * @returns %TRUE if the row was successfully deleted
     */
    dragDataDelete(path: TreePath): boolean
    /**
     * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
     * the row at `path`. Should robustly handle a `path` no
     * longer found in the model!
     * @virtual
     * @param path row that was dragged
     * @returns a `GdkContentProvider` for the    given @path
     */
    dragDataGet(path: TreePath): Gdk.ContentProvider | null
    /**
     * Asks the `GtkTreeDragSource` whether a particular row can be used as
     * the source of a DND operation. If the source doesn’t implement
     * this interface, the row is assumed draggable.
     * @virtual
     * @param path row on which user is initiating a drag
     * @returns %TRUE if the row can be dragged
     */
    rowDraggable(path: TreePath): boolean

    // Class property signals of Gtk-4.0.Gtk.TreeDragSource

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Interface for Drag-and-Drop destinations in `GtkTreeView`.
   * @interface
   */
  class TreeDragSource extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeDragSource

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeDragSource

    constructor(config?: TreeDragSource.ConstructorProperties)
    _init(config?: TreeDragSource.ConstructorProperties): void
  }

  module TreeModel {
    // Signal callback interfaces

    /**
     * Signal callback interface for `row-changed`
     */
    interface RowChangedSignalCallback {
      (path: TreePath, iter: TreeIter): void
    }

    /**
     * Signal callback interface for `row-deleted`
     */
    interface RowDeletedSignalCallback {
      (path: TreePath): void
    }

    /**
     * Signal callback interface for `row-has-child-toggled`
     */
    interface RowHasChildToggledSignalCallback {
      (path: TreePath, iter: TreeIter): void
    }

    /**
     * Signal callback interface for `row-inserted`
     */
    interface RowInsertedSignalCallback {
      (path: TreePath, iter: TreeIter): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface TreeModel {
    // Own properties of Gtk-4.0.Gtk.TreeModel

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeModel

    /**
     * Creates a new `GtkTreeModel`, with `child_model` as the child_model
     * and `root` as the virtual root.
     * @param root A `GtkTreePath`
     * @returns A new `GtkTreeModel`.
     */
    filterNew(root: TreePath | null): TreeModel
    /**
     * Calls `func` on each node in model in a depth-first fashion.
     *
     * If `func` returns %TRUE, then the tree ceases to be walked,
     * and gtk_tree_model_foreach() returns.
     * @param func a function to be called on each row
     */
    foreach(func: TreeModelForeachFunc): void
    // Has conflict: getColumnType(index: number): GObject.GType
    // Has conflict: getFlags(): TreeModelFlags
    // Has conflict: getIter(path: TreePath): [ /* returnType */ boolean, /* iter */ TreeIter ]
    /**
     * Initializes `iter` with the first iterator in the tree
     * (the one at the path "0").
     *
     * Returns %FALSE if the tree is empty, %TRUE otherwise.
     * @returns %TRUE, if @iter was set
     */
    getIterFirst(): [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Sets `iter` to a valid iterator pointing to `path_string,` if it
     * exists.
     *
     * Otherwise, `iter` is left invalid and %FALSE is returned.
     * @param pathString a string representation of a `GtkTreePath`
     * @returns %TRUE, if @iter was set
     */
    getIterFromString(
      pathString: string
    ): [/* returnType */ boolean, /* iter */ TreeIter]
    // Has conflict: getNColumns(): number
    // Has conflict: getPath(iter: TreeIter): TreePath
    /**
     * Generates a string representation of the iter.
     *
     * This string is a “:” separated list of numbers.
     * For example, “4:10:0:3” would be an acceptable
     * return value for this string.
     * @param iter a `GtkTreeIter`
     * @returns a newly-allocated string
     */
    getStringFromIter(iter: TreeIter): string | null
    // Has conflict: getValue(iter: TreeIter, column: number): /* value */ any
    // Has conflict: iterChildren(parent: TreeIter | null): [ /* returnType */ boolean, /* iter */ TreeIter ]
    // Has conflict: iterHasChild(iter: TreeIter): boolean
    // Has conflict: iterNChildren(iter: TreeIter | null): number
    // Has conflict: iterNext(iter: TreeIter): boolean
    // Has conflict: iterNthChild(parent: TreeIter | null, n: number): [ /* returnType */ boolean, /* iter */ TreeIter ]
    // Has conflict: iterParent(child: TreeIter): [ /* returnType */ boolean, /* iter */ TreeIter ]
    // Has conflict: iterPrevious(iter: TreeIter): boolean
    // Has conflict: refNode(iter: TreeIter): void
    // Has conflict: rowChanged(path: TreePath, iter: TreeIter): void
    // Has conflict: rowDeleted(path: TreePath): void
    // Has conflict: rowHasChildToggled(path: TreePath, iter: TreeIter): void
    // Has conflict: rowInserted(path: TreePath, iter: TreeIter): void
    /**
     * Emits the ::rows-reordered signal on `tree_model`.
     *
     * See [signal`Gtk`.TreeModel::rows-reordered].
     *
     * This should be called by models when their rows have been
     * reordered.
     * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
     * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of `path` is 0
     * @param newOrder an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. `new_order``[newpos] = oldpos`
     */
    rowsReordered(
      path: TreePath,
      iter: TreeIter | null,
      newOrder: number[]
    ): void
    // Has conflict: unrefNode(iter: TreeIter): void

    // Own virtual methods of Gtk-4.0.Gtk.TreeModel

    /**
     * Returns the type of the column.
     * @virtual
     * @param index the column index
     * @returns the type of the column
     */
    getColumnType(index: number): GObject.GType
    /**
     * Returns a set of flags supported by this interface.
     *
     * The flags are a bitwise combination of `GtkTreeModel`Flags.
     * The flags supported should not change during the lifetime
     * of the `tree_model`.
     * @virtual
     * @returns the flags supported by this interface
     */
    getFlags(): TreeModelFlags
    /**
     * Sets `iter` to a valid iterator pointing to `path`.
     *
     * If `path` does not exist, `iter` is set to an invalid
     * iterator and %FALSE is returned.
     * @virtual
     * @param path the `GtkTreePath`
     * @returns %TRUE, if @iter was set
     */
    getIter(path: TreePath): [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Returns the number of columns supported by `tree_model`.
     * @virtual
     * @returns the number of columns
     */
    getNColumns(): number
    /**
     * Returns a newly-created `GtkTreePath` referenced by `iter`.
     *
     * This path should be freed with gtk_tree_path_free().
     * @virtual
     * @param iter the `GtkTreeIter`
     * @returns a newly-created `GtkTreePath`
     */
    getPath(iter: TreeIter): TreePath
    /**
     * Initializes and sets `value` to that at `column`.
     *
     * When done with `value,` g_value_unset() needs to be called
     * to free any allocated memory.
     * @virtual
     * @param iter the `GtkTreeIter`
     * @param column the column to lookup the value at
     */
    getValue(iter: TreeIter, column: number): /* value */ any
    /**
     * Sets `iter` to point to the first child of `parent`.
     *
     * If `parent` has no children, %FALSE is returned and `iter` is
     * set to be invalid. `parent` will remain a valid node after this
     * function has been called.
     *
     * If `parent` is %NULL returns the first node, equivalent to
     * `gtk_tree_model_get_iter_first (tree_model, iter);`
     * @virtual
     * @param parent the `GtkTreeIter`
     * @returns %TRUE, if @iter has been set to the first child
     */
    iterChildren(
      parent: TreeIter | null
    ): [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Returns %TRUE if `iter` has children, %FALSE otherwise.
     * @virtual
     * @param iter the `GtkTreeIter` to test for children
     * @returns %TRUE if @iter has children
     */
    iterHasChild(iter: TreeIter): boolean
    /**
     * Returns the number of children that `iter` has.
     *
     * As a special case, if `iter` is %NULL, then the number
     * of toplevel nodes is returned.
     * @virtual
     * @param iter the `GtkTreeIter`
     * @returns the number of children of @iter
     */
    iterNChildren(iter: TreeIter | null): number
    /**
     * Sets `iter` to point to the node following it at the current level.
     *
     * If there is no next `iter,` %FALSE is returned and `iter` is set
     * to be invalid.
     * @virtual
     * @param iter the `GtkTreeIter`
     * @returns %TRUE if @iter has been changed to the next node
     */
    iterNext(iter: TreeIter): boolean
    /**
     * Sets `iter` to be the child of `parent,` using the given index.
     *
     * The first index is 0. If `n` is too big, or `parent` has no children,
     * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
     * will remain a valid node after this function has been called. As a
     * special case, if `parent` is %NULL, then the `n-th` root node
     * is set.
     * @virtual
     * @param parent the `GtkTreeIter` to get the child from
     * @param n the index of the desired child
     * @returns %TRUE, if @parent has an @n-th child
     */
    iterNthChild(
      parent: TreeIter | null,
      n: number
    ): [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Sets `iter` to be the parent of `child`.
     *
     * If `child` is at the toplevel, and doesn’t have a parent, then
     * `iter` is set to an invalid iterator and %FALSE is returned.
     * `child` will remain a valid node after this function has been
     * called.
     *
     * `iter` will be initialized before the lookup is performed, so `child`
     * and `iter` cannot point to the same memory location.
     * @virtual
     * @param child the `GtkTreeIter`
     * @returns %TRUE, if @iter is set to the parent of @child
     */
    iterParent(child: TreeIter): [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Sets `iter` to point to the previous node at the current level.
     *
     * If there is no previous `iter,` %FALSE is returned and `iter` is
     * set to be invalid.
     * @virtual
     * @param iter the `GtkTreeIter`
     * @returns %TRUE if @iter has been changed to the previous node
     */
    iterPrevious(iter: TreeIter): boolean
    /**
     * Lets the tree ref the node.
     *
     * This is an optional method for models to implement.
     * To be more specific, models may ignore this call as it exists
     * primarily for performance reasons.
     *
     * This function is primarily meant as a way for views to let
     * caching models know when nodes are being displayed (and hence,
     * whether or not to cache that node). Being displayed means a node
     * is in an expanded branch, regardless of whether the node is currently
     * visible in the viewport. For example, a file-system based model
     * would not want to keep the entire file-hierarchy in memory,
     * just the sections that are currently being displayed by
     * every current view.
     *
     * A model should be expected to be able to get an iter independent
     * of its reffed state.
     * @virtual
     * @param iter the `GtkTreeIter`
     */
    refNode(iter: TreeIter): void
    /**
     * Emits the ::row-changed signal on `tree_model`.
     *
     * See [signal`Gtk`.TreeModel::row-changed].
     * @virtual
     * @param path a `GtkTreePath` pointing to the changed row
     * @param iter a valid `GtkTreeIter` pointing to the changed row
     */
    rowChanged(path: TreePath, iter: TreeIter): void
    /**
     * Emits the ::row-deleted signal on `tree_model`.
     *
     * See [signal`Gtk`.TreeModel::row-deleted].
     *
     * This should be called by models after a row has been removed.
     * The location pointed to by `path` should be the location that
     * the row previously was at. It may not be a valid location anymore.
     *
     * Nodes that are deleted are not unreffed, this means that any
     * outstanding references on the deleted node should not be released.
     * @virtual
     * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
     */
    rowDeleted(path: TreePath): void
    /**
     * Emits the ::row-has-child-toggled signal on `tree_model`.
     *
     * See [signal`Gtk`.TreeModel::row-has-child-toggled].
     *
     * This should be called by models after the child
     * state of a node changes.
     * @virtual
     * @param path a `GtkTreePath` pointing to the changed row
     * @param iter a valid `GtkTreeIter` pointing to the changed row
     */
    rowHasChildToggled(path: TreePath, iter: TreeIter): void
    /**
     * Emits the ::row-inserted signal on `tree_model`.
     *
     * See [signal`Gtk`.TreeModel::row-inserted].
     * @virtual
     * @param path a `GtkTreePath` pointing to the inserted row
     * @param iter a valid `GtkTreeIter` pointing to the inserted row
     */
    rowInserted(path: TreePath, iter: TreeIter): void
    /**
     * Lets the tree unref the node.
     *
     * This is an optional method for models to implement.
     * To be more specific, models may ignore this call as it exists
     * primarily for performance reasons. For more information on what
     * this means, see gtk_tree_model_ref_node().
     *
     * Please note that nodes that are deleted are not unreffed.
     * @virtual
     * @param iter the `GtkTreeIter`
     */
    unrefNode(iter: TreeIter): void

    // Own signals of Gtk-4.0.Gtk.TreeModel

    connect(
      sigName: "row-changed",
      callback: TreeModel.RowChangedSignalCallback
    ): number
    on(
      sigName: "row-changed",
      callback: TreeModel.RowChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-changed",
      callback: TreeModel.RowChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-changed",
      callback: TreeModel.RowChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "row-changed", iter: TreeIter, ...args: any[]): void
    connect(
      sigName: "row-deleted",
      callback: TreeModel.RowDeletedSignalCallback
    ): number
    on(
      sigName: "row-deleted",
      callback: TreeModel.RowDeletedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-deleted",
      callback: TreeModel.RowDeletedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-deleted",
      callback: TreeModel.RowDeletedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "row-deleted", ...args: any[]): void
    connect(
      sigName: "row-has-child-toggled",
      callback: TreeModel.RowHasChildToggledSignalCallback
    ): number
    on(
      sigName: "row-has-child-toggled",
      callback: TreeModel.RowHasChildToggledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-has-child-toggled",
      callback: TreeModel.RowHasChildToggledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-has-child-toggled",
      callback: TreeModel.RowHasChildToggledSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "row-has-child-toggled", iter: TreeIter, ...args: any[]): void
    connect(
      sigName: "row-inserted",
      callback: TreeModel.RowInsertedSignalCallback
    ): number
    on(
      sigName: "row-inserted",
      callback: TreeModel.RowInsertedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-inserted",
      callback: TreeModel.RowInsertedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-inserted",
      callback: TreeModel.RowInsertedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "row-inserted", iter: TreeIter, ...args: any[]): void
    connect(
      sigName: "rows-reordered",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "rows-reordered",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "rows-reordered",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "rows-reordered",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(
      sigName: "rows-reordered",
      iter: TreeIter,
      newOrder: any | null,
      ...args: any[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.TreeModel

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The tree interface used by GtkTreeView
   *
   * The `GtkTreeModel` interface defines a generic tree interface for
   * use by the `GtkTreeView` widget. It is an abstract interface, and
   * is designed to be usable with any appropriate data structure. The
   * programmer just has to implement this interface on their own data
   * type for it to be viewable by a `GtkTreeView` widget.
   *
   * The model is represented as a hierarchical tree of strongly-typed,
   * columned data. In other words, the model can be seen as a tree where
   * every node has different values depending on which column is being
   * queried. The type of data found in a column is determined by using
   * the GType system (ie. %G_TYPE_INT, %GTK_TYPE_BUTTON, %G_TYPE_POINTER,
   * etc). The types are homogeneous per column across all nodes. It is
   * important to note that this interface only provides a way of examining
   * a model and observing changes. The implementation of each individual
   * model decides how and if changes are made.
   *
   * In order to make life simpler for programmers who do not need to
   * write their own specialized model, two generic models are provided
   * — the `GtkTreeStore` and the `GtkListStore`. To use these, the
   * developer simply pushes data into these models as necessary. These
   * models provide the data structure as well as all appropriate tree
   * interfaces. As a result, implementing drag and drop, sorting, and
   * storing data is trivial. For the vast majority of trees and lists,
   * these two models are sufficient.
   *
   * Models are accessed on a node/column level of granularity. One can
   * query for the value of a model at a certain node and a certain
   * column on that node. There are two structures used to reference a
   * particular node in a model. They are the [struct`Gtk`.TreePath] and
   * the [struct`Gtk`.TreeIter] (“iter” is short for iterator). Most of the
   * interface consists of operations on a [struct`Gtk`.TreeIter].
   *
   * A path is essentially a potential node. It is a location on a model
   * that may or may not actually correspond to a node on a specific
   * model. A [struct`Gtk`.TreePath] can be converted into either an
   * array of unsigned integers or a string. The string form is a list
   * of numbers separated by a colon. Each number refers to the offset
   * at that level. Thus, the path `0` refers to the root
   * node and the path `2:4` refers to the fifth child of
   * the third node.
   *
   * By contrast, a [struct`Gtk`.TreeIter] is a reference to a specific node on
   * a specific model. It is a generic struct with an integer and three
   * generic pointers. These are filled in by the model in a model-specific
   * way. One can convert a path to an iterator by calling
   * gtk_tree_model_get_iter(). These iterators are the primary way
   * of accessing a model and are similar to the iterators used by
   * `GtkTextBuffer`. They are generally statically allocated on the
   * stack and only used for a short time. The model interface defines
   * a set of operations using them for navigating the model.
   *
   * It is expected that models fill in the iterator with private data.
   * For example, the `GtkListStore` model, which is internally a simple
   * linked list, stores a list node in one of the pointers. The
   * `GtkTreeModel`Sort stores an array and an offset in two of the
   * pointers. Additionally, there is an integer field. This field is
   * generally filled with a unique stamp per model. This stamp is for
   * catching errors resulting from using invalid iterators with a model.
   *
   * The lifecycle of an iterator can be a little confusing at first.
   * Iterators are expected to always be valid for as long as the model
   * is unchanged (and doesn’t emit a signal). The model is considered
   * to own all outstanding iterators and nothing needs to be done to
   * free them from the user’s point of view. Additionally, some models
   * guarantee that an iterator is valid for as long as the node it refers
   * to is valid (most notably the `GtkTreeStore` and `GtkListStore`).
   * Although generally uninteresting, as one always has to allow for
   * the case where iterators do not persist beyond a signal, some very
   * important performance enhancements were made in the sort model.
   * As a result, the %GTK_TREE_MODEL_ITERS_PERSIST flag was added to
   * indicate this behavior.
   *
   * To help show some common operation of a model, some examples are
   * provided. The first example shows three ways of getting the iter at
   * the location `3:2:5`. While the first method shown is
   * easier, the second is much more common, as you often get paths from
   * callbacks.
   *
   * ## Acquiring a `GtkTreeIter`
   *
   * ```c
   * // Three ways of getting the iter pointing to the location
   * GtkTreePath *path;
   * GtkTreeIter iter;
   * GtkTreeIter parent_iter;
   *
   * // get the iterator from a string
   * gtk_tree_model_get_iter_from_string (model,
   *                                      &iter,
   *                                      "3:2:5");
   *
   * // get the iterator from a path
   * path = gtk_tree_path_new_from_string ("3:2:5");
   * gtk_tree_model_get_iter (model, &iter, path);
   * gtk_tree_path_free (path);
   *
   * // walk the tree to find the iterator
   * gtk_tree_model_iter_nth_child (model, &iter,
   *                                NULL, 3);
   * parent_iter = iter;
   * gtk_tree_model_iter_nth_child (model, &iter,
   *                                &parent_iter, 2);
   * parent_iter = iter;
   * gtk_tree_model_iter_nth_child (model, &iter,
   *                                &parent_iter, 5);
   * ```
   *
   * This second example shows a quick way of iterating through a list
   * and getting a string and an integer from each row. The
   * populate_model() function used below is not
   * shown, as it is specific to the `GtkListStore`. For information on
   * how to write such a function, see the `GtkListStore` documentation.
   *
   * ## Reading data from a `GtkTreeModel`
   *
   * ```c
   * enum
   * {
   *   STRING_COLUMN,
   *   INT_COLUMN,
   *   N_COLUMNS
   * };
   *
   * ...
   *
   * GtkTreeModel *list_store;
   * GtkTreeIter iter;
   * gboolean valid;
   * int row_count = 0;
   *
   * // make a new list_store
   * list_store = gtk_list_store_new (N_COLUMNS,
   *                                  G_TYPE_STRING,
   *                                  G_TYPE_INT);
   *
   * // Fill the list store with data
   * populate_model (list_store);
   *
   * // Get the first iter in the list, check it is valid and walk
   * // through the list, reading each row.
   *
   * valid = gtk_tree_model_get_iter_first (list_store,
   *                                        &iter);
   * while (valid)
   *  {
   *    char *str_data;
   *    int    int_data;
   *
   *    // Make sure you terminate calls to gtk_tree_model_get() with a “-1” value
   *    gtk_tree_model_get (list_store, &iter,
   *                        STRING_COLUMN, &str_data,
   *                        INT_COLUMN, &int_data,
   *                        -1);
   *
   *    // Do something with the data
   *    g_print ("Row %d: (%s,%d)\n",
   *             row_count, str_data, int_data);
   *    g_free (str_data);
   *
   *    valid = gtk_tree_model_iter_next (list_store,
   *                                      &iter);
   *    row_count++;
   *  }
   * ```
   *
   * The `GtkTreeModel` interface contains two methods for reference
   * counting: gtk_tree_model_ref_node() and gtk_tree_model_unref_node().
   * These two methods are optional to implement. The reference counting
   * is meant as a way for views to let models know when nodes are being
   * displayed. `GtkTreeView` will take a reference on a node when it is
   * visible, which means the node is either in the toplevel or expanded.
   * Being displayed does not mean that the node is currently directly
   * visible to the user in the viewport. Based on this reference counting
   * scheme a caching model, for example, can decide whether or not to cache
   * a node based on the reference count. A file-system based model would
   * not want to keep the entire file hierarchy in memory, but just the
   * folders that are currently expanded in every current view.
   *
   * When working with reference counting, the following rules must be taken
   * into account:
   *
   * - Never take a reference on a node without owning a reference on its parent.
   *   This means that all parent nodes of a referenced node must be referenced
   *   as well.
   *
   * - Outstanding references on a deleted node are not released. This is not
   *   possible because the node has already been deleted by the time the
   *   row-deleted signal is received.
   *
   * - Models are not obligated to emit a signal on rows of which none of its
   *   siblings are referenced. To phrase this differently, signals are only
   *   required for levels in which nodes are referenced. For the root level
   *   however, signals must be emitted at all times (however the root level
   *   is always referenced when any view is attached).
   * @interface
   */
  class TreeModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeModel

    constructor(config?: TreeModel.ConstructorProperties)
    _init(config?: TreeModel.ConstructorProperties): void
  }

  module TreeSortable {
    // Signal callback interfaces

    /**
     * Signal callback interface for `sort-column-changed`
     */
    interface SortColumnChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends TreeModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface TreeSortable extends TreeModel {
    // Own properties of Gtk-4.0.Gtk.TreeSortable

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeSortable

    // Has conflict: getSortColumnId(): [ /* returnType */ boolean, /* sortColumnId */ number, /* order */ SortType ]
    // Has conflict: hasDefaultSortFunc(): boolean
    // Has conflict: setDefaultSortFunc(sortFunc: TreeIterCompareFunc): void
    // Has conflict: setSortColumnId(sortColumnId: number, order: SortType): void
    // Has conflict: setSortFunc(sortColumnId: number, sortFunc: TreeIterCompareFunc): void
    // Has conflict: sortColumnChanged(): void

    // Own virtual methods of Gtk-4.0.Gtk.TreeSortable

    /**
     * Fills in `sort_column_id` and `order` with the current sort column and the
     * order. It returns %TRUE unless the `sort_column_id` is
     * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
     * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
     * @virtual
     * @returns %TRUE if the sort column is not one of the special sort   column ids.
     */
    getSortColumnId(): [
      /* returnType */ boolean,
      /* sortColumnId */ number,
      /* order */ SortType,
    ]
    /**
     * Returns %TRUE if the model has a default sort function. This is used
     * primarily by GtkTreeViewColumns in order to determine if a model can
     * go back to the default state, or not.
     * @virtual
     * @returns %TRUE, if the model has a default sort function
     */
    hasDefaultSortFunc(): boolean
    /**
     * Sets the default comparison function used when sorting to be `sort_func`.
     * If the current sort column id of `sortable` is
     * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
     * this function.
     *
     * If `sort_func` is %NULL, then there will be no default comparison function.
     * This means that once the model  has been sorted, it can’t go back to the
     * default state. In this case, when the current sort column id of `sortable`
     * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
     * @virtual
     * @param sortFunc The comparison function
     */
    setDefaultSortFunc(sortFunc: TreeIterCompareFunc): void
    /**
     * Sets the current sort column to be `sort_column_id`. The `sortable` will
     * resort itself to reflect this change, after emitting a
     * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
     * a regular column id, or one of the following special values:
     *
     * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
     *   will be used, if it is set
     *
     * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
     * @virtual
     * @param sortColumnId the sort column id to set
     * @param order The sort order of the column
     */
    setSortColumnId(sortColumnId: number, order: SortType): void
    /**
     * Sets the comparison function used when sorting to be `sort_func`. If the
     * current sort column id of `sortable` is the same as `sort_column_id,` then
     * the model will sort using this function.
     * @virtual
     * @param sortColumnId the sort column id to set the function for
     * @param sortFunc The comparison function
     */
    setSortFunc(sortColumnId: number, sortFunc: TreeIterCompareFunc): void
    /**
     * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
     * @virtual
     */
    sortColumnChanged(): void

    // Own signals of Gtk-4.0.Gtk.TreeSortable

    connect(
      sigName: "sort-column-changed",
      callback: TreeSortable.SortColumnChangedSignalCallback
    ): number
    on(
      sigName: "sort-column-changed",
      callback: TreeSortable.SortColumnChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "sort-column-changed",
      callback: TreeSortable.SortColumnChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "sort-column-changed",
      callback: TreeSortable.SortColumnChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "sort-column-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.TreeSortable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The interface for sortable models used by GtkTreeView
   *
   * `GtkTreeSortable` is an interface to be implemented by tree models which
   * support sorting. The `GtkTreeView` uses the methods provided by this interface
   * to sort the model.
   * @interface
   */
  class TreeSortable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeSortable

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeSortable

    constructor(config?: TreeSortable.ConstructorProperties)
    _init(config?: TreeSortable.ConstructorProperties): void
  }

  module ATContext {
    // Signal callback interfaces

    /**
     * Signal callback interface for `state-change`
     */
    interface StateChangeSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ATContext

      /**
       * The `GtkAccessible` that created the `GtkATContext` instance.
       */
      accessible?: Accessible | null
      /**
       * The accessible role used by the AT context.
       *
       * Depending on the given role, different states and properties can be
       * set or retrieved.
       */
      accessible_role?: AccessibleRole | null
      /**
       * The `GdkDisplay` for the `GtkATContext`.
       */
      display?: Gdk.Display | null
    }
  }

  interface ATContext {
    // Own properties of Gtk-4.0.Gtk.ATContext

    /**
     * The `GtkAccessible` that created the `GtkATContext` instance.
     */
    readonly accessible: Accessible
    /**
     * The accessible role used by the AT context.
     *
     * Depending on the given role, different states and properties can be
     * set or retrieved.
     */
    accessibleRole: AccessibleRole
    /**
     * The `GdkDisplay` for the `GtkATContext`.
     */
    display: Gdk.Display
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ATContext

    /**
     * Retrieves the `GtkAccessible` using this context.
     * @returns a `GtkAccessible`
     */
    getAccessible(): Accessible
    /**
     * Retrieves the accessible role of this context.
     * @returns a `GtkAccessibleRole`
     */
    getAccessibleRole(): AccessibleRole

    // Own signals of Gtk-4.0.Gtk.ATContext

    connect(
      sigName: "state-change",
      callback: ATContext.StateChangeSignalCallback
    ): number
    on(
      sigName: "state-change",
      callback: ATContext.StateChangeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "state-change",
      callback: ATContext.StateChangeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "state-change",
      callback: ATContext.StateChangeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "state-change", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ATContext

    connect(
      sigName: "notify::accessible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkATContext` is an abstract class provided by GTK to communicate to
   * platform-specific assistive technologies API.
   *
   * Each platform supported by GTK implements a `GtkATContext` subclass, and
   * is responsible for updating the accessible state in response to state
   * changes in `GtkAccessible`.
   * @class
   */
  class ATContext extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ATContext

    static name: string

    // Constructors of Gtk-4.0.Gtk.ATContext

    constructor(config?: ATContext.ConstructorProperties)
    /**
     * Creates a new `GtkATContext` instance for the given accessible role,
     * accessible instance, and display connection.
     *
     * The `GtkATContext` implementation being instantiated will depend on the
     * platform.
     * @constructor
     * @param accessibleRole the accessible role used by the `GtkATContext`
     * @param accessible the `GtkAccessible` implementation using the `GtkATContext`
     * @param display the `GdkDisplay` used by the `GtkATContext`
     * @returns the `GtkATContext`
     */
    static create(
      accessibleRole: AccessibleRole,
      accessible: Accessible,
      display: Gdk.Display
    ): ATContext
    _init(config?: ATContext.ConstructorProperties): void
  }

  module AboutDialog {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate-link`
     */
    interface ActivateLinkSignalCallback {
      (uri: string | null): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Window.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AboutDialog

      /**
       * The people who contributed artwork to the program, as a `NULL`-terminated
       * array of strings.
       *
       * Each string may contain email addresses and URLs, which will be displayed
       * as links.
       */
      artists?: string[] | null
      /**
       * The authors of the program, as a `NULL`-terminated array of strings.
       *
       * Each string may contain email addresses and URLs, which will be displayed
       * as links, see the introduction for more details.
       */
      authors?: string[] | null
      /**
       * Comments about the program.
       *
       * This string is displayed in a label in the main dialog, thus it
       * should be a short explanation of the main purpose of the program,
       * not a detailed list of features.
       */
      comments?: string | null
      /**
       * Copyright information for the program.
       */
      copyright?: string | null
      /**
       * The people documenting the program, as a `NULL`-terminated array of strings.
       *
       * Each string may contain email addresses and URLs, which will be displayed
       * as links, see the introduction for more details.
       */
      documenters?: string[] | null
      /**
       * The license of the program, as free-form text.
       *
       * This string is displayed in a text view in a secondary dialog, therefore
       * it is fine to use a long multi-paragraph text. Note that the text is only
       * wrapped in the text view if the "wrap-license" property is set to `TRUE`;
       * otherwise the text itself must contain the intended linebreaks.
       *
       * When setting this property to a non-`NULL` value, the
       * [property`Gtk`.AboutDialog:license-type] property is set to
       * `GTK_LICENSE_CUSTOM` as a side effect.
       *
       * The text may contain links in this format `<http://www.some.place/>`
       * and email references in the form `<mail-to`some`.body>`, and these will
       * be converted into clickable links.
       */
      license?: string | null
      /**
       * The license of the program.
       *
       * The `GtkAboutDialog` will automatically fill out a standard disclaimer
       * and link the user to the appropriate online resource for the license
       * text.
       *
       * If `GTK_LICENSE_UNKNOWN` is used, the link used will be the same
       * specified in the [property`Gtk`.AboutDialog:website] property.
       *
       * If `GTK_LICENSE_CUSTOM` is used, the current contents of the
       * [property`Gtk`.AboutDialog:license] property are used.
       *
       * For any other [enum`Gtk`.License] value, the contents of the
       * [property`Gtk`.AboutDialog:license] property are also set by this property as
       * a side effect.
       */
      license_type?: License | null
      /**
       * A logo for the about box.
       *
       * If it is `NULL`, the default window icon set with
       * [func`Gtk`.Window.set_default_icon_name] will be used.
       */
      logo?: Gdk.Paintable | null
      /**
       * A named icon to use as the logo for the about box.
       *
       * This property overrides the [property`Gtk`.AboutDialog:logo] property.
       */
      logo_icon_name?: string | null
      /**
       * The name of the program.
       *
       * If this is not set, it defaults to the value returned by
       * `g_get_application_name()`.
       */
      program_name?: string | null
      /**
       * Information about the system on which the program is running.
       *
       * This information is displayed in a separate page, therefore it is fine
       * to use a long multi-paragraph text. Note that the text should contain
       * the intended linebreaks.
       *
       * The text may contain links in this format `<http://www.some.place/>`
       * and email references in the form `<mail-to`some`.body>`, and these will
       * be converted into clickable links.
       */
      system_information?: string | null
      /**
       * Credits to the translators.
       *
       * This string should be marked as translatable.
       *
       * The string may contain email addresses and URLs, which will be displayed
       * as links, see the introduction for more details.
       */
      translator_credits?: string | null
      /**
       * The version of the program.
       */
      version?: string | null
      /**
       * The URL for the link to the website of the program.
       *
       * This should be a string starting with `http://` or `https://`.
       */
      website?: string | null
      /**
       * The label for the link to the website of the program.
       */
      website_label?: string | null
      /**
       * Whether to wrap the text in the license dialog.
       */
      wrap_license?: boolean | null
    }
  }

  interface AboutDialog
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.AboutDialog

    /**
     * The people who contributed artwork to the program, as a `NULL`-terminated
     * array of strings.
     *
     * Each string may contain email addresses and URLs, which will be displayed
     * as links.
     */
    artists: string[]
    /**
     * The authors of the program, as a `NULL`-terminated array of strings.
     *
     * Each string may contain email addresses and URLs, which will be displayed
     * as links, see the introduction for more details.
     */
    authors: string[]
    /**
     * Comments about the program.
     *
     * This string is displayed in a label in the main dialog, thus it
     * should be a short explanation of the main purpose of the program,
     * not a detailed list of features.
     */
    comments: string | null
    /**
     * Copyright information for the program.
     */
    copyright: string | null
    /**
     * The people documenting the program, as a `NULL`-terminated array of strings.
     *
     * Each string may contain email addresses and URLs, which will be displayed
     * as links, see the introduction for more details.
     */
    documenters: string[]
    /**
     * The license of the program, as free-form text.
     *
     * This string is displayed in a text view in a secondary dialog, therefore
     * it is fine to use a long multi-paragraph text. Note that the text is only
     * wrapped in the text view if the "wrap-license" property is set to `TRUE`;
     * otherwise the text itself must contain the intended linebreaks.
     *
     * When setting this property to a non-`NULL` value, the
     * [property`Gtk`.AboutDialog:license-type] property is set to
     * `GTK_LICENSE_CUSTOM` as a side effect.
     *
     * The text may contain links in this format `<http://www.some.place/>`
     * and email references in the form `<mail-to`some`.body>`, and these will
     * be converted into clickable links.
     */
    license: string | null
    /**
     * The license of the program.
     *
     * The `GtkAboutDialog` will automatically fill out a standard disclaimer
     * and link the user to the appropriate online resource for the license
     * text.
     *
     * If `GTK_LICENSE_UNKNOWN` is used, the link used will be the same
     * specified in the [property`Gtk`.AboutDialog:website] property.
     *
     * If `GTK_LICENSE_CUSTOM` is used, the current contents of the
     * [property`Gtk`.AboutDialog:license] property are used.
     *
     * For any other [enum`Gtk`.License] value, the contents of the
     * [property`Gtk`.AboutDialog:license] property are also set by this property as
     * a side effect.
     */
    licenseType: License
    /**
     * A logo for the about box.
     *
     * If it is `NULL`, the default window icon set with
     * [func`Gtk`.Window.set_default_icon_name] will be used.
     */
    logo: Gdk.Paintable
    /**
     * A named icon to use as the logo for the about box.
     *
     * This property overrides the [property`Gtk`.AboutDialog:logo] property.
     */
    logoIconName: string | null
    /**
     * The name of the program.
     *
     * If this is not set, it defaults to the value returned by
     * `g_get_application_name()`.
     */
    programName: string | null
    /**
     * Information about the system on which the program is running.
     *
     * This information is displayed in a separate page, therefore it is fine
     * to use a long multi-paragraph text. Note that the text should contain
     * the intended linebreaks.
     *
     * The text may contain links in this format `<http://www.some.place/>`
     * and email references in the form `<mail-to`some`.body>`, and these will
     * be converted into clickable links.
     */
    systemInformation: string | null
    /**
     * Credits to the translators.
     *
     * This string should be marked as translatable.
     *
     * The string may contain email addresses and URLs, which will be displayed
     * as links, see the introduction for more details.
     */
    translatorCredits: string | null
    /**
     * The version of the program.
     */
    version: string | null
    /**
     * The URL for the link to the website of the program.
     *
     * This should be a string starting with `http://` or `https://`.
     */
    website: string | null
    /**
     * The label for the link to the website of the program.
     */
    websiteLabel: string | null
    /**
     * Whether to wrap the text in the license dialog.
     */
    wrapLicense: boolean
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.AboutDialog

    /**
     * Creates a new section in the "Credits" page.
     * @param sectionName The name of the section
     * @param people The people who belong to that section
     */
    addCreditSection(sectionName: string, people: string[]): void
    /**
     * Returns the names of the artists which are displayed
     * in the credits page.
     * @returns A   `NULL`-terminated string array containing the artists
     */
    getArtists(): string[]
    /**
     * Returns the names of the authors which are displayed
     * in the credits page.
     * @returns A   `NULL`-terminated string array containing the authors
     */
    getAuthors(): string[]
    /**
     * Returns the comments string.
     * @returns The comments
     */
    getComments(): string | null
    /**
     * Returns the copyright string.
     * @returns The copyright string
     */
    getCopyright(): string | null
    /**
     * Returns the name of the documenters which are displayed
     * in the credits page.
     * @returns A   `NULL`-terminated string array containing the documenters
     */
    getDocumenters(): string[]
    /**
     * Returns the license information.
     * @returns The license information
     */
    getLicense(): string | null
    /**
     * Retrieves the license type.
     * @returns a [enum@Gtk.License] value
     */
    getLicenseType(): License
    /**
     * Returns the paintable displayed as logo in the about dialog.
     * @returns the paintable displayed as   logo or `NULL` if the logo is unset or has been set via   [method@Gtk.AboutDialog.set_logo_icon_name]
     */
    getLogo(): Gdk.Paintable | null
    /**
     * Returns the icon name displayed as logo in the about dialog.
     * @returns the icon name displayed as logo,   or `NULL` if the logo has been set via [method@Gtk.AboutDialog.set_logo]
     */
    getLogoIconName(): string | null
    /**
     * Returns the program name displayed in the about dialog.
     * @returns The program name
     */
    getProgramName(): string | null
    /**
     * Returns the system information that is shown in the about dialog.
     * @returns the system information
     */
    getSystemInformation(): string | null
    /**
     * Returns the translator credits string which is displayed
     * in the credits page.
     * @returns The translator credits string
     */
    getTranslatorCredits(): string | null
    /**
     * Returns the version string.
     * @returns The version string
     */
    getVersion(): string | null
    /**
     * Returns the website URL.
     * @returns The website URL
     */
    getWebsite(): string | null
    /**
     * Returns the label used for the website link.
     * @returns The label used for the website link
     */
    getWebsiteLabel(): string | null
    /**
     * Returns whether the license text in the about dialog is
     * automatically wrapped.
     * @returns `TRUE` if the license text is wrapped
     */
    getWrapLicense(): boolean
    /**
     * Sets the names of the artists to be displayed
     * in the "Credits" page.
     * @param artists the authors of the artwork   of the application
     */
    setArtists(artists: string[]): void
    /**
     * Sets the names of the authors which are displayed
     * in the "Credits" page of the about dialog.
     * @param authors the authors of the application
     */
    setAuthors(authors: string[]): void
    /**
     * Sets the comments string to display in the about dialog.
     *
     * This should be a short string of one or two lines.
     * @param comments a comments string
     */
    setComments(comments: string | null): void
    /**
     * Sets the copyright string to display in the about dialog.
     *
     * This should be a short string of one or two lines.
     * @param copyright the copyright string
     */
    setCopyright(copyright: string | null): void
    /**
     * Sets the names of the documenters which are displayed
     * in the "Credits" page.
     * @param documenters the authors of the documentation   of the application
     */
    setDocumenters(documenters: string[]): void
    /**
     * Sets the license information to be displayed in the
     * about dialog.
     *
     * If `license` is `NULL`, the license page is hidden.
     * @param license the license information
     */
    setLicense(license: string | null): void
    /**
     * Sets the license of the application showing the about dialog from a
     * list of known licenses.
     *
     * This function overrides the license set using
     * [method`Gtk`.AboutDialog.set_license].
     * @param licenseType the type of license
     */
    setLicenseType(licenseType: License): void
    /**
     * Sets the logo in the about dialog.
     * @param logo a `GdkPaintable`
     */
    setLogo(logo: Gdk.Paintable | null): void
    /**
     * Sets the icon name to be displayed as logo in the about dialog.
     * @param iconName an icon name
     */
    setLogoIconName(iconName: string | null): void
    /**
     * Sets the name to display in the about dialog.
     *
     * If `name` is not set, the string returned
     * by `g_get_application_name()` is used.
     * @param name the program name
     */
    setProgramName(name: string | null): void
    /**
     * Sets the system information to be displayed in the about
     * dialog.
     *
     * If `system_information` is `NULL`, the system information
     * page is hidden.
     *
     * See [property`Gtk`.AboutDialog:system-information].
     * @param systemInformation system information
     */
    setSystemInformation(systemInformation: string | null): void
    /**
     * Sets the translator credits string which is displayed in
     * the credits page.
     *
     * The intended use for this string is to display the translator
     * of the language which is currently used in the user interface.
     * Using `gettext()`, a simple way to achieve that is to mark the
     * string for translation:
     *
     * ```c
     * GtkWidget *about = gtk_about_dialog_new ();
     *  gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about),
     *                                           _("translator-credits"));
     * ```
     *
     * It is a good idea to use the customary `msgid` “translator-credits”
     * for this purpose, since translators will already know the purpose of
     * that `msgid`, and since `GtkAboutDialog` will detect if “translator-credits”
     * is untranslated and omit translator credits.
     * @param translatorCredits the translator credits
     */
    setTranslatorCredits(translatorCredits: string | null): void
    /**
     * Sets the version string to display in the about dialog.
     * @param version the version string
     */
    setVersion(version: string | null): void
    /**
     * Sets the URL to use for the website link.
     * @param website a URL string starting with `http://`
     */
    setWebsite(website: string | null): void
    /**
     * Sets the label to be used for the website link.
     * @param websiteLabel the label used for the website link
     */
    setWebsiteLabel(websiteLabel: string): void
    /**
     * Sets whether the license text in the about dialog should be
     * automatically wrapped.
     * @param wrapLicense whether to wrap the license
     */
    setWrapLicense(wrapLicense: boolean): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Own signals of Gtk-4.0.Gtk.AboutDialog

    connect(
      sigName: "activate-link",
      callback: AboutDialog.ActivateLinkSignalCallback
    ): number
    on(
      sigName: "activate-link",
      callback: AboutDialog.ActivateLinkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-link",
      callback: AboutDialog.ActivateLinkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-link",
      callback: AboutDialog.ActivateLinkSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-link", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.AboutDialog

    connect(
      sigName: "notify::artists",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::artists",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::artists",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::artists",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::artists", ...args: any[]): void
    connect(
      sigName: "notify::authors",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::authors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::authors",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::authors",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::authors", ...args: any[]): void
    connect(
      sigName: "notify::comments",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::comments",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::comments",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::comments",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::comments", ...args: any[]): void
    connect(
      sigName: "notify::copyright",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::copyright",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::copyright",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::copyright",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::copyright", ...args: any[]): void
    connect(
      sigName: "notify::documenters",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::documenters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::documenters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::documenters",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::documenters", ...args: any[]): void
    connect(
      sigName: "notify::license",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::license",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::license",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::license",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::license", ...args: any[]): void
    connect(
      sigName: "notify::license-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::license-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::license-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::license-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::license-type", ...args: any[]): void
    connect(sigName: "notify::logo", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::logo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::logo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::logo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::logo", ...args: any[]): void
    connect(
      sigName: "notify::logo-icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::logo-icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::logo-icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::logo-icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::logo-icon-name", ...args: any[]): void
    connect(
      sigName: "notify::program-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::program-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::program-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::program-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::program-name", ...args: any[]): void
    connect(
      sigName: "notify::system-information",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::system-information",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::system-information",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::system-information",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::system-information", ...args: any[]): void
    connect(
      sigName: "notify::translator-credits",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::translator-credits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::translator-credits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::translator-credits",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::translator-credits", ...args: any[]): void
    connect(
      sigName: "notify::version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::version", ...args: any[]): void
    connect(
      sigName: "notify::website",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::website",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::website",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::website",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::website", ...args: any[]): void
    connect(
      sigName: "notify::website-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::website-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::website-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::website-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::website-label", ...args: any[]): void
    connect(
      sigName: "notify::wrap-license",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-license",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-license",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-license",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-license", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkAboutDialog` offers a simple way to display information about
   * a program.
   *
   * The shown information includes the programs' logo, name, copyright,
   * website and license. It is also possible to give credits to the authors,
   * documenters, translators and artists who have worked on the program.
   *
   * An about dialog is typically opened when the user selects the `About`
   * option from the `Help` menu. All parts of the dialog are optional.
   *
   * ![An example GtkAboutDialog](aboutdialog.png)
   *
   * About dialogs often contain links and email addresses. `GtkAboutDialog`
   * displays these as clickable links. By default, it calls [method`Gtk`.FileLauncher.launch]
   * when a user clicks one. The behaviour can be overridden with the
   * [signal`Gtk`.AboutDialog::activate-link] signal.
   *
   * To specify a person with an email address, use a string like
   * `Edgar Allan Poe <edgar`poe`.com>`. To specify a website with a title,
   * use a string like `GTK team https://www.gtk.org`.
   *
   * To make constructing a `GtkAboutDialog` as convenient as possible, you can
   * use the function [func`Gtk`.show_about_dialog] which constructs and shows
   * a dialog and keeps it around so that it can be shown again.
   *
   * Note that GTK sets a default title of `_("About %s")` on the dialog
   * window (where `%s` is replaced by the name of the application, but in
   * order to ensure proper translation of the title, applications should
   * set the title property explicitly when constructing a `GtkAboutDialog`,
   * as shown in the following example:
   *
   * ```c
   * GFile *logo_file = g_file_new_for_path ("./logo.png");
   * GdkTexture *example_logo = gdk_texture_new_from_file (logo_file, NULL);
   * g_object_unref (logo_file);
   *
   * gtk_show_about_dialog (NULL,
   *                        "program-name", "ExampleCode",
   *                        "logo", example_logo,
   *                        "title", _("About ExampleCode"),
   *                        NULL);
   * ```
   *
   * ## CSS nodes
   *
   * `GtkAboutDialog` has a single CSS node with the name `window` and style
   * class `.aboutdialog`.
   * @class
   */
  class AboutDialog extends Window {
    // Own properties of Gtk-4.0.Gtk.AboutDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.AboutDialog

    constructor(config?: AboutDialog.ConstructorProperties)
    /**
     * Creates a new `GtkAboutDialog`.
     * @constructor
     * @returns a newly created `GtkAboutDialog`
     */
    constructor()
    /**
     * Creates a new `GtkAboutDialog`.
     * @constructor
     * @returns a newly created `GtkAboutDialog`
     */
    static new(): AboutDialog
    _init(config?: AboutDialog.ConstructorProperties): void
  }

  module ActionBar {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ActionBar

      /**
       * Controls whether the action bar shows its contents.
       */
      revealed?: boolean | null
    }
  }

  interface ActionBar extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ActionBar

    /**
     * Controls whether the action bar shows its contents.
     */
    revealed: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ActionBar

    /**
     * Retrieves the center bar widget of the bar.
     * @returns the center `GtkWidget`
     */
    getCenterWidget(): Widget | null
    /**
     * Gets whether the contents of the action bar are revealed.
     * @returns the current value of the [property@Gtk.ActionBar:revealed]   property
     */
    getRevealed(): boolean
    /**
     * Adds `child` to `action_bar,` packed with reference to the
     * end of the `action_bar`.
     * @param child the `GtkWidget` to be added to `action_bar`
     */
    packEnd(child: Widget): void
    /**
     * Adds `child` to `action_bar,` packed with reference to the
     * start of the `action_bar`.
     * @param child the `GtkWidget` to be added to `action_bar`
     */
    packStart(child: Widget): void
    /**
     * Removes a child from `action_bar`.
     * @param child the `GtkWidget` to be removed
     */
    remove(child: Widget): void
    /**
     * Sets the center widget for the `GtkActionBar`.
     * @param centerWidget a widget to use for the center
     */
    setCenterWidget(centerWidget: Widget | null): void
    /**
     * Reveals or conceals the content of the action bar.
     *
     * Note: this does not show or hide `action_bar` in the
     * [property`Gtk`.Widget:visible] sense, so revealing has
     * no effect if the action bar is hidden.
     * @param revealed The new value of the property
     */
    setRevealed(revealed: boolean): void

    // Class property signals of Gtk-4.0.Gtk.ActionBar

    connect(
      sigName: "notify::revealed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::revealed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::revealed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::revealed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::revealed", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkActionBar` is designed to present contextual actions.
   *
   * ![An example GtkActionBar](action-bar.png)
   *
   * It is expected to be displayed below the content and expand
   * horizontally to fill the area.
   *
   * It allows placing children at the start or the end. In addition, it
   * contains an internal centered box which is centered with respect to
   * the full width of the box, even if the children at either side take
   * up different amounts of space.
   *
   * # GtkActionBar as GtkBuildable
   *
   * The `GtkActionBar` implementation of the `GtkBuildable` interface supports
   * adding children at the start or end sides by specifying “start” or “end” as
   * the “type” attribute of a `<child>` element, or setting the center widget
   * by specifying “center” value.
   *
   * # CSS nodes
   *
   * ```
   * actionbar
   * ╰── revealer
   *     ╰── box
   *         ├── box.start
   *         │   ╰── [start children]
   *         ├── [center widget]
   *         ╰── box.end
   *             ╰── [end children]
   * ```
   *
   * A `GtkActionBar`'s CSS node is called `actionbar`. It contains a `revealer`
   * subnode, which contains a `box` subnode, which contains two `box` subnodes at
   * the start and end of the action bar, with `start` and `end style classes
   * respectively, as well as a center node that represents the center child.
   *
   * Each of the boxes contains children packed for that side.
   * @class
   */
  class ActionBar extends Widget {
    // Own properties of Gtk-4.0.Gtk.ActionBar

    static name: string

    // Constructors of Gtk-4.0.Gtk.ActionBar

    constructor(config?: ActionBar.ConstructorProperties)
    /**
     * Creates a new `GtkActionBar` widget.
     * @constructor
     * @returns a new `GtkActionBar`
     */
    constructor()
    /**
     * Creates a new `GtkActionBar` widget.
     * @constructor
     * @returns a new `GtkActionBar`
     */
    static new(): ActionBar
    _init(config?: ActionBar.ConstructorProperties): void
  }

  module ActivateAction {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutAction.ConstructorProperties {}
  }

  interface ActivateAction {
    // Own properties of Gtk-4.0.Gtk.ActivateAction

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.ActivateAction

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutAction` that calls gtk_widget_activate().
   * @class
   */
  class ActivateAction extends ShortcutAction {
    // Own properties of Gtk-4.0.Gtk.ActivateAction

    static name: string

    // Constructors of Gtk-4.0.Gtk.ActivateAction

    constructor(config?: ActivateAction.ConstructorProperties)
    _init(config?: ActivateAction.ConstructorProperties): void
    /**
     * Gets the activate action.
     *
     * This is an action that calls gtk_widget_activate()
     * on the given widget upon activation.
     * @returns The activate action
     */
    static get(): ActivateAction
  }

  module Adjustment {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `value-changed`
     */
    interface ValueChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.InitiallyUnowned.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Adjustment

      /**
       * The minimum value of the adjustment.
       */
      lower?: number | null
      /**
       * The page increment of the adjustment.
       */
      page_increment?: number | null
      /**
       * The page size of the adjustment.
       *
       * Note that the page-size is irrelevant and should be set to zero
       * if the adjustment is used for a simple scalar value, e.g. in a
       * `GtkSpinButton`.
       */
      page_size?: number | null
      /**
       * The step increment of the adjustment.
       */
      step_increment?: number | null
      /**
       * The maximum value of the adjustment.
       *
       * Note that values will be restricted by `upper - page-size` if the page-size
       * property is nonzero.
       */
      upper?: number | null
      /**
       * The value of the adjustment.
       */
      value?: number | null
    }
  }

  interface Adjustment {
    // Own properties of Gtk-4.0.Gtk.Adjustment

    /**
     * The minimum value of the adjustment.
     */
    lower: number
    /**
     * The page increment of the adjustment.
     */
    pageIncrement: number
    /**
     * The page size of the adjustment.
     *
     * Note that the page-size is irrelevant and should be set to zero
     * if the adjustment is used for a simple scalar value, e.g. in a
     * `GtkSpinButton`.
     */
    pageSize: number
    /**
     * The step increment of the adjustment.
     */
    stepIncrement: number
    /**
     * The maximum value of the adjustment.
     *
     * Note that values will be restricted by `upper - page-size` if the page-size
     * property is nonzero.
     */
    upper: number
    /**
     * The value of the adjustment.
     */
    value: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Adjustment

    parentInstance: GObject.InitiallyUnowned

    // Owm methods of Gtk-4.0.Gtk.Adjustment

    /**
     * Updates the value property to ensure that the range
     * between `lower` and `upper` is in the current page.
     *
     * The current page goes from `value` to `value` + `page-size`.
     * If the range is larger than the page size, then only the
     * start of it will be in the current page.
     *
     * A [signal`Gtk`.Adjustment::value-changed] signal will be emitted
     * if the value is changed.
     * @param lower the lower value
     * @param upper the upper value
     */
    clampPage(lower: number, upper: number): void
    /**
     * Sets all properties of the adjustment at once.
     *
     * Use this function to avoid multiple emissions of the
     * [signal`Gtk`.Adjustment::changed] signal. See
     * [method`Gtk`.Adjustment.set_lower] for an alternative
     * way of compressing multiple emissions of
     * [signal`Gtk`.Adjustment::changed] into one.
     * @param value the new value
     * @param lower the new minimum value
     * @param upper the new maximum value
     * @param stepIncrement the new step increment
     * @param pageIncrement the new page increment
     * @param pageSize the new page size
     */
    configure(
      value: number,
      lower: number,
      upper: number,
      stepIncrement: number,
      pageIncrement: number,
      pageSize: number
    ): void
    /**
     * Retrieves the minimum value of the adjustment.
     * @returns The current minimum value of the adjustment
     */
    getLower(): number
    /**
     * Gets the smaller of step increment and page increment.
     * @returns the minimum increment of @adjustment
     */
    getMinimumIncrement(): number
    /**
     * Retrieves the page increment of the adjustment.
     * @returns The current page increment of the adjustment
     */
    getPageIncrement(): number
    /**
     * Retrieves the page size of the adjustment.
     * @returns The current page size of the adjustment
     */
    getPageSize(): number
    /**
     * Retrieves the step increment of the adjustment.
     * @returns The current step increment of the adjustment.
     */
    getStepIncrement(): number
    /**
     * Retrieves the maximum value of the adjustment.
     * @returns The current maximum value of the adjustment
     */
    getUpper(): number
    /**
     * Gets the current value of the adjustment.
     * @returns The current value of the adjustment
     */
    getValue(): number
    /**
     * Sets the minimum value of the adjustment.
     *
     * When setting multiple adjustment properties via their individual
     * setters, multiple [signal`Gtk`.Adjustment::changed] signals will
     * be emitted. However, since the emission of the
     * [signal`Gtk`.Adjustment::changed] signal is tied to the emission
     * of the ::notify signals of the changed properties, it’s possible
     * to compress the [signal`Gtk`.Adjustment::changed] signals into one
     * by calling g_object_freeze_notify() and g_object_thaw_notify()
     * around the calls to the individual setters.
     *
     * Alternatively, using a single g_object_set() for all the properties
     * to change, or using [method`Gtk`.Adjustment.configure] has the same effect.
     * @param lower the new minimum value
     */
    setLower(lower: number): void
    /**
     * Sets the page increment of the adjustment.
     *
     * See [method`Gtk`.Adjustment.set_lower] about how to compress
     * multiple emissions of the [signal`Gtk`.Adjustment::changed]
     * signal when setting multiple adjustment properties.
     * @param pageIncrement the new page increment
     */
    setPageIncrement(pageIncrement: number): void
    /**
     * Sets the page size of the adjustment.
     *
     * See [method`Gtk`.Adjustment.set_lower] about how to compress
     * multiple emissions of the [signal`Gtk`.Adjustment::changed]
     * signal when setting multiple adjustment properties.
     * @param pageSize the new page size
     */
    setPageSize(pageSize: number): void
    /**
     * Sets the step increment of the adjustment.
     *
     * See [method`Gtk`.Adjustment.set_lower] about how to compress
     * multiple emissions of the [signal`Gtk`.Adjustment::changed]
     * signal when setting multiple adjustment properties.
     * @param stepIncrement the new step increment
     */
    setStepIncrement(stepIncrement: number): void
    /**
     * Sets the maximum value of the adjustment.
     *
     * Note that values will be restricted by `upper - page-size`
     * if the page-size property is nonzero.
     *
     * See [method`Gtk`.Adjustment.set_lower] about how to compress
     * multiple emissions of the [signal`Gtk`.Adjustment::changed]
     * signal when setting multiple adjustment properties.
     * @param upper the new maximum value
     */
    setUpper(upper: number): void
    /**
     * Sets the `GtkAdjustment` value.
     *
     * The value is clamped to lie between [property`Gtk`.Adjustment:lower]
     * and [property`Gtk`.Adjustment:upper].
     *
     * Note that for adjustments which are used in a `GtkScrollbar`,
     * the effective range of allowed values goes from
     * [property`Gtk`.Adjustment:lower] to
     * [property`Gtk`.Adjustment:upper] - [property`Gtk`.Adjustment:page-size].
     * @param value the new value
     */
    setValue(value: number): void

    // Own virtual methods of Gtk-4.0.Gtk.Adjustment

    changed(): void
    valueChanged(): void

    // Own signals of Gtk-4.0.Gtk.Adjustment

    connect(
      sigName: "changed",
      callback: Adjustment.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: Adjustment.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Adjustment.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Adjustment.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "value-changed",
      callback: Adjustment.ValueChangedSignalCallback
    ): number
    on(
      sigName: "value-changed",
      callback: Adjustment.ValueChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "value-changed",
      callback: Adjustment.ValueChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "value-changed",
      callback: Adjustment.ValueChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "value-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Adjustment

    connect(
      sigName: "notify::lower",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::lower",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::lower",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::lower",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::lower", ...args: any[]): void
    connect(
      sigName: "notify::page-increment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::page-increment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::page-increment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::page-increment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::page-increment", ...args: any[]): void
    connect(
      sigName: "notify::page-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::page-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::page-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::page-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::page-size", ...args: any[]): void
    connect(
      sigName: "notify::step-increment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::step-increment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::step-increment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::step-increment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::step-increment", ...args: any[]): void
    connect(
      sigName: "notify::upper",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::upper",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::upper",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::upper",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::upper", ...args: any[]): void
    connect(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::value", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAdjustment` is a model for a numeric value.
   *
   * The `GtkAdjustment` has an associated lower and upper bound.
   * It also contains step and page increments, and a page size.
   *
   * Adjustments are used within several GTK widgets, including
   * [class`Gtk`.SpinButton], [class`Gtk`.Viewport], [class`Gtk`.Scrollbar]
   * and [class`Gtk`.Scale].
   *
   * The `GtkAdjustment` object does not update the value itself. Instead
   * it is left up to the owner of the `GtkAdjustment` to control the value.
   * @class
   */
  class Adjustment extends GObject.InitiallyUnowned {
    // Own properties of Gtk-4.0.Gtk.Adjustment

    static name: string

    // Constructors of Gtk-4.0.Gtk.Adjustment

    constructor(config?: Adjustment.ConstructorProperties)
    /**
     * Creates a new `GtkAdjustment`.
     * @constructor
     * @param value the initial value
     * @param lower the minimum value
     * @param upper the maximum value
     * @param stepIncrement the step increment
     * @param pageIncrement the page increment
     * @param pageSize the page size
     * @returns a new `GtkAdjustment`
     */
    constructor(
      value: number,
      lower: number,
      upper: number,
      stepIncrement: number,
      pageIncrement: number,
      pageSize: number
    )
    /**
     * Creates a new `GtkAdjustment`.
     * @constructor
     * @param value the initial value
     * @param lower the minimum value
     * @param upper the maximum value
     * @param stepIncrement the step increment
     * @param pageIncrement the page increment
     * @param pageSize the page size
     * @returns a new `GtkAdjustment`
     */
    static new(
      value: number,
      lower: number,
      upper: number,
      stepIncrement: number,
      pageIncrement: number,
      pageSize: number
    ): Adjustment
    _init(config?: Adjustment.ConstructorProperties): void
  }

  module AlertDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AlertDialog

      /**
       * Labels for buttons to show in the alert.
       *
       * The labels should be translated and may contain
       * a _ to indicate the mnemonic character.
       *
       * If this property is not set, then a 'Close' button is
       * automatically created.
       */
      buttons?: string[] | null
      /**
       * This property determines what happens when the Escape key is
       * pressed while the alert is shown.
       *
       * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
       * then pressing Escape is treated as if that button was pressed. If it is -1
       * or not a valid index for the `buttons` array, then an error is returned.
       *
       * If `buttons` is `NULL`, then the automatically created 'Close' button
       * is treated as both cancel and default button, so 0 is returned.
       */
      cancel_button?: number | null
      /**
       * This property determines what happens when the Return key is
       * pressed while the alert is shown.
       *
       * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
       * then pressing Return is treated as if that button was pressed. If it is -1
       * or not a valid index for the `buttons` array, then nothing happens.
       *
       * If `buttons` is `NULL`, then the automatically created 'Close' button
       * is treated as both cancel and default button, so 0 is returned.
       */
      default_button?: number | null
      /**
       * The detail text for the alert.
       */
      detail?: string | null
      /**
       * The message for the alert.
       */
      message?: string | null
      /**
       * Whether the alert is modal.
       */
      modal?: boolean | null
    }
  }

  interface AlertDialog {
    // Own properties of Gtk-4.0.Gtk.AlertDialog

    /**
     * Labels for buttons to show in the alert.
     *
     * The labels should be translated and may contain
     * a _ to indicate the mnemonic character.
     *
     * If this property is not set, then a 'Close' button is
     * automatically created.
     */
    buttons: string[]
    /**
     * This property determines what happens when the Escape key is
     * pressed while the alert is shown.
     *
     * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
     * then pressing Escape is treated as if that button was pressed. If it is -1
     * or not a valid index for the `buttons` array, then an error is returned.
     *
     * If `buttons` is `NULL`, then the automatically created 'Close' button
     * is treated as both cancel and default button, so 0 is returned.
     */
    cancelButton: number
    /**
     * This property determines what happens when the Return key is
     * pressed while the alert is shown.
     *
     * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
     * then pressing Return is treated as if that button was pressed. If it is -1
     * or not a valid index for the `buttons` array, then nothing happens.
     *
     * If `buttons` is `NULL`, then the automatically created 'Close' button
     * is treated as both cancel and default button, so 0 is returned.
     */
    defaultButton: number
    /**
     * The detail text for the alert.
     */
    detail: string | null
    /**
     * The message for the alert.
     */
    message: string | null
    /**
     * Whether the alert is modal.
     */
    modal: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.AlertDialog

    /**
     * This function shows the alert to the user.
     *
     * The `callback` will be called when the alert is dismissed.
     * It should call [method`Gtk`.AlertDialog.choose_finish]
     * to obtain the result.
     *
     * It is ok to pass `NULL` for the callback if the alert
     * does not have more than one button. A simpler API for
     * this case is [method`Gtk`.AlertDialog.show].
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    choose(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.AlertDialog.choose] call
     * and returns the index of the button that was clicked.
     * @param result a `GAsyncResult`
     * @returns the index of the button that was clicked, or -1 if   the dialog was cancelled and [property@Gtk.AlertDialog:cancel-button]   is not set
     */
    chooseFinish(result: Gio.AsyncResult): number
    /**
     * Returns the button labels for the alert.
     * @returns the button labels
     */
    getButtons(): string[] | null
    /**
     * Returns the index of the cancel button.
     * @returns the index of the cancel button, or -1
     */
    getCancelButton(): number
    /**
     * Returns the index of the default button.
     * @returns the index of the default button, or -1
     */
    getDefaultButton(): number
    /**
     * Returns the detail text that will be shown in the alert.
     * @returns the detail text
     */
    getDetail(): string
    /**
     * Returns the message that will be shown in the alert.
     * @returns the message
     */
    getMessage(): string
    /**
     * Returns whether the alert blocks interaction
     * with the parent window while it is presented.
     * @returns `TRUE` if the alert is modal
     */
    getModal(): boolean
    /**
     * Sets the button labels for the alert.
     * @param labels the new button labels
     */
    setButtons(labels: string[]): void
    /**
     * Sets the index of the cancel button.
     *
     * See [property`Gtk`.AlertDialog:cancel-button] for
     * details of how this value is used.
     * @param button the new cancel button
     */
    setCancelButton(button: number): void
    /**
     * Sets the index of the default button.
     *
     * See [property`Gtk`.AlertDialog:default-button] for
     * details of how this value is used.
     * @param button the new default button
     */
    setDefaultButton(button: number): void
    /**
     * Sets the detail text that will be shown in the alert.
     * @param detail the new detail text
     */
    setDetail(detail: string): void
    /**
     * Sets the message that will be shown in the alert.
     * @param message the new message
     */
    setMessage(message: string): void
    /**
     * Sets whether the alert blocks interaction
     * with the parent window while it is presented.
     * @param modal the new value
     */
    setModal(modal: boolean): void
    /**
     * Show the alert to the user.
     *
     * This function is a simple version of [method`Gtk`.AlertDialog.choose]
     * intended for dialogs with a single button.
     * If you want to cancel the dialog or if the alert has more than one button,
     * you should use that function instead and provide it with a #GCancellable or
     * callback respectively.
     * @param parent the parent `GtkWindow`
     */
    show(parent: Window | null): void

    // Class property signals of Gtk-4.0.Gtk.AlertDialog

    connect(
      sigName: "notify::buttons",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::buttons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::buttons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::buttons",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::buttons", ...args: any[]): void
    connect(
      sigName: "notify::cancel-button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cancel-button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cancel-button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cancel-button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cancel-button", ...args: any[]): void
    connect(
      sigName: "notify::default-button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-button", ...args: any[]): void
    connect(
      sigName: "notify::detail",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::detail",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::detail",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::detail",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::detail", ...args: any[]): void
    connect(
      sigName: "notify::message",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::message",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::message",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::message",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::message", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkAlertDialog` object collects the arguments that
   * are needed to present a message to the user.
   *
   * The message is shown with the [method`Gtk`.AlertDialog.choose]
   * function. This API follows the GIO async pattern, and the result can
   * be obtained by calling [method`Gtk`.AlertDialog.choose_finish].
   *
   * If you don't need to wait for a button to be clicked, you can use
   * [method`Gtk`.AlertDialog.show].
   * @class
   */
  class AlertDialog extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.AlertDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.AlertDialog

    constructor(config?: AlertDialog.ConstructorProperties)
    _init(config?: AlertDialog.ConstructorProperties): void
  }

  module AlternativeTrigger {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutTrigger.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AlternativeTrigger

      /**
       * The first `GtkShortcutTrigger` to check.
       */
      first?: ShortcutTrigger | null
      /**
       * The second `GtkShortcutTrigger` to check.
       */
      second?: ShortcutTrigger | null
    }
  }

  interface AlternativeTrigger {
    // Own properties of Gtk-4.0.Gtk.AlternativeTrigger

    /**
     * The first `GtkShortcutTrigger` to check.
     */
    readonly first: ShortcutTrigger
    /**
     * The second `GtkShortcutTrigger` to check.
     */
    readonly second: ShortcutTrigger
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.AlternativeTrigger

    /**
     * Gets the first of the two alternative triggers that may
     * trigger `self`.
     *
     * [method`Gtk`.AlternativeTrigger.get_second] will return
     * the other one.
     * @returns the first alternative trigger
     */
    getFirst(): ShortcutTrigger
    /**
     * Gets the second of the two alternative triggers that may
     * trigger `self`.
     *
     * [method`Gtk`.AlternativeTrigger.get_first] will return
     * the other one.
     * @returns the second alternative trigger
     */
    getSecond(): ShortcutTrigger

    // Class property signals of Gtk-4.0.Gtk.AlternativeTrigger

    connect(
      sigName: "notify::first",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::first",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::first",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::first",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::first", ...args: any[]): void
    connect(
      sigName: "notify::second",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::second",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::second",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::second",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::second", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutTrigger` that combines two triggers.
   *
   * The `GtkAlternativeTrigger` triggers when either of two trigger.
   *
   * This can be cascaded to combine more than two triggers.
   * @class
   */
  class AlternativeTrigger extends ShortcutTrigger {
    // Own properties of Gtk-4.0.Gtk.AlternativeTrigger

    static name: string

    // Constructors of Gtk-4.0.Gtk.AlternativeTrigger

    constructor(config?: AlternativeTrigger.ConstructorProperties)
    /**
     * Creates a `GtkShortcutTrigger` that will trigger whenever
     * either of the two given triggers gets triggered.
     *
     * Note that nesting is allowed, so if you want more than two
     * alternative, create a new alternative trigger for each option.
     * @constructor
     * @param first The first trigger that may trigger
     * @param second The second trigger that may trigger
     * @returns a new `GtkShortcutTrigger`
     */
    constructor(first: ShortcutTrigger, second: ShortcutTrigger)
    /**
     * Creates a `GtkShortcutTrigger` that will trigger whenever
     * either of the two given triggers gets triggered.
     *
     * Note that nesting is allowed, so if you want more than two
     * alternative, create a new alternative trigger for each option.
     * @constructor
     * @param first The first trigger that may trigger
     * @param second The second trigger that may trigger
     * @returns a new `GtkShortcutTrigger`
     */
    static new(
      first: ShortcutTrigger,
      second: ShortcutTrigger
    ): AlternativeTrigger
    _init(config?: AlternativeTrigger.ConstructorProperties): void
  }

  module AnyFilter {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        Buildable.ConstructorProperties,
        MultiFilter.ConstructorProperties {}
  }

  interface AnyFilter extends Gio.ListModel, Buildable {
    // Own properties of Gtk-4.0.Gtk.AnyFilter

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.AnyFilter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAnyFilter` matches an item when at least one of its filters matches.
   *
   * To add filters to a `GtkAnyFilter`, use [method`Gtk`.MultiFilter.append].
   * @class
   */
  class AnyFilter extends MultiFilter {
    // Own properties of Gtk-4.0.Gtk.AnyFilter

    static name: string

    // Constructors of Gtk-4.0.Gtk.AnyFilter

    constructor(config?: AnyFilter.ConstructorProperties)
    /**
     * Creates a new empty "any" filter.
     *
     * Use [method`Gtk`.MultiFilter.append] to add filters to it.
     *
     * This filter matches an item if any of the filters added to it
     * matches the item. In particular, this means that if no filter
     * has been added to it, the filter matches no item.
     * @constructor
     * @returns a new `GtkAnyFilter`
     */
    constructor()
    /**
     * Creates a new empty "any" filter.
     *
     * Use [method`Gtk`.MultiFilter.append] to add filters to it.
     *
     * This filter matches an item if any of the filters added to it
     * matches the item. In particular, this means that if no filter
     * has been added to it, the filter matches no item.
     * @constructor
     * @returns a new `GtkAnyFilter`
     */
    static new(): AnyFilter
    _init(config?: AnyFilter.ConstructorProperties): void
  }

  module AppChooserButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `custom-item-activated`
     */
    interface CustomItemActivatedSignalCallback {
      (itemName: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AppChooser.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AppChooserButton

      /**
       * The text to show at the top of the dialog that can be
       * opened from the button.
       *
       * The string may contain Pango markup.
       */
      heading?: string | null
      /**
       * Whether the app chooser dialog should be modal.
       */
      modal?: boolean | null
      /**
       * Determines whether the dropdown menu shows the default application
       * on top for the provided content type.
       */
      show_default_item?: boolean | null
      /**
       * Determines whether the dropdown menu shows an item to open
       * a `GtkAppChooserDialog`.
       */
      show_dialog_item?: boolean | null
    }
  }

  interface AppChooserButton
    extends Accessible,
      AppChooser,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.AppChooserButton

    /**
     * The text to show at the top of the dialog that can be
     * opened from the button.
     *
     * The string may contain Pango markup.
     */
    heading: string | null
    /**
     * Whether the app chooser dialog should be modal.
     */
    modal: boolean
    /**
     * Determines whether the dropdown menu shows the default application
     * on top for the provided content type.
     */
    showDefaultItem: boolean
    /**
     * Determines whether the dropdown menu shows an item to open
     * a `GtkAppChooserDialog`.
     */
    showDialogItem: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.AppChooserButton

    /**
     * Appends a custom item to the list of applications that is shown
     * in the popup.
     *
     * The item name must be unique per-widget. Clients can use the
     * provided name as a detail for the
     * [signal`Gtk`.AppChooserButton::custom-item-activated] signal, to add a
     * callback for the activation of a particular custom item in the list.
     *
     * See also [method`Gtk`.AppChooserButton.append_separator].
     * @param name the name of the custom item
     * @param label the label for the custom item
     * @param icon the icon for the custom item
     */
    appendCustomItem(name: string, label: string, icon: Gio.Icon): void
    /**
     * Appends a separator to the list of applications that is shown
     * in the popup.
     */
    appendSeparator(): void
    /**
     * Returns the text to display at the top of the dialog.
     * @returns the text to display at the top of the dialog,   or %NULL, in which case a default text is displayed
     */
    getHeading(): string | null
    /**
     * Gets whether the dialog is modal.
     * @returns %TRUE if the dialog is modal
     */
    getModal(): boolean
    /**
     * Returns whether the dropdown menu should show the default
     * application at the top.
     * @returns the value of [property@Gtk.AppChooserButton:show-default-item]
     */
    getShowDefaultItem(): boolean
    /**
     * Returns whether the dropdown menu shows an item
     * for a `GtkAppChooserDialog`.
     * @returns the value of [property@Gtk.AppChooserButton:show-dialog-item]
     */
    getShowDialogItem(): boolean
    /**
     * Selects a custom item.
     *
     * See [method`Gtk`.AppChooserButton.append_custom_item].
     *
     * Use [method`Gtk`.AppChooser.refresh] to bring the selection
     * to its initial state.
     * @param name the name of the custom item
     */
    setActiveCustomItem(name: string): void
    /**
     * Sets the text to display at the top of the dialog.
     *
     * If the heading is not set, the dialog displays a default text.
     * @param heading a string containing Pango markup
     */
    setHeading(heading: string): void
    /**
     * Sets whether the dialog should be modal.
     * @param modal %TRUE to make the dialog modal
     */
    setModal(modal: boolean): void
    /**
     * Sets whether the dropdown menu of this button should show the
     * default application for the given content type at top.
     * @param setting the new value for [property`Gtk`.AppChooserButton:show-default-item]
     */
    setShowDefaultItem(setting: boolean): void
    /**
     * Sets whether the dropdown menu of this button should show an
     * entry to trigger a `GtkAppChooserDialog`.
     * @param setting the new value for [property`Gtk`.AppChooserButton:show-dialog-item]
     */
    setShowDialogItem(setting: boolean): void

    // Own signals of Gtk-4.0.Gtk.AppChooserButton

    connect(
      sigName: "activate",
      callback: AppChooserButton.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: AppChooserButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: AppChooserButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: AppChooserButton.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "changed",
      callback: AppChooserButton.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: AppChooserButton.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: AppChooserButton.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: AppChooserButton.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "custom-item-activated",
      callback: AppChooserButton.CustomItemActivatedSignalCallback
    ): number
    on(
      sigName: "custom-item-activated",
      callback: AppChooserButton.CustomItemActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "custom-item-activated",
      callback: AppChooserButton.CustomItemActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "custom-item-activated",
      callback: AppChooserButton.CustomItemActivatedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "custom-item-activated", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.AppChooserButton

    connect(
      sigName: "notify::heading",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::heading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::heading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::heading",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::heading", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::show-default-item",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-default-item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-default-item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-default-item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-default-item", ...args: any[]): void
    connect(
      sigName: "notify::show-dialog-item",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-dialog-item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-dialog-item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-dialog-item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-dialog-item", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content-type", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkAppChooserButton` lets the user select an application.
   *
   * ![An example GtkAppChooserButton](appchooserbutton.png)
   *
   * Initially, a `GtkAppChooserButton` selects the first application
   * in its list, which will either be the most-recently used application
   * or, if [property`Gtk`.AppChooserButton:show-default-item] is %TRUE, the
   * default application.
   *
   * The list of applications shown in a `GtkAppChooserButton` includes
   * the recommended applications for the given content type. When
   * [property`Gtk`.AppChooserButton:show-default-item] is set, the default
   * application is also included. To let the user chooser other applications,
   * you can set the [property`Gtk`.AppChooserButton:show-dialog-item] property,
   * which allows to open a full [class`Gtk`.AppChooserDialog].
   *
   * It is possible to add custom items to the list, using
   * [method`Gtk`.AppChooserButton.append_custom_item]. These items cause
   * the [signal`Gtk`.AppChooserButton::custom-item-activated] signal to be
   * emitted when they are selected.
   *
   * To track changes in the selected application, use the
   * [signal`Gtk`.AppChooserButton::changed] signal.
   *
   * ## CSS nodes
   *
   * `GtkAppChooserButton` has a single CSS node with the name “appchooserbutton”.
   * @class
   */
  class AppChooserButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.AppChooserButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.AppChooserButton

    constructor(config?: AppChooserButton.ConstructorProperties)
    /**
     * Creates a new `GtkAppChooserButton` for applications
     * that can handle content of the given type.
     * @constructor
     * @param contentType the content type to show applications for
     * @returns a newly created `GtkAppChooserButton`
     */
    constructor(contentType: string)
    /**
     * Creates a new `GtkAppChooserButton` for applications
     * that can handle content of the given type.
     * @constructor
     * @param contentType the content type to show applications for
     * @returns a newly created `GtkAppChooserButton`
     */
    static new(contentType: string): AppChooserButton
    _init(config?: AppChooserButton.ConstructorProperties): void
  }

  module AppChooserDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AppChooser.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Dialog.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AppChooserDialog

      /**
       * The GFile used by the `GtkAppChooserDialog`.
       *
       * The dialog's `GtkAppChooserWidget` content type will
       * be guessed from the file, if present.
       */
      gfile?: Gio.File | null
      /**
       * The text to show at the top of the dialog.
       *
       * The string may contain Pango markup.
       */
      heading?: string | null
    }
  }

  interface AppChooserDialog
    extends Accessible,
      AppChooser,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.AppChooserDialog

    /**
     * The GFile used by the `GtkAppChooserDialog`.
     *
     * The dialog's `GtkAppChooserWidget` content type will
     * be guessed from the file, if present.
     */
    readonly gfile: Gio.File
    /**
     * The text to show at the top of the dialog.
     *
     * The string may contain Pango markup.
     */
    heading: string | null
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.AppChooserDialog

    /**
     * Returns the text to display at the top of the dialog.
     * @returns the text to display at the top of the dialog,   or %NULL, in which case a default text is displayed
     */
    getHeading(): string | null
    /**
     * Returns the `GtkAppChooserWidget` of this dialog.
     * @returns the `GtkAppChooserWidget` of @self
     */
    getWidget(): Widget
    /**
     * Sets the text to display at the top of the dialog.
     *
     * If the heading is not set, the dialog displays a default text.
     * @param heading a string containing Pango markup
     */
    setHeading(heading: string): void

    // Conflicting methods

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @virtual
     */
    close(): void

    // Overloads of close

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void

    // Class property signals of Gtk-4.0.Gtk.AppChooserDialog

    connect(
      sigName: "notify::gfile",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gfile",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gfile",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gfile",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gfile", ...args: any[]): void
    connect(
      sigName: "notify::heading",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::heading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::heading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::heading",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::heading", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content-type", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAppChooserDialog` shows a `GtkAppChooserWidget` inside a `GtkDialog`.
   *
   * ![An example GtkAppChooserDialog](appchooserdialog.png)
   *
   * Note that `GtkAppChooserDialog` does not have any interesting methods
   * of its own. Instead, you should get the embedded `GtkAppChooserWidget`
   * using [method`Gtk`.AppChooserDialog.get_widget] and call its methods if
   * the generic [iface`Gtk`.AppChooser] interface is not sufficient for
   * your needs.
   *
   * To set the heading that is shown above the `GtkAppChooserWidget`,
   * use [method`Gtk`.AppChooserDialog.set_heading].
   *
   * ## CSS nodes
   *
   * `GtkAppChooserDialog` has a single CSS node with the name `window` and style
   * class `.appchooser`.
   * @class
   */
  class AppChooserDialog extends Dialog {
    // Own properties of Gtk-4.0.Gtk.AppChooserDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.AppChooserDialog

    constructor(config?: AppChooserDialog.ConstructorProperties)
    /**
     * Creates a new `GtkAppChooserDialog` for the provided `GFile`.
     *
     * The dialog will show applications that can open the file.
     * @constructor
     * @param parent a `GtkWindow`
     * @param flags flags for this dialog
     * @param file a `GFile`
     * @returns a newly created `GtkAppChooserDialog`
     */
    constructor(parent: Window | null, flags: DialogFlags, file: Gio.File)
    /**
     * Creates a new `GtkAppChooserDialog` for the provided `GFile`.
     *
     * The dialog will show applications that can open the file.
     * @constructor
     * @param parent a `GtkWindow`
     * @param flags flags for this dialog
     * @param file a `GFile`
     * @returns a newly created `GtkAppChooserDialog`
     */
    static new(
      parent: Window | null,
      flags: DialogFlags,
      file: Gio.File
    ): AppChooserDialog

    // Overloads of new

    /**
     * Creates a new dialog box.
     *
     * Widgets should not be packed into the `GtkWindow`
     * directly, but into the `content_area` and `action_area,`
     * as described above.
     * @constructor
     * @returns the new dialog as a `GtkWidget`
     */
    static new(): Dialog
    /**
     * Creates a new `GtkAppChooserDialog` for the provided content type.
     *
     * The dialog will show applications that can open the content type.
     * @constructor
     * @param parent a `GtkWindow`
     * @param flags flags for this dialog
     * @param contentType a content type string
     * @returns a newly created `GtkAppChooserDialog`
     */
    static newForContentType(
      parent: Window | null,
      flags: DialogFlags,
      contentType: string
    ): AppChooserDialog
    _init(config?: AppChooserDialog.ConstructorProperties): void
  }

  module AppChooserWidget {
    // Signal callback interfaces

    /**
     * Signal callback interface for `application-activated`
     */
    interface ApplicationActivatedSignalCallback {
      (application: Gio.AppInfo): void
    }

    /**
     * Signal callback interface for `application-selected`
     */
    interface ApplicationSelectedSignalCallback {
      (application: Gio.AppInfo): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AppChooser.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AppChooserWidget

      /**
       * The text that appears in the widget when there are no applications
       * for the given content type.
       */
      default_text?: string | null
      /**
       * If %TRUE, the app chooser presents all applications
       * in a single list, without subsections for default,
       * recommended or related applications.
       */
      show_all?: boolean | null
      /**
       * Determines whether the app chooser should show the default
       * handler for the content type in a separate section.
       *
       * If %FALSE, the default handler is listed among the recommended
       * applications.
       */
      show_default?: boolean | null
      /**
       * Determines whether the app chooser should show a section
       * for fallback applications.
       *
       * If %FALSE, the fallback applications are listed among the
       * other applications.
       */
      show_fallback?: boolean | null
      /**
       * Determines whether the app chooser should show a section
       * for other applications.
       */
      show_other?: boolean | null
      /**
       * Determines whether the app chooser should show a section
       * for recommended applications.
       *
       * If %FALSE, the recommended applications are listed
       * among the other applications.
       */
      show_recommended?: boolean | null
    }
  }

  interface AppChooserWidget
    extends Accessible,
      AppChooser,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.AppChooserWidget

    /**
     * The text that appears in the widget when there are no applications
     * for the given content type.
     */
    defaultText: string | null
    /**
     * If %TRUE, the app chooser presents all applications
     * in a single list, without subsections for default,
     * recommended or related applications.
     */
    showAll: boolean
    /**
     * Determines whether the app chooser should show the default
     * handler for the content type in a separate section.
     *
     * If %FALSE, the default handler is listed among the recommended
     * applications.
     */
    showDefault: boolean
    /**
     * Determines whether the app chooser should show a section
     * for fallback applications.
     *
     * If %FALSE, the fallback applications are listed among the
     * other applications.
     */
    showFallback: boolean
    /**
     * Determines whether the app chooser should show a section
     * for other applications.
     */
    showOther: boolean
    /**
     * Determines whether the app chooser should show a section
     * for recommended applications.
     *
     * If %FALSE, the recommended applications are listed
     * among the other applications.
     */
    showRecommended: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.AppChooserWidget

    /**
     * Returns the text that is shown if there are not applications
     * that can handle the content type.
     * @returns the value of [property@Gtk.AppChooserWidget:default-text]
     */
    getDefaultText(): string | null
    /**
     * Gets whether the app chooser should show all applications
     * in a flat list.
     * @returns the value of [property@Gtk.AppChooserWidget:show-all]
     */
    getShowAll(): boolean
    /**
     * Gets whether the app chooser should show the default handler
     * for the content type in a separate section.
     * @returns the value of [property@Gtk.AppChooserWidget:show-default]
     */
    getShowDefault(): boolean
    /**
     * Gets whether the app chooser should show related applications
     * for the content type in a separate section.
     * @returns the value of [property@Gtk.AppChooserWidget:show-fallback]
     */
    getShowFallback(): boolean
    /**
     * Gets whether the app chooser should show applications
     * which are unrelated to the content type.
     * @returns the value of [property@Gtk.AppChooserWidget:show-other]
     */
    getShowOther(): boolean
    /**
     * Gets whether the app chooser should show recommended applications
     * for the content type in a separate section.
     * @returns the value of [property@Gtk.AppChooserWidget:show-recommended]
     */
    getShowRecommended(): boolean
    /**
     * Sets the text that is shown if there are not applications
     * that can handle the content type.
     * @param text the new value for [property`Gtk`.AppChooserWidget:default-text]
     */
    setDefaultText(text: string): void
    /**
     * Sets whether the app chooser should show all applications
     * in a flat list.
     * @param setting the new value for [property`Gtk`.AppChooserWidget:show-all]
     */
    setShowAll(setting: boolean): void
    /**
     * Sets whether the app chooser should show the default handler
     * for the content type in a separate section.
     * @param setting the new value for [property`Gtk`.AppChooserWidget:show-default]
     */
    setShowDefault(setting: boolean): void
    /**
     * Sets whether the app chooser should show related applications
     * for the content type in a separate section.
     * @param setting the new value for [property`Gtk`.AppChooserWidget:show-fallback]
     */
    setShowFallback(setting: boolean): void
    /**
     * Sets whether the app chooser should show applications
     * which are unrelated to the content type.
     * @param setting the new value for [property`Gtk`.AppChooserWidget:show-other]
     */
    setShowOther(setting: boolean): void
    /**
     * Sets whether the app chooser should show recommended applications
     * for the content type in a separate section.
     * @param setting the new value for [property`Gtk`.AppChooserWidget:show-recommended]
     */
    setShowRecommended(setting: boolean): void

    // Own signals of Gtk-4.0.Gtk.AppChooserWidget

    connect(
      sigName: "application-activated",
      callback: AppChooserWidget.ApplicationActivatedSignalCallback
    ): number
    on(
      sigName: "application-activated",
      callback: AppChooserWidget.ApplicationActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "application-activated",
      callback: AppChooserWidget.ApplicationActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "application-activated",
      callback: AppChooserWidget.ApplicationActivatedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "application-activated", ...args: any[]): void
    connect(
      sigName: "application-selected",
      callback: AppChooserWidget.ApplicationSelectedSignalCallback
    ): number
    on(
      sigName: "application-selected",
      callback: AppChooserWidget.ApplicationSelectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "application-selected",
      callback: AppChooserWidget.ApplicationSelectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "application-selected",
      callback: AppChooserWidget.ApplicationSelectedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "application-selected", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.AppChooserWidget

    connect(
      sigName: "notify::default-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-text", ...args: any[]): void
    connect(
      sigName: "notify::show-all",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-all",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-all",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-all",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-all", ...args: any[]): void
    connect(
      sigName: "notify::show-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-default", ...args: any[]): void
    connect(
      sigName: "notify::show-fallback",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-fallback",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-fallback", ...args: any[]): void
    connect(
      sigName: "notify::show-other",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-other",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-other",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-other",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-other", ...args: any[]): void
    connect(
      sigName: "notify::show-recommended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-recommended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-recommended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-recommended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-recommended", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content-type", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAppChooserWidget` is a widget for selecting applications.
   *
   * It is the main building block for [class`Gtk`.AppChooserDialog].
   * Most applications only need to use the latter; but you can use
   * this widget as part of a larger widget if you have special needs.
   *
   * `GtkAppChooserWidget` offers detailed control over what applications
   * are shown, using the
   * [property`Gtk`.AppChooserWidget:show-default],
   * [property`Gtk`.AppChooserWidget:show-recommended],
   * [property`Gtk`.AppChooserWidget:show-fallback],
   * [property`Gtk`.AppChooserWidget:show-other] and
   * [property`Gtk`.AppChooserWidget:show-all] properties. See the
   * [iface`Gtk`.AppChooser] documentation for more information about these
   * groups of applications.
   *
   * To keep track of the selected application, use the
   * [signal`Gtk`.AppChooserWidget::application-selected] and
   * [signal`Gtk`.AppChooserWidget::application-activated] signals.
   *
   * ## CSS nodes
   *
   * `GtkAppChooserWidget` has a single CSS node with name appchooser.
   * @class
   */
  class AppChooserWidget extends Widget {
    // Own properties of Gtk-4.0.Gtk.AppChooserWidget

    static name: string

    // Constructors of Gtk-4.0.Gtk.AppChooserWidget

    constructor(config?: AppChooserWidget.ConstructorProperties)
    /**
     * Creates a new `GtkAppChooserWidget` for applications
     * that can handle content of the given type.
     * @constructor
     * @param contentType the content type to show applications for
     * @returns a newly created `GtkAppChooserWidget`
     */
    constructor(contentType: string)
    /**
     * Creates a new `GtkAppChooserWidget` for applications
     * that can handle content of the given type.
     * @constructor
     * @param contentType the content type to show applications for
     * @returns a newly created `GtkAppChooserWidget`
     */
    static new(contentType: string): AppChooserWidget
    _init(config?: AppChooserWidget.ConstructorProperties): void
  }

  module Application {
    // Signal callback interfaces

    /**
     * Signal callback interface for `query-end`
     */
    interface QueryEndSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `window-added`
     */
    interface WindowAddedSignalCallback {
      (window: Window): void
    }

    /**
     * Signal callback interface for `window-removed`
     */
    interface WindowRemovedSignalCallback {
      (window: Window): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ActionGroup.ConstructorProperties,
        Gio.ActionMap.ConstructorProperties,
        Gio.Application.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Application

      /**
       * The `GMenuModel` to be used for the application's menu bar.
       */
      menubar?: Gio.MenuModel | null
      /**
       * Set this property to `TRUE` to register with the session manager.
       *
       * This will make GTK track the session state (such as the
       * [property`Gtk`.Application:screensaver-active] property).
       */
      register_session?: boolean | null
    }
  }

  interface Application extends Gio.ActionGroup, Gio.ActionMap {
    // Own properties of Gtk-4.0.Gtk.Application

    /**
     * The currently focused window of the application.
     */
    readonly activeWindow: Window
    /**
     * The `GMenuModel` to be used for the application's menu bar.
     */
    menubar: Gio.MenuModel
    /**
     * Set this property to `TRUE` to register with the session manager.
     *
     * This will make GTK track the session state (such as the
     * [property`Gtk`.Application:screensaver-active] property).
     */
    registerSession: boolean
    /**
     * This property is `TRUE` if GTK believes that the screensaver is
     * currently active.
     *
     * GTK only tracks session state (including this) when
     * [property`Gtk`.Application:register-session] is set to %TRUE.
     *
     * Tracking the screensaver state is currently only supported on
     * Linux.
     */
    readonly screensaverActive: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Application

    parentInstance: Gio.Application

    // Owm methods of Gtk-4.0.Gtk.Application

    /**
     * Adds a window to `application`.
     *
     * This call can only happen after the `application` has started;
     * typically, you should add new application windows in response
     * to the emission of the `GApplication::activate` signal.
     *
     * This call is equivalent to setting the [property`Gtk`.Window:application]
     * property of `window` to `application`.
     *
     * Normally, the connection between the application and the window
     * will remain until the window is destroyed, but you can explicitly
     * remove it with [method`Gtk`.Application.remove_window].
     *
     * GTK will keep the `application` running as long as it has
     * any windows.
     * @param window a `GtkWindow`
     */
    addWindow(window: Window): void
    /**
     * Gets the accelerators that are currently associated with
     * the given action.
     * @param detailedActionName a detailed action name, specifying an action   and target to obtain accelerators for
     * @returns accelerators for `detailed_action_name`
     */
    getAccelsForAction(detailedActionName: string): string[]
    /**
     * Returns the list of actions (possibly empty) that `accel` maps to.
     *
     * Each item in the list is a detailed action name in the usual form.
     *
     * This might be useful to discover if an accel already exists in
     * order to prevent installation of a conflicting accelerator (from
     * an accelerator editor or a plugin system, for example). Note that
     * having more than one action per accelerator may not be a bad thing
     * and might make sense in cases where the actions never appear in the
     * same context.
     *
     * In case there are no actions for a given accelerator, an empty array
     * is returned. `NULL` is never returned.
     *
     * It is a programmer error to pass an invalid accelerator string.
     *
     * If you are unsure, check it with [func`Gtk`.accelerator_parse] first.
     * @param accel an accelerator that can be parsed by [func`Gtk`.accelerator_parse]
     * @returns a %NULL-terminated array of actions for `accel`
     */
    getActionsForAccel(accel: string): string[]
    /**
     * Gets the “active” window for the application.
     *
     * The active window is the one that was most recently focused (within
     * the application).  This window may not have the focus at the moment
     * if another application has it — this is just the most
     * recently-focused window within this application.
     * @returns the active window
     */
    getActiveWindow(): Window | null
    /**
     * Gets a menu from automatically loaded resources.
     *
     * See [the section on Automatic resources](class.Application.html#automatic-resources)
     * for more information.
     * @param id the id of the menu to look up
     * @returns Gets the menu with the   given id from the automatically loaded resources
     */
    getMenuById(id: string): Gio.Menu | null
    /**
     * Returns the menu model that has been set with
     * [method`Gtk`.Application.set_menubar].
     * @returns the menubar for windows of `application`
     */
    getMenubar(): Gio.MenuModel | null
    /**
     * Returns the [class`Gtk`.ApplicationWindow] with the given ID.
     *
     * The ID of a `GtkApplicationWindow` can be retrieved with
     * [method`Gtk`.ApplicationWindow.get_id].
     * @param id an identifier number
     * @returns the window for the given `id`
     */
    getWindowById(id: number): Window | null
    /**
     * Gets a list of the [class`Gtk`.Window] instances associated with `application`.
     *
     * The list is sorted by most recently focused window, such that the first
     * element is the currently focused window. (Useful for choosing a parent
     * for a transient window.)
     *
     * The list that is returned should not be modified in any way. It will
     * only remain valid until the next focus change or window creation or
     * deletion.
     * @returns a `GList` of `GtkWindow`   instances
     */
    getWindows(): Window[]
    /**
     * Inform the session manager that certain types of actions should be
     * inhibited.
     *
     * This is not guaranteed to work on all platforms and for all types of
     * actions.
     *
     * Applications should invoke this method when they begin an operation
     * that should not be interrupted, such as creating a CD or DVD. The
     * types of actions that may be blocked are specified by the `flags`
     * parameter. When the application completes the operation it should
     * call [method`Gtk`.Application.uninhibit] to remove the inhibitor. Note
     * that an application can have multiple inhibitors, and all of them must
     * be individually removed. Inhibitors are also cleared when the
     * application exits.
     *
     * Applications should not expect that they will always be able to block
     * the action. In most cases, users will be given the option to force
     * the action to take place.
     *
     * The `reason` message should be short and to the point.
     *
     * If `window` is given, the session manager may point the user to
     * this window to find out more about why the action is inhibited.
     * @param window a `GtkWindow`
     * @param flags what types of actions should be inhibited
     * @param reason a short, human-readable string that explains   why these operations are inhibited
     * @returns A non-zero cookie that is used to uniquely identify this   request. It should be used as an argument to [method@Gtk.Application.uninhibit]   in order to remove the request. If the platform does not support   inhibiting or the request failed for some reason, 0 is returned.
     */
    inhibit(
      window: Window | null,
      flags: ApplicationInhibitFlags,
      reason: string | null
    ): number
    /**
     * Lists the detailed action names which have associated accelerators.
     *
     * See [method`Gtk`.Application.set_accels_for_action].
     * @returns the detailed action names
     */
    listActionDescriptions(): string[]
    /**
     * Remove a window from `application`.
     *
     * If `window` belongs to `application` then this call is equivalent to
     * setting the [property`Gtk`.Window:application] property of `window` to
     * `NULL`.
     *
     * The application may stop running as a result of a call to this
     * function, if `window` was the last window of the `application`.
     * @param window a `GtkWindow`
     */
    removeWindow(window: Window): void
    /**
     * Sets zero or more keyboard accelerators that will trigger the
     * given action.
     *
     * The first item in `accels` will be the primary accelerator, which may be
     * displayed in the UI.
     *
     * To remove all accelerators for an action, use an empty, zero-terminated
     * array for `accels`.
     *
     * For the `detailed_action_name`, see `g_action_parse_detailed_name()` and
     * `g_action_print_detailed_name()`.
     * @param detailedActionName a detailed action name, specifying an action   and target to associate accelerators with
     * @param accels a list of accelerators in the format   understood by [func`Gtk`.accelerator_parse]
     */
    setAccelsForAction(detailedActionName: string, accels: string[]): void
    /**
     * Sets or unsets the menubar for windows of `application`.
     *
     * This is a menubar in the traditional sense.
     *
     * This can only be done in the primary instance of the application,
     * after it has been registered. `GApplication::startup` is a good place
     * to call this.
     *
     * Depending on the desktop environment, this may appear at the top of
     * each window, or at the top of the screen.  In some environments, if
     * both the application menu and the menubar are set, the application
     * menu will be presented as if it were the first item of the menubar.
     * Other environments treat the two as completely separate — for example,
     * the application menu may be rendered by the desktop shell while the
     * menubar (if set) remains in each individual window.
     *
     * Use the base `GActionMap` interface to add actions, to respond to the
     * user selecting these menu items.
     * @param menubar a `GMenuModel`
     */
    setMenubar(menubar: Gio.MenuModel | null): void
    /**
     * Removes an inhibitor that has been previously established.
     *
     * See [method`Gtk`.Application.inhibit].
     *
     * Inhibitors are also cleared when the application exits.
     * @param cookie a cookie that was returned by [method`Gtk`.Application.inhibit]
     */
    uninhibit(cookie: number): void

    // Own virtual methods of Gtk-4.0.Gtk.Application

    /**
     * Signal emitted when a `GtkWindow` is added to
     *    application through gtk_application_add_window().
     * @virtual
     * @param window
     */
    windowAdded(window: Window): void
    /**
     * Signal emitted when a `GtkWindow` is removed from
     *    application, either as a side-effect of being destroyed or
     *    explicitly through gtk_application_remove_window().
     * @virtual
     * @param window
     */
    windowRemoved(window: Window): void

    // Own signals of Gtk-4.0.Gtk.Application

    connect(
      sigName: "query-end",
      callback: Application.QueryEndSignalCallback
    ): number
    on(
      sigName: "query-end",
      callback: Application.QueryEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "query-end",
      callback: Application.QueryEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "query-end",
      callback: Application.QueryEndSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "query-end", ...args: any[]): void
    connect(
      sigName: "window-added",
      callback: Application.WindowAddedSignalCallback
    ): number
    on(
      sigName: "window-added",
      callback: Application.WindowAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "window-added",
      callback: Application.WindowAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "window-added",
      callback: Application.WindowAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "window-added", ...args: any[]): void
    connect(
      sigName: "window-removed",
      callback: Application.WindowRemovedSignalCallback
    ): number
    on(
      sigName: "window-removed",
      callback: Application.WindowRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "window-removed",
      callback: Application.WindowRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "window-removed",
      callback: Application.WindowRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "window-removed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Application

    connect(
      sigName: "notify::active-window",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active-window",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active-window",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active-window",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active-window", ...args: any[]): void
    connect(
      sigName: "notify::menubar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::menubar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::menubar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::menubar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::menubar", ...args: any[]): void
    connect(
      sigName: "notify::register-session",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::register-session",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::register-session",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::register-session",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::register-session", ...args: any[]): void
    connect(
      sigName: "notify::screensaver-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::screensaver-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::screensaver-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::screensaver-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::screensaver-active", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-group", ...args: any[]): void
    connect(
      sigName: "notify::application-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application-id", ...args: any[]): void
    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::inactivity-timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inactivity-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inactivity-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inactivity-timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inactivity-timeout", ...args: any[]): void
    connect(
      sigName: "notify::is-busy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-busy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-busy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-busy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-busy", ...args: any[]): void
    connect(
      sigName: "notify::is-registered",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-registered",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-registered",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-registered",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-registered", ...args: any[]): void
    connect(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-remote",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-remote", ...args: any[]): void
    connect(
      sigName: "notify::resource-base-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resource-base-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resource-base-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resource-base-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resource-base-path", ...args: any[]): void
    connect(
      sigName: "notify::version",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::version",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::version",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::version", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkApplication` is a high-level API for writing applications.
   *
   * It supports many aspects of writing a GTK application in a convenient
   * fashion, without enforcing a one-size-fits-all model.
   *
   * Currently, `GtkApplication` handles GTK initialization, application
   * uniqueness, session management, provides some basic scriptability and
   * desktop shell integration by exporting actions and menus and manages a
   * list of toplevel windows whose life-cycle is automatically tied to the
   * life-cycle of your application.
   *
   * While `GtkApplication` works fine with plain [class`Gtk`.Window]s, it is
   * recommended to use it together with [class`Gtk`.ApplicationWindow].
   *
   * ## Automatic resources
   *
   * `GtkApplication` will automatically load menus from the `GtkBuilder`
   * resource located at "gtk/menus.ui", relative to the application's
   * resource base path (see [method`Gio`.Application.set_resource_base_path]).
   * The menu with the ID "menubar" is taken as the application's
   * menubar. Additional menus (most interesting submenus) can be named
   * and accessed via [method`Gtk`.Application.get_menu_by_id] which allows for
   * dynamic population of a part of the menu structure.
   *
   * Note that automatic resource loading uses the resource base path
   * that is set at construction time and will not work if the resource
   * base path is changed at a later time.
   *
   * It is also possible to provide the menubar manually using
   * [method`Gtk`.Application.set_menubar].
   *
   * `GtkApplication` will also automatically setup an icon search path for
   * the default icon theme by appending "icons" to the resource base
   * path. This allows your application to easily store its icons as
   * resources. See [method`Gtk`.IconTheme.add_resource_path] for more
   * information.
   *
   * If there is a resource located at `gtk/help-overlay.ui` which
   * defines a [class`Gtk`.ShortcutsWindow] with ID `help_overlay` then
   * `GtkApplication` associates an instance of this shortcuts window with
   * each [class`Gtk`.ApplicationWindow] and sets up the keyboard accelerator
   * <kbd>Control</kbd>+<kbd>?</kbd> to open it. To create a menu item that
   * displays the shortcuts window, associate the item with the action
   * `win.show-help-overlay`.
   *
   * ## A simple application
   *
   * [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/bp/bloatpad.c)
   * is available in the GTK source code repository
   *
   * `GtkApplication` optionally registers with a session manager of the
   * users session (if you set the [property`Gtk`.Application:register-session]
   * property) and offers various functionality related to the session
   * life-cycle.
   *
   * An application can block various ways to end the session with
   * the [method`Gtk`.Application.inhibit] function. Typical use cases for
   * this kind of inhibiting are long-running, uninterruptible operations,
   * such as burning a CD or performing a disk backup. The session
   * manager may not honor the inhibitor, but it can be expected to
   * inform the user about the negative consequences of ending the
   * session while inhibitors are present.
   *
   * ## See Also
   *
   * [HowDoI: Using GtkApplication](https://wiki.gnome.org/HowDoI/GtkApplication),
   * [Getting Started with GTK: Basics](getting_started.html#basics)
   * @class
   */
  class Application extends Gio.Application {
    // Own properties of Gtk-4.0.Gtk.Application

    static name: string

    // Constructors of Gtk-4.0.Gtk.Application

    constructor(config?: Application.ConstructorProperties)
    /**
     * Creates a new `GtkApplication` instance.
     *
     * When using `GtkApplication`, it is not necessary to call [func`Gtk`.init]
     * manually. It is called as soon as the application gets registered as
     * the primary instance.
     *
     * Concretely, [func`Gtk`.init] is called in the default handler for the
     * `GApplication::startup` signal. Therefore, `GtkApplication` subclasses should
     * always chain up in their `GApplication::startup` handler before using any GTK
     * API.
     *
     * Note that commandline arguments are not passed to [func`Gtk`.init].
     *
     * If `application_id` is not %NULL, then it must be valid. See
     * `g_application_id_is_valid()`.
     *
     * If no application ID is given then some features (most notably application
     * uniqueness) will be disabled.
     * @constructor
     * @param applicationId The application ID
     * @param flags the application flags
     * @returns a new `GtkApplication` instance
     */
    constructor(applicationId: string | null, flags: Gio.ApplicationFlags)
    /**
     * Creates a new `GtkApplication` instance.
     *
     * When using `GtkApplication`, it is not necessary to call [func`Gtk`.init]
     * manually. It is called as soon as the application gets registered as
     * the primary instance.
     *
     * Concretely, [func`Gtk`.init] is called in the default handler for the
     * `GApplication::startup` signal. Therefore, `GtkApplication` subclasses should
     * always chain up in their `GApplication::startup` handler before using any GTK
     * API.
     *
     * Note that commandline arguments are not passed to [func`Gtk`.init].
     *
     * If `application_id` is not %NULL, then it must be valid. See
     * `g_application_id_is_valid()`.
     *
     * If no application ID is given then some features (most notably application
     * uniqueness) will be disabled.
     * @constructor
     * @param applicationId The application ID
     * @param flags the application flags
     * @returns a new `GtkApplication` instance
     */
    static new(
      applicationId: string | null,
      flags: Gio.ApplicationFlags
    ): Application

    // Overloads of new

    /**
     * Creates a new #GApplication instance.
     *
     * If non-%NULL, the application id must be valid.  See
     * g_application_id_is_valid().
     *
     * If no application ID is given then some features of #GApplication
     * (most notably application uniqueness) will be disabled.
     * @constructor
     * @param applicationId the application id
     * @param flags the application flags
     * @returns a new #GApplication instance
     */
    static new(
      applicationId: string | null,
      flags: Gio.ApplicationFlags
    ): Gio.Application
    _init(config?: Application.ConstructorProperties): void
  }

  module ApplicationWindow {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ActionGroup.ConstructorProperties,
        Gio.ActionMap.ConstructorProperties,
        Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Window.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ApplicationWindow

      /**
       * If this property is %TRUE, the window will display a menubar
       * unless it is shown by the desktop shell.
       *
       * See [method`Gtk`.Application.set_menubar].
       *
       * If %FALSE, the window will not display a menubar, regardless
       * of whether the desktop shell is showing it or not.
       */
      show_menubar?: boolean | null
    }
  }

  interface ApplicationWindow
    extends Gio.ActionGroup,
      Gio.ActionMap,
      Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.ApplicationWindow

    /**
     * If this property is %TRUE, the window will display a menubar
     * unless it is shown by the desktop shell.
     *
     * See [method`Gtk`.Application.set_menubar].
     *
     * If %FALSE, the window will not display a menubar, regardless
     * of whether the desktop shell is showing it or not.
     */
    showMenubar: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.ApplicationWindow

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.ApplicationWindow

    /**
     * Gets the `GtkShortcutsWindow` that is associated with `window`.
     *
     * See [method`Gtk`.ApplicationWindow.set_help_overlay].
     * @returns the help overlay associated   with @window
     */
    getHelpOverlay(): ShortcutsWindow | null
    /**
     * Returns the unique ID of the window.
     *
     *  If the window has not yet been added to a `GtkApplication`, returns `0`.
     * @returns the unique ID for @window, or `0` if the window   has not yet been added to a `GtkApplication`
     */
    getId(): number

    // Overloads of getId

    /**
     * The getter corresponding to `set_id`. Implement this
     *   if you implement `set_id`.
     * @virtual
     */
    getId(): string
    /**
     * Returns whether the window will display a menubar for the app menu
     * and menubar as needed.
     * @returns %TRUE if @window will display a menubar when needed
     */
    getShowMenubar(): boolean
    /**
     * Associates a shortcuts window with the application window.
     *
     * Additionally, sets up an action with the name
     * `win.show-help-overlay` to present it.
     *
     * `window` takes responsibility for destroying `help_overlay`.
     * @param helpOverlay a `GtkShortcutsWindow`
     */
    setHelpOverlay(helpOverlay: ShortcutsWindow | null): void
    /**
     * Sets whether the window will display a menubar for the app menu
     * and menubar as needed.
     * @param showMenubar whether to show a menubar when needed
     */
    setShowMenubar(showMenubar: boolean): void

    // Conflicting methods

    /**
     * Activate the named action within `action_group`.
     *
     * If the action is expecting a parameter, then the correct type of
     * parameter must be given as `parameter`.  If the action is expecting no
     * parameters then `parameter` must be %NULL.  See
     * g_action_group_get_action_parameter_type().
     *
     * If the #GActionGroup implementation supports asynchronous remote
     * activation over D-Bus, this call may return before the relevant
     * D-Bus traffic has been sent, or any replies have been received. In
     * order to block on such asynchronous activation calls,
     * g_dbus_connection_flush() should be called prior to the code, which
     * depends on the result of the action activation. Without flushing
     * the D-Bus connection, there is no guarantee that the action would
     * have been activated.
     *
     * The following code which runs in a remote app instance, shows an
     * example of a "quit" action being activated on the primary app
     * instance over D-Bus. Here g_dbus_connection_flush() is called
     * before `exit()`. Without g_dbus_connection_flush(), the "quit" action
     * may fail to be activated on the primary instance.
     *
     *
     * ```c
     * // call "quit" action on primary instance
     * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
     *
     * // make sure the action is activated now
     * g_dbus_connection_flush (...);
     *
     * g_debug ("application has been terminated. exiting.");
     *
     * exit (0);
     * ```
     *
     * @virtual
     * @param actionName the name of the action to activate
     * @param parameter parameters to the activation
     */
    activateAction(actionName: string, parameter: GLib.Variant | null): void
    /**
     * Looks up the action in the action groups associated with
     * `widget` and its ancestors, and activates it.
     *
     * If the action is in an action group added with
     * [method`Gtk`.Widget.insert_action_group], the `name` is expected
     * to be prefixed with the prefix that was used when the group was
     * inserted.
     *
     * The arguments must match the actions expected parameter type,
     * as returned by `g_action_get_parameter_type()`.
     * @param name the name of the action to activate
     * @param args parameters to use
     * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
     */
    activateAction(name: string, args: GLib.Variant | null): boolean
    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Class property signals of Gtk-4.0.Gtk.ApplicationWindow

    connect(
      sigName: "notify::show-menubar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-menubar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-menubar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-menubar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-menubar", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkApplicationWindow` is a `GtkWindow` subclass that integrates with
   * `GtkApplication`.
   *
   * Notably, `GtkApplicationWindow` can handle an application menubar.
   *
   * This class implements the `GActionGroup` and `GActionMap` interfaces,
   * to let you add window-specific actions that will be exported by the
   * associated [class`Gtk`.Application], together with its application-wide
   * actions. Window-specific actions are prefixed with the “win.”
   * prefix and application-wide actions are prefixed with the “app.”
   * prefix. Actions must be addressed with the prefixed name when
   * referring to them from a `GMenuModel`.
   *
   * Note that widgets that are placed inside a `GtkApplicationWindow`
   * can also activate these actions, if they implement the
   * [iface`Gtk`.Actionable] interface.
   *
   * The settings [property`Gtk`.Settings:gtk-shell-shows-app-menu] and
   * [property`Gtk`.Settings:gtk-shell-shows-menubar] tell GTK whether the
   * desktop environment is showing the application menu and menubar
   * models outside the application as part of the desktop shell.
   * For instance, on OS X, both menus will be displayed remotely;
   * on Windows neither will be.
   *
   * If the desktop environment does not display the menubar, then
   * `GtkApplicationWindow` will automatically show a menubar for it.
   * This behaviour can be overridden with the
   * [property`Gtk`.ApplicationWindow:show-menubar] property. If the
   * desktop environment does not display the application menu, then
   * it will automatically be included in the menubar or in the windows
   * client-side decorations.
   *
   * See [class`Gtk`.PopoverMenu] for information about the XML language
   * used by `GtkBuilder` for menu models.
   *
   * See also: [method`Gtk`.Application.set_menubar].
   *
   * ## A GtkApplicationWindow with a menubar
   *
   * The code sample below shows how to set up a `GtkApplicationWindow`
   * with a menu bar defined on the [class`Gtk`.Application]:
   *
   * ```c
   * GtkApplication *app = gtk_application_new ("org.gtk.test", 0);
   *
   * GtkBuilder *builder = gtk_builder_new_from_string (
   *     "<interface>"
   *     "  <menu id='menubar'>"
   *     "    <submenu>"
   *     "      <attribute name='label' translatable='yes'>_Edit</attribute>"
   *     "      <item>"
   *     "        <attribute name='label' translatable='yes'>_Copy</attribute>"
   *     "        <attribute name='action'>win.copy</attribute>"
   *     "      </item>"
   *     "      <item>"
   *     "        <attribute name='label' translatable='yes'>_Paste</attribute>"
   *     "        <attribute name='action'>win.paste</attribute>"
   *     "      </item>"
   *     "    </submenu>"
   *     "  </menu>"
   *     "</interface>",
   *     -1);
   *
   * GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
   * gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
   * g_object_unref (builder);
   *
   * // ...
   *
   * GtkWidget *window = gtk_application_window_new (app);
   * ```
   * @class
   */
  class ApplicationWindow extends Window {
    // Own properties of Gtk-4.0.Gtk.ApplicationWindow

    static name: string

    // Constructors of Gtk-4.0.Gtk.ApplicationWindow

    constructor(config?: ApplicationWindow.ConstructorProperties)
    /**
     * Creates a new `GtkApplicationWindow`.
     * @constructor
     * @param application a `GtkApplication`
     * @returns a newly created `GtkApplicationWindow`
     */
    constructor(application: Application)
    /**
     * Creates a new `GtkApplicationWindow`.
     * @constructor
     * @param application a `GtkApplication`
     * @returns a newly created `GtkApplicationWindow`
     */
    static new(application: Application): ApplicationWindow

    // Overloads of new

    /**
     * Creates a new `GtkWindow`.
     *
     * To get an undecorated window (no window borders), use
     * [method`Gtk`.Window.set_decorated].
     *
     * All top-level windows created by gtk_window_new() are stored
     * in an internal top-level window list. This list can be obtained
     * from [func`Gtk`.Window.list_toplevels]. Due to GTK keeping a
     * reference to the window internally, gtk_window_new() does not
     * return a reference to the caller.
     *
     * To delete a `GtkWindow`, call [method`Gtk`.Window.destroy].
     * @constructor
     * @returns a new `GtkWindow`.
     */
    static new(): Window
    _init(config?: ApplicationWindow.ConstructorProperties): void
  }

  module AspectFrame {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AspectFrame

      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Whether the `GtkAspectFrame` should use the aspect ratio of its child.
       */
      obey_child?: boolean | null
      /**
       * The aspect ratio to be used by the `GtkAspectFrame`.
       *
       * This property is only used if
       * [property`Gtk`.AspectFrame:obey-child] is set to %FALSE.
       */
      ratio?: number | null
      /**
       * The horizontal alignment of the child.
       */
      xalign?: number | null
      /**
       * The vertical alignment of the child.
       */
      yalign?: number | null
    }
  }

  interface AspectFrame extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.AspectFrame

    /**
     * The child widget.
     */
    child: Widget
    /**
     * Whether the `GtkAspectFrame` should use the aspect ratio of its child.
     */
    obeyChild: boolean
    /**
     * The aspect ratio to be used by the `GtkAspectFrame`.
     *
     * This property is only used if
     * [property`Gtk`.AspectFrame:obey-child] is set to %FALSE.
     */
    ratio: number
    /**
     * The horizontal alignment of the child.
     */
    xalign: number
    /**
     * The vertical alignment of the child.
     */
    yalign: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.AspectFrame

    /**
     * Gets the child widget of `self`.
     * @returns the child widget of @self
     */
    getChild(): Widget | null
    /**
     * Returns whether the child's size request should override
     * the set aspect ratio of the `GtkAspectFrame`.
     * @returns whether to obey the child's size request
     */
    getObeyChild(): boolean
    /**
     * Returns the desired aspect ratio of the child.
     * @returns the desired aspect ratio
     */
    getRatio(): number
    /**
     * Returns the horizontal alignment of the child within the
     * allocation of the `GtkAspectFrame`.
     * @returns the horizontal alignment
     */
    getXalign(): number
    /**
     * Returns the vertical alignment of the child within the
     * allocation of the `GtkAspectFrame`.
     * @returns the vertical alignment
     */
    getYalign(): number
    /**
     * Sets the child widget of `self`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets whether the aspect ratio of the child's size
     * request should override the set aspect ratio of
     * the `GtkAspectFrame`.
     * @param obeyChild If %TRUE, `ratio` is ignored, and the aspect    ratio is taken from the requisition of the child.
     */
    setObeyChild(obeyChild: boolean): void
    /**
     * Sets the desired aspect ratio of the child.
     * @param ratio aspect ratio of the child
     */
    setRatio(ratio: number): void
    /**
     * Sets the horizontal alignment of the child within the allocation
     * of the `GtkAspectFrame`.
     * @param xalign horizontal alignment, from 0.0 (left aligned) to 1.0 (right aligned)
     */
    setXalign(xalign: number): void
    /**
     * Sets the vertical alignment of the child within the allocation
     * of the `GtkAspectFrame`.
     * @param yalign horizontal alignment, from 0.0 (top aligned) to 1.0 (bottom aligned)
     */
    setYalign(yalign: number): void

    // Class property signals of Gtk-4.0.Gtk.AspectFrame

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::obey-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::obey-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::obey-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::obey-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::obey-child", ...args: any[]): void
    connect(
      sigName: "notify::ratio",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ratio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ratio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ratio",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ratio", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAspectFrame` preserves the aspect ratio of its child.
   *
   * The frame can respect the aspect ratio of the child widget,
   * or use its own aspect ratio.
   *
   * # CSS nodes
   *
   * `GtkAspectFrame` uses a CSS node with name `frame`.
   *
   * # Accessibility
   *
   * Until GTK 4.10, `GtkAspectFrame` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   *
   * Starting from GTK 4.12, `GtkAspectFrame` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
   * @class
   */
  class AspectFrame extends Widget {
    // Own properties of Gtk-4.0.Gtk.AspectFrame

    static name: string

    // Constructors of Gtk-4.0.Gtk.AspectFrame

    constructor(config?: AspectFrame.ConstructorProperties)
    /**
     * Create a new `GtkAspectFrame`.
     * @constructor
     * @param xalign Horizontal alignment of the child within the parent.   Ranges from 0.0 (left aligned) to 1.0 (right aligned)
     * @param yalign Vertical alignment of the child within the parent.   Ranges from 0.0 (top aligned) to 1.0 (bottom aligned)
     * @param ratio The desired aspect ratio.
     * @param obeyChild If %TRUE, `ratio` is ignored, and the aspect   ratio is taken from the requistion of the child.
     * @returns the new `GtkAspectFrame`.
     */
    constructor(
      xalign: number,
      yalign: number,
      ratio: number,
      obeyChild: boolean
    )
    /**
     * Create a new `GtkAspectFrame`.
     * @constructor
     * @param xalign Horizontal alignment of the child within the parent.   Ranges from 0.0 (left aligned) to 1.0 (right aligned)
     * @param yalign Vertical alignment of the child within the parent.   Ranges from 0.0 (top aligned) to 1.0 (bottom aligned)
     * @param ratio The desired aspect ratio.
     * @param obeyChild If %TRUE, `ratio` is ignored, and the aspect   ratio is taken from the requistion of the child.
     * @returns the new `GtkAspectFrame`.
     */
    static new(
      xalign: number,
      yalign: number,
      ratio: number,
      obeyChild: boolean
    ): AspectFrame
    _init(config?: AspectFrame.ConstructorProperties): void
  }

  module Assistant {
    // Signal callback interfaces

    /**
     * Signal callback interface for `apply`
     */
    interface ApplySignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `cancel`
     */
    interface CancelSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `close`
     */
    interface CloseSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `escape`
     */
    interface EscapeSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `prepare`
     */
    interface PrepareSignalCallback {
      (page: Widget): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Window.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Assistant

      /**
       * %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
       * instead of the action-area.
       *
       * For technical reasons, this property is declared as an integer
       * property, but you should only set it to %TRUE or %FALSE.
       */
      use_header_bar?: number | null
    }
  }

  interface Assistant
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.Assistant

    /**
     * `GListModel` containing the pages.
     */
    readonly pages: Gio.ListModel
    /**
     * %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
     * instead of the action-area.
     *
     * For technical reasons, this property is declared as an integer
     * property, but you should only set it to %TRUE or %FALSE.
     */
    readonly useHeaderBar: number
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.Assistant

    /**
     * Adds a widget to the action area of a `GtkAssistant`.
     * @param child a `GtkWidget`
     */
    addActionWidget(child: Widget): void
    /**
     * Appends a page to the `assistant`.
     * @param page a `GtkWidget`
     * @returns the index (starting at 0) of the inserted page
     */
    appendPage(page: Widget): number
    /**
     * Erases the visited page history.
     *
     * GTK will then hide the back button on the current page,
     * and removes the cancel button from subsequent pages.
     *
     * Use this when the information provided up to the current
     * page is hereafter deemed permanent and cannot be modified
     * or undone. For example, showing a progress page to track
     * a long-running, unreversible operation after the user has
     * clicked apply on a confirmation page.
     */
    commit(): void
    /**
     * Returns the page number of the current page.
     * @returns The index (starting from 0) of the current   page in the @assistant, or -1 if the @assistant has no pages,   or no current page
     */
    getCurrentPage(): number
    /**
     * Returns the number of pages in the `assistant`
     * @returns the number of pages in the @assistant
     */
    getNPages(): number
    /**
     * Returns the child widget contained in page number `page_num`.
     * @param pageNum the index of a page in the `assistant,`   or -1 to get the last page
     * @returns the child widget, or %NULL   if @page_num is out of bounds
     */
    getNthPage(pageNum: number): Widget | null
    /**
     * Returns the `GtkAssistantPage` object for `child`.
     * @param child a child of `assistant`
     * @returns the `GtkAssistantPage` for @child
     */
    getPage(child: Widget): AssistantPage
    /**
     * Gets whether `page` is complete.
     * @param page a page of `assistant`
     * @returns %TRUE if @page is complete.
     */
    getPageComplete(page: Widget): boolean
    /**
     * Gets the title for `page`.
     * @param page a page of `assistant`
     * @returns the title for @page
     */
    getPageTitle(page: Widget): string
    /**
     * Gets the page type of `page`.
     * @param page a page of `assistant`
     * @returns the page type of @page
     */
    getPageType(page: Widget): AssistantPageType
    /**
     * Gets a list model of the assistant pages.
     * @returns A list model of the pages.
     */
    getPages(): Gio.ListModel
    /**
     * Inserts a page in the `assistant` at a given position.
     * @param page a `GtkWidget`
     * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page to the `assistant`
     * @returns the index (starting from 0) of the inserted page
     */
    insertPage(page: Widget, position: number): number
    /**
     * Navigate to the next page.
     *
     * It is a programming error to call this function when
     * there is no next page.
     *
     * This function is for use when creating pages of the
     * %GTK_ASSISTANT_PAGE_CUSTOM type.
     */
    nextPage(): void
    /**
     * Prepends a page to the `assistant`.
     * @param page a `GtkWidget`
     * @returns the index (starting at 0) of the inserted page
     */
    prependPage(page: Widget): number
    /**
     * Navigate to the previous visited page.
     *
     * It is a programming error to call this function when
     * no previous page is available.
     *
     * This function is for use when creating pages of the
     * %GTK_ASSISTANT_PAGE_CUSTOM type.
     */
    previousPage(): void
    /**
     * Removes a widget from the action area of a `GtkAssistant`.
     * @param child a `GtkWidget`
     */
    removeActionWidget(child: Widget): void
    /**
     * Removes the `page_num’`s page from `assistant`.
     * @param pageNum the index of a page in the `assistant,`   or -1 to remove the last page
     */
    removePage(pageNum: number): void
    /**
     * Switches the page to `page_num`.
     *
     * Note that this will only be necessary in custom buttons,
     * as the `assistant` flow can be set with
     * gtk_assistant_set_forward_page_func().
     * @param pageNum index of the page to switch to, starting from 0.   If negative, the last page will be used. If greater   than the number of pages in the `assistant,` nothing   will be done.
     */
    setCurrentPage(pageNum: number): void
    /**
     * Sets the page forwarding function to be `page_func`.
     *
     * This function will be used to determine what will be
     * the next page when the user presses the forward button.
     * Setting `page_func` to %NULL will make the assistant to
     * use the default forward function, which just goes to the
     * next visible page.
     * @param pageFunc the `GtkAssistantPageFunc`, or %NULL   to use the default one
     */
    setForwardPageFunc(pageFunc: AssistantPageFunc | null): void
    /**
     * Sets whether `page` contents are complete.
     *
     * This will make `assistant` update the buttons state
     * to be able to continue the task.
     * @param page a page of `assistant`
     * @param complete the completeness status of the page
     */
    setPageComplete(page: Widget, complete: boolean): void
    /**
     * Sets a title for `page`.
     *
     * The title is displayed in the header area of the assistant
     * when `page` is the current page.
     * @param page a page of `assistant`
     * @param title the new title for `page`
     */
    setPageTitle(page: Widget, title: string): void
    /**
     * Sets the page type for `page`.
     *
     * The page type determines the page behavior in the `assistant`.
     * @param page a page of `assistant`
     * @param type the new type for `page`
     */
    setPageType(page: Widget, type: AssistantPageType): void
    /**
     * Forces `assistant` to recompute the buttons state.
     *
     * GTK automatically takes care of this in most situations,
     * e.g. when the user goes to a different page, or when the
     * visibility or completeness of a page changes.
     *
     * One situation where it can be necessary to call this
     * function is when changing a value on the current page
     * affects the future page flow of the assistant.
     */
    updateButtonsState(): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Own signals of Gtk-4.0.Gtk.Assistant

    connect(sigName: "apply", callback: Assistant.ApplySignalCallback): number
    on(
      sigName: "apply",
      callback: Assistant.ApplySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "apply",
      callback: Assistant.ApplySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "apply",
      callback: Assistant.ApplySignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "apply", ...args: any[]): void
    connect(sigName: "cancel", callback: Assistant.CancelSignalCallback): number
    on(
      sigName: "cancel",
      callback: Assistant.CancelSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cancel",
      callback: Assistant.CancelSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cancel",
      callback: Assistant.CancelSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cancel", ...args: any[]): void
    connect(sigName: "close", callback: Assistant.CloseSignalCallback): number
    on(
      sigName: "close",
      callback: Assistant.CloseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "close",
      callback: Assistant.CloseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "close",
      callback: Assistant.CloseSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "close", ...args: any[]): void
    connect(sigName: "escape", callback: Assistant.EscapeSignalCallback): number
    on(
      sigName: "escape",
      callback: Assistant.EscapeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "escape",
      callback: Assistant.EscapeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "escape",
      callback: Assistant.EscapeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "escape", ...args: any[]): void
    connect(
      sigName: "prepare",
      callback: Assistant.PrepareSignalCallback
    ): number
    on(
      sigName: "prepare",
      callback: Assistant.PrepareSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "prepare",
      callback: Assistant.PrepareSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "prepare",
      callback: Assistant.PrepareSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "prepare", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Assistant

    connect(
      sigName: "notify::pages",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pages",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pages",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pages",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pages", ...args: any[]): void
    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAssistant` is used to represent a complex as a series of steps.
   *
   * ![An example GtkAssistant](assistant.png)
   *
   * Each step consists of one or more pages. `GtkAssistant` guides the user
   * through the pages, and controls the page flow to collect the data needed
   * for the operation.
   *
   * `GtkAssistant` handles which buttons to show and to make sensitive based
   * on page sequence knowledge and the [enum`Gtk`.AssistantPageType] of each
   * page in addition to state information like the *completed* and *committed*
   * page statuses.
   *
   * If you have a case that doesn’t quite fit in `GtkAssistant`s way of
   * handling buttons, you can use the %GTK_ASSISTANT_PAGE_CUSTOM page
   * type and handle buttons yourself.
   *
   * `GtkAssistant` maintains a `GtkAssistantPage` object for each added
   * child, which holds additional per-child properties. You
   * obtain the `GtkAssistantPage` for a child with [method`Gtk`.Assistant.get_page].
   *
   * # GtkAssistant as GtkBuildable
   *
   * The `GtkAssistant` implementation of the `GtkBuildable` interface
   * exposes the `action_area` as internal children with the name
   * “action_area”.
   *
   * To add pages to an assistant in `GtkBuilder`, simply add it as a
   * child to the `GtkAssistant` object. If you need to set per-object
   * properties, create a `GtkAssistantPage` object explicitly, and
   * set the child widget as a property on it.
   *
   * # CSS nodes
   *
   * `GtkAssistant` has a single CSS node with the name window and style
   * class .assistant.
   * @class
   */
  class Assistant extends Window {
    // Own properties of Gtk-4.0.Gtk.Assistant

    static name: string

    // Constructors of Gtk-4.0.Gtk.Assistant

    constructor(config?: Assistant.ConstructorProperties)
    /**
     * Creates a new `GtkAssistant`.
     * @constructor
     * @returns a newly created `GtkAssistant`
     */
    constructor()
    /**
     * Creates a new `GtkAssistant`.
     * @constructor
     * @returns a newly created `GtkAssistant`
     */
    static new(): Assistant
    _init(config?: Assistant.ConstructorProperties): void
  }

  module AssistantPage {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.AssistantPage

      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Whether all required fields are filled in.
       *
       * GTK uses this information to control the sensitivity
       * of the navigation buttons.
       */
      complete?: boolean | null
      /**
       * The type of the assistant page.
       */
      page_type?: AssistantPageType | null
      /**
       * The title of the page.
       */
      title?: string | null
    }
  }

  interface AssistantPage {
    // Own properties of Gtk-4.0.Gtk.AssistantPage

    /**
     * The child widget.
     */
    readonly child: Widget
    /**
     * Whether all required fields are filled in.
     *
     * GTK uses this information to control the sensitivity
     * of the navigation buttons.
     */
    complete: boolean
    /**
     * The type of the assistant page.
     */
    pageType: AssistantPageType
    /**
     * The title of the page.
     */
    title: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.AssistantPage

    /**
     * Returns the child to which `page` belongs.
     * @returns the child to which @page belongs
     */
    getChild(): Widget

    // Class property signals of Gtk-4.0.Gtk.AssistantPage

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::complete",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::complete",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::complete",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::complete",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::complete", ...args: any[]): void
    connect(
      sigName: "notify::page-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::page-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::page-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::page-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::page-type", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkAssistantPage` is an auxiliary object used by `GtkAssistant.
   * @class
   */
  class AssistantPage extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.AssistantPage

    static name: string

    // Constructors of Gtk-4.0.Gtk.AssistantPage

    constructor(config?: AssistantPage.ConstructorProperties)
    _init(config?: AssistantPage.ConstructorProperties): void
  }

  module BinLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends LayoutManager.ConstructorProperties {}
  }

  interface BinLayout {
    // Own properties of Gtk-4.0.Gtk.BinLayout

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.BinLayout

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkBinLayout` is a `GtkLayoutManager` subclass useful for create "bins" of
   * widgets.
   *
   * `GtkBinLayout` will stack each child of a widget on top of each other,
   * using the [property`Gtk`.Widget:hexpand], [property`Gtk`.Widget:vexpand],
   * [property`Gtk`.Widget:halign], and [property`Gtk`.Widget:valign] properties
   * of each child to determine where they should be positioned.
   * @class
   */
  class BinLayout extends LayoutManager {
    // Own properties of Gtk-4.0.Gtk.BinLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.BinLayout

    constructor(config?: BinLayout.ConstructorProperties)
    /**
     * Creates a new `GtkBinLayout` instance.
     * @constructor
     * @returns the newly created `GtkBinLayout`
     */
    constructor()
    /**
     * Creates a new `GtkBinLayout` instance.
     * @constructor
     * @returns the newly created `GtkBinLayout`
     */
    static new(): BinLayout
    _init(config?: BinLayout.ConstructorProperties): void
  }

  module BookmarkList {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.BookmarkList

      /**
       * The attributes to query.
       */
      attributes?: string | null
      /**
       * The bookmark file to load.
       */
      filename?: string | null
      /**
       * Priority used when loading.
       */
      io_priority?: number | null
    }
  }

  interface BookmarkList extends Gio.ListModel {
    // Own properties of Gtk-4.0.Gtk.BookmarkList

    /**
     * The attributes to query.
     */
    attributes: string | null
    /**
     * The bookmark file to load.
     */
    readonly filename: string | null
    /**
     * Priority used when loading.
     */
    ioPriority: number
    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * %TRUE if files are being loaded.
     */
    readonly loading: boolean
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.BookmarkList

    /**
     * Gets the attributes queried on the children.
     * @returns The queried attributes
     */
    getAttributes(): string | null
    /**
     * Returns the filename of the bookmark file that
     * this list is loading.
     * @returns the filename of the .xbel file
     */
    getFilename(): string
    /**
     * Gets the IO priority to use while loading file.
     * @returns The IO priority.
     */
    getIoPriority(): number
    /**
     * Returns %TRUE if the files are currently being loaded.
     *
     * Files will be added to `self` from time to time while loading is
     * going on. The order in which are added is undefined and may change
     * in between runs.
     * @returns %TRUE if @self is loading
     */
    isLoading(): boolean
    /**
     * Sets the `attributes` to be enumerated and starts the enumeration.
     *
     * If `attributes` is %NULL, no attributes will be queried, but a list
     * of `GFileInfo`s will still be created.
     * @param attributes the attributes to enumerate
     */
    setAttributes(attributes: string | null): void
    /**
     * Sets the IO priority to use while loading files.
     *
     * The default IO priority is %G_PRIORITY_DEFAULT.
     * @param ioPriority IO priority to use
     */
    setIoPriority(ioPriority: number): void

    // Class property signals of Gtk-4.0.Gtk.BookmarkList

    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::filename",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filename",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filename",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filename",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filename", ...args: any[]): void
    connect(
      sigName: "notify::io-priority",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::io-priority",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::io-priority",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::io-priority",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::io-priority", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::loading",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::loading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::loading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::loading",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::loading", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkBookmarkList` is a list model that wraps `GBookmarkFile`.
   *
   * It presents a `GListModel` and fills it asynchronously with the
   * `GFileInfo`s returned from that function.
   *
   * The `GFileInfo`s in the list have some attributes in the recent
   * namespace added: `recent::private` (boolean) and `recent:applications`
   * (stringv).
   * @class
   */
  class BookmarkList extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.BookmarkList

    static name: string

    // Constructors of Gtk-4.0.Gtk.BookmarkList

    constructor(config?: BookmarkList.ConstructorProperties)
    /**
     * Creates a new `GtkBookmarkList` with the given `attributes`.
     * @constructor
     * @param filename The bookmark file to load
     * @param attributes The attributes to query
     * @returns a new `GtkBookmarkList`
     */
    constructor(filename: string | null, attributes: string | null)
    /**
     * Creates a new `GtkBookmarkList` with the given `attributes`.
     * @constructor
     * @param filename The bookmark file to load
     * @param attributes The attributes to query
     * @returns a new `GtkBookmarkList`
     */
    static new(filename: string | null, attributes: string | null): BookmarkList
    _init(config?: BookmarkList.ConstructorProperties): void
  }

  module BoolFilter {
    // Constructor properties interface

    interface ConstructorProperties extends Filter.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.BoolFilter

      /**
       * The boolean expression to evaluate on item.
       */
      expression?: Expression | null
      /**
       * If the expression result should be inverted.
       */
      invert?: boolean | null
    }
  }

  interface BoolFilter {
    // Own properties of Gtk-4.0.Gtk.BoolFilter

    /**
     * The boolean expression to evaluate on item.
     */
    expression: Expression
    /**
     * If the expression result should be inverted.
     */
    invert: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.BoolFilter

    /**
     * Gets the expression that the filter uses to evaluate if
     * an item should be filtered.
     * @returns a `GtkExpression`
     */
    getExpression(): Expression | null
    /**
     * Returns whether the filter inverts the expression.
     * @returns %TRUE if the filter inverts
     */
    getInvert(): boolean
    /**
     * Sets the expression that the filter uses to check if items
     * should be filtered.
     *
     * The expression must have a value type of %G_TYPE_BOOLEAN.
     * @param expression a `GtkExpression`
     */
    setExpression(expression: Expression | null): void
    /**
     * Sets whether the filter should invert the expression.
     * @param invert %TRUE to invert
     */
    setInvert(invert: boolean): void

    // Class property signals of Gtk-4.0.Gtk.BoolFilter

    connect(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expression", ...args: any[]): void
    connect(
      sigName: "notify::invert",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::invert",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::invert",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::invert",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::invert", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkBoolFilter` evaluates a boolean `GtkExpression`
   * to determine whether to include items.
   * @class
   */
  class BoolFilter extends Filter {
    // Own properties of Gtk-4.0.Gtk.BoolFilter

    static name: string

    // Constructors of Gtk-4.0.Gtk.BoolFilter

    constructor(config?: BoolFilter.ConstructorProperties)
    /**
     * Creates a new bool filter.
     * @constructor
     * @param expression The expression to evaluate
     * @returns a new `GtkBoolFilter`
     */
    constructor(expression: Expression | null)
    /**
     * Creates a new bool filter.
     * @constructor
     * @param expression The expression to evaluate
     * @returns a new `GtkBoolFilter`
     */
    static new(expression: Expression | null): BoolFilter
    _init(config?: BoolFilter.ConstructorProperties): void
  }

  module Box {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Box

      /**
       * The child that determines the baseline, in vertical orientation.
       */
      baseline_child?: number | null
      /**
       * The position of the baseline aligned widgets if extra space is available.
       */
      baseline_position?: BaselinePosition | null
      /**
       * Whether the children should all be the same size.
       */
      homogeneous?: boolean | null
      /**
       * The amount of space between children.
       */
      spacing?: number | null
    }
  }

  interface Box extends Accessible, Buildable, ConstraintTarget, Orientable {
    // Own properties of Gtk-4.0.Gtk.Box

    /**
     * The child that determines the baseline, in vertical orientation.
     */
    baselineChild: number
    /**
     * The position of the baseline aligned widgets if extra space is available.
     */
    baselinePosition: BaselinePosition
    /**
     * Whether the children should all be the same size.
     */
    homogeneous: boolean
    /**
     * The amount of space between children.
     */
    spacing: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Box

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.Box

    /**
     * Adds `child` as the last child to `box`.
     * @param child the `GtkWidget` to append
     */
    append(child: Widget): void
    /**
     * Gets the value set by gtk_box_set_baseline_child().
     * @returns the baseline child
     */
    getBaselineChild(): number
    /**
     * Gets the value set by gtk_box_set_baseline_position().
     * @returns the baseline position
     */
    getBaselinePosition(): BaselinePosition
    /**
     * Returns whether the box is homogeneous (all children are the
     * same size).
     * @returns %TRUE if the box is homogeneous.
     */
    getHomogeneous(): boolean
    /**
     * Gets the value set by gtk_box_set_spacing().
     * @returns spacing between children
     */
    getSpacing(): number
    /**
     * Inserts `child` in the position after `sibling` in the list
     * of `box` children.
     *
     * If `sibling` is %NULL, insert `child` at the first position.
     * @param child the `GtkWidget` to insert
     * @param sibling the sibling after which to insert `child`
     */
    insertChildAfter(child: Widget, sibling: Widget | null): void
    /**
     * Adds `child` as the first child to `box`.
     * @param child the `GtkWidget` to prepend
     */
    prepend(child: Widget): void
    /**
     * Removes a child widget from `box`.
     *
     * The child must have been added before with
     * [method`Gtk`.Box.append], [method`Gtk`.Box.prepend], or
     * [method`Gtk`.Box.insert_child_after].
     * @param child the child to remove
     */
    remove(child: Widget): void
    /**
     * Moves `child` to the position after `sibling` in the list
     * of `box` children.
     *
     * If `sibling` is %NULL, move `child` to the first position.
     * @param child the `GtkWidget` to move, must be a child of `box`
     * @param sibling the sibling to move `child` after
     */
    reorderChildAfter(child: Widget, sibling: Widget | null): void
    /**
     * Sets the baseline child of a box.
     *
     * This affects only vertical boxes.
     * @param child a child, or -1
     */
    setBaselineChild(child: number): void
    /**
     * Sets the baseline position of a box.
     *
     * This affects only horizontal boxes with at least one baseline
     * aligned child. If there is more vertical space available than
     * requested, and the baseline is not allocated by the parent then
     * `position` is used to allocate the baseline with respect to the
     * extra space available.
     * @param position a `GtkBaselinePosition`
     */
    setBaselinePosition(position: BaselinePosition): void
    /**
     * Sets whether or not all children of `box` are given equal space
     * in the box.
     * @param homogeneous a boolean value, %TRUE to create equal allotments,   %FALSE for variable allotments
     */
    setHomogeneous(homogeneous: boolean): void
    /**
     * Sets the number of pixels to place between children of `box`.
     * @param spacing the number of pixels to put between children
     */
    setSpacing(spacing: number): void

    // Class property signals of Gtk-4.0.Gtk.Box

    connect(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-child", ...args: any[]): void
    connect(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-position", ...args: any[]): void
    connect(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::spacing", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkBox` widget arranges child widgets into a single row or column.
   *
   * ![An example GtkBox](box.png)
   *
   * Whether it is a row or column depends on the value of its
   * [property`Gtk`.Orientable:orientation] property. Within the other
   * dimension, all children are allocated the same size. Of course, the
   * [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign] properties
   * can be used on the children to influence their allocation.
   *
   * Use repeated calls to [method`Gtk`.Box.append] to pack widgets into a
   * `GtkBox` from start to end. Use [method`Gtk`.Box.remove] to remove widgets
   * from the `GtkBox`. [method`Gtk`.Box.insert_child_after] can be used to add
   * a child at a particular position.
   *
   * Use [method`Gtk`.Box.set_homogeneous] to specify whether or not all children
   * of the `GtkBox` are forced to get the same amount of space.
   *
   * Use [method`Gtk`.Box.set_spacing] to determine how much space will be minimally
   * placed between all children in the `GtkBox`. Note that spacing is added
   * *between* the children.
   *
   * Use [method`Gtk`.Box.reorder_child_after] to move a child to a different
   * place in the box.
   *
   * # CSS nodes
   *
   * `GtkBox` uses a single CSS node with name box.
   *
   * # Accessibility
   *
   * Until GTK 4.10, `GtkBox` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   *
   * Starting from GTK 4.12, `GtkBox` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
   * @class
   */
  class Box extends Widget {
    // Own properties of Gtk-4.0.Gtk.Box

    static name: string

    // Constructors of Gtk-4.0.Gtk.Box

    constructor(config?: Box.ConstructorProperties)
    /**
     * Creates a new `GtkBox`.
     * @constructor
     * @param orientation the box’s orientation
     * @param spacing the number of pixels to place by default between children
     * @returns a new `GtkBox`.
     */
    constructor(orientation: Orientation, spacing: number)
    /**
     * Creates a new `GtkBox`.
     * @constructor
     * @param orientation the box’s orientation
     * @param spacing the number of pixels to place by default between children
     * @returns a new `GtkBox`.
     */
    static new(orientation: Orientation, spacing: number): Box
    _init(config?: Box.ConstructorProperties): void
  }

  module BoxLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends Orientable.ConstructorProperties,
        LayoutManager.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.BoxLayout

      /**
       * The child that determines the baseline of the box
       * in vertical layout.
       *
       * If the child does baseline positioning, then its baseline
       * is lined up with the baseline of the box. If it doesn't, then
       * the bottom edge of the child is used.
       */
      baseline_child?: number | null
      /**
       * The position of the allocated baseline within the extra space
       * allocated to each child.
       *
       * This property is only relevant for horizontal layouts containing
       * at least one child with a baseline alignment.
       */
      baseline_position?: BaselinePosition | null
      /**
       * Whether the box layout should distribute the available space
       * equally among the children.
       */
      homogeneous?: boolean | null
      /**
       * The space to put between the children.
       */
      spacing?: number | null
    }
  }

  interface BoxLayout extends Orientable {
    // Own properties of Gtk-4.0.Gtk.BoxLayout

    /**
     * The child that determines the baseline of the box
     * in vertical layout.
     *
     * If the child does baseline positioning, then its baseline
     * is lined up with the baseline of the box. If it doesn't, then
     * the bottom edge of the child is used.
     */
    baselineChild: number
    /**
     * The position of the allocated baseline within the extra space
     * allocated to each child.
     *
     * This property is only relevant for horizontal layouts containing
     * at least one child with a baseline alignment.
     */
    baselinePosition: BaselinePosition
    /**
     * Whether the box layout should distribute the available space
     * equally among the children.
     */
    homogeneous: boolean
    /**
     * The space to put between the children.
     */
    spacing: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.BoxLayout

    /**
     * Gets the value set by gtk_box_layout_set_baseline_child().
     * @returns the index of the child that determines the baseline     in vertical layout, or -1
     */
    getBaselineChild(): number
    /**
     * Gets the value set by gtk_box_layout_set_baseline_position().
     * @returns the baseline position
     */
    getBaselinePosition(): BaselinePosition
    /**
     * Returns whether the layout is set to be homogeneous.
     * @returns %TRUE if the layout is homogeneous
     */
    getHomogeneous(): boolean
    /**
     * Returns the space that `box_layout` puts between children.
     * @returns the spacing of the layout
     */
    getSpacing(): number
    /**
     * Sets the index of the child that determines the baseline
     * in vertical layout.
     * @param child the child position, or -1
     */
    setBaselineChild(child: number): void
    /**
     * Sets the baseline position of a box layout.
     *
     * The baseline position affects only horizontal boxes with at least one
     * baseline aligned child. If there is more vertical space available than
     * requested, and the baseline is not allocated by the parent then the
     * given `position` is used to allocate the baseline within the extra
     * space available.
     * @param position a `GtkBaselinePosition`
     */
    setBaselinePosition(position: BaselinePosition): void
    /**
     * Sets whether the box layout will allocate the same
     * size to all children.
     * @param homogeneous %TRUE to set the box layout as homogeneous
     */
    setHomogeneous(homogeneous: boolean): void
    /**
     * Sets how much spacing to put between children.
     * @param spacing the spacing to apply between children
     */
    setSpacing(spacing: number): void

    // Class property signals of Gtk-4.0.Gtk.BoxLayout

    connect(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-child", ...args: any[]): void
    connect(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-position", ...args: any[]): void
    connect(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::spacing", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkBoxLayout` is a layout manager that arranges children in a single
   * row or column.
   *
   * Whether it is a row or column depends on the value of its
   * [property`Gtk`.Orientable:orientation] property. Within the other dimension
   * all children all allocated the same size. The `GtkBoxLayout` will respect
   * the [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
   * properties of each child widget.
   *
   * If you want all children to be assigned the same size, you can use
   * the [property`Gtk`.BoxLayout:homogeneous] property.
   *
   * If you want to specify the amount of space placed between each child,
   * you can use the [property`Gtk`.BoxLayout:spacing] property.
   * @class
   */
  class BoxLayout extends LayoutManager {
    // Own properties of Gtk-4.0.Gtk.BoxLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.BoxLayout

    constructor(config?: BoxLayout.ConstructorProperties)
    /**
     * Creates a new `GtkBoxLayout`.
     * @constructor
     * @param orientation the orientation for the new layout
     * @returns a new box layout
     */
    constructor(orientation: Orientation)
    /**
     * Creates a new `GtkBoxLayout`.
     * @constructor
     * @param orientation the orientation for the new layout
     * @returns a new box layout
     */
    static new(orientation: Orientation): BoxLayout
    _init(config?: BoxLayout.ConstructorProperties): void
  }

  module Builder {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Builder

      /**
       * The object the builder is evaluating for.
       */
      current_object?: GObject.Object | null
      /**
       * The scope the builder is operating in
       */
      scope?: BuilderScope | null
      /**
       * The translation domain used when translating property values that
       * have been marked as translatable.
       *
       * If the translation domain is %NULL, `GtkBuilder` uses gettext(),
       * otherwise g_dgettext().
       */
      translation_domain?: string | null
    }
  }

  interface Builder {
    // Own properties of Gtk-4.0.Gtk.Builder

    /**
     * The object the builder is evaluating for.
     */
    currentObject: GObject.Object
    /**
     * The scope the builder is operating in
     */
    scope: BuilderScope
    /**
     * The translation domain used when translating property values that
     * have been marked as translatable.
     *
     * If the translation domain is %NULL, `GtkBuilder` uses gettext(),
     * otherwise g_dgettext().
     */
    translationDomain: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Builder

    /**
     * Parses a file containing a UI definition and merges it with
     * the current contents of `builder`.
     *
     * This function is useful if you need to call
     * [method`Gtk`.Builder.set_current_object]) to add user data to
     * callbacks before loading GtkBuilder UI. Otherwise, you probably
     * want [ctor`Gtk`.Builder.new_from_file] instead.
     *
     * If an error occurs, 0 will be returned and `error` will be assigned a
     * `GError` from the `GTK_BUILDER_ERROR`, `G_MARKUP_ERROR` or `G_FILE_ERROR`
     * domains.
     *
     * It’s not really reasonable to attempt to handle failures of this
     * call. You should not use this function with untrusted files (ie:
     * files that are not part of your application). Broken `GtkBuilder`
     * files can easily crash your program, and it’s possible that memory
     * was leaked leading up to the reported failure. The only reasonable
     * thing to do when an error is detected is to call `g_error()`.
     * @param filename the name of the file to parse
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    addFromFile(filename: string): boolean
    /**
     * Parses a resource file containing a UI definition
     * and merges it with the current contents of `builder`.
     *
     * This function is useful if you need to call
     * [method`Gtk`.Builder.set_current_object] to add user data to
     * callbacks before loading GtkBuilder UI. Otherwise, you probably
     * want [ctor`Gtk`.Builder.new_from_resource] instead.
     *
     * If an error occurs, 0 will be returned and `error` will be assigned a
     * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_RESOURCE_ERROR
     * domain.
     *
     * It’s not really reasonable to attempt to handle failures of this
     * call.  The only reasonable thing to do when an error is detected is
     * to call g_error().
     * @param resourcePath the path of the resource file to parse
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    addFromResource(resourcePath: string): boolean
    /**
     * Parses a string containing a UI definition and merges it
     * with the current contents of `builder`.
     *
     * This function is useful if you need to call
     * [method`Gtk`.Builder.set_current_object] to add user data to
     * callbacks before loading `GtkBuilder` UI. Otherwise, you probably
     * want [ctor`Gtk`.Builder.new_from_string] instead.
     *
     * Upon errors %FALSE will be returned and `error` will be assigned a
     * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or
     * %G_VARIANT_PARSE_ERROR domain.
     *
     * It’s not really reasonable to attempt to handle failures of this
     * call.  The only reasonable thing to do when an error is detected is
     * to call g_error().
     * @param buffer the string to parse
     * @param length the length of `buffer` (may be -1 if `buffer` is nul-terminated)
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    addFromString(buffer: string, length: number): boolean
    /**
     * Parses a file containing a UI definition building only the
     * requested objects and merges them with the current contents
     * of `builder`.
     *
     * Upon errors, 0 will be returned and `error` will be assigned a
     * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_FILE_ERROR
     * domain.
     *
     * If you are adding an object that depends on an object that is not
     * its child (for instance a `GtkTreeView` that depends on its
     * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
     * @param filename the name of the file to parse
     * @param objectIds nul-terminated array of objects to build
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    addObjectsFromFile(filename: string, objectIds: string[]): boolean
    /**
     * Parses a resource file containing a UI definition, building
     * only the requested objects and merges them with the current
     * contents of `builder`.
     *
     * Upon errors, 0 will be returned and `error` will be assigned a
     * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_RESOURCE_ERROR
     * domain.
     *
     * If you are adding an object that depends on an object that is not
     * its child (for instance a `GtkTreeView` that depends on its
     * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
     * @param resourcePath the path of the resource file to parse
     * @param objectIds nul-terminated array of objects to build
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    addObjectsFromResource(resourcePath: string, objectIds: string[]): boolean
    /**
     * Parses a string containing a UI definition, building only the
     * requested objects and merges them with the current contents of
     * `builder`.
     *
     * Upon errors %FALSE will be returned and `error` will be assigned a
     * `GError` from the %GTK_BUILDER_ERROR or %G_MARKUP_ERROR domain.
     *
     * If you are adding an object that depends on an object that is not
     * its child (for instance a `GtkTreeView` that depends on its
     * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
     * @param buffer the string to parse
     * @param length the length of `buffer` (may be -1 if `buffer` is nul-terminated)
     * @param objectIds nul-terminated array of objects to build
     * @returns %TRUE on success, %FALSE if an error occurred
     */
    addObjectsFromString(
      buffer: string,
      length: number,
      objectIds: string[]
    ): boolean
    /**
     * Creates a closure to invoke the function called `function_name`.
     *
     * This is using the create_closure() implementation of `builder'`s
     * [iface`Gtk`.BuilderScope].
     *
     * If no closure could be created, %NULL will be returned and `error`
     * will be set.
     * @param functionName name of the function to look up
     * @param flags closure creation flags
     * @param object Object to create the closure with
     * @returns A new closure for invoking @function_name
     */
    createClosure(
      functionName: string,
      flags: BuilderClosureFlags,
      object: GObject.Object | null
    ): GObject.TClosure | null
    /**
     * Add `object` to the `builder` object pool so it can be
     * referenced just like any other object built by builder.
     *
     * Only a single object may be added using `name`. However,
     * it is not an error to expose the same object under multiple
     * names. `gtk_builder_get_object()` may be used to determine
     * if an object has already been added with `name`.
     * @param name the name of the object exposed to the builder
     * @param object the object to expose
     */
    exposeObject(name: string, object: GObject.Object): void
    /**
     * Main private entry point for building composite components
     * from template XML.
     *
     * Most likely you do not need to call this function in applications as
     * templates are handled by `GtkWidget`.
     * @param object the object that is being extended
     * @param templateType the type that the template is for
     * @param buffer the string to parse
     * @param length the length of `buffer` (may be -1 if `buffer` is nul-terminated)
     * @returns A positive value on success, 0 if an error occurred
     */
    extendWithTemplate(
      object: GObject.Object,
      templateType: GObject.GType,
      buffer: string,
      length: number
    ): boolean
    /**
     * Gets the current object set via gtk_builder_set_current_object().
     * @returns the current object
     */
    getCurrentObject(): GObject.Object | null
    /**
     * Gets the object named `name`.
     *
     * Note that this function does not increment the reference count
     * of the returned object.
     * @param name name of object to get
     * @returns the object named @name
     */
    getObject(name: string): GObject.Object | null
    /**
     * Gets all objects that have been constructed by `builder`.
     *
     * Note that this function does not increment the reference
     * counts of the returned objects.
     * @returns a   newly-allocated `GSList` containing all the objects   constructed by the `GtkBuilder instance`. It should be   freed by g_slist_free()
     */
    getObjects(): GObject.Object[]
    /**
     * Gets the scope in use that was set via gtk_builder_set_scope().
     * @returns the current scope
     */
    getScope(): BuilderScope
    /**
     * Gets the translation domain of `builder`.
     * @returns the translation domain
     */
    getTranslationDomain(): string | null
    /**
     * Looks up a type by name.
     *
     * This is using the virtual function that `GtkBuilder` has
     * for that purpose. This is mainly used when implementing
     * the `GtkBuildable` interface on a type.
     * @param typeName type name to lookup
     * @returns the `GType` found for @type_name or %G_TYPE_INVALID   if no type was found
     */
    getTypeFromName(typeName: string): GObject.GType
    /**
     * Sets the current object for the `builder`.
     *
     * The current object can be thought of as the `this` object that the
     * builder is working for and will often be used as the default object
     * when an object is optional.
     *
     * [method`Gtk`.Widget.init_template] for example will set the current
     * object to the widget the template is inited for. For functions like
     * [ctor`Gtk`.Builder.new_from_resource], the current object will be %NULL.
     * @param currentObject the new current object
     */
    setCurrentObject(currentObject: GObject.Object | null): void
    /**
     * Sets the scope the builder should operate in.
     *
     * If `scope` is %NULL, a new [class`Gtk`.BuilderCScope] will be created.
     * @param scope the scope to use
     */
    setScope(scope: BuilderScope | null): void
    /**
     * Sets the translation domain of `builder`.
     * @param domain the translation domain
     */
    setTranslationDomain(domain: string | null): void
    /**
     * Demarshals a value from a string.
     *
     * This function calls g_value_init() on the `value` argument,
     * so it need not be initialised beforehand.
     *
     * Can handle char, uchar, boolean, int, uint, long,
     * ulong, enum, flags, float, double, string, `GdkRGBA` and
     * `GtkAdjustment` type values.
     *
     * Upon errors %FALSE will be returned and `error` will be
     * assigned a `GError` from the %GTK_BUILDER_ERROR domain.
     * @param pspec the `GParamSpec` for the property
     * @param string the string representation of the value
     * @returns %TRUE on success
     */
    valueFromString(
      pspec: GObject.ParamSpec,
      string: string
    ): [/* returnType */ boolean, /* value */ any]
    /**
     * Demarshals a value from a string.
     *
     * Unlike [method`Gtk`.Builder.value_from_string], this function
     * takes a `GType` instead of `GParamSpec`.
     *
     * Calls g_value_init() on the `value` argument, so it
     * need not be initialised beforehand.
     *
     * Upon errors %FALSE will be returned and `error` will be
     * assigned a `GError` from the %GTK_BUILDER_ERROR domain.
     * @param type the `GType` of the value
     * @param string the string representation of the value
     * @returns %TRUE on success
     */
    valueFromStringType(
      type: GObject.GType,
      string: string
    ): [/* returnType */ boolean, /* value */ any]

    // Class property signals of Gtk-4.0.Gtk.Builder

    connect(
      sigName: "notify::current-object",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::current-object",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::current-object",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::current-object",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::current-object", ...args: any[]): void
    connect(
      sigName: "notify::scope",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scope",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scope",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scope",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scope", ...args: any[]): void
    connect(
      sigName: "notify::translation-domain",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::translation-domain",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::translation-domain",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::translation-domain",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::translation-domain", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkBuilder` reads XML descriptions of a user interface and
   * instantiates the described objects.
   *
   * To create a `GtkBuilder` from a user interface description, call
   * [ctor`Gtk`.Builder.new_from_file], [ctor`Gtk`.Builder.new_from_resource]
   * or [ctor`Gtk`.Builder.new_from_string].
   *
   * In the (unusual) case that you want to add user interface
   * descriptions from multiple sources to the same `GtkBuilder` you can
   * call [ctor`Gtk`.Builder.new] to get an empty builder and populate it by
   * (multiple) calls to [method`Gtk`.Builder.add_from_file],
   * [method`Gtk`.Builder.add_from_resource] or
   * [method`Gtk`.Builder.add_from_string].
   *
   * A `GtkBuilder` holds a reference to all objects that it has constructed
   * and drops these references when it is finalized. This finalization can
   * cause the destruction of non-widget objects or widgets which are not
   * contained in a toplevel window. For toplevel windows constructed by a
   * builder, it is the responsibility of the user to call
   * [method`Gtk`.Window.destroy] to get rid of them and all the widgets
   * they contain.
   *
   * The functions [method`Gtk`.Builder.get_object] and
   * [method`Gtk`.Builder.get_objects] can be used to access the widgets in
   * the interface by the names assigned to them inside the UI description.
   * Toplevel windows returned by these functions will stay around until the
   * user explicitly destroys them with [method`Gtk`.Window.destroy]. Other
   * widgets will either be part of a larger hierarchy constructed by the
   * builder (in which case you should not have to worry about their lifecycle),
   * or without a parent, in which case they have to be added to some container
   * to make use of them. Non-widget objects need to be reffed with
   * g_object_ref() to keep them beyond the lifespan of the builder.
   *
   * ## GtkBuilder UI Definitions
   *
   * `GtkBuilder` parses textual descriptions of user interfaces which are
   * specified in XML format. We refer to these descriptions as “GtkBuilder
   * UI definitions” or just “UI definitions” if the context is clear.
   *
   * ### Structure of UI definitions
   *
   * UI definition files are always encoded in UTF-8.
   *
   * The toplevel element is `<interface>`. It optionally takes a “domain”
   * attribute, which will make the builder look for translated strings
   * using `dgettext()` in the domain specified. This can also be done by
   * calling [method`Gtk`.Builder.set_translation_domain] on the builder.
   * For example:
   *
   * ```xml
   * <?xml version="1.0" encoding="UTF-8">
   * <interface domain="your-app">
   *   ...
   * </interface>
   * ```
   *
   * ### Requirements
   *
   * The target toolkit version(s) are described by `<requires>` elements,
   * the “lib” attribute specifies the widget library in question (currently
   * the only supported value is “gtk”) and the “version” attribute specifies
   * the target version in the form “`<major>`.`<minor>`”. `GtkBuilder` will
   * error out if the version requirements are not met. For example:
   *
   * ```xml
   * <?xml version="1.0" encoding="UTF-8">
   * <interface domain="your-app">
   *   <requires lib="gtk" version="4.0" />
   * </interface>
   * ```
   *
   * ### Objects
   *
   * Objects are defined as children of the `<interface>` element.
   *
   * Objects are described by `<object>` elements, which can contain
   * `<property>` elements to set properties, `<signal>` elements which
   * connect signals to handlers, and `<child>` elements, which describe
   * child objects.
   *
   * Typically, the specific kind of object represented by an `<object>`
   * element is specified by the “class” attribute. If the type has not
   * been loaded yet, GTK tries to find the `get_type()` function from the
   * class name by applying heuristics. This works in most cases, but if
   * necessary, it is possible to specify the name of the `get_type()`
   * function explicitly with the "type-func" attribute. If your UI definition
   * is referencing internal types, you should make sure to call
   * `g_type_ensure()` for each object type before parsing the UI definition.
   *
   * Objects may be given a name with the “id” attribute, which allows the
   * application to retrieve them from the builder with
   * [method`Gtk`.Builder.get_object]. An id is also necessary to use the
   * object as property value in other parts of the UI definition. GTK
   * reserves ids starting and ending with `___` (three consecutive
   * underscores) for its own purposes.
   *
   * ### Properties
   *
   * Setting properties of objects is pretty straightforward with the
   * `<property>` element: the “name” attribute specifies the name of the
   * property, and the content of the element specifies the value:
   *
   * ```xml
   * <object class="GtkButton">
   *   <property name="label">Hello, world</property>
   * </object>
   * ```
   *
   * If the “translatable” attribute is set to a true value, GTK uses
   * `gettext()` (or `dgettext()` if the builder has a translation domain set)
   * to find a translation for the value. This happens before the value
   * is parsed, so it can be used for properties of any type, but it is
   * probably most useful for string properties. It is also possible to
   * specify a context to disambiguate short strings, and comments which
   * may help the translators:
   *
   * ```xml
   * <object class="GtkButton">
   *   <property name="label" translatable="yes" context="button">Hello, world</property>
   * </object>
   * ```
   *
   * `GtkBuilder` can parse textual representations for the most common
   * property types:
   *
   * - characters
   * - strings
   * - integers
   * - floating-point numbers
   * - booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted
   *   as true values, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted
   *   as false values)
   * - enumeration types (can be specified by their full C identifier their short
   *   name used when registering the enumeration type, or their integer value)
   * - flag types (can be specified by their C identifier, short name, integer
   *   value, and optionally combined with “|” for bitwise OR, e.g.
   *   “GTK_INPUT_HINT_EMOJI|GTK_INPUT_HINT_LOWERCASE”, or “emoji|lowercase”)
   * - colors (in a format understood by [method`Gdk`.RGBA.parse])
   * - `GVariant` (can be specified in the format understood by
   *    [func`GLib`.Variant.parse])
   * - pixbufs (can be specified as a filename of an image file to load)
   *
   * Objects can be referred to by their name and by default refer to
   * objects declared in the local XML fragment and objects exposed via
   * [method`Gtk`.Builder.expose_object]. In general, `GtkBuilder` allows
   * forward references to objects declared in the local XML; an object
   * doesn’t have to be constructed before it can be referred to. The
   * exception to this rule is that an object has to be constructed before
   * it can be used as the value of a construct-only property.
   *
   * ### Child objects
   *
   * Many widgets have properties for child widgets, such as
   * [property`Gtk`.Expander:child]. In this case, the preferred way to
   * specify the child widget in a ui file is to simply set the property:
   *
   * ```xml
   * <object class="GtkExpander">
   *   <property name="child">
   *     <object class="GtkLabel">
   *     ...
   *     </object>
   *   </property>
   * </object>
   * ```
   *
   * Generic containers that can contain an arbitrary number of children,
   * such as [class`Gtk`.Box] instead use the `<child>` element. A `<child>`
   * element contains an `<object>` element which describes the child object.
   * Most often, child objects are widgets inside a container, but they can
   * also be, e.g., actions in an action group, or columns in a tree model.
   *
   * Any object type that implements the [iface`Gtk`.Buildable] interface can
   * specify how children may be added to it. Since many objects and widgets that
   * are included with GTK already implement the `GtkBuildable` interface,
   * typically child objects can be added using the `<child>` element without
   * having to be concerned about the underlying implementation.
   *
   * See the [`GtkWidget` documentation](class.Widget.html#gtkwidget-as-gtkbuildable)
   * for many examples of using `GtkBuilder` with widgets, including setting
   * child objects using the `<child>` element.
   *
   * A noteworthy special case to the general rule that only objects implementing
   * `GtkBuildable` may specify how to handle the `<child>` element is that
   * `GtkBuilder` provides special support for adding objects to a
   * [class`Gio`.ListStore] by using the `<child>` element. For instance:
   *
   * ```xml
   * <object class="GListStore">
   *   <property name="item-type">MyObject</property>
   *   <child>
   *     <object class="MyObject" />
   *   </child>
   *   ...
   * </object>
   * ```
   *
   * ### Property bindings
   *
   * It is also possible to bind a property value to another object's
   * property value using the attributes "bind-source" to specify the
   * source object of the binding, and optionally, "bind-property" and
   * "bind-flags" to specify the source property and source binding flags
   * respectively. Internally, `GtkBuilder` implements this using
   * [class`GObject`.Binding] objects.
   *
   * For instance, in the example below the “label” property of the
   * `bottom_label` widget is bound to the “label” property of the
   * `top_button` widget:
   *
   * ```xml
   * <object class="GtkBox">
   *   <property name="orientation">vertical</property>
   *   <child>
   *     <object class="GtkButton" id="top_button">
   *       <property name="label">Hello, world</property>
   *     </object>
   *   </child>
   *   <child>
   *     <object class="GtkLabel" id="bottom_label">
   *       <property name="label"
   *                 bind-source="top_button"
   *                 bind-property="label"
   *                 bind-flags="sync-create" />
   *     </object>
   *   </child>
   * </object>
   * ```
   *
   * For more information, see the documentation of the
   * [method`GObject`.Object.bind_property] method.
   *
   * Please note that another way to set up bindings between objects in .ui files
   * is to use the `GtkExpression` methodology. See the
   * [`GtkExpression` documentation](class.Expression.html#gtkexpression-in-ui-files)
   * for more information.
   *
   * ### Internal children
   *
   * Sometimes it is necessary to refer to widgets which have implicitly
   * been constructed by GTK as part of a composite widget, to set
   * properties on them or to add further children (e.g. the content area
   * of a `GtkDialog`). This can be achieved by setting the “internal-child”
   * property of the `<child>` element to a true value. Note that `GtkBuilder`
   * still requires an `<object>` element for the internal child, even if it
   * has already been constructed.
   *
   * ### Specialized children
   *
   * A number of widgets have different places where a child can be added
   * (e.g. tabs vs. page content in notebooks). This can be reflected in
   * a UI definition by specifying the “type” attribute on a `<child>`
   * The possible values for the “type” attribute are described in the
   * sections describing the widget-specific portions of UI definitions.
   *
   * ### Signal handlers and function pointers
   *
   * Signal handlers are set up with the `<signal>` element. The “name”
   * attribute specifies the name of the signal, and the “handler” attribute
   * specifies the function to connect to the signal.
   *
   * ```xml
   * <object class="GtkButton" id="hello_button">
   *   <signal name="clicked" handler="hello_button__clicked" />
   * </object>
   * ```
   *
   * The remaining attributes, “after”, “swapped” and “object”, have the
   * same meaning as the corresponding parameters of the
   * [func`GObject`.signal_connect_object] or [func`GObject`.signal_connect_data]
   * functions:
   *
   * - “after” matches the `G_CONNECT_AFTER` flag, and will ensure that the
   *   handler is called after the default class closure for the signal
   * - “swapped” matches the `G_CONNECT_SWAPPED` flag, and will swap the
   *   instance and closure arguments when invoking the signal handler
   * - “object” will bind the signal handler to the lifetime of the object
   *   referenced by the attribute
   *
   * By default "swapped" will be set to "yes" if not specified otherwise, in
   * the case where "object" is set, for convenience. A “last_modification_time”
   * attribute is also allowed, but it does not have a meaning to the builder.
   *
   * When compiling applications for Windows, you must declare signal callbacks
   * with the `G_MODULE_EXPORT` decorator, or they will not be put in the symbol
   * table:
   *
   * ```c
   * G_MODULE_EXPORT void
   * hello_button__clicked (GtkButton *button,
   *                        gpointer data)
   * {
   *   // ...
   * }
   * ```
   *
   * On Linux and Unix, this is not necessary; applications should instead
   * be compiled with the `-Wl,--export-dynamic` argument inside their compiler
   * flags, and linked against `gmodule-export-2.0`.
   *
   * ## Example UI Definition
   *
   * ```xml
   * <interface>
   *   <object class="GtkDialog" id="dialog1">
   *     <child internal-child="content_area">
   *       <object class="GtkBox">
   *         <child internal-child="action_area">
   *           <object class="GtkBox">
   *             <child>
   *               <object class="GtkButton" id="ok_button">
   *                 <property name="label" translatable="yes">_Ok</property>
   *                 <property name="use-underline">True</property>
   *                 <signal name="clicked" handler="ok_button_clicked"/>
   *               </object>
   *             </child>
   *           </object>
   *         </child>
   *       </object>
   *     </child>
   *   </object>
   * </interface>
   * ```
   *
   * ## Using GtkBuildable for extending UI definitions
   *
   * Objects can implement the [iface`Gtk`.Buildable] interface to add custom
   * elements and attributes to the XML. Typically, any extension will be
   * documented in each type that implements the interface.
   *
   * ## Templates
   *
   * When describing a [class`Gtk`.Widget], you can use the `<template>` tag to
   * describe a UI bound to a specific widget type. GTK will automatically load
   * the UI definition when instantiating the type, and bind children and
   * signal handlers to instance fields and function symbols.
   *
   * For more information, see the [`GtkWidget` documentation](class.Widget.html#building-composite-widgets-from-template-xml)
   * for details.
   * @class
   */
  class Builder extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Builder

    static name: string

    // Constructors of Gtk-4.0.Gtk.Builder

    constructor(config?: Builder.ConstructorProperties)
    /**
     * Creates a new empty builder object.
     *
     * This function is only useful if you intend to make multiple calls
     * to [method`Gtk`.Builder.add_from_file], [method`Gtk`.Builder.add_from_resource]
     * or [method`Gtk`.Builder.add_from_string] in order to merge multiple UI
     * descriptions into a single builder.
     * @constructor
     * @returns a new (empty) `GtkBuilder` object
     */
    constructor()
    /**
     * Creates a new empty builder object.
     *
     * This function is only useful if you intend to make multiple calls
     * to [method`Gtk`.Builder.add_from_file], [method`Gtk`.Builder.add_from_resource]
     * or [method`Gtk`.Builder.add_from_string] in order to merge multiple UI
     * descriptions into a single builder.
     * @constructor
     * @returns a new (empty) `GtkBuilder` object
     */
    static new(): Builder
    /**
     * Parses the UI definition in the file `filename`.
     *
     * If there is an error opening the file or parsing the description then
     * the program will be aborted. You should only ever attempt to parse
     * user interface descriptions that are shipped as part of your program.
     * @constructor
     * @param filename filename of user interface description file
     * @returns a `GtkBuilder` containing the described interface
     */
    static newFromFile(filename: string): Builder
    /**
     * Parses the UI definition at `resource_path`.
     *
     * If there is an error locating the resource or parsing the
     * description, then the program will be aborted.
     * @constructor
     * @param resourcePath a `GResource` resource path
     * @returns a `GtkBuilder` containing the described interface
     */
    static newFromResource(resourcePath: string): Builder
    /**
     * Parses the UI definition in `string`.
     *
     * If `string` is %NULL-terminated, then `length` should be -1.
     * If `length` is not -1, then it is the length of `string`.
     *
     * If there is an error parsing `string` then the program will be
     * aborted. You should not attempt to parse user interface description
     * from untrusted sources.
     * @constructor
     * @param string a user interface (XML) description
     * @param length the length of `string,` or -1
     * @returns a `GtkBuilder` containing the interface described by @string
     */
    static newFromString(string: string, length: number): Builder
    _init(config?: Builder.ConstructorProperties): void
  }

  module BuilderCScope {
    // Constructor properties interface

    interface ConstructorProperties
      extends BuilderScope.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface BuilderCScope extends BuilderScope {
    // Own properties of Gtk-4.0.Gtk.BuilderCScope

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.BuilderCScope

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.BuilderCScope

    /**
     * Adds the `callback_symbol` to the scope of `builder` under the
     * given `callback_name`.
     *
     * Using this function overrides the behavior of
     * [method`Gtk`.Builder.create_closure] for any callback symbols that
     * are added. Using this method allows for better encapsulation as it
     * does not require that callback symbols be declared in the global
     * namespace.
     * @param callbackName The name of the callback, as expected in the XML
     * @param callbackSymbol The callback pointer
     */
    addCallbackSymbol(
      callbackName: string,
      callbackSymbol: GObject.Callback
    ): void

    // Class property signals of Gtk-4.0.Gtk.BuilderCScope

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkBuilderScope` implementation for the C language.
   *
   * `GtkBuilderCScope` instances use symbols explicitly added to `builder`
   * with prior calls to [method`Gtk`.BuilderCScope.add_callback_symbol].
   * If developers want to do that, they are encouraged to create their
   * own scopes for that purpose.
   *
   * In the case that symbols are not explicitly added; GTK will uses
   * `GModule`’s introspective features (by opening the module %NULL) to
   * look at the application’s symbol table. From here it tries to match
   * the signal function names given in the interface description with
   * symbols in the application.
   *
   * Note that unless [method`Gtk`.BuilderCScope.add_callback_symbol] is
   * called for all signal callbacks which are referenced by the loaded XML,
   * this functionality will require that `GModule` be supported on the platform.
   * @class
   */
  class BuilderCScope extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.BuilderCScope

    static name: string

    // Constructors of Gtk-4.0.Gtk.BuilderCScope

    constructor(config?: BuilderCScope.ConstructorProperties)
    /**
     * Creates a new `GtkBuilderCScope` object to use with future
     * `GtkBuilder` instances.
     *
     * Calling this function is only necessary if you want to add
     * custom callbacks via [method`Gtk`.BuilderCScope.add_callback_symbol].
     * @constructor
     * @returns a new `GtkBuilderCScope`
     */
    constructor()
    /**
     * Creates a new `GtkBuilderCScope` object to use with future
     * `GtkBuilder` instances.
     *
     * Calling this function is only necessary if you want to add
     * custom callbacks via [method`Gtk`.BuilderCScope.add_callback_symbol].
     * @constructor
     * @returns a new `GtkBuilderCScope`
     */
    static new(): BuilderCScope
    _init(config?: BuilderCScope.ConstructorProperties): void
  }

  module BuilderListItemFactory {
    // Constructor properties interface

    interface ConstructorProperties
      extends ListItemFactory.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.BuilderListItemFactory

      /**
       * `GBytes` containing the UI definition.
       */
      bytes?: any | null
      /**
       * Path of the resource containing the UI definition.
       */
      resource?: string | null
      /**
       * `GtkBuilderScope` to use when instantiating listitems
       */
      scope?: BuilderScope | null
    }
  }

  interface BuilderListItemFactory {
    // Own properties of Gtk-4.0.Gtk.BuilderListItemFactory

    /**
     * `GBytes` containing the UI definition.
     */
    readonly bytes: any
    /**
     * Path of the resource containing the UI definition.
     */
    readonly resource: string | null
    /**
     * `GtkBuilderScope` to use when instantiating listitems
     */
    readonly scope: BuilderScope
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.BuilderListItemFactory

    /**
     * Gets the data used as the `GtkBuilder` UI template for constructing
     * listitems.
     * @returns The `GtkBuilder` data
     */
    getBytes(): any
    /**
     * If the data references a resource, gets the path of that resource.
     * @returns The path to the resource
     */
    getResource(): string | null
    /**
     * Gets the scope used when constructing listitems.
     * @returns The scope used when constructing listitems
     */
    getScope(): BuilderScope | null

    // Class property signals of Gtk-4.0.Gtk.BuilderListItemFactory

    connect(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::bytes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::bytes", ...args: any[]): void
    connect(
      sigName: "notify::resource",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resource",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resource",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resource",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resource", ...args: any[]): void
    connect(
      sigName: "notify::scope",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scope",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scope",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scope",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scope", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkBuilderListItemFactory` is a `GtkListItemFactory` that creates
   * widgets by instantiating `GtkBuilder` UI templates.
   *
   * The templates must be extending `GtkListItem`, and typically use
   * `GtkExpression`s to obtain data from the items in the model.
   *
   * Example:
   * ```xml
   *   <interface>
   *     <template class="GtkListItem">
   *       <property name="child">
   *         <object class="GtkLabel">
   *           <property name="xalign">0</property>
   *           <binding name="label">
   *             <lookup name="name" type="SettingsKey">
   *               <lookup name="item">GtkListItem</lookup>
   *             </lookup>
   *           </binding>
   *         </object>
   *       </property>
   *     </template>
   *   </interface>
   * ```
   * @class
   */
  class BuilderListItemFactory extends ListItemFactory {
    // Own properties of Gtk-4.0.Gtk.BuilderListItemFactory

    static name: string

    // Constructors of Gtk-4.0.Gtk.BuilderListItemFactory

    constructor(config?: BuilderListItemFactory.ConstructorProperties)
    /**
     * Creates a new `GtkBuilderListItemFactory` that instantiates widgets
     * using `bytes` as the data to pass to `GtkBuilder`.
     * @constructor
     * @param scope A scope to use when instantiating
     * @param bytes the `GBytes` containing the ui file to instantiate
     * @returns a new `GtkBuilderListItemFactory`
     */
    static newFromBytes(
      scope: BuilderScope | null,
      bytes: any
    ): BuilderListItemFactory
    /**
     * Creates a new `GtkBuilderListItemFactory` that instantiates widgets
     * using data read from the given `resource_path` to pass to `GtkBuilder`.
     * @constructor
     * @param scope A scope to use when instantiating
     * @param resourcePath valid path to a resource that contains the data
     * @returns a new `GtkBuilderListItemFactory`
     */
    static newFromResource(
      scope: BuilderScope | null,
      resourcePath: string
    ): BuilderListItemFactory
    _init(config?: BuilderListItemFactory.ConstructorProperties): void
  }

  module Button {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `clicked`
     */
    interface ClickedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Actionable.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Button

      /**
       * Whether the size of the button can be made smaller than the natural
       * size of its contents.
       *
       * For text buttons, setting this property will allow ellipsizing the label.
       *
       * If the contents of a button are an icon or a custom widget, setting this
       * property has no effect.
       */
      can_shrink?: boolean | null
      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Whether the button has a frame.
       */
      has_frame?: boolean | null
      /**
       * The name of the icon used to automatically populate the button.
       */
      icon_name?: string | null
      /**
       * Text of the label inside the button, if the button contains a label widget.
       */
      label?: string | null
      /**
       * If set, an underline in the text indicates that the following character is
       * to be used as mnemonic.
       */
      use_underline?: boolean | null
    }
  }

  interface Button extends Accessible, Actionable, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Button

    /**
     * Whether the size of the button can be made smaller than the natural
     * size of its contents.
     *
     * For text buttons, setting this property will allow ellipsizing the label.
     *
     * If the contents of a button are an icon or a custom widget, setting this
     * property has no effect.
     */
    canShrink: boolean
    /**
     * The child widget.
     */
    child: Widget
    /**
     * Whether the button has a frame.
     */
    hasFrame: boolean
    /**
     * The name of the icon used to automatically populate the button.
     */
    iconName: string | null
    /**
     * Text of the label inside the button, if the button contains a label widget.
     */
    label: string | null
    /**
     * If set, an underline in the text indicates that the following character is
     * to be used as mnemonic.
     */
    useUnderline: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Button

    /**
     * Retrieves whether the button can be smaller than the natural
     * size of its contents.
     * @returns true if the button can shrink, and false otherwise
     */
    getCanShrink(): boolean
    /**
     * Gets the child widget of `button`.
     * @returns the child widget of @button
     */
    getChild(): Widget | null
    /**
     * Returns whether the button has a frame.
     * @returns %TRUE if the button has a frame
     */
    getHasFrame(): boolean
    /**
     * Returns the icon name of the button.
     *
     * If the icon name has not been set with [method`Gtk`.Button.set_icon_name]
     * the return value will be %NULL. This will be the case if you create
     * an empty button with [ctor`Gtk`.Button.new] to use as a container.
     * @returns The icon name set via [method@Gtk.Button.set_icon_name]
     */
    getIconName(): string | null
    /**
     * Fetches the text from the label of the button.
     *
     * If the label text has not been set with [method`Gtk`.Button.set_label]
     * the return value will be %NULL. This will be the case if you create
     * an empty button with [ctor`Gtk`.Button.new] to use as a container.
     * @returns The text of the label widget. This string is owned by the widget and must not be modified or freed.
     */
    getLabel(): string | null
    /**
     * gets whether underlines are interpreted as mnemonics.
     *
     * See [method`Gtk`.Button.set_use_underline].
     * @returns %TRUE if an embedded underline in the button label   indicates the mnemonic accelerator keys.
     */
    getUseUnderline(): boolean
    /**
     * Sets whether the button size can be smaller than the natural size of
     * its contents.
     *
     * For text buttons, setting `can_shrink` to true will ellipsize the label.
     *
     * For icons and custom children, this function has no effect.
     * @param canShrink whether the button can shrink
     */
    setCanShrink(canShrink: boolean): void
    /**
     * Sets the child widget of `button`.
     *
     * Note that by using this API, you take full responsibility for setting
     * up the proper accessibility label and description information for `button`.
     * Most likely, you'll either set the accessibility label or description
     * for `button` explicitly, or you'll set a labelled-by or described-by
     * relations from `child` to `button`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets the style of the button.
     *
     * Buttons can have a flat appearance or have a frame drawn around them.
     * @param hasFrame whether the button should have a visible frame
     */
    setHasFrame(hasFrame: boolean): void
    /**
     * Adds a `GtkImage` with the given icon name as a child.
     *
     * If `button` already contains a child widget, that child widget will
     * be removed and replaced with the image.
     * @param iconName An icon name
     */
    setIconName(iconName: string): void
    /**
     * Sets the text of the label of the button to `label`.
     *
     * This will also clear any previously set labels.
     * @param label a string
     */
    setLabel(label: string): void
    /**
     * Sets whether to use underlines as mnemonics.
     *
     * If true, an underline in the text of the button label indicates
     * the next character should be used for the mnemonic accelerator key.
     * @param useUnderline %TRUE if underlines in the text indicate mnemonics
     */
    setUseUnderline(useUnderline: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.Button

    /**
     * Signal that causes the button to animate press then
     *    release. Applications should never connect to this signal, but use
     *    the `clicked` signal.
     * @virtual
     */
    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean
    /**
     * Signal emitted when the button has been activated (pressed and released).
     * @virtual
     */
    clicked(): void

    // Own signals of Gtk-4.0.Gtk.Button

    connect(
      sigName: "activate",
      callback: Button.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: Button.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: Button.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: Button.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(sigName: "clicked", callback: Button.ClickedSignalCallback): number
    on(
      sigName: "clicked",
      callback: Button.ClickedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "clicked",
      callback: Button.ClickedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "clicked",
      callback: Button.ClickedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "clicked", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Button

    connect(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-shrink", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-target", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkButton` widget is generally used to trigger a callback function that is
   * called when the button is pressed.
   *
   * ![An example GtkButton](button.png)
   *
   * The `GtkButton` widget can hold any valid child widget. That is, it can hold
   * almost any other standard `GtkWidget`. The most commonly used child is the
   * `GtkLabel`.
   *
   * # CSS nodes
   *
   * `GtkButton` has a single CSS node with name button. The node will get the
   * style classes .image-button or .text-button, if the content is just an
   * image or label, respectively. It may also receive the .flat style class.
   * When activating a button via the keyboard, the button will temporarily
   * gain the .keyboard-activating style class.
   *
   * Other style classes that are commonly used with `GtkButton` include
   * .suggested-action and .destructive-action. In special cases, buttons
   * can be made round by adding the .circular style class.
   *
   * Button-like widgets like [class`Gtk`.ToggleButton], [class`Gtk`.MenuButton],
   * [class`Gtk`.VolumeButton], [class`Gtk`.LockButton], [class`Gtk`.ColorButton]
   * or [class`Gtk`.FontButton] use style classes such as .toggle, .popup, .scale,
   * .lock, .color on the button node to differentiate themselves from a plain
   * `GtkButton`.
   *
   * # Accessibility
   *
   * `GtkButton` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
   * @class
   */
  class Button extends Widget {
    // Own properties of Gtk-4.0.Gtk.Button

    static name: string

    // Constructors of Gtk-4.0.Gtk.Button

    constructor(config?: Button.ConstructorProperties)
    /**
     * Creates a new `GtkButton` widget.
     *
     * To add a child widget to the button, use [method`Gtk`.Button.set_child].
     * @constructor
     * @returns The newly created `GtkButton` widget.
     */
    constructor()
    /**
     * Creates a new `GtkButton` widget.
     *
     * To add a child widget to the button, use [method`Gtk`.Button.set_child].
     * @constructor
     * @returns The newly created `GtkButton` widget.
     */
    static new(): Button
    /**
     * Creates a new button containing an icon from the current icon theme.
     *
     * If the icon name isn’t known, a “broken image” icon will be
     * displayed instead. If the current icon theme is changed, the icon
     * will be updated appropriately.
     * @constructor
     * @param iconName an icon name
     * @returns a new `GtkButton` displaying the themed icon
     */
    static newFromIconName(iconName: string): Button
    /**
     * Creates a `GtkButton` widget with a `GtkLabel` child.
     * @constructor
     * @param label The text you want the `GtkLabel` to hold
     * @returns The newly created `GtkButton` widget
     */
    static newWithLabel(label: string): Button
    /**
     * Creates a new `GtkButton` containing a label.
     *
     * If characters in `label` are preceded by an underscore, they are underlined.
     * If you need a literal underscore character in a label, use “__” (two
     * underscores). The first underlined character represents a keyboard
     * accelerator called a mnemonic. Pressing <kbd>Alt</kbd> and that key
     * activates the button.
     * @constructor
     * @param label The text of the button, with an underscore in front of the   mnemonic character
     * @returns a new `GtkButton`
     */
    static newWithMnemonic(label: string): Button
    _init(config?: Button.ConstructorProperties): void
  }

  interface CClosureExpression {}

  /**
   * A variant of `GtkClosureExpression` using a C closure.
   * @class
   */
  class CClosureExpression extends Expression {
    // Own properties of Gtk-4.0.Gtk.CClosureExpression

    static name: string

    // Constructors of Gtk-4.0.Gtk.CClosureExpression

    /**
     * Creates a `GtkExpression` that calls `callback_func` when it is evaluated.
     *
     * This function is a variant of [ctor`Gtk`.ClosureExpression.new] that
     * creates a `GClosure` by calling g_cclosure_new() with the given
     * `callback_func`, `user_data` and `user_destroy`.
     * @constructor
     * @param valueType the type of the value that this expression evaluates to
     * @param marshal marshaller used for creating a closure
     * @param params expressions for each parameter
     * @param callbackFunc callback used for creating a closure
     * @returns a new `GtkExpression`
     */
    constructor(
      valueType: GObject.GType,
      marshal: GObject.ClosureMarshal | null,
      params: Expression[],
      callbackFunc: GObject.Callback
    )
    /**
     * Creates a `GtkExpression` that calls `callback_func` when it is evaluated.
     *
     * This function is a variant of [ctor`Gtk`.ClosureExpression.new] that
     * creates a `GClosure` by calling g_cclosure_new() with the given
     * `callback_func`, `user_data` and `user_destroy`.
     * @constructor
     * @param valueType the type of the value that this expression evaluates to
     * @param marshal marshaller used for creating a closure
     * @param params expressions for each parameter
     * @param callbackFunc callback used for creating a closure
     * @returns a new `GtkExpression`
     */
    static new(
      valueType: GObject.GType,
      marshal: GObject.ClosureMarshal | null,
      params: Expression[],
      callbackFunc: GObject.Callback
    ): CClosureExpression
  }

  module Calendar {
    // Signal callback interfaces

    /**
     * Signal callback interface for `day-selected`
     */
    interface DaySelectedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `next-month`
     */
    interface NextMonthSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `next-year`
     */
    interface NextYearSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `prev-month`
     */
    interface PrevMonthSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `prev-year`
     */
    interface PrevYearSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Calendar

      /**
       * The selected day (as a number between 1 and 31).
       */
      day?: number | null
      /**
       * The selected month (as a number between 0 and 11).
       *
       * This property gets initially set to the current month.
       */
      month?: number | null
      /**
       * Determines whether day names are displayed.
       */
      show_day_names?: boolean | null
      /**
       * Determines whether a heading is displayed.
       */
      show_heading?: boolean | null
      /**
       * Determines whether week numbers are displayed.
       */
      show_week_numbers?: boolean | null
      /**
       * The selected year.
       *
       * This property gets initially set to the current year.
       */
      year?: number | null
    }
  }

  interface Calendar extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Calendar

    /**
     * The selected day (as a number between 1 and 31).
     */
    day: number
    /**
     * The selected month (as a number between 0 and 11).
     *
     * This property gets initially set to the current month.
     */
    month: number
    /**
     * Determines whether day names are displayed.
     */
    showDayNames: boolean
    /**
     * Determines whether a heading is displayed.
     */
    showHeading: boolean
    /**
     * Determines whether week numbers are displayed.
     */
    showWeekNumbers: boolean
    /**
     * The selected year.
     *
     * This property gets initially set to the current year.
     */
    year: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Calendar

    /**
     * Remove all visual markers.
     */
    clearMarks(): void
    /**
     * Returns a `GDateTime` representing the shown
     * year, month and the selected day.
     *
     * The returned date is in the local time zone.
     * @returns the `GDateTime` representing the shown date
     */
    getDate(): GLib.DateTime
    /**
     * Gets the day of the selected date.
     * @returns the day of the selected date.
     */
    getDay(): number
    /**
     * Returns if the `day` of the `calendar` is already marked.
     * @param day the day number between 1 and 31.
     * @returns whether the day is marked.
     */
    getDayIsMarked(day: number): boolean
    /**
     * Gets the month of the selected date.
     * @returns The month of the selected date (as a number between 0 and 11).
     */
    getMonth(): number
    /**
     * Returns whether `self` is currently showing the names
     * of the week days.
     *
     * This is the value of the [property`Gtk`.Calendar:show-day-names]
     * property.
     * @returns Whether the calendar shows day names.
     */
    getShowDayNames(): boolean
    /**
     * Returns whether `self` is currently showing the heading.
     *
     * This is the value of the [property`Gtk`.Calendar:show-heading]
     * property.
     * @returns Whether the calendar is showing a heading.
     */
    getShowHeading(): boolean
    /**
     * Returns whether `self` is showing week numbers right
     * now.
     *
     * This is the value of the [property`Gtk`.Calendar:show-week-numbers]
     * property.
     * @returns Whether the calendar is showing week numbers.
     */
    getShowWeekNumbers(): boolean
    /**
     * Gets the year of the selected date.
     * @returns the year of the selected date.
     */
    getYear(): number
    /**
     * Places a visual marker on a particular day of the current month.
     * @param day the day number to mark between 1 and 31.
     */
    markDay(day: number): void
    /**
     * Switches to `date'`s year and month and select its day.
     * @param date a `GDateTime` representing the day to select
     */
    selectDay(date: GLib.DateTime): void
    /**
     * Sets the day for the selected date.
     *
     * The new date must be valid. For example, setting 31 for the day when the
     * month is February, fails.
     * @param day The desired day for the selected date (as a number between 1 and 31).
     */
    setDay(day: number): void
    /**
     * Sets the month for the selected date.
     *
     * The new date must be valid. For example, setting 1 (February) for the month
     * when the day is 31, fails.
     * @param month The desired month for the selected date (as a number between 0 and 11).
     */
    setMonth(month: number): void
    /**
     * Sets whether the calendar shows day names.
     * @param value Whether to show day names above the day numbers
     */
    setShowDayNames(value: boolean): void
    /**
     * Sets whether the calendar should show a heading.
     *
     * The heading contains the current year and month as well as
     * buttons for changing both.
     * @param value Whether to show the heading in the calendar
     */
    setShowHeading(value: boolean): void
    /**
     * Sets whether week numbers are shown in the calendar.
     * @param value whether to show week numbers on the left of the days
     */
    setShowWeekNumbers(value: boolean): void
    /**
     * Sets the year for the selected date.
     *
     * The new date must be valid. For example, setting 2023 for the year when then
     * the date is 2024-02-29, fails.
     * @param year The desired year for the selected date (within [struct`GLib`.DateTime]   limits, i.e. from 0001 to 9999).
     */
    setYear(year: number): void
    /**
     * Removes the visual marker from a particular day.
     * @param day the day number to unmark between 1 and 31.
     */
    unmarkDay(day: number): void

    // Own signals of Gtk-4.0.Gtk.Calendar

    connect(
      sigName: "day-selected",
      callback: Calendar.DaySelectedSignalCallback
    ): number
    on(
      sigName: "day-selected",
      callback: Calendar.DaySelectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "day-selected",
      callback: Calendar.DaySelectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "day-selected",
      callback: Calendar.DaySelectedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "day-selected", ...args: any[]): void
    connect(
      sigName: "next-month",
      callback: Calendar.NextMonthSignalCallback
    ): number
    on(
      sigName: "next-month",
      callback: Calendar.NextMonthSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "next-month",
      callback: Calendar.NextMonthSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "next-month",
      callback: Calendar.NextMonthSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "next-month", ...args: any[]): void
    connect(
      sigName: "next-year",
      callback: Calendar.NextYearSignalCallback
    ): number
    on(
      sigName: "next-year",
      callback: Calendar.NextYearSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "next-year",
      callback: Calendar.NextYearSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "next-year",
      callback: Calendar.NextYearSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "next-year", ...args: any[]): void
    connect(
      sigName: "prev-month",
      callback: Calendar.PrevMonthSignalCallback
    ): number
    on(
      sigName: "prev-month",
      callback: Calendar.PrevMonthSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "prev-month",
      callback: Calendar.PrevMonthSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "prev-month",
      callback: Calendar.PrevMonthSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "prev-month", ...args: any[]): void
    connect(
      sigName: "prev-year",
      callback: Calendar.PrevYearSignalCallback
    ): number
    on(
      sigName: "prev-year",
      callback: Calendar.PrevYearSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "prev-year",
      callback: Calendar.PrevYearSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "prev-year",
      callback: Calendar.PrevYearSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "prev-year", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Calendar

    connect(sigName: "notify::day", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::day",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::day",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::day",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::day", ...args: any[]): void
    connect(
      sigName: "notify::month",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::month",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::month",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::month",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::month", ...args: any[]): void
    connect(
      sigName: "notify::show-day-names",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-day-names",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-day-names",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-day-names",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-day-names", ...args: any[]): void
    connect(
      sigName: "notify::show-heading",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-heading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-heading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-heading",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-heading", ...args: any[]): void
    connect(
      sigName: "notify::show-week-numbers",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-week-numbers",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-week-numbers",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-week-numbers",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-week-numbers", ...args: any[]): void
    connect(sigName: "notify::year", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::year",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::year",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::year",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::year", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkCalendar` is a widget that displays a Gregorian calendar, one month
   * at a time.
   *
   * ![An example GtkCalendar](calendar.png)
   *
   * A `GtkCalendar` can be created with [ctor`Gtk`.Calendar.new].
   *
   * The date that is currently displayed can be altered with
   * [method`Gtk`.Calendar.select_day].
   *
   * To place a visual marker on a particular day, use
   * [method`Gtk`.Calendar.mark_day] and to remove the marker,
   * [method`Gtk`.Calendar.unmark_day]. Alternative, all
   * marks can be cleared with [method`Gtk`.Calendar.clear_marks].
   *
   * The selected date can be retrieved from a `GtkCalendar` using
   * [method`Gtk`.Calendar.get_date].
   *
   * Users should be aware that, although the Gregorian calendar is the
   * legal calendar in most countries, it was adopted progressively
   * between 1582 and 1929. Display before these dates is likely to be
   * historically incorrect.
   *
   * # CSS nodes
   *
   * ```
   * calendar.view
   * ├── header
   * │   ├── button
   * │   ├── stack.month
   * │   ├── button
   * │   ├── button
   * │   ├── label.year
   * │   ╰── button
   * ╰── grid
   *     ╰── label[.day-name][.week-number][.day-number][.other-month][.today]
   * ```
   *
   * `GtkCalendar` has a main node with name calendar. It contains a subnode
   * called header containing the widgets for switching between years and months.
   *
   * The grid subnode contains all day labels, including week numbers on the left
   * (marked with the .week-number css class) and day names on top (marked with the
   * .day-name css class).
   *
   * Day labels that belong to the previous or next month get the .other-month
   * style class. The label of the current day get the .today style class.
   *
   * Marked day labels get the :selected state assigned.
   * @class
   */
  class Calendar extends Widget {
    // Own properties of Gtk-4.0.Gtk.Calendar

    static name: string

    // Constructors of Gtk-4.0.Gtk.Calendar

    constructor(config?: Calendar.ConstructorProperties)
    /**
     * Creates a new calendar, with the current date being selected.
     * @constructor
     * @returns a newly `GtkCalendar` widget
     */
    constructor()
    /**
     * Creates a new calendar, with the current date being selected.
     * @constructor
     * @returns a newly `GtkCalendar` widget
     */
    static new(): Calendar
    _init(config?: Calendar.ConstructorProperties): void
  }

  module CallbackAction {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutAction.ConstructorProperties {}
  }

  interface CallbackAction {
    // Own properties of Gtk-4.0.Gtk.CallbackAction

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.CallbackAction

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutAction` that invokes a callback.
   * @class
   */
  class CallbackAction extends ShortcutAction {
    // Own properties of Gtk-4.0.Gtk.CallbackAction

    static name: string

    // Constructors of Gtk-4.0.Gtk.CallbackAction

    constructor(config?: CallbackAction.ConstructorProperties)
    /**
     * Create a custom action that calls the given `callback` when
     * activated.
     * @constructor
     * @returns A new shortcut action
     */
    constructor()
    /**
     * Create a custom action that calls the given `callback` when
     * activated.
     * @constructor
     * @returns A new shortcut action
     */
    static new(): CallbackAction
    _init(config?: CallbackAction.ConstructorProperties): void
  }

  module CellArea {
    // Signal callback interfaces

    /**
     * Signal callback interface for `add-editable`
     */
    interface AddEditableSignalCallback {
      (
        renderer: CellRenderer,
        editable: CellEditable,
        cellArea: Gdk.Rectangle,
        path: string | null
      ): void
    }

    /**
     * Signal callback interface for `apply-attributes`
     */
    interface ApplyAttributesSignalCallback {
      (
        model: TreeModel,
        iter: TreeIter,
        isExpander: boolean,
        isExpanded: boolean
      ): void
    }

    /**
     * Signal callback interface for `focus-changed`
     */
    interface FocusChangedSignalCallback {
      (renderer: CellRenderer, path: string | null): void
    }

    /**
     * Signal callback interface for `remove-editable`
     */
    interface RemoveEditableSignalCallback {
      (renderer: CellRenderer, editable: CellEditable): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        CellLayout.ConstructorProperties,
        GObject.InitiallyUnowned.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellArea

      /**
       * The cell in the area that currently has focus
       */
      focus_cell?: CellRenderer | null
    }
  }

  interface CellArea extends Buildable, CellLayout {
    // Own properties of Gtk-4.0.Gtk.CellArea

    /**
     * The widget currently editing the edited cell
     *
     * This property is read-only and only changes as
     * a result of a call gtk_cell_area_activate_cell().
     */
    readonly editWidget: CellEditable
    /**
     * The cell in the area that is currently edited
     *
     * This property is read-only and only changes as
     * a result of a call gtk_cell_area_activate_cell().
     */
    readonly editedCell: CellRenderer
    /**
     * The cell in the area that currently has focus
     */
    focusCell: CellRenderer
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CellArea

    // Has conflict: activate(context: CellAreaContext, widget: Widget, cellArea: Gdk.Rectangle, flags: CellRendererState, editOnly: boolean): boolean
    /**
     * This is used by `GtkCellArea` subclasses when handling events
     * to activate cells, the base `GtkCellArea` class activates cells
     * for keyboard events for free in its own GtkCellArea->activate()
     * implementation.
     * @param widget the `GtkWidget` that `area` is rendering onto
     * @param renderer the `GtkCellRenderer` in `area` to activate
     * @param event the `GdkEvent` for which cell activation should occur
     * @param cellArea the `GdkRectangle` in `widget` relative coordinates             of `renderer` for the current row.
     * @param flags the `GtkCellRenderer`State for `renderer`
     * @returns whether cell activation was successful
     */
    activateCell(
      widget: Widget,
      renderer: CellRenderer,
      event: Gdk.Event,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ): boolean
    // Has conflict: add(renderer: CellRenderer): void
    /**
     * Adds `sibling` to `renderer’`s focusable area, focus will be drawn
     * around `renderer` and all of its siblings if `renderer` can
     * focus for a given row.
     *
     * Events handled by focus siblings can also activate the given
     * focusable `renderer`.
     * @param renderer the `GtkCellRenderer` expected to have focus
     * @param sibling the `GtkCellRenderer` to add to `renderer’`s focus area
     */
    addFocusSibling(renderer: CellRenderer, sibling: CellRenderer): void
    // Has conflict: applyAttributes(treeModel: TreeModel, iter: TreeIter, isExpander: boolean, isExpanded: boolean): void
    /**
     * Connects an `attribute` to apply values from `column` for the
     * `GtkTreeModel` in use.
     * @param renderer the `GtkCellRenderer` to connect an attribute for
     * @param attribute the attribute name
     * @param column the `GtkTreeModel` column to fetch attribute values from
     */
    attributeConnect(
      renderer: CellRenderer,
      attribute: string,
      column: number
    ): void
    /**
     * Disconnects `attribute` for the `renderer` in `area` so that
     * attribute will no longer be updated with values from the
     * model.
     * @param renderer the `GtkCellRenderer` to disconnect an attribute for
     * @param attribute the attribute name
     */
    attributeDisconnect(renderer: CellRenderer, attribute: string): void
    /**
     * Returns the model column that an attribute has been mapped to,
     * or -1 if the attribute is not mapped.
     * @param renderer a `GtkCellRenderer`
     * @param attribute an attribute on the renderer
     * @returns the model column, or -1
     */
    attributeGetColumn(renderer: CellRenderer, attribute: string): number
    /**
     * Gets the value of a cell property for `renderer` in `area`.
     * @param renderer a `GtkCellRenderer` inside `area`
     * @param propertyName the name of the property to get
     * @param value a location to return the value
     */
    cellGetProperty(
      renderer: CellRenderer,
      propertyName: string,
      value: any
    ): void
    /**
     * Sets a cell property for `renderer` in `area`.
     * @param renderer a `GtkCellRenderer` inside `area`
     * @param propertyName the name of the cell property to set
     * @param value the value to set the cell property to
     */
    cellSetProperty(
      renderer: CellRenderer,
      propertyName: string,
      value: any
    ): void
    // Has conflict: copyContext(context: CellAreaContext): CellAreaContext
    // Has conflict: createContext(): CellAreaContext
    // Has conflict: event(context: CellAreaContext, widget: Widget, event: Gdk.Event, cellArea: Gdk.Rectangle, flags: CellRendererState): number
    // Has conflict: focus(direction: DirectionType): boolean
    // Has conflict: foreach(callback: CellCallback): void
    // Has conflict: foreachAlloc(context: CellAreaContext, widget: Widget, cellArea: Gdk.Rectangle, backgroundArea: Gdk.Rectangle, callback: CellAllocCallback): void
    /**
     * Derives the allocation of `renderer` inside `area` if `area`
     * were to be rendered in `cell_area`.
     * @param context the `GtkCellArea`Context used to hold sizes for `area`.
     * @param widget the `GtkWidget` that `area` is rendering on
     * @param renderer the `GtkCellRenderer` to get the allocation for
     * @param cellArea the whole allocated area for `area` in `widget`             for this row
     */
    getCellAllocation(
      context: CellAreaContext,
      widget: Widget,
      renderer: CellRenderer,
      cellArea: Gdk.Rectangle
    ): /* allocation */ Gdk.Rectangle
    /**
     * Gets the `GtkCellRenderer` at `x` and `y` coordinates inside `area` and optionally
     * returns the full cell allocation for it inside `cell_area`.
     * @param context the `GtkCellArea`Context used to hold sizes for `area`.
     * @param widget the `GtkWidget` that `area` is rendering on
     * @param cellArea the whole allocated area for `area` in `widget`   for this row
     * @param x the x position
     * @param y the y position
     * @returns the `GtkCellRenderer` at @x and @y.
     */
    getCellAtPosition(
      context: CellAreaContext,
      widget: Widget,
      cellArea: Gdk.Rectangle,
      x: number,
      y: number
    ): [/* returnType */ CellRenderer, /* allocArea */ Gdk.Rectangle]
    /**
     * Gets the current `GtkTreePath` string for the currently
     * applied `GtkTreeIter`, this is implicitly updated when
     * gtk_cell_area_apply_attributes() is called and can be
     * used to interact with renderers from `GtkCellArea`
     * subclasses.
     * @returns The current `GtkTreePath` string for the current attributes applied to @area. This string belongs to the area and should not be freed.
     */
    getCurrentPathString(): string
    /**
     * Gets the `GtkCellEditable` widget currently used
     * to edit the currently edited cell.
     * @returns The currently active `GtkCellEditable` widget
     */
    getEditWidget(): CellEditable | null
    /**
     * Gets the `GtkCellRenderer` in `area` that is currently
     * being edited.
     * @returns The currently edited `GtkCellRenderer`
     */
    getEditedCell(): CellRenderer | null
    /**
     * Retrieves the currently focused cell for `area`
     * @returns the currently focused cell in @area.
     */
    getFocusCell(): CellRenderer | null
    /**
     * Gets the `GtkCellRenderer` which is expected to be focusable
     * for which `renderer` is, or may be a sibling.
     *
     * This is handy for `GtkCellArea` subclasses when handling events,
     * after determining the renderer at the event location it can
     * then chose to activate the focus cell for which the event
     * cell may have been a sibling.
     * @param renderer the `GtkCellRenderer`
     * @returns the `GtkCellRenderer`   for which @renderer is a sibling
     */
    getFocusFromSibling(renderer: CellRenderer): CellRenderer | null
    /**
     * Gets the focus sibling cell renderers for `renderer`.
     * @param renderer the `GtkCellRenderer` expected to have focus
     * @returns A `GList` of `GtkCellRenderer`s.       The returned list is internal and should not be freed.
     */
    getFocusSiblings(renderer: CellRenderer): CellRenderer[]
    // Has conflict: getPreferredHeight(context: CellAreaContext, widget: Widget): [ /* minimumHeight */ number, /* naturalHeight */ number ]
    // Has conflict: getPreferredHeightForWidth(context: CellAreaContext, widget: Widget, width: number): [ /* minimumHeight */ number, /* naturalHeight */ number ]
    // Has conflict: getPreferredWidth(context: CellAreaContext, widget: Widget): [ /* minimumWidth */ number, /* naturalWidth */ number ]
    // Has conflict: getPreferredWidthForHeight(context: CellAreaContext, widget: Widget, height: number): [ /* minimumWidth */ number, /* naturalWidth */ number ]
    // Has conflict: getRequestMode(): SizeRequestMode
    /**
     * Checks if `area` contains `renderer`.
     * @param renderer the `GtkCellRenderer` to check
     * @returns %TRUE if @renderer is in the @area.
     */
    hasRenderer(renderer: CellRenderer): boolean
    /**
     * This is a convenience function for `GtkCellArea` implementations
     * to get the inner area where a given `GtkCellRenderer` will be
     * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
     * @param widget the `GtkWidget` that `area` is rendering onto
     * @param cellArea the `widget` relative coordinates where one of `area’`s cells             is to be placed
     */
    innerCellArea(
      widget: Widget,
      cellArea: Gdk.Rectangle
    ): /* innerArea */ Gdk.Rectangle
    // Has conflict: isActivatable(): boolean
    /**
     * Returns whether `sibling` is one of `renderer’`s focus siblings
     * (see gtk_cell_area_add_focus_sibling()).
     * @param renderer the `GtkCellRenderer` expected to have focus
     * @param sibling the `GtkCellRenderer` to check against `renderer’`s sibling list
     * @returns %TRUE if @sibling is a focus sibling of @renderer
     */
    isFocusSibling(renderer: CellRenderer, sibling: CellRenderer): boolean
    // Has conflict: remove(renderer: CellRenderer): void
    /**
     * Removes `sibling` from `renderer’`s focus sibling list
     * (see gtk_cell_area_add_focus_sibling()).
     * @param renderer the `GtkCellRenderer` expected to have focus
     * @param sibling the `GtkCellRenderer` to remove from `renderer’`s focus area
     */
    removeFocusSibling(renderer: CellRenderer, sibling: CellRenderer): void
    /**
     * This is a convenience function for `GtkCellArea` implementations
     * to request size for cell renderers. It’s important to use this
     * function to request size and then use gtk_cell_area_inner_cell_area()
     * at render and event time since this function will add padding
     * around the cell for focus painting.
     * @param renderer the `GtkCellRenderer` to request size for
     * @param orientation the `GtkOrientation` in which to request size
     * @param widget the `GtkWidget` that `area` is rendering onto
     * @param forSize the allocation contextual size to request for, or -1 if the base request for the orientation is to be returned.
     */
    requestRenderer(
      renderer: CellRenderer,
      orientation: Orientation,
      widget: Widget,
      forSize: number
    ): [/* minimumSize */ number, /* naturalSize */ number]
    /**
     * Explicitly sets the currently focused cell to `renderer`.
     *
     * This is generally called by implementations of
     * `GtkCellAreaClass.focus()` or `GtkCellAreaClass.event()`,
     * however it can also be used to implement functions such
     * as gtk_tree_view_set_cursor_on_cell().
     * @param renderer the `GtkCellRenderer` to give focus to
     */
    setFocusCell(renderer: CellRenderer | null): void
    // Has conflict: snapshot(context: CellAreaContext, widget: Widget, snapshot: Snapshot, backgroundArea: Gdk.Rectangle, cellArea: Gdk.Rectangle, flags: CellRendererState, paintFocus: boolean): void
    /**
     * Explicitly stops the editing of the currently edited cell.
     *
     * If `canceled` is %TRUE, the currently edited cell renderer
     * will emit the ::editing-canceled signal, otherwise the
     * the ::editing-done signal will be emitted on the current
     * edit widget.
     *
     * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
     * @param canceled whether editing was canceled.
     */
    stopEditing(canceled: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.CellArea

    /**
     * Activates `area,` usually by activating the currently focused
     * cell, however some subclasses which embed widgets in the area
     * can also activate a widget if it currently has the focus.
     * @virtual
     * @param context the `GtkCellArea`Context in context with the current row data
     * @param widget the `GtkWidget` that `area` is rendering on
     * @param cellArea the size and location of `area` relative to `widget’`s allocation
     * @param flags the `GtkCellRenderer`State flags for `area` for this row of data.
     * @param editOnly if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE             will be activated.
     * @returns Whether @area was successfully activated.
     */
    activate(
      context: CellAreaContext,
      widget: Widget,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState,
      editOnly: boolean
    ): boolean
    /**
     * Adds `renderer` to `area` with the default child cell properties.
     * @virtual
     * @param renderer the `GtkCellRenderer` to add to `area`
     */
    add(renderer: CellRenderer): void
    /**
     * Applies any connected attributes to the renderers in
     * `area` by pulling the values from `tree_model`.
     * @virtual
     * @param treeModel the `GtkTreeModel` to pull values from
     * @param iter the `GtkTreeIter` in `tree_model` to apply values for
     * @param isExpander whether `iter` has children
     * @param isExpanded whether `iter` is expanded in the view and               children are visible
     */
    applyAttributes(
      treeModel: TreeModel,
      iter: TreeIter,
      isExpander: boolean,
      isExpanded: boolean
    ): void
    /**
     * This is sometimes needed for cases where rows need to share
     * alignments in one orientation but may be separately grouped
     * in the opposing orientation.
     *
     * For instance, `GtkIconView` creates all icons (rows) to have
     * the same width and the cells theirin to have the same
     * horizontal alignments. However each row of icons may have
     * a separate collective height. `GtkIconView` uses this to
     * request the heights of each row based on a context which
     * was already used to request all the row widths that are
     * to be displayed.
     * @virtual
     * @param context the `GtkCellArea`Context to copy
     * @returns a newly created `GtkCellArea`Context copy of @context.
     */
    copyContext(context: CellAreaContext): CellAreaContext
    /**
     * Creates a `GtkCellArea`Context to be used with `area` for
     * all purposes. `GtkCellArea`Context stores geometry information
     * for rows for which it was operated on, it is important to use
     * the same context for the same row of data at all times (i.e.
     * one should render and handle events with the same `GtkCellArea`Context
     * which was used to request the size of those rows of data).
     * @virtual
     * @returns a newly created `GtkCellArea`Context which can be used with @area.
     */
    createContext(): CellAreaContext
    /**
     * Delegates event handling to a `GtkCellArea`.
     * @virtual
     * @param context the `GtkCellArea`Context for this row of data.
     * @param widget the `GtkWidget` that `area` is rendering to
     * @param event the `GdkEvent` to handle
     * @param cellArea the `widget` relative coordinates for `area`
     * @param flags the `GtkCellRenderer`State for `area` in this row.
     * @returns %TRUE if the event was handled by @area.
     */
    event(
      context: CellAreaContext,
      widget: Widget,
      event: Gdk.Event,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ): number
    /**
     * This should be called by the `area’`s owning layout widget
     * when focus is to be passed to `area,` or moved within `area`
     * for a given `direction` and row data.
     *
     * Implementing `GtkCellArea` classes should implement this
     * method to receive and navigate focus in its own way particular
     * to how it lays out cells.
     * @virtual
     * @param direction the `GtkDirectionType`
     * @returns %TRUE if focus remains inside @area as a result of this call.
     */
    focus(direction: DirectionType): boolean
    /**
     * Calls `callback` for every `GtkCellRenderer` in `area`.
     * @virtual
     * @param callback the `GtkCellCallback` to call
     */
    foreach(callback: CellCallback): void
    /**
     * Calls `callback` for every `GtkCellRenderer` in `area` with the
     * allocated rectangle inside `cell_area`.
     * @virtual
     * @param context the `GtkCellArea`Context for this row of data.
     * @param widget the `GtkWidget` that `area` is rendering to
     * @param cellArea the `widget` relative coordinates and size for `area`
     * @param backgroundArea the `widget` relative coordinates of the background area
     * @param callback the `GtkCellAllocCallback` to call
     */
    foreachAlloc(
      context: CellAreaContext,
      widget: Widget,
      cellArea: Gdk.Rectangle,
      backgroundArea: Gdk.Rectangle,
      callback: CellAllocCallback
    ): void
    /**
     * This should be implemented to report the values of
     *   child cell properties for a given child `GtkCellRenderer`.
     * @virtual
     * @param renderer
     * @param propertyId
     * @param value
     * @param pspec
     */
    getCellProperty(
      renderer: CellRenderer,
      propertyId: number,
      value: any,
      pspec: GObject.ParamSpec
    ): void
    /**
     * Retrieves a cell area’s initial minimum and natural height.
     *
     * `area` will store some geometrical information in `context` along the way;
     * when requesting sizes over an arbitrary number of rows, it’s not important
     * to check the `minimum_height` and `natural_height` of this call but rather to
     * consult gtk_cell_area_context_get_preferred_height() after a series of
     * requests.
     * @virtual
     * @param context the `GtkCellArea`Context to perform this request with
     * @param widget the `GtkWidget` where `area` will be rendering
     */
    getPreferredHeight(
      context: CellAreaContext,
      widget: Widget
    ): [/* minimumHeight */ number, /* naturalHeight */ number]
    /**
     * Retrieves a cell area’s minimum and natural height if it would be given
     * the specified `width`.
     *
     * `area` stores some geometrical information in `context` along the way
     * while calling gtk_cell_area_get_preferred_width(). It’s important to
     * perform a series of gtk_cell_area_get_preferred_width() requests with
     * `context` first and then call gtk_cell_area_get_preferred_height_for_width()
     * on each cell area individually to get the height for width of each
     * fully requested row.
     *
     * If at some point, the width of a single row changes, it should be
     * requested with gtk_cell_area_get_preferred_width() again and then
     * the full width of the requested rows checked again with
     * gtk_cell_area_context_get_preferred_width().
     * @virtual
     * @param context the `GtkCellArea`Context which has already been requested for widths.
     * @param widget the `GtkWidget` where `area` will be rendering
     * @param width the width for which to check the height of this area
     */
    getPreferredHeightForWidth(
      context: CellAreaContext,
      widget: Widget,
      width: number
    ): [/* minimumHeight */ number, /* naturalHeight */ number]
    /**
     * Retrieves a cell area’s initial minimum and natural width.
     *
     * `area` will store some geometrical information in `context` along the way;
     * when requesting sizes over an arbitrary number of rows, it’s not important
     * to check the `minimum_width` and `natural_width` of this call but rather to
     * consult gtk_cell_area_context_get_preferred_width() after a series of
     * requests.
     * @virtual
     * @param context the `GtkCellArea`Context to perform this request with
     * @param widget the `GtkWidget` where `area` will be rendering
     */
    getPreferredWidth(
      context: CellAreaContext,
      widget: Widget
    ): [/* minimumWidth */ number, /* naturalWidth */ number]
    /**
     * Retrieves a cell area’s minimum and natural width if it would be given
     * the specified `height`.
     *
     * `area` stores some geometrical information in `context` along the way
     * while calling gtk_cell_area_get_preferred_height(). It’s important to
     * perform a series of gtk_cell_area_get_preferred_height() requests with
     * `context` first and then call gtk_cell_area_get_preferred_width_for_height()
     * on each cell area individually to get the height for width of each
     * fully requested row.
     *
     * If at some point, the height of a single row changes, it should be
     * requested with gtk_cell_area_get_preferred_height() again and then
     * the full height of the requested rows checked again with
     * gtk_cell_area_context_get_preferred_height().
     * @virtual
     * @param context the `GtkCellArea`Context which has already been requested for widths.
     * @param widget the `GtkWidget` where `area` will be rendering
     * @param height the height for which to check the width of this area
     */
    getPreferredWidthForHeight(
      context: CellAreaContext,
      widget: Widget,
      height: number
    ): [/* minimumWidth */ number, /* naturalWidth */ number]
    /**
     * Gets whether the area prefers a height-for-width layout
     * or a width-for-height layout.
     * @virtual
     * @returns The `GtkSizeRequestMode` preferred by @area.
     */
    getRequestMode(): SizeRequestMode
    /**
     * Returns whether the area can do anything when activated,
     * after applying new attributes to `area`.
     * @virtual
     * @returns whether @area can do anything when activated.
     */
    isActivatable(): boolean
    /**
     * Removes `renderer` from `area`.
     * @virtual
     * @param renderer the `GtkCellRenderer` to remove from `area`
     */
    remove(renderer: CellRenderer): void
    /**
     * This should be implemented to handle changes in child
     *   cell properties for a given `GtkCellRenderer` that were previously
     *   installed on the `GtkCellAreaClass` with gtk_cell_area_class_install_cell_property().
     * @virtual
     * @param renderer
     * @param propertyId
     * @param value
     * @param pspec
     */
    setCellProperty(
      renderer: CellRenderer,
      propertyId: number,
      value: any,
      pspec: GObject.ParamSpec
    ): void
    /**
     * Snapshots `area’`s cells according to `area’`s layout onto at
     * the given coordinates.
     * @virtual
     * @param context the `GtkCellArea`Context for this row of data.
     * @param widget the `GtkWidget` that `area` is rendering to
     * @param snapshot the `GtkSnapshot` to draw to
     * @param backgroundArea the `widget` relative coordinates for `area’`s background
     * @param cellArea the `widget` relative coordinates for `area`
     * @param flags the `GtkCellRenderer`State for `area` in this row.
     * @param paintFocus whether `area` should paint focus on focused cells for focused rows or not.
     */
    snapshot(
      context: CellAreaContext,
      widget: Widget,
      snapshot: Snapshot,
      backgroundArea: Gdk.Rectangle,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState,
      paintFocus: boolean
    ): void

    // Own signals of Gtk-4.0.Gtk.CellArea

    connect(
      sigName: "add-editable",
      callback: CellArea.AddEditableSignalCallback
    ): number
    on(
      sigName: "add-editable",
      callback: CellArea.AddEditableSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "add-editable",
      callback: CellArea.AddEditableSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "add-editable",
      callback: CellArea.AddEditableSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "add-editable",
      editable: CellEditable,
      cellArea: Gdk.Rectangle,
      path: string | null,
      ...args: any[]
    ): void
    connect(
      sigName: "apply-attributes",
      callback: CellArea.ApplyAttributesSignalCallback
    ): number
    on(
      sigName: "apply-attributes",
      callback: CellArea.ApplyAttributesSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "apply-attributes",
      callback: CellArea.ApplyAttributesSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "apply-attributes",
      callback: CellArea.ApplyAttributesSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "apply-attributes",
      iter: TreeIter,
      isExpander: boolean,
      isExpanded: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "focus-changed",
      callback: CellArea.FocusChangedSignalCallback
    ): number
    on(
      sigName: "focus-changed",
      callback: CellArea.FocusChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "focus-changed",
      callback: CellArea.FocusChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "focus-changed",
      callback: CellArea.FocusChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "focus-changed", path: string | null, ...args: any[]): void
    connect(
      sigName: "remove-editable",
      callback: CellArea.RemoveEditableSignalCallback
    ): number
    on(
      sigName: "remove-editable",
      callback: CellArea.RemoveEditableSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "remove-editable",
      callback: CellArea.RemoveEditableSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "remove-editable",
      callback: CellArea.RemoveEditableSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "remove-editable",
      editable: CellEditable,
      ...args: any[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.CellArea

    connect(
      sigName: "notify::edit-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::edit-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::edit-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::edit-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::edit-widget", ...args: any[]): void
    connect(
      sigName: "notify::edited-cell",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::edited-cell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::edited-cell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::edited-cell",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::edited-cell", ...args: any[]): void
    connect(
      sigName: "notify::focus-cell",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-cell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-cell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-cell",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-cell", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An abstract class for laying out `GtkCellRenderer`s
   *
   * The `GtkCellArea` is an abstract class for [iface`Gtk`.CellLayout]
   * widgets (also referred to as "layouting widgets") to interface with
   * an arbitrary number of [class`Gtk`.CellRenderer]s and interact with the user
   * for a given [iface`Gtk`.TreeModel] row.
   *
   * The cell area handles events, focus navigation, drawing and
   * size requests and allocations for a given row of data.
   *
   * Usually users dont have to interact with the `GtkCellArea` directly
   * unless they are implementing a cell-layouting widget themselves.
   *
   * ## Requesting area sizes
   *
   * As outlined in
   * [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management),
   * GTK uses a height-for-width
   * geometry management system to compute the sizes of widgets and user
   * interfaces. `GtkCellArea` uses the same semantics to calculate the
   * size of an area for an arbitrary number of `GtkTreeModel` rows.
   *
   * When requesting the size of a cell area one needs to calculate
   * the size for a handful of rows, and this will be done differently by
   * different layouting widgets. For instance a [class`Gtk`.TreeViewColumn]
   * always lines up the areas from top to bottom while a [class`Gtk`.IconView]
   * on the other hand might enforce that all areas received the same
   * width and wrap the areas around, requesting height for more cell
   * areas when allocated less width.
   *
   * It’s also important for areas to maintain some cell
   * alignments with areas rendered for adjacent rows (cells can
   * appear “columnized” inside an area even when the size of
   * cells are different in each row). For this reason the `GtkCellArea`
   * uses a [class`Gtk`.CellAreaContext] object to store the alignments
   * and sizes along the way (as well as the overall largest minimum
   * and natural size for all the rows which have been calculated
   * with the said context).
   *
   * The [class`Gtk`.CellAreaContext] is an opaque object specific to the
   * `GtkCellArea` which created it (see [method`Gtk`.CellArea.create_context]).
   *
   * The owning cell-layouting widget can create as many contexts as
   * it wishes to calculate sizes of rows which should receive the
   * same size in at least one orientation (horizontally or vertically),
   * However, it’s important that the same [class`Gtk`.CellAreaContext] which
   * was used to request the sizes for a given `GtkTreeModel` row be
   * used when rendering or processing events for that row.
   *
   * In order to request the width of all the rows at the root level
   * of a `GtkTreeModel` one would do the following:
   *
   * ```c
   * GtkTreeIter iter;
   * int minimum_width;
   * int natural_width;
   *
   * valid = gtk_tree_model_get_iter_first (model, &iter);
   * while (valid)
   *   {
   *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
   *     gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
   *
   *     valid = gtk_tree_model_iter_next (model, &iter);
   *   }
   *
   * gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
   * ```
   *
   * Note that in this example it’s not important to observe the
   * returned minimum and natural width of the area for each row
   * unless the cell-layouting object is actually interested in the
   * widths of individual rows. The overall width is however stored
   * in the accompanying `GtkCellAreaContext` object and can be consulted
   * at any time.
   *
   * This can be useful since `GtkCellLayout` widgets usually have to
   * support requesting and rendering rows in treemodels with an
   * exceedingly large amount of rows. The `GtkCellLayout` widget in
   * that case would calculate the required width of the rows in an
   * idle or timeout source (see [func`GLib`.timeout_add]) and when the widget
   * is requested its actual width in [vfunc`Gtk`.Widget.measure]
   * it can simply consult the width accumulated so far in the
   * `GtkCellAreaContext` object.
   *
   * A simple example where rows are rendered from top to bottom and
   * take up the full width of the layouting widget would look like:
   *
   * ```c
   * static void
   * foo_get_preferred_width (GtkWidget *widget,
   *                          int       *minimum_size,
   *                          int       *natural_size)
   * {
   *   Foo *self = FOO (widget);
   *   FooPrivate *priv = foo_get_instance_private (self);
   *
   *   foo_ensure_at_least_one_handfull_of_rows_have_been_requested (self);
   *
   *   gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
   * }
   * ```
   *
   * In the above example the `Foo` widget has to make sure that some
   * row sizes have been calculated (the amount of rows that `Foo` judged
   * was appropriate to request space for in a single timeout iteration)
   * before simply returning the amount of space required by the area via
   * the `GtkCellAreaContext`.
   *
   * Requesting the height for width (or width for height) of an area is
   * a similar task except in this case the `GtkCellAreaContext` does not
   * store the data (actually, it does not know how much space the layouting
   * widget plans to allocate it for every row. It’s up to the layouting
   * widget to render each row of data with the appropriate height and
   * width which was requested by the `GtkCellArea`).
   *
   * In order to request the height for width of all the rows at the
   * root level of a `GtkTreeModel` one would do the following:
   *
   * ```c
   * GtkTreeIter iter;
   * int minimum_height;
   * int natural_height;
   * int full_minimum_height = 0;
   * int full_natural_height = 0;
   *
   * valid = gtk_tree_model_get_iter_first (model, &iter);
   * while (valid)
   *   {
   *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
   *     gtk_cell_area_get_preferred_height_for_width (area, context, widget,
   *                                                   width, &minimum_height, &natural_height);
   *
   *     if (width_is_for_allocation)
   *        cache_row_height (&iter, minimum_height, natural_height);
   *
   *     full_minimum_height += minimum_height;
   *     full_natural_height += natural_height;
   *
   *     valid = gtk_tree_model_iter_next (model, &iter);
   *   }
   * ```
   *
   * Note that in the above example we would need to cache the heights
   * returned for each row so that we would know what sizes to render the
   * areas for each row. However we would only want to really cache the
   * heights if the request is intended for the layouting widgets real
   * allocation.
   *
   * In some cases the layouting widget is requested the height for an
   * arbitrary for_width, this is a special case for layouting widgets
   * who need to request size for tens of thousands  of rows. For this
   * case it’s only important that the layouting widget calculate
   * one reasonably sized chunk of rows and return that height
   * synchronously. The reasoning here is that any layouting widget is
   * at least capable of synchronously calculating enough height to fill
   * the screen height (or scrolled window height) in response to a single
   * call to [vfunc`Gtk`.Widget.measure]. Returning
   * a perfect height for width that is larger than the screen area is
   * inconsequential since after the layouting receives an allocation
   * from a scrolled window it simply continues to drive the scrollbar
   * values while more and more height is required for the row heights
   * that are calculated in the background.
   *
   * ## Rendering Areas
   *
   * Once area sizes have been acquired at least for the rows in the
   * visible area of the layouting widget they can be rendered at
   * [vfunc`Gtk`.Widget.snapshot] time.
   *
   * A crude example of how to render all the rows at the root level
   * runs as follows:
   *
   * ```c
   * GtkAllocation allocation;
   * GdkRectangle cell_area = { 0, };
   * GtkTreeIter iter;
   * int minimum_width;
   * int natural_width;
   *
   * gtk_widget_get_allocation (widget, &allocation);
   * cell_area.width = allocation.width;
   *
   * valid = gtk_tree_model_get_iter_first (model, &iter);
   * while (valid)
   *   {
   *     cell_area.height = get_cached_height_for_row (&iter);
   *
   *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
   *     gtk_cell_area_render (area, context, widget, cr,
   *                           &cell_area, &cell_area, state_flags, FALSE);
   *
   *     cell_area.y += cell_area.height;
   *
   *     valid = gtk_tree_model_iter_next (model, &iter);
   *   }
   * ```
   *
   * Note that the cached height in this example really depends on how
   * the layouting widget works. The layouting widget might decide to
   * give every row its minimum or natural height or, if the model content
   * is expected to fit inside the layouting widget without scrolling, it
   * would make sense to calculate the allocation for each row at
   * the time the widget is allocated using [func`Gtk`.distribute_natural_allocation].
   *
   * ## Handling Events and Driving Keyboard Focus
   *
   * Passing events to the area is as simple as handling events on any
   * normal widget and then passing them to the [method`Gtk`.CellArea.event]
   * API as they come in. Usually `GtkCellArea` is only interested in
   * button events, however some customized derived areas can be implemented
   * who are interested in handling other events. Handling an event can
   * trigger the [signal`Gtk`.CellArea::focus-changed] signal to fire; as well
   * as [signal`Gtk`.CellArea::add-editable] in the case that an editable cell
   * was clicked and needs to start editing. You can call
   * [method`Gtk`.CellArea.stop_editing] at any time to cancel any cell editing
   * that is currently in progress.
   *
   * The `GtkCellArea` drives keyboard focus from cell to cell in a way
   * similar to `GtkWidget`. For layouting widgets that support giving
   * focus to cells it’s important to remember to pass `GTK_CELL_RENDERER_FOCUSED`
   * to the area functions for the row that has focus and to tell the
   * area to paint the focus at render time.
   *
   * Layouting widgets that accept focus on cells should implement the
   * [vfunc`Gtk`.Widget.focus] virtual method. The layouting widget is always
   * responsible for knowing where `GtkTreeModel` rows are rendered inside
   * the widget, so at [vfunc`Gtk`.Widget.focus] time the layouting widget
   * should use the `GtkCellArea` methods to navigate focus inside the area
   * and then observe the [enum`Gtk`.DirectionType] to pass the focus to adjacent
   * rows and areas.
   *
   * A basic example of how the [vfunc`Gtk`.Widget.focus] virtual method
   * should be implemented:
   *
   * ```
   * static gboolean
   * foo_focus (GtkWidget       *widget,
   *            GtkDirectionType direction)
   * {
   *   Foo *self = FOO (widget);
   *   FooPrivate *priv = foo_get_instance_private (self);
   *   int focus_row = priv->focus_row;
   *   gboolean have_focus = FALSE;
   *
   *   if (!gtk_widget_has_focus (widget))
   *     gtk_widget_grab_focus (widget);
   *
   *   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
   *   while (valid)
   *     {
   *       gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
   *
   *       if (gtk_cell_area_focus (priv->area, direction))
   *         {
   *            priv->focus_row = focus_row;
   *            have_focus = TRUE;
   *            break;
   *         }
   *       else
   *         {
   *           if (direction == GTK_DIR_RIGHT ||
   *               direction == GTK_DIR_LEFT)
   *             break;
   *           else if (direction == GTK_DIR_UP ||
   *                    direction == GTK_DIR_TAB_BACKWARD)
   *            {
   *               if (focus_row == 0)
   *                 break;
   *               else
   *                {
   *                   focus_row--;
   *                   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
   *                }
   *             }
   *           else
   *             {
   *               if (focus_row == last_row)
   *                 break;
   *               else
   *                 {
   *                   focus_row++;
   *                   valid = gtk_tree_model_iter_next (priv->model, &iter);
   *                 }
   *             }
   *         }
   *     }
   *     return have_focus;
   * }
   * ```
   *
   * Note that the layouting widget is responsible for matching the
   * `GtkDirectionType` values to the way it lays out its cells.
   *
   * ## Cell Properties
   *
   * The `GtkCellArea` introduces cell properties for `GtkCellRenderer`s.
   * This provides some general interfaces for defining the relationship
   * cell areas have with their cells. For instance in a [class`Gtk`.CellAreaBox]
   * a cell might “expand” and receive extra space when the area is allocated
   * more than its full natural request, or a cell might be configured to “align”
   * with adjacent rows which were requested and rendered with the same
   * `GtkCellAreaContext`.
   *
   * Use [method`Gtk`.CellAreaClass.install_cell_property] to install cell
   * properties for a cell area class and [method`Gtk`.CellAreaClass.find_cell_property]
   * or [method`Gtk`.CellAreaClass.list_cell_properties] to get information about
   * existing cell properties.
   *
   * To set the value of a cell property, use [method`Gtk`.CellArea.cell_set_property],
   * [method`Gtk`.CellArea.cell_set] or [method`Gtk`.CellArea.cell_set_valist]. To obtain
   * the value of a cell property, use [method`Gtk`.CellArea.cell_get_property]
   * [method`Gtk`.CellArea.cell_get] or [method`Gtk`.CellArea.cell_get_valist].
   * @class
   */
  class CellArea extends GObject.InitiallyUnowned {
    // Own properties of Gtk-4.0.Gtk.CellArea

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellArea

    constructor(config?: CellArea.ConstructorProperties)
    _init(config?: CellArea.ConstructorProperties): void
    /**
     * Finds a cell property of a cell area class by name.
     * @param propertyName the name of the child property to find
     * @returns the `GParamSpec` of the child property
     */
    static findCellProperty(
      aclass: CellArea | Function | GObject.GType,
      propertyName: string
    ): GObject.ParamSpec
    /**
     * Installs a cell property on a cell area class.
     * @param propertyId the id for the property
     * @param pspec the `GParamSpec` for the property
     */
    static installCellProperty(
      aclass: CellArea | Function | GObject.GType,
      propertyId: number,
      pspec: GObject.ParamSpec
    ): void
    /**
     * Returns all cell properties of a cell area class.
     * @returns a newly     allocated %NULL-terminated array of `GParamSpec`*.  The array     must be freed with g_free().
     */
    static listCellProperties(
      aclass: CellArea | Function | GObject.GType
    ): GObject.ParamSpec[]
  }

  module CellAreaBox {
    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        CellLayout.ConstructorProperties,
        Orientable.ConstructorProperties,
        CellArea.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellAreaBox

      /**
       * The amount of space to reserve between cells.
       */
      spacing?: number | null
    }
  }

  interface CellAreaBox extends Buildable, CellLayout, Orientable {
    // Own properties of Gtk-4.0.Gtk.CellAreaBox

    /**
     * The amount of space to reserve between cells.
     */
    spacing: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CellAreaBox

    /**
     * Gets the spacing added between cell renderers.
     * @returns the space added between cell renderers in @box.
     */
    getSpacing(): number
    /**
     * Adds `renderer` to `box,` packed with reference to the end of `box`.
     *
     * The `renderer` is packed after (away from end of) any other
     * `GtkCellRenderer` packed with reference to the end of `box`.
     * @param renderer the `GtkCellRenderer` to add
     * @param expand whether `renderer` should receive extra space when the area receives more than its natural size
     * @param align whether `renderer` should be aligned in adjacent rows
     * @param fixed whether `renderer` should have the same size in all rows
     */
    packEnd(
      renderer: CellRenderer,
      expand: boolean,
      align: boolean,
      fixed: boolean
    ): void

    // Overloads of packEnd

    /**
     * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
     * `cell` is allocated no more space than it needs. Any unused space is
     * divided evenly between cells for which `expand` is %TRUE.
     *
     * Note that reusing the same cell renderer is not supported.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param expand %TRUE if `cell` is to be given extra space allocated to `cell_layout`
     */
    packEnd(cell: CellRenderer, expand: boolean): void
    /**
     * Adds `renderer` to `box,` packed with reference to the start of `box`.
     *
     * The `renderer` is packed after any other `GtkCellRenderer` packed
     * with reference to the start of `box`.
     * @param renderer the `GtkCellRenderer` to add
     * @param expand whether `renderer` should receive extra space when the area receives more than its natural size
     * @param align whether `renderer` should be aligned in adjacent rows
     * @param fixed whether `renderer` should have the same size in all rows
     */
    packStart(
      renderer: CellRenderer,
      expand: boolean,
      align: boolean,
      fixed: boolean
    ): void

    // Overloads of packStart

    /**
     * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
     * then the `cell` is allocated no more space than it needs. Any unused space
     * is divided evenly between cells for which `expand` is %TRUE.
     *
     * Note that reusing the same cell renderer is not supported.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param expand %TRUE if `cell` is to be given extra space allocated to `cell_layout`
     */
    packStart(cell: CellRenderer, expand: boolean): void
    /**
     * Sets the spacing to add between cell renderers in `box`.
     * @param spacing the space to add between `GtkCellRenderer`s
     */
    setSpacing(spacing: number): void

    // Class property signals of Gtk-4.0.Gtk.CellAreaBox

    connect(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::spacing", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::edit-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::edit-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::edit-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::edit-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::edit-widget", ...args: any[]): void
    connect(
      sigName: "notify::edited-cell",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::edited-cell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::edited-cell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::edited-cell",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::edited-cell", ...args: any[]): void
    connect(
      sigName: "notify::focus-cell",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-cell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-cell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-cell",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-cell", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A cell area that renders GtkCellRenderers into a row or a column
   *
   * The `GtkCellAreaBox` renders cell renderers into a row or a column
   * depending on its `GtkOrientation`.
   *
   * GtkCellAreaBox uses a notion of packing. Packing
   * refers to adding cell renderers with reference to a particular position
   * in a `GtkCellAreaBox`. There are two reference positions: the
   * start and the end of the box.
   * When the `GtkCellAreaBox` is oriented in the %GTK_ORIENTATION_VERTICAL
   * orientation, the start is defined as the top of the box and the end is
   * defined as the bottom. In the %GTK_ORIENTATION_HORIZONTAL orientation
   * start is defined as the left side and the end is defined as the right
   * side.
   *
   * Alignments of `GtkCellRenderer`s rendered in adjacent rows can be
   * configured by configuring the `GtkCellAreaBox` align child cell property
   * with gtk_cell_area_cell_set_property() or by specifying the "align"
   * argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end().
   * @class
   */
  class CellAreaBox extends CellArea {
    // Own properties of Gtk-4.0.Gtk.CellAreaBox

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellAreaBox

    constructor(config?: CellAreaBox.ConstructorProperties)
    /**
     * Creates a new `GtkCellAreaBox`.
     * @constructor
     * @returns a newly created `GtkCellAreaBox`
     */
    constructor()
    /**
     * Creates a new `GtkCellAreaBox`.
     * @constructor
     * @returns a newly created `GtkCellAreaBox`
     */
    static new(): CellAreaBox
    _init(config?: CellAreaBox.ConstructorProperties): void
  }

  module CellAreaContext {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellAreaContext

      /**
       * The `GtkCellArea` this context was created by
       */
      area?: CellArea | null
    }
  }

  interface CellAreaContext {
    // Own properties of Gtk-4.0.Gtk.CellAreaContext

    /**
     * The `GtkCellArea` this context was created by
     */
    readonly area: CellArea
    /**
     * The minimum height for the `GtkCellArea` in this context
     * for all `GtkTreeModel` rows that this context was requested
     * for using gtk_cell_area_get_preferred_height().
     */
    readonly minimumHeight: number
    /**
     * The minimum width for the `GtkCellArea` in this context
     * for all `GtkTreeModel` rows that this context was requested
     * for using gtk_cell_area_get_preferred_width().
     */
    readonly minimumWidth: number
    /**
     * The natural height for the `GtkCellArea` in this context
     * for all `GtkTreeModel` rows that this context was requested
     * for using gtk_cell_area_get_preferred_height().
     */
    readonly naturalHeight: number
    /**
     * The natural width for the `GtkCellArea` in this context
     * for all `GtkTreeModel` rows that this context was requested
     * for using gtk_cell_area_get_preferred_width().
     */
    readonly naturalWidth: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CellAreaContext

    // Has conflict: allocate(width: number, height: number): void
    /**
     * Fetches the current allocation size for `context`.
     *
     * If the context was not allocated in width or height, or if the
     * context was recently reset with gtk_cell_area_context_reset(),
     * the returned value will be -1.
     */
    getAllocation(): [/* width */ number, /* height */ number]
    /**
     * Fetches the `GtkCellArea` this `context` was created by.
     *
     * This is generally unneeded by layouting widgets; however,
     * it is important for the context implementation itself to
     * fetch information about the area it is being used for.
     *
     * For instance at `GtkCellAreaContextClass.allocate()` time
     * it’s important to know details about any cell spacing
     * that the `GtkCellArea` is configured with in order to
     * compute a proper allocation.
     * @returns the `GtkCellArea` this context was created by.
     */
    getArea(): CellArea
    /**
     * Gets the accumulative preferred height for all rows which have been
     * requested with this context.
     *
     * After gtk_cell_area_context_reset() is called and/or before ever
     * requesting the size of a `GtkCellArea`, the returned values are 0.
     */
    getPreferredHeight(): [
      /* minimumHeight */ number,
      /* naturalHeight */ number,
    ]
    // Has conflict: getPreferredHeightForWidth(width: number): [ /* minimumHeight */ number, /* naturalHeight */ number ]
    /**
     * Gets the accumulative preferred width for all rows which have been
     * requested with this context.
     *
     * After gtk_cell_area_context_reset() is called and/or before ever
     * requesting the size of a `GtkCellArea`, the returned values are 0.
     */
    getPreferredWidth(): [/* minimumWidth */ number, /* naturalWidth */ number]
    // Has conflict: getPreferredWidthForHeight(height: number): [ /* minimumWidth */ number, /* naturalWidth */ number ]
    /**
     * Causes the minimum and/or natural height to grow if the new
     * proposed sizes exceed the current minimum and natural height.
     *
     * This is used by `GtkCellAreaContext` implementations during
     * the request process over a series of `GtkTreeModel` rows to
     * progressively push the requested height over a series of
     * gtk_cell_area_get_preferred_height() requests.
     * @param minimumHeight the proposed new minimum height for `context`
     * @param naturalHeight the proposed new natural height for `context`
     */
    pushPreferredHeight(minimumHeight: number, naturalHeight: number): void
    /**
     * Causes the minimum and/or natural width to grow if the new
     * proposed sizes exceed the current minimum and natural width.
     *
     * This is used by `GtkCellAreaContext` implementations during
     * the request process over a series of `GtkTreeModel` rows to
     * progressively push the requested width over a series of
     * gtk_cell_area_get_preferred_width() requests.
     * @param minimumWidth the proposed new minimum width for `context`
     * @param naturalWidth the proposed new natural width for `context`
     */
    pushPreferredWidth(minimumWidth: number, naturalWidth: number): void
    // Has conflict: reset(): void

    // Own virtual methods of Gtk-4.0.Gtk.CellAreaContext

    /**
     * Allocates a width and/or a height for all rows which are to be
     * rendered with `context`.
     *
     * Usually allocation is performed only horizontally or sometimes
     * vertically since a group of rows are usually rendered side by
     * side vertically or horizontally and share either the same width
     * or the same height. Sometimes they are allocated in both horizontal
     * and vertical orientations producing a homogeneous effect of the
     * rows. This is generally the case for `GtkTreeView` when
     * `GtkTreeView:fixed-height-mode` is enabled.
     * @virtual
     * @param width the allocated width for all `GtkTreeModel` rows rendered   with `context,` or -1
     * @param height the allocated height for all `GtkTreeModel` rows rendered   with `context,` or -1
     */
    allocate(width: number, height: number): void
    /**
     * Gets the accumulative preferred height for `width` for all rows
     * which have been requested for the same said `width` with this context.
     *
     * After gtk_cell_area_context_reset() is called and/or before ever
     * requesting the size of a `GtkCellArea`, the returned values are -1.
     * @virtual
     * @param width a proposed width for allocation
     */
    getPreferredHeightForWidth(
      width: number
    ): [/* minimumHeight */ number, /* naturalHeight */ number]
    /**
     * Gets the accumulative preferred width for `height` for all rows which
     * have been requested for the same said `height` with this context.
     *
     * After gtk_cell_area_context_reset() is called and/or before ever
     * requesting the size of a `GtkCellArea`, the returned values are -1.
     * @virtual
     * @param height a proposed height for allocation
     */
    getPreferredWidthForHeight(
      height: number
    ): [/* minimumWidth */ number, /* naturalWidth */ number]
    /**
     * Resets any previously cached request and allocation
     * data.
     *
     * When underlying `GtkTreeModel` data changes its
     * important to reset the context if the content
     * size is allowed to shrink. If the content size
     * is only allowed to grow (this is usually an option
     * for views rendering large data stores as a measure
     * of optimization), then only the row that changed
     * or was inserted needs to be (re)requested with
     * gtk_cell_area_get_preferred_width().
     *
     * When the new overall size of the context requires
     * that the allocated size changes (or whenever this
     * allocation changes at all), the variable row
     * sizes need to be re-requested for every row.
     *
     * For instance, if the rows are displayed all with
     * the same width from top to bottom then a change
     * in the allocated width necessitates a recalculation
     * of all the displayed row heights using
     * gtk_cell_area_get_preferred_height_for_width().
     * @virtual
     */
    reset(): void

    // Class property signals of Gtk-4.0.Gtk.CellAreaContext

    connect(sigName: "notify::area", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::area",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::area", ...args: any[]): void
    connect(
      sigName: "notify::minimum-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::minimum-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::minimum-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::minimum-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::minimum-height", ...args: any[]): void
    connect(
      sigName: "notify::minimum-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::minimum-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::minimum-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::minimum-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::minimum-width", ...args: any[]): void
    connect(
      sigName: "notify::natural-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::natural-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::natural-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::natural-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::natural-height", ...args: any[]): void
    connect(
      sigName: "notify::natural-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::natural-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::natural-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::natural-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::natural-width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Stores geometrical information for a series of rows in a GtkCellArea
   *
   * The `GtkCellAreaContext` object is created by a given `GtkCellArea`
   * implementation via its `GtkCellAreaClass.create_context()` virtual
   * method and is used to store cell sizes and alignments for a series of
   * `GtkTreeModel` rows that are requested and rendered in the same context.
   *
   * `GtkCellLayout` widgets can create any number of contexts in which to
   * request and render groups of data rows. However, it’s important that the
   * same context which was used to request sizes for a given `GtkTreeModel`
   * row also be used for the same row when calling other `GtkCellArea` APIs
   * such as gtk_cell_area_render() and gtk_cell_area_event().
   * @class
   */
  class CellAreaContext extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.CellAreaContext

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellAreaContext

    constructor(config?: CellAreaContext.ConstructorProperties)
    _init(config?: CellAreaContext.ConstructorProperties): void
  }

  module CellRenderer {
    // Signal callback interfaces

    /**
     * Signal callback interface for `editing-canceled`
     */
    interface EditingCanceledSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `editing-started`
     */
    interface EditingStartedSignalCallback {
      (editable: CellEditable, path: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.InitiallyUnowned.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRenderer

      cell_background?: string | null
      /**
       * Cell background as a `GdkRGBA`
       */
      cell_background_rgba?: Gdk.RGBA | null
      cell_background_set?: boolean | null
      height?: number | null
      is_expanded?: boolean | null
      is_expander?: boolean | null
      mode?: CellRendererMode | null
      sensitive?: boolean | null
      visible?: boolean | null
      width?: number | null
      xalign?: number | null
      xpad?: number | null
      yalign?: number | null
      ypad?: number | null
    }
  }

  interface CellRenderer {
    // Own properties of Gtk-4.0.Gtk.CellRenderer

    cellBackground: string | null
    /**
     * Cell background as a `GdkRGBA`
     */
    cellBackgroundRgba: Gdk.RGBA
    cellBackgroundSet: boolean
    readonly editing: boolean
    height: number
    isExpanded: boolean
    isExpander: boolean
    mode: CellRendererMode
    sensitive: boolean
    visible: boolean
    width: number
    xalign: number
    xpad: number
    yalign: number
    ypad: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.CellRenderer

    parentInstance: GObject.InitiallyUnowned

    // Owm methods of Gtk-4.0.Gtk.CellRenderer

    // Has conflict: activate(event: Gdk.Event, widget: Widget, path: string, backgroundArea: Gdk.Rectangle, cellArea: Gdk.Rectangle, flags: CellRendererState): boolean
    // Has conflict: getAlignedArea(widget: Widget, flags: CellRendererState, cellArea: Gdk.Rectangle): /* alignedArea */ Gdk.Rectangle
    /**
     * Fills in `xalign` and `yalign` with the appropriate values of `cell`.
     */
    getAlignment(): [/* xalign */ number, /* yalign */ number]
    /**
     * Fills in `width` and `height` with the appropriate size of `cell`.
     */
    getFixedSize(): [/* width */ number, /* height */ number]
    /**
     * Checks whether the given `GtkCellRenderer` is expanded.
     * @returns %TRUE if the cell renderer is expanded
     */
    getIsExpanded(): boolean
    /**
     * Checks whether the given `GtkCellRenderer` is an expander.
     * @returns %TRUE if @cell is an expander, and %FALSE otherwise
     */
    getIsExpander(): boolean
    /**
     * Fills in `xpad` and `ypad` with the appropriate values of `cell`.
     */
    getPadding(): [/* xpad */ number, /* ypad */ number]
    // Has conflict: getPreferredHeight(widget: Widget): [ /* minimumSize */ number, /* naturalSize */ number ]
    // Has conflict: getPreferredHeightForWidth(widget: Widget, width: number): [ /* minimumHeight */ number, /* naturalHeight */ number ]
    /**
     * Retrieves the minimum and natural size of a cell taking
     * into account the widget’s preference for height-for-width management.
     * @param widget the `GtkWidget` this cell will be rendering to
     */
    getPreferredSize(
      widget: Widget
    ): [/* minimumSize */ Requisition, /* naturalSize */ Requisition]
    // Has conflict: getPreferredWidth(widget: Widget): [ /* minimumSize */ number, /* naturalSize */ number ]
    // Has conflict: getPreferredWidthForHeight(widget: Widget, height: number): [ /* minimumWidth */ number, /* naturalWidth */ number ]
    // Has conflict: getRequestMode(): SizeRequestMode
    /**
     * Returns the cell renderer’s sensitivity.
     * @returns %TRUE if the cell renderer is sensitive
     */
    getSensitive(): boolean
    /**
     * Translates the cell renderer state to `GtkStateFlags`,
     * based on the cell renderer and widget sensitivity, and
     * the given `GtkCellRenderer`State.
     * @param widget a `GtkWidget`
     * @param cellState cell renderer state
     * @returns the widget state flags applying to @cell
     */
    getState(widget: Widget | null, cellState: CellRendererState): StateFlags
    /**
     * Returns the cell renderer’s visibility.
     * @returns %TRUE if the cell renderer is visible
     */
    getVisible(): boolean
    /**
     * Checks whether the cell renderer can do something when activated.
     * @returns %TRUE if the cell renderer can do anything when activated
     */
    isActivatable(): boolean
    /**
     * Sets the renderer’s alignment within its available space.
     * @param xalign the x alignment of the cell renderer
     * @param yalign the y alignment of the cell renderer
     */
    setAlignment(xalign: number, yalign: number): void
    /**
     * Sets the renderer size to be explicit, independent of the properties set.
     * @param width the width of the cell renderer, or -1
     * @param height the height of the cell renderer, or -1
     */
    setFixedSize(width: number, height: number): void
    /**
     * Sets whether the given `GtkCellRenderer` is expanded.
     * @param isExpanded whether `cell` should be expanded
     */
    setIsExpanded(isExpanded: boolean): void
    /**
     * Sets whether the given `GtkCellRenderer` is an expander.
     * @param isExpander whether `cell` is an expander
     */
    setIsExpander(isExpander: boolean): void
    /**
     * Sets the renderer’s padding.
     * @param xpad the x padding of the cell renderer
     * @param ypad the y padding of the cell renderer
     */
    setPadding(xpad: number, ypad: number): void
    /**
     * Sets the cell renderer’s sensitivity.
     * @param sensitive the sensitivity of the cell
     */
    setSensitive(sensitive: boolean): void
    /**
     * Sets the cell renderer’s visibility.
     * @param visible the visibility of the cell
     */
    setVisible(visible: boolean): void
    // Has conflict: snapshot(snapshot: Snapshot, widget: Widget, backgroundArea: Gdk.Rectangle, cellArea: Gdk.Rectangle, flags: CellRendererState): void
    // Has conflict: startEditing(event: Gdk.Event | null, widget: Widget, path: string, backgroundArea: Gdk.Rectangle, cellArea: Gdk.Rectangle, flags: CellRendererState): CellEditable | null
    /**
     * Informs the cell renderer that the editing is stopped.
     * If `canceled` is %TRUE, the cell renderer will emit the
     * `GtkCellRenderer`::editing-canceled signal.
     *
     * This function should be called by cell renderer implementations
     * in response to the `GtkCellEditable::editing-done` signal of
     * `GtkCellEditable`.
     * @param canceled %TRUE if the editing has been canceled
     */
    stopEditing(canceled: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.CellRenderer

    /**
     * Passes an activate event to the cell renderer for possible processing.
     * Some cell renderers may use events; for example, `GtkCellRendererToggle`
     * toggles when it gets a mouse click.
     * @virtual
     * @param event a `GdkEvent`
     * @param widget widget that received the event
     * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
     * @param backgroundArea background area as passed to gtk_cell_renderer_render()
     * @param cellArea cell area as passed to gtk_cell_renderer_render()
     * @param flags render flags
     * @returns %TRUE if the event was consumed/handled
     */
    activate(
      event: Gdk.Event,
      widget: Widget,
      path: string,
      backgroundArea: Gdk.Rectangle,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ): boolean
    /**
     * Signal gets emitted when the user cancels the process of editing a cell.
     * @virtual
     */
    editingCanceled(): void
    /**
     * Signal gets emitted when a cell starts to be edited.
     * @virtual
     * @param editable
     * @param path
     */
    editingStarted(editable: CellEditable, path: string): void
    /**
     * Gets the aligned area used by `cell` inside `cell_area`. Used for finding
     * the appropriate edit and focus rectangle.
     * @virtual
     * @param widget the `GtkWidget` this cell will be rendering to
     * @param flags render flags
     * @param cellArea cell area which would be passed to gtk_cell_renderer_render()
     */
    getAlignedArea(
      widget: Widget,
      flags: CellRendererState,
      cellArea: Gdk.Rectangle
    ): /* alignedArea */ Gdk.Rectangle
    /**
     * Retrieves a renderer’s natural size when rendered to `widget`.
     * @virtual
     * @param widget the `GtkWidget` this cell will be rendering to
     */
    getPreferredHeight(
      widget: Widget
    ): [/* minimumSize */ number, /* naturalSize */ number]
    /**
     * Retrieves a cell renderers’s minimum and natural height if it were rendered to
     * `widget` with the specified `width`.
     * @virtual
     * @param widget the `GtkWidget` this cell will be rendering to
     * @param width the size which is available for allocation
     */
    getPreferredHeightForWidth(
      widget: Widget,
      width: number
    ): [/* minimumHeight */ number, /* naturalHeight */ number]
    /**
     * Retrieves a renderer’s natural size when rendered to `widget`.
     * @virtual
     * @param widget the `GtkWidget` this cell will be rendering to
     */
    getPreferredWidth(
      widget: Widget
    ): [/* minimumSize */ number, /* naturalSize */ number]
    /**
     * Retrieves a cell renderers’s minimum and natural width if it were rendered to
     * `widget` with the specified `height`.
     * @virtual
     * @param widget the `GtkWidget` this cell will be rendering to
     * @param height the size which is available for allocation
     */
    getPreferredWidthForHeight(
      widget: Widget,
      height: number
    ): [/* minimumWidth */ number, /* naturalWidth */ number]
    /**
     * Gets whether the cell renderer prefers a height-for-width layout
     * or a width-for-height layout.
     * @virtual
     * @returns The `GtkSizeRequestMode` preferred by this renderer.
     */
    getRequestMode(): SizeRequestMode
    /**
     * Invokes the virtual render function of the `GtkCellRenderer`. The three
     * passed-in rectangles are areas in `cr`. Most renderers will draw within
     * `cell_area;` the xalign, yalign, xpad, and ypad fields of the `GtkCellRenderer`
     * should be honored with respect to `cell_area`. `background_area` includes the
     * blank space around the cell, and also the area containing the tree expander;
     * so the `background_area` rectangles for all cells tile to cover the entire
     * `window`.
     * @virtual
     * @param snapshot a `GtkSnapshot` to draw to
     * @param widget the widget owning `window`
     * @param backgroundArea entire cell area (including tree expanders and maybe    padding on the sides)
     * @param cellArea area normally rendered by a cell renderer
     * @param flags flags that affect rendering
     */
    snapshot(
      snapshot: Snapshot,
      widget: Widget,
      backgroundArea: Gdk.Rectangle,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ): void
    /**
     * Starts editing the contents of this `cell,` through a new `GtkCellEditable`
     * widget created by the `GtkCellRenderer`Class.start_editing virtual function.
     * @virtual
     * @param event a `GdkEvent`
     * @param widget widget that received the event
     * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
     * @param backgroundArea background area as passed to gtk_cell_renderer_render()
     * @param cellArea cell area as passed to gtk_cell_renderer_render()
     * @param flags render flags
     * @returns A new `GtkCellEditable` for editing this   @cell, or %NULL if editing is not possible
     */
    startEditing(
      event: Gdk.Event | null,
      widget: Widget,
      path: string,
      backgroundArea: Gdk.Rectangle,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ): CellEditable | null

    // Own signals of Gtk-4.0.Gtk.CellRenderer

    connect(
      sigName: "editing-canceled",
      callback: CellRenderer.EditingCanceledSignalCallback
    ): number
    on(
      sigName: "editing-canceled",
      callback: CellRenderer.EditingCanceledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "editing-canceled",
      callback: CellRenderer.EditingCanceledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "editing-canceled",
      callback: CellRenderer.EditingCanceledSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "editing-canceled", ...args: any[]): void
    connect(
      sigName: "editing-started",
      callback: CellRenderer.EditingStartedSignalCallback
    ): number
    on(
      sigName: "editing-started",
      callback: CellRenderer.EditingStartedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "editing-started",
      callback: CellRenderer.EditingStartedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "editing-started",
      callback: CellRenderer.EditingStartedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "editing-started", path: string | null, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.CellRenderer

    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * An object for rendering a single cell
   *
   * The `GtkCellRenderer` is a base class of a set of objects used for
   * rendering a cell to a `cairo_t`.  These objects are used primarily by
   * the `GtkTreeView` widget, though they aren’t tied to them in any
   * specific way.  It is worth noting that `GtkCellRenderer` is not a
   * `GtkWidget` and cannot be treated as such.
   *
   * The primary use of a `GtkCellRenderer` is for drawing a certain graphical
   * elements on a `cairo_t`. Typically, one cell renderer is used to
   * draw many cells on the screen.  To this extent, it isn’t expected that a
   * CellRenderer keep any permanent state around.  Instead, any state is set
   * just prior to use using `GObject`s property system.  Then, the
   * cell is measured using gtk_cell_renderer_get_preferred_size(). Finally, the cell
   * is rendered in the correct location using gtk_cell_renderer_snapshot().
   *
   * There are a number of rules that must be followed when writing a new
   * `GtkCellRenderer`.  First and foremost, it’s important that a certain set
   * of properties will always yield a cell renderer of the same size,
   * barring a style change. The `GtkCellRenderer` also has a number of
   * generic properties that are expected to be honored by all children.
   *
   * Beyond merely rendering a cell, cell renderers can optionally
   * provide active user interface elements. A cell renderer can be
   * “activatable” like `GtkCellRenderer`Toggle,
   * which toggles when it gets activated by a mouse click, or it can be
   * “editable” like `GtkCellRenderer`Text, which
   * allows the user to edit the text using a widget implementing the
   * `GtkCellEditable` interface, e.g. `GtkEntry`.
   * To make a cell renderer activatable or editable, you have to
   * implement the `GtkCellRenderer`Class.activate or
   * `GtkCellRenderer`Class.start_editing virtual functions, respectively.
   *
   * Many properties of `GtkCellRenderer` and its subclasses have a
   * corresponding “set” property, e.g. “cell-background-set” corresponds
   * to “cell-background”. These “set” properties reflect whether a property
   * has been set or not. You should not set them independently.
   * @class
   */
  class CellRenderer extends GObject.InitiallyUnowned {
    // Own properties of Gtk-4.0.Gtk.CellRenderer

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRenderer

    constructor(config?: CellRenderer.ConstructorProperties)
    _init(config?: CellRenderer.ConstructorProperties): void
  }

  module CellRendererAccel {
    // Signal callback interfaces

    /**
     * Signal callback interface for `accel-cleared`
     */
    interface AccelClearedSignalCallback {
      (pathString: string | null): void
    }

    /**
     * Signal callback interface for `accel-edited`
     */
    interface AccelEditedSignalCallback {
      (
        pathString: string | null,
        accelKey: number,
        accelMods: Gdk.ModifierType,
        hardwareKeycode: number
      ): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends CellRendererText.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRendererAccel

      /**
       * The keyval of the accelerator.
       */
      accel_key?: number | null
      /**
       * Determines if the edited accelerators are GTK accelerators. If
       * they are, consumed modifiers are suppressed, only accelerators
       * accepted by GTK are allowed, and the accelerators are rendered
       * in the same way as they are in menus.
       */
      accel_mode?: CellRendererAccelMode | null
      /**
       * The modifier mask of the accelerator.
       */
      accel_mods?: Gdk.ModifierType | null
      /**
       * The hardware keycode of the accelerator. Note that the hardware keycode is
       * only relevant if the key does not have a keyval. Normally, the keyboard
       * configuration should assign keyvals to all keys.
       */
      keycode?: number | null
    }
  }

  interface CellRendererAccel {
    // Own properties of Gtk-4.0.Gtk.CellRendererAccel

    /**
     * The keyval of the accelerator.
     */
    accelKey: number
    /**
     * Determines if the edited accelerators are GTK accelerators. If
     * they are, consumed modifiers are suppressed, only accelerators
     * accepted by GTK are allowed, and the accelerators are rendered
     * in the same way as they are in menus.
     */
    accelMode: CellRendererAccelMode
    /**
     * The modifier mask of the accelerator.
     */
    accelMods: Gdk.ModifierType
    /**
     * The hardware keycode of the accelerator. Note that the hardware keycode is
     * only relevant if the key does not have a keyval. Normally, the keyboard
     * configuration should assign keyvals to all keys.
     */
    keycode: number
    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.CellRendererAccel

    connect(
      sigName: "accel-cleared",
      callback: CellRendererAccel.AccelClearedSignalCallback
    ): number
    on(
      sigName: "accel-cleared",
      callback: CellRendererAccel.AccelClearedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "accel-cleared",
      callback: CellRendererAccel.AccelClearedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "accel-cleared",
      callback: CellRendererAccel.AccelClearedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "accel-cleared", ...args: any[]): void
    connect(
      sigName: "accel-edited",
      callback: CellRendererAccel.AccelEditedSignalCallback
    ): number
    on(
      sigName: "accel-edited",
      callback: CellRendererAccel.AccelEditedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "accel-edited",
      callback: CellRendererAccel.AccelEditedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "accel-edited",
      callback: CellRendererAccel.AccelEditedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "accel-edited",
      accelKey: number,
      accelMods: Gdk.ModifierType,
      hardwareKeycode: number,
      ...args: any[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.CellRendererAccel

    connect(
      sigName: "notify::accel-key",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accel-key",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accel-key",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accel-key",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accel-key", ...args: any[]): void
    connect(
      sigName: "notify::accel-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accel-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accel-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accel-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accel-mode", ...args: any[]): void
    connect(
      sigName: "notify::accel-mods",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accel-mods",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accel-mods",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accel-mods",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accel-mods", ...args: any[]): void
    connect(
      sigName: "notify::keycode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::keycode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::keycode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::keycode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::keycode", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::align-set", ...args: any[]): void
    connect(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::alignment", ...args: any[]): void
    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background", ...args: any[]): void
    connect(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-set", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable-set", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize-set", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family-set", ...args: any[]): void
    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground", ...args: any[]): void
    connect(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-rgba", ...args: any[]): void
    connect(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-set", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language-set", ...args: any[]): void
    connect(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::markup", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::placeholder-text", ...args: any[]): void
    connect(sigName: "notify::rise", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise", ...args: any[]): void
    connect(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise-set", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-set", ...args: any[]): void
    connect(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::single-paragraph-mode", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-points", ...args: any[]): void
    connect(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-set", ...args: any[]): void
    connect(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch", ...args: any[]): void
    connect(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch-set", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough-set", ...args: any[]): void
    connect(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style", ...args: any[]): void
    connect(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style-set", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline", ...args: any[]): void
    connect(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline-set", ...args: any[]): void
    connect(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant", ...args: any[]): void
    connect(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant-set", ...args: any[]): void
    connect(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight", ...args: any[]): void
    connect(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight-set", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-width", ...args: any[]): void
    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Renders a keyboard accelerator in a cell
   *
   * `GtkCellRendererAccel` displays a keyboard accelerator (i.e. a key
   * combination like `Control + a`). If the cell renderer is editable,
   * the accelerator can be changed by simply typing the new combination.
   * @class
   */
  class CellRendererAccel extends CellRendererText {
    // Own properties of Gtk-4.0.Gtk.CellRendererAccel

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRendererAccel

    constructor(config?: CellRendererAccel.ConstructorProperties)
    /**
     * Creates a new `GtkCellRendererAccel`.
     * @constructor
     * @returns the new cell renderer
     */
    constructor()
    /**
     * Creates a new `GtkCellRendererAccel`.
     * @constructor
     * @returns the new cell renderer
     */
    static new(): CellRendererAccel
    _init(config?: CellRendererAccel.ConstructorProperties): void
  }

  module CellRendererCombo {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (pathString: string | null, newIter: TreeIter): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends CellRendererText.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRendererCombo

      /**
       * If %TRUE, the cell renderer will include an entry and allow to enter
       * values other than the ones in the popup list.
       */
      has_entry?: boolean | null
      /**
       * Holds a tree model containing the possible values for the combo box.
       * Use the text_column property to specify the column holding the values.
       */
      model?: TreeModel | null
      /**
       * Specifies the model column which holds the possible values for the
       * combo box.
       *
       * Note that this refers to the model specified in the model property,
       * not the model backing the tree view to which
       * this cell renderer is attached.
       *
       * `GtkCellRendererCombo` automatically adds a text cell renderer for
       * this column to its combo box.
       */
      text_column?: number | null
    }
  }

  interface CellRendererCombo {
    // Own properties of Gtk-4.0.Gtk.CellRendererCombo

    /**
     * If %TRUE, the cell renderer will include an entry and allow to enter
     * values other than the ones in the popup list.
     */
    hasEntry: boolean
    /**
     * Holds a tree model containing the possible values for the combo box.
     * Use the text_column property to specify the column holding the values.
     */
    model: TreeModel
    /**
     * Specifies the model column which holds the possible values for the
     * combo box.
     *
     * Note that this refers to the model specified in the model property,
     * not the model backing the tree view to which
     * this cell renderer is attached.
     *
     * `GtkCellRendererCombo` automatically adds a text cell renderer for
     * this column to its combo box.
     */
    textColumn: number
    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.CellRendererCombo

    connect(
      sigName: "changed",
      callback: CellRendererCombo.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: CellRendererCombo.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: CellRendererCombo.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: CellRendererCombo.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", newIter: TreeIter, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.CellRendererCombo

    connect(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-entry", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-column", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::align-set", ...args: any[]): void
    connect(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::alignment", ...args: any[]): void
    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background", ...args: any[]): void
    connect(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-set", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable-set", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize-set", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family-set", ...args: any[]): void
    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground", ...args: any[]): void
    connect(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-rgba", ...args: any[]): void
    connect(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-set", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language-set", ...args: any[]): void
    connect(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::markup", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::placeholder-text", ...args: any[]): void
    connect(sigName: "notify::rise", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise", ...args: any[]): void
    connect(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise-set", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-set", ...args: any[]): void
    connect(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::single-paragraph-mode", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-points", ...args: any[]): void
    connect(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-set", ...args: any[]): void
    connect(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch", ...args: any[]): void
    connect(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch-set", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough-set", ...args: any[]): void
    connect(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style", ...args: any[]): void
    connect(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style-set", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline", ...args: any[]): void
    connect(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline-set", ...args: any[]): void
    connect(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant", ...args: any[]): void
    connect(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant-set", ...args: any[]): void
    connect(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight", ...args: any[]): void
    connect(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight-set", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-width", ...args: any[]): void
    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Renders a combobox in a cell
   *
   * `GtkCellRendererCombo` renders text in a cell like `GtkCellRendererText` from
   * which it is derived. But while `GtkCellRendererText` offers a simple entry to
   * edit the text, `GtkCellRendererCombo` offers a `GtkComboBox`
   * widget to edit the text. The values to display in the combo box are taken from
   * the tree model specified in the `GtkCellRendererCombo`:model property.
   *
   * The combo cell renderer takes care of adding a text cell renderer to the combo
   * box and sets it to display the column specified by its
   * `GtkCellRendererCombo`:text-column property. Further properties of the combo box
   * can be set in a handler for the `GtkCellRenderer::editing-started` signal.
   * @class
   */
  class CellRendererCombo extends CellRendererText {
    // Own properties of Gtk-4.0.Gtk.CellRendererCombo

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRendererCombo

    constructor(config?: CellRendererCombo.ConstructorProperties)
    /**
     * Creates a new `GtkCellRendererCombo`.
     * Adjust how text is drawn using object properties.
     * Object properties can be set globally (with g_object_set()).
     * Also, with `GtkTreeViewColumn`, you can bind a property to a value
     * in a `GtkTreeModel`. For example, you can bind the “text” property
     * on the cell renderer to a string value in the model, thus rendering
     * a different string in each row of the `GtkTreeView`.
     * @constructor
     * @returns the new cell renderer
     */
    constructor()
    /**
     * Creates a new `GtkCellRendererCombo`.
     * Adjust how text is drawn using object properties.
     * Object properties can be set globally (with g_object_set()).
     * Also, with `GtkTreeViewColumn`, you can bind a property to a value
     * in a `GtkTreeModel`. For example, you can bind the “text” property
     * on the cell renderer to a string value in the model, thus rendering
     * a different string in each row of the `GtkTreeView`.
     * @constructor
     * @returns the new cell renderer
     */
    static new(): CellRendererCombo
    _init(config?: CellRendererCombo.ConstructorProperties): void
  }

  module CellRendererPixbuf {
    // Constructor properties interface

    interface ConstructorProperties extends CellRenderer.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRendererPixbuf

      /**
       * The GIcon representing the icon to display.
       * If the icon theme is changed, the image will be updated
       * automatically.
       */
      gicon?: Gio.Icon | null
      /**
       * The name of the themed icon to display.
       * This property only has an effect if not overridden by the "pixbuf" property.
       */
      icon_name?: string | null
      /**
       * The `GtkIconSize` value that specifies the size of the rendered icon.
       */
      icon_size?: IconSize | null
      pixbuf?: GdkPixbuf.Pixbuf | null
      pixbuf_expander_closed?: GdkPixbuf.Pixbuf | null
      pixbuf_expander_open?: GdkPixbuf.Pixbuf | null
      texture?: Gdk.Texture | null
    }
  }

  interface CellRendererPixbuf {
    // Own properties of Gtk-4.0.Gtk.CellRendererPixbuf

    /**
     * The GIcon representing the icon to display.
     * If the icon theme is changed, the image will be updated
     * automatically.
     */
    gicon: Gio.Icon
    /**
     * The name of the themed icon to display.
     * This property only has an effect if not overridden by the "pixbuf" property.
     */
    iconName: string | null
    /**
     * The `GtkIconSize` value that specifies the size of the rendered icon.
     */
    iconSize: IconSize
    pixbuf: GdkPixbuf.Pixbuf
    pixbufExpanderClosed: GdkPixbuf.Pixbuf
    pixbufExpanderOpen: GdkPixbuf.Pixbuf
    texture: Gdk.Texture
    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.CellRendererPixbuf

    connect(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gicon", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::icon-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-size", ...args: any[]): void
    connect(
      sigName: "notify::pixbuf",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixbuf",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixbuf",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixbuf",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixbuf", ...args: any[]): void
    connect(
      sigName: "notify::pixbuf-expander-closed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixbuf-expander-closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixbuf-expander-closed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixbuf-expander-closed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixbuf-expander-closed", ...args: any[]): void
    connect(
      sigName: "notify::pixbuf-expander-open",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixbuf-expander-open",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixbuf-expander-open",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixbuf-expander-open",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixbuf-expander-open", ...args: any[]): void
    connect(
      sigName: "notify::texture",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::texture",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::texture",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::texture",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::texture", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Renders a pixbuf in a cell
   *
   * A `GtkCellRendererPixbuf` can be used to render an image in a cell. It allows
   * to render either a given `GdkPixbuf` (set via the
   * `GtkCellRendererPixbuf:pixbuf` property) or a named icon (set via the
   * `GtkCellRendererPixbuf:icon-name` property).
   *
   * To support the tree view, `GtkCellRendererPixbuf` also supports rendering two
   * alternative pixbufs, when the `GtkCellRenderer:is-expander` property is %TRUE.
   * If the `GtkCellRenderer:is-expanded property` is %TRUE and the
   * `GtkCellRendererPixbuf:pixbuf-expander-open` property is set to a pixbuf, it
   * renders that pixbuf, if the `GtkCellRenderer:is-expanded` property is %FALSE
   * and the `GtkCellRendererPixbuf:pixbuf-expander-closed` property is set to a
   * pixbuf, it renders that one.
   * @class
   */
  class CellRendererPixbuf extends CellRenderer {
    // Own properties of Gtk-4.0.Gtk.CellRendererPixbuf

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRendererPixbuf

    constructor(config?: CellRendererPixbuf.ConstructorProperties)
    /**
     * Creates a new `GtkCellRendererPixbuf`. Adjust rendering
     * parameters using object properties. Object properties can be set
     * globally (with g_object_set()). Also, with `GtkTreeViewColumn`, you
     * can bind a property to a value in a `GtkTreeModel`. For example, you
     * can bind the “pixbuf” property on the cell renderer to a pixbuf value
     * in the model, thus rendering a different image in each row of the
     * `GtkTreeView`.
     * @constructor
     * @returns the new cell renderer
     */
    constructor()
    /**
     * Creates a new `GtkCellRendererPixbuf`. Adjust rendering
     * parameters using object properties. Object properties can be set
     * globally (with g_object_set()). Also, with `GtkTreeViewColumn`, you
     * can bind a property to a value in a `GtkTreeModel`. For example, you
     * can bind the “pixbuf” property on the cell renderer to a pixbuf value
     * in the model, thus rendering a different image in each row of the
     * `GtkTreeView`.
     * @constructor
     * @returns the new cell renderer
     */
    static new(): CellRendererPixbuf
    _init(config?: CellRendererPixbuf.ConstructorProperties): void
  }

  module CellRendererProgress {
    // Constructor properties interface

    interface ConstructorProperties
      extends Orientable.ConstructorProperties,
        CellRenderer.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRendererProgress

      inverted?: boolean | null
      /**
       * Setting this to a non-negative value causes the cell renderer to
       * enter "activity mode", where a block bounces back and forth to
       * indicate that some progress is made, without specifying exactly how
       * much.
       *
       * Each increment of the property causes the block to move by a little
       * bit.
       *
       * To indicate that the activity has not started yet, set the property
       * to zero. To indicate completion, set the property to %G_MAXINT.
       */
      pulse?: number | null
      /**
       * The "text" property determines the label which will be drawn
       * over the progress bar. Setting this property to %NULL causes the default
       * label to be displayed. Setting this property to an empty string causes
       * no label to be displayed.
       */
      text?: string | null
      /**
       * The "text-xalign" property controls the horizontal alignment of the
       * text in the progress bar.  Valid values range from 0 (left) to 1
       * (right).  Reserved for RTL layouts.
       */
      text_xalign?: number | null
      /**
       * The "text-yalign" property controls the vertical alignment of the
       * text in the progress bar.  Valid values range from 0 (top) to 1
       * (bottom).
       */
      text_yalign?: number | null
      /**
       * The "value" property determines the percentage to which the
       * progress bar will be "filled in".
       */
      value?: number | null
    }
  }

  interface CellRendererProgress extends Orientable {
    // Own properties of Gtk-4.0.Gtk.CellRendererProgress

    inverted: boolean
    /**
     * Setting this to a non-negative value causes the cell renderer to
     * enter "activity mode", where a block bounces back and forth to
     * indicate that some progress is made, without specifying exactly how
     * much.
     *
     * Each increment of the property causes the block to move by a little
     * bit.
     *
     * To indicate that the activity has not started yet, set the property
     * to zero. To indicate completion, set the property to %G_MAXINT.
     */
    pulse: number
    /**
     * The "text" property determines the label which will be drawn
     * over the progress bar. Setting this property to %NULL causes the default
     * label to be displayed. Setting this property to an empty string causes
     * no label to be displayed.
     */
    text: string | null
    /**
     * The "text-xalign" property controls the horizontal alignment of the
     * text in the progress bar.  Valid values range from 0 (left) to 1
     * (right).  Reserved for RTL layouts.
     */
    textXalign: number
    /**
     * The "text-yalign" property controls the vertical alignment of the
     * text in the progress bar.  Valid values range from 0 (top) to 1
     * (bottom).
     */
    textYalign: number
    /**
     * The "value" property determines the percentage to which the
     * progress bar will be "filled in".
     */
    value: number
    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.CellRendererProgress

    connect(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inverted", ...args: any[]): void
    connect(
      sigName: "notify::pulse",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pulse",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pulse",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pulse",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pulse", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::text-xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-xalign", ...args: any[]): void
    connect(
      sigName: "notify::text-yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-yalign", ...args: any[]): void
    connect(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::value", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Renders numbers as progress bars
   *
   * `GtkCellRendererProgress` renders a numeric value as a progress par in a cell.
   * Additionally, it can display a text on top of the progress bar.
   * @class
   */
  class CellRendererProgress extends CellRenderer {
    // Own properties of Gtk-4.0.Gtk.CellRendererProgress

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRendererProgress

    constructor(config?: CellRendererProgress.ConstructorProperties)
    /**
     * Creates a new `GtkCellRendererProgress`.
     * @constructor
     * @returns the new cell renderer
     */
    constructor()
    /**
     * Creates a new `GtkCellRendererProgress`.
     * @constructor
     * @returns the new cell renderer
     */
    static new(): CellRendererProgress
    _init(config?: CellRendererProgress.ConstructorProperties): void
  }

  module CellRendererSpin {
    // Constructor properties interface

    interface ConstructorProperties
      extends CellRendererText.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRendererSpin

      /**
       * The adjustment that holds the value of the spinbutton.
       * This must be non-%NULL for the cell renderer to be editable.
       */
      adjustment?: Adjustment | null
      /**
       * The acceleration rate when you hold down a button.
       */
      climb_rate?: number | null
      /**
       * The number of decimal places to display.
       */
      digits?: number | null
    }
  }

  interface CellRendererSpin {
    // Own properties of Gtk-4.0.Gtk.CellRendererSpin

    /**
     * The adjustment that holds the value of the spinbutton.
     * This must be non-%NULL for the cell renderer to be editable.
     */
    adjustment: Adjustment
    /**
     * The acceleration rate when you hold down a button.
     */
    climbRate: number
    /**
     * The number of decimal places to display.
     */
    digits: number
    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.CellRendererSpin

    connect(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::adjustment", ...args: any[]): void
    connect(
      sigName: "notify::climb-rate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::climb-rate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::climb-rate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::climb-rate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::climb-rate", ...args: any[]): void
    connect(
      sigName: "notify::digits",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::digits",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::digits", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::align-set", ...args: any[]): void
    connect(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::alignment", ...args: any[]): void
    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background", ...args: any[]): void
    connect(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-set", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable-set", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize-set", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family-set", ...args: any[]): void
    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground", ...args: any[]): void
    connect(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-rgba", ...args: any[]): void
    connect(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-set", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language-set", ...args: any[]): void
    connect(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::markup", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::placeholder-text", ...args: any[]): void
    connect(sigName: "notify::rise", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise", ...args: any[]): void
    connect(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise-set", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-set", ...args: any[]): void
    connect(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::single-paragraph-mode", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-points", ...args: any[]): void
    connect(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-set", ...args: any[]): void
    connect(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch", ...args: any[]): void
    connect(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch-set", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough-set", ...args: any[]): void
    connect(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style", ...args: any[]): void
    connect(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style-set", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline", ...args: any[]): void
    connect(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline-set", ...args: any[]): void
    connect(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant", ...args: any[]): void
    connect(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant-set", ...args: any[]): void
    connect(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight", ...args: any[]): void
    connect(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight-set", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-width", ...args: any[]): void
    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Renders a spin button in a cell
   *
   * `GtkCellRendererSpin` renders text in a cell like `GtkCellRendererText` from
   * which it is derived. But while `GtkCellRendererText` offers a simple entry to
   * edit the text, `GtkCellRendererSpin` offers a `GtkSpinButton` widget. Of course,
   * that means that the text has to be parseable as a floating point number.
   *
   * The range of the spinbutton is taken from the adjustment property of the
   * cell renderer, which can be set explicitly or mapped to a column in the
   * tree model, like all properties of cell renders. `GtkCellRendererSpin`
   * also has properties for the `GtkCellRendererSpin:climb-rate` and the number
   * of `GtkCellRendererSpin:digits` to display. Other `GtkSpinButton` properties
   * can be set in a handler for the `GtkCellRenderer::editing-started` signal.
   * @class
   */
  class CellRendererSpin extends CellRendererText {
    // Own properties of Gtk-4.0.Gtk.CellRendererSpin

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRendererSpin

    constructor(config?: CellRendererSpin.ConstructorProperties)
    /**
     * Creates a new `GtkCellRendererSpin`.
     * @constructor
     * @returns a new `GtkCellRendererSpin`
     */
    constructor()
    /**
     * Creates a new `GtkCellRendererSpin`.
     * @constructor
     * @returns a new `GtkCellRendererSpin`
     */
    static new(): CellRendererSpin
    _init(config?: CellRendererSpin.ConstructorProperties): void
  }

  module CellRendererSpinner {
    // Constructor properties interface

    interface ConstructorProperties extends CellRenderer.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRendererSpinner

      active?: boolean | null
      /**
       * Pulse of the spinner. Increment this value to draw the next frame of the
       * spinner animation. Usually, you would update this value in a timeout.
       *
       * By default, the `GtkSpinner` widget draws one full cycle of the animation,
       * consisting of 12 frames, in 750 milliseconds.
       */
      pulse?: number | null
      /**
       * The `GtkIconSize` value that specifies the size of the rendered spinner.
       */
      size?: IconSize | null
    }
  }

  interface CellRendererSpinner {
    // Own properties of Gtk-4.0.Gtk.CellRendererSpinner

    active: boolean
    /**
     * Pulse of the spinner. Increment this value to draw the next frame of the
     * spinner animation. Usually, you would update this value in a timeout.
     *
     * By default, the `GtkSpinner` widget draws one full cycle of the animation,
     * consisting of 12 frames, in 750 milliseconds.
     */
    pulse: number
    /**
     * The `GtkIconSize` value that specifies the size of the rendered spinner.
     */
    size: IconSize
    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.CellRendererSpinner

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::pulse",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pulse",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pulse",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pulse",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pulse", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Renders a spinning animation in a cell
   *
   * `GtkCellRendererSpinner` renders a spinning animation in a cell, very
   * similar to `GtkSpinner`. It can often be used as an alternative
   * to a `GtkCellRendererProgress` for displaying indefinite activity,
   * instead of actual progress.
   *
   * To start the animation in a cell, set the `GtkCellRendererSpinner:active`
   * property to %TRUE and increment the `GtkCellRendererSpinner:pulse` property
   * at regular intervals. The usual way to set the cell renderer properties
   * for each cell is to bind them to columns in your tree model using e.g.
   * gtk_tree_view_column_add_attribute().
   * @class
   */
  class CellRendererSpinner extends CellRenderer {
    // Own properties of Gtk-4.0.Gtk.CellRendererSpinner

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRendererSpinner

    constructor(config?: CellRendererSpinner.ConstructorProperties)
    /**
     * Returns a new cell renderer which will show a spinner to indicate
     * activity.
     * @constructor
     * @returns a new `GtkCellRenderer`
     */
    constructor()
    /**
     * Returns a new cell renderer which will show a spinner to indicate
     * activity.
     * @constructor
     * @returns a new `GtkCellRenderer`
     */
    static new(): CellRendererSpinner
    _init(config?: CellRendererSpinner.ConstructorProperties): void
  }

  module CellRendererText {
    // Signal callback interfaces

    /**
     * Signal callback interface for `edited`
     */
    interface EditedSignalCallback {
      (path: string | null, newText: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties extends CellRenderer.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRendererText

      align_set?: boolean | null
      /**
       * Specifies how to align the lines of text with respect to each other.
       *
       * Note that this property describes how to align the lines of text in
       * case there are several of them. The "xalign" property of `GtkCellRenderer`,
       * on the other hand, sets the horizontal alignment of the whole text.
       */
      alignment?: Pango.Alignment | null
      attributes?: Pango.AttrList | null
      background?: string | null
      /**
       * Background color as a `GdkRGBA`
       */
      background_rgba?: Gdk.RGBA | null
      background_set?: boolean | null
      editable?: boolean | null
      editable_set?: boolean | null
      /**
       * Specifies the preferred place to ellipsize the string, if the cell renderer
       * does not have enough room to display the entire string. Setting it to
       * %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property
       * for another way of making the text fit into a given width.
       */
      ellipsize?: Pango.EllipsizeMode | null
      ellipsize_set?: boolean | null
      family?: string | null
      family_set?: boolean | null
      font?: string | null
      font_desc?: Pango.FontDescription | null
      foreground?: string | null
      /**
       * Foreground color as a `GdkRGBA`
       */
      foreground_rgba?: Gdk.RGBA | null
      foreground_set?: boolean | null
      language?: string | null
      language_set?: boolean | null
      markup?: string | null
      /**
       * The desired maximum width of the cell, in characters. If this property
       * is set to -1, the width will be calculated automatically.
       *
       * For cell renderers that ellipsize or wrap text; this property
       * controls the maximum reported width of the cell. The
       * cell should not receive any greater allocation unless it is
       * set to expand in its `GtkCellLayout` and all of the cell's siblings
       * have received their natural width.
       */
      max_width_chars?: number | null
      /**
       * The text that will be displayed in the `GtkCellRenderer` if
       * `GtkCellRendererText:editable` is %TRUE and the cell is empty.
       */
      placeholder_text?: string | null
      rise?: number | null
      rise_set?: boolean | null
      scale?: number | null
      scale_set?: boolean | null
      single_paragraph_mode?: boolean | null
      size?: number | null
      size_points?: number | null
      size_set?: boolean | null
      stretch?: Pango.Stretch | null
      stretch_set?: boolean | null
      strikethrough?: boolean | null
      strikethrough_set?: boolean | null
      style?: Pango.Style | null
      style_set?: boolean | null
      text?: string | null
      underline?: Pango.Underline | null
      underline_set?: boolean | null
      variant?: Pango.Variant | null
      variant_set?: boolean | null
      weight?: number | null
      weight_set?: boolean | null
      /**
       * The desired width of the cell, in characters. If this property is set to
       * -1, the width will be calculated automatically, otherwise the cell will
       * request either 3 characters or the property value, whichever is greater.
       */
      width_chars?: number | null
      /**
       * Specifies how to break the string into multiple lines, if the cell
       * renderer does not have enough room to display the entire string.
       * This property has no effect unless the wrap-width property is set.
       */
      wrap_mode?: Pango.WrapMode | null
      /**
       * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
       * be used to influence at what character positions the line breaks can be placed.
       * Setting wrap-width to -1 turns wrapping off.
       */
      wrap_width?: number | null
    }
  }

  interface CellRendererText {
    // Own properties of Gtk-4.0.Gtk.CellRendererText

    alignSet: boolean
    /**
     * Specifies how to align the lines of text with respect to each other.
     *
     * Note that this property describes how to align the lines of text in
     * case there are several of them. The "xalign" property of `GtkCellRenderer`,
     * on the other hand, sets the horizontal alignment of the whole text.
     */
    alignment: Pango.Alignment
    attributes: Pango.AttrList
    background: string | null
    /**
     * Background color as a `GdkRGBA`
     */
    backgroundRgba: Gdk.RGBA
    backgroundSet: boolean
    editable: boolean
    editableSet: boolean
    /**
     * Specifies the preferred place to ellipsize the string, if the cell renderer
     * does not have enough room to display the entire string. Setting it to
     * %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property
     * for another way of making the text fit into a given width.
     */
    ellipsize: Pango.EllipsizeMode
    ellipsizeSet: boolean
    family: string | null
    familySet: boolean
    font: string | null
    fontDesc: Pango.FontDescription
    foreground: string | null
    /**
     * Foreground color as a `GdkRGBA`
     */
    foregroundRgba: Gdk.RGBA
    foregroundSet: boolean
    language: string | null
    languageSet: boolean
    markup: string | null
    /**
     * The desired maximum width of the cell, in characters. If this property
     * is set to -1, the width will be calculated automatically.
     *
     * For cell renderers that ellipsize or wrap text; this property
     * controls the maximum reported width of the cell. The
     * cell should not receive any greater allocation unless it is
     * set to expand in its `GtkCellLayout` and all of the cell's siblings
     * have received their natural width.
     */
    maxWidthChars: number
    /**
     * The text that will be displayed in the `GtkCellRenderer` if
     * `GtkCellRendererText:editable` is %TRUE and the cell is empty.
     */
    placeholderText: string | null
    rise: number
    riseSet: boolean
    scale: number
    scaleSet: boolean
    singleParagraphMode: boolean
    size: number
    sizePoints: number
    sizeSet: boolean
    stretch: Pango.Stretch
    stretchSet: boolean
    strikethrough: boolean
    strikethroughSet: boolean
    style: Pango.Style
    styleSet: boolean
    text: string | null
    underline: Pango.Underline
    underlineSet: boolean
    variant: Pango.Variant
    variantSet: boolean
    weight: number
    weightSet: boolean
    /**
     * The desired width of the cell, in characters. If this property is set to
     * -1, the width will be calculated automatically, otherwise the cell will
     * request either 3 characters or the property value, whichever is greater.
     */
    widthChars: number
    /**
     * Specifies how to break the string into multiple lines, if the cell
     * renderer does not have enough room to display the entire string.
     * This property has no effect unless the wrap-width property is set.
     */
    wrapMode: Pango.WrapMode
    /**
     * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
     * be used to influence at what character positions the line breaks can be placed.
     * Setting wrap-width to -1 turns wrapping off.
     */
    wrapWidth: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.CellRendererText

    parent: CellRenderer

    // Owm methods of Gtk-4.0.Gtk.CellRendererText

    /**
     * Sets the height of a renderer to explicitly be determined by the “font” and
     * “y_pad” property set on it.  Further changes in these properties do not
     * affect the height, so they must be accompanied by a subsequent call to this
     * function.  Using this function is inflexible, and should really only be used
     * if calculating the size of a cell is too slow (ie, a massive number of cells
     * displayed).  If `number_of_rows` is -1, then the fixed height is unset, and
     * the height is determined by the properties again.
     * @param numberOfRows Number of rows of text each cell renderer is allocated, or -1
     */
    setFixedHeightFromFont(numberOfRows: number): void

    // Own virtual methods of Gtk-4.0.Gtk.CellRendererText

    edited(path: string, newText: string): void

    // Own signals of Gtk-4.0.Gtk.CellRendererText

    connect(
      sigName: "edited",
      callback: CellRendererText.EditedSignalCallback
    ): number
    on(
      sigName: "edited",
      callback: CellRendererText.EditedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "edited",
      callback: CellRendererText.EditedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "edited",
      callback: CellRendererText.EditedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "edited", newText: string | null, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.CellRendererText

    connect(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::align-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::align-set", ...args: any[]): void
    connect(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::alignment", ...args: any[]): void
    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background", ...args: any[]): void
    connect(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-set", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable-set", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize-set", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family-set", ...args: any[]): void
    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground", ...args: any[]): void
    connect(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-rgba", ...args: any[]): void
    connect(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-set", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language-set", ...args: any[]): void
    connect(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::markup", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::placeholder-text", ...args: any[]): void
    connect(sigName: "notify::rise", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise", ...args: any[]): void
    connect(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise-set", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-set", ...args: any[]): void
    connect(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::single-paragraph-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::single-paragraph-mode", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-points", ...args: any[]): void
    connect(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-set", ...args: any[]): void
    connect(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch", ...args: any[]): void
    connect(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch-set", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough-set", ...args: any[]): void
    connect(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style", ...args: any[]): void
    connect(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style-set", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline", ...args: any[]): void
    connect(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline-set", ...args: any[]): void
    connect(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant", ...args: any[]): void
    connect(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant-set", ...args: any[]): void
    connect(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight", ...args: any[]): void
    connect(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight-set", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Renders text in a cell
   *
   * A `GtkCellRendererText` renders a given text in its cell, using the font, color and
   * style information provided by its properties. The text will be ellipsized if it is
   * too long and the `GtkCellRendererText:ellipsize` property allows it.
   *
   * If the `GtkCellRenderer:mode` is %GTK_CELL_RENDERER_MODE_EDITABLE,
   * the `GtkCellRendererText` allows to edit its text using an entry.
   * @class
   */
  class CellRendererText extends CellRenderer {
    // Own properties of Gtk-4.0.Gtk.CellRendererText

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRendererText

    constructor(config?: CellRendererText.ConstructorProperties)
    /**
     * Creates a new `GtkCellRendererText`. Adjust how text is drawn using
     * object properties. Object properties can be
     * set globally (with g_object_set()). Also, with `GtkTreeViewColumn`,
     * you can bind a property to a value in a `GtkTreeModel`. For example,
     * you can bind the “text” property on the cell renderer to a string
     * value in the model, thus rendering a different string in each row
     * of the `GtkTreeView`.
     * @constructor
     * @returns the new cell renderer
     */
    constructor()
    /**
     * Creates a new `GtkCellRendererText`. Adjust how text is drawn using
     * object properties. Object properties can be
     * set globally (with g_object_set()). Also, with `GtkTreeViewColumn`,
     * you can bind a property to a value in a `GtkTreeModel`. For example,
     * you can bind the “text” property on the cell renderer to a string
     * value in the model, thus rendering a different string in each row
     * of the `GtkTreeView`.
     * @constructor
     * @returns the new cell renderer
     */
    static new(): CellRendererText
    _init(config?: CellRendererText.ConstructorProperties): void
  }

  module CellRendererToggle {
    // Signal callback interfaces

    /**
     * Signal callback interface for `toggled`
     */
    interface ToggledSignalCallback {
      (path: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties extends CellRenderer.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellRendererToggle

      activatable?: boolean | null
      active?: boolean | null
      inconsistent?: boolean | null
      radio?: boolean | null
    }
  }

  interface CellRendererToggle {
    // Own properties of Gtk-4.0.Gtk.CellRendererToggle

    activatable: boolean
    active: boolean
    inconsistent: boolean
    radio: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CellRendererToggle

    /**
     * Returns whether the cell renderer is activatable. See
     * gtk_cell_renderer_toggle_set_activatable().
     * @returns %TRUE if the cell renderer is activatable.
     */
    getActivatable(): boolean
    /**
     * Returns whether the cell renderer is active. See
     * gtk_cell_renderer_toggle_set_active().
     * @returns %TRUE if the cell renderer is active.
     */
    getActive(): boolean
    /**
     * Returns whether we’re rendering radio toggles rather than checkboxes.
     * @returns %TRUE if we’re rendering radio toggles rather than checkboxes
     */
    getRadio(): boolean
    /**
     * Makes the cell renderer activatable.
     * @param setting the value to set.
     */
    setActivatable(setting: boolean): void
    /**
     * Activates or deactivates a cell renderer.
     * @param setting the value to set.
     */
    setActive(setting: boolean): void
    /**
     * If `radio` is %TRUE, the cell renderer renders a radio toggle
     * (i.e. a toggle in a group of mutually-exclusive toggles).
     * If %FALSE, it renders a check toggle (a standalone boolean option).
     * This can be set globally for the cell renderer, or changed just
     * before rendering each cell in the model (for `GtkTreeView`, you set
     * up a per-row setting using `GtkTreeViewColumn` to associate model
     * columns with cell renderer properties).
     * @param radio %TRUE to make the toggle look like a radio button
     */
    setRadio(radio: boolean): void

    // Own signals of Gtk-4.0.Gtk.CellRendererToggle

    connect(
      sigName: "toggled",
      callback: CellRendererToggle.ToggledSignalCallback
    ): number
    on(
      sigName: "toggled",
      callback: CellRendererToggle.ToggledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggled",
      callback: CellRendererToggle.ToggledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggled",
      callback: CellRendererToggle.ToggledSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggled", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.CellRendererToggle

    connect(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activatable", ...args: any[]): void
    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::inconsistent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inconsistent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inconsistent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inconsistent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inconsistent", ...args: any[]): void
    connect(
      sigName: "notify::radio",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::radio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::radio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::radio",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::radio", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-background-set", ...args: any[]): void
    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expanded", ...args: any[]): void
    connect(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-expander", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: "notify::xpad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xpad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xpad", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(sigName: "notify::ypad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ypad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ypad", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Renders a toggle button in a cell
   *
   * `GtkCellRendererToggle` renders a toggle button in a cell. The
   * button is drawn as a radio or a checkbutton, depending on the
   * `GtkCellRendererToggle:radio` property.
   * When activated, it emits the `GtkCellRendererToggle::toggled` signal.
   * @class
   */
  class CellRendererToggle extends CellRenderer {
    // Own properties of Gtk-4.0.Gtk.CellRendererToggle

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellRendererToggle

    constructor(config?: CellRendererToggle.ConstructorProperties)
    /**
     * Creates a new `GtkCellRendererToggle`. Adjust rendering
     * parameters using object properties. Object properties can be set
     * globally (with g_object_set()). Also, with `GtkTreeViewColumn`, you
     * can bind a property to a value in a `GtkTreeModel`. For example, you
     * can bind the “active” property on the cell renderer to a boolean value
     * in the model, thus causing the check button to reflect the state of
     * the model.
     * @constructor
     * @returns the new cell renderer
     */
    constructor()
    /**
     * Creates a new `GtkCellRendererToggle`. Adjust rendering
     * parameters using object properties. Object properties can be set
     * globally (with g_object_set()). Also, with `GtkTreeViewColumn`, you
     * can bind a property to a value in a `GtkTreeModel`. For example, you
     * can bind the “active” property on the cell renderer to a boolean value
     * in the model, thus causing the check button to reflect the state of
     * the model.
     * @constructor
     * @returns the new cell renderer
     */
    static new(): CellRendererToggle
    _init(config?: CellRendererToggle.ConstructorProperties): void
  }

  module CellView {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        CellLayout.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CellView

      /**
       * The `GtkCellArea` rendering cells
       *
       * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
       * a horizontally oriented `GtkCellArea`Box will be used.
       *
       * since 3.0
       */
      cell_area?: CellArea | null
      /**
       * The `GtkCellAreaContext` used to compute the geometry of the cell view.
       *
       * A group of cell views can be assigned the same context in order to
       * ensure the sizes and cell alignments match across all the views with
       * the same context.
       *
       * `GtkComboBox` menus uses this to assign the same context to all cell views
       * in the menu items for a single menu (each submenu creates its own
       * context since the size of each submenu does not depend on parent
       * or sibling menus).
       *
       * since 3.0
       */
      cell_area_context?: CellAreaContext | null
      /**
       * Whether all cells should be draw as sensitive for this view regardless
       * of the actual cell properties (used to make menus with submenus appear
       * sensitive when the items in submenus might be insensitive).
       *
       * since 3.0
       */
      draw_sensitive?: boolean | null
      /**
       * Whether the view should request enough space to always fit
       * the size of every row in the model (used by the combo box to
       * ensure the combo box size doesn't change when different items
       * are selected).
       *
       * since 3.0
       */
      fit_model?: boolean | null
      /**
       * The model for cell view
       *
       * since 2.10
       */
      model?: TreeModel | null
    }
  }

  interface CellView
    extends Accessible,
      Buildable,
      CellLayout,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.CellView

    /**
     * The `GtkCellArea` rendering cells
     *
     * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
     * a horizontally oriented `GtkCellArea`Box will be used.
     *
     * since 3.0
     */
    readonly cellArea: CellArea
    /**
     * The `GtkCellAreaContext` used to compute the geometry of the cell view.
     *
     * A group of cell views can be assigned the same context in order to
     * ensure the sizes and cell alignments match across all the views with
     * the same context.
     *
     * `GtkComboBox` menus uses this to assign the same context to all cell views
     * in the menu items for a single menu (each submenu creates its own
     * context since the size of each submenu does not depend on parent
     * or sibling menus).
     *
     * since 3.0
     */
    readonly cellAreaContext: CellAreaContext
    /**
     * Whether all cells should be draw as sensitive for this view regardless
     * of the actual cell properties (used to make menus with submenus appear
     * sensitive when the items in submenus might be insensitive).
     *
     * since 3.0
     */
    drawSensitive: boolean
    /**
     * Whether the view should request enough space to always fit
     * the size of every row in the model (used by the combo box to
     * ensure the combo box size doesn't change when different items
     * are selected).
     *
     * since 3.0
     */
    fitModel: boolean
    /**
     * The model for cell view
     *
     * since 2.10
     */
    model: TreeModel
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CellView

    /**
     * Returns a `GtkTreePath` referring to the currently
     * displayed row. If no row is currently displayed,
     * %NULL is returned.
     * @returns the currently displayed row
     */
    getDisplayedRow(): TreePath | null
    /**
     * Gets whether `cell_view` is configured to draw all of its
     * cells in a sensitive state.
     * @returns whether @cell_view draws all of its cells in a sensitive state
     */
    getDrawSensitive(): boolean
    /**
     * Gets whether `cell_view` is configured to request space
     * to fit the entire `GtkTreeModel`.
     * @returns whether @cell_view requests space to fit the entire `GtkTreeModel`.
     */
    getFitModel(): boolean
    /**
     * Returns the model for `cell_view`. If no model is used %NULL is
     * returned.
     * @returns a `GtkTreeModel` used
     */
    getModel(): TreeModel | null
    /**
     * Sets the row of the model that is currently displayed
     * by the `GtkCellView`. If the path is unset, then the
     * contents of the cellview “stick” at their last value;
     * this is not normally a desired result, but may be
     * a needed intermediate state if say, the model for
     * the `GtkCellView` becomes temporarily empty.
     * @param path a `GtkTreePath` or %NULL to unset.
     */
    setDisplayedRow(path: TreePath | null): void
    /**
     * Sets whether `cell_view` should draw all of its
     * cells in a sensitive state, this is used by `GtkComboBox` menus
     * to ensure that rows with insensitive cells that contain
     * children appear sensitive in the parent menu item.
     * @param drawSensitive whether to draw all cells in a sensitive state.
     */
    setDrawSensitive(drawSensitive: boolean): void
    /**
     * Sets whether `cell_view` should request space to fit the entire `GtkTreeModel`.
     *
     * This is used by `GtkComboBox` to ensure that the cell view displayed on
     * the combo box’s button always gets enough space and does not resize
     * when selection changes.
     * @param fitModel whether `cell_view` should request space for the whole model.
     */
    setFitModel(fitModel: boolean): void
    /**
     * Sets the model for `cell_view`.  If `cell_view` already has a model
     * set, it will remove it before setting the new model.  If `model` is
     * %NULL, then it will unset the old model.
     * @param model a `GtkTreeModel`
     */
    setModel(model: TreeModel | null): void

    // Class property signals of Gtk-4.0.Gtk.CellView

    connect(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-area", ...args: any[]): void
    connect(
      sigName: "notify::cell-area-context",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-area-context",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-area-context",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-area-context",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-area-context", ...args: any[]): void
    connect(
      sigName: "notify::draw-sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::draw-sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::draw-sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::draw-sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::draw-sensitive", ...args: any[]): void
    connect(
      sigName: "notify::fit-model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fit-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fit-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fit-model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fit-model", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A widget displaying a single row of a GtkTreeModel
   *
   * A `GtkCellView` displays a single row of a `GtkTreeModel` using a `GtkCellArea`
   * and `GtkCellAreaContext`. A `GtkCellAreaContext` can be provided to the
   * `GtkCellView` at construction time in order to keep the cellview in context
   * of a group of cell views, this ensures that the renderers displayed will
   * be properly aligned with each other (like the aligned cells in the menus
   * of `GtkComboBox`).
   *
   * `GtkCellView` is `GtkOrientable` in order to decide in which orientation
   * the underlying `GtkCellAreaContext` should be allocated. Taking the `GtkComboBox`
   * menu as an example, cellviews should be oriented horizontally if the menus are
   * listed top-to-bottom and thus all share the same width but may have separate
   * individual heights (left-to-right menus should be allocated vertically since
   * they all share the same height but may have variable widths).
   *
   * ## CSS nodes
   *
   * GtkCellView has a single CSS node with name cellview.
   * @class
   */
  class CellView extends Widget {
    // Own properties of Gtk-4.0.Gtk.CellView

    static name: string

    // Constructors of Gtk-4.0.Gtk.CellView

    constructor(config?: CellView.ConstructorProperties)
    /**
     * Creates a new `GtkCellView` widget.
     * @constructor
     * @returns A newly created `GtkCellView` widget.
     */
    constructor()
    /**
     * Creates a new `GtkCellView` widget.
     * @constructor
     * @returns A newly created `GtkCellView` widget.
     */
    static new(): CellView
    /**
     * Creates a new `GtkCellView` widget with a specific `GtkCellArea`
     * to layout cells and a specific `GtkCellAreaContext`.
     *
     * Specifying the same context for a handful of cells lets
     * the underlying area synchronize the geometry for those cells,
     * in this way alignments with cellviews for other rows are
     * possible.
     * @constructor
     * @param area the `GtkCellArea` to layout cells
     * @param context the `GtkCellAreaContext` in which to calculate cell geometry
     * @returns A newly created `GtkCellView` widget.
     */
    static newWithContext(area: CellArea, context: CellAreaContext): CellView
    /**
     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererText`
     * to it, and makes it show `markup`. The text can be marked up with
     * the [Pango text markup language](https://docs.gtk.org/Pango/pango_markup.html).
     * @constructor
     * @param markup the text to display in the cell view
     * @returns A newly created `GtkCellView` widget.
     */
    static newWithMarkup(markup: string): CellView
    /**
     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererText`
     * to it, and makes it show `text`.
     * @constructor
     * @param text the text to display in the cell view
     * @returns A newly created `GtkCellView` widget.
     */
    static newWithText(text: string): CellView
    /**
     * Creates a new `GtkCellView` widget, adds a `GtkCellRendererPixbuf`
     * to it, and makes it show `texture`.
     * @constructor
     * @param texture the image to display in the cell view
     * @returns A newly created `GtkCellView` widget.
     */
    static newWithTexture(texture: Gdk.Texture): CellView
    _init(config?: CellView.ConstructorProperties): void
  }

  module CenterBox {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CenterBox

      /**
       * The position of the baseline aligned widget if extra space is available.
       */
      baseline_position?: BaselinePosition | null
      /**
       * The widget that is placed at the center position.
       */
      center_widget?: Widget | null
      /**
       * The widget that is placed at the end position.
       *
       * In vertical orientation, the end position is at the bottom.
       * In horizontal orientation, the end position is at the trailing
       * edge wrt. to the text direction.
       */
      end_widget?: Widget | null
      /**
       * Whether to shrink the center widget after other children.
       *
       * By default, when there's no space to give all three children their
       * natural widths, the start and end widgets start shrinking and the
       * center child keeps natural width until they reach minimum width.
       *
       * If set to `FALSE`, start and end widgets keep natural width and the
       * center widget starts shrinking instead.
       */
      shrink_center_last?: boolean | null
      /**
       * The widget that is placed at the start position.
       *
       * In vertical orientation, the start position is at the top.
       * In horizontal orientation, the start position is at the leading
       * edge wrt. to the text direction.
       */
      start_widget?: Widget | null
    }
  }

  interface CenterBox
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.CenterBox

    /**
     * The position of the baseline aligned widget if extra space is available.
     */
    baselinePosition: BaselinePosition
    /**
     * The widget that is placed at the center position.
     */
    centerWidget: Widget
    /**
     * The widget that is placed at the end position.
     *
     * In vertical orientation, the end position is at the bottom.
     * In horizontal orientation, the end position is at the trailing
     * edge wrt. to the text direction.
     */
    endWidget: Widget
    /**
     * Whether to shrink the center widget after other children.
     *
     * By default, when there's no space to give all three children their
     * natural widths, the start and end widgets start shrinking and the
     * center child keeps natural width until they reach minimum width.
     *
     * If set to `FALSE`, start and end widgets keep natural width and the
     * center widget starts shrinking instead.
     */
    shrinkCenterLast: boolean
    /**
     * The widget that is placed at the start position.
     *
     * In vertical orientation, the start position is at the top.
     * In horizontal orientation, the start position is at the leading
     * edge wrt. to the text direction.
     */
    startWidget: Widget
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CenterBox

    /**
     * Gets the value set by gtk_center_box_set_baseline_position().
     * @returns the baseline position
     */
    getBaselinePosition(): BaselinePosition
    /**
     * Gets the center widget, or %NULL if there is none.
     * @returns the center widget.
     */
    getCenterWidget(): Widget | null
    /**
     * Gets the end widget, or %NULL if there is none.
     * @returns the end widget.
     */
    getEndWidget(): Widget | null
    /**
     * Gets whether `self` shrinks the center widget after other children.
     * @returns whether to shrink the center widget after others
     */
    getShrinkCenterLast(): boolean
    /**
     * Gets the start widget, or %NULL if there is none.
     * @returns the start widget.
     */
    getStartWidget(): Widget | null
    /**
     * Sets the baseline position of a center box.
     *
     * This affects only horizontal boxes with at least one baseline
     * aligned child. If there is more vertical space available than
     * requested, and the baseline is not allocated by the parent then
     * `position` is used to allocate the baseline wrt. the extra space
     * available.
     * @param position a `GtkBaselinePosition`
     */
    setBaselinePosition(position: BaselinePosition): void
    /**
     * Sets the center widget.
     *
     * To remove the existing center widget, pass %NULL.
     * @param child the new center widget
     */
    setCenterWidget(child: Widget | null): void
    /**
     * Sets the end widget.
     *
     * To remove the existing end widget, pass %NULL.
     * @param child the new end widget
     */
    setEndWidget(child: Widget | null): void
    /**
     * Sets whether to shrink the center widget after other children.
     *
     * By default, when there's no space to give all three children their
     * natural widths, the start and end widgets start shrinking and the
     * center child keeps natural width until they reach minimum width.
     *
     * If set to `FALSE`, start and end widgets keep natural width and the
     * center widget starts shrinking instead.
     * @param shrinkCenterLast whether to shrink the center widget after others
     */
    setShrinkCenterLast(shrinkCenterLast: boolean): void
    /**
     * Sets the start widget.
     *
     * To remove the existing start widget, pass %NULL.
     * @param child the new start widget
     */
    setStartWidget(child: Widget | null): void

    // Class property signals of Gtk-4.0.Gtk.CenterBox

    connect(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-position", ...args: any[]): void
    connect(
      sigName: "notify::center-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::center-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::center-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::center-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::center-widget", ...args: any[]): void
    connect(
      sigName: "notify::end-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::end-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::end-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::end-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::end-widget", ...args: any[]): void
    connect(
      sigName: "notify::shrink-center-last",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shrink-center-last",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shrink-center-last",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shrink-center-last",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shrink-center-last", ...args: any[]): void
    connect(
      sigName: "notify::start-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::start-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::start-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::start-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::start-widget", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkCenterBox` arranges three children in a row, keeping the middle child
   * centered as well as possible.
   *
   * ![An example GtkCenterBox](centerbox.png)
   *
   * To add children to `GtkCenterBox`, use [method`Gtk`.CenterBox.set_start_widget],
   * [method`Gtk`.CenterBox.set_center_widget] and
   * [method`Gtk`.CenterBox.set_end_widget].
   *
   * The sizing and positioning of children can be influenced with the
   * align and expand properties of the children.
   *
   * # GtkCenterBox as GtkBuildable
   *
   * The `GtkCenterBox` implementation of the `GtkBuildable` interface
   * supports placing children in the 3 positions by specifying “start”, “center”
   * or “end” as the “type” attribute of a `<child>` element.
   *
   * # CSS nodes
   *
   * `GtkCenterBox` uses a single CSS node with the name “box”,
   *
   * The first child of the `GtkCenterBox` will be allocated depending on the
   * text direction, i.e. in left-to-right layouts it will be allocated on the
   * left and in right-to-left layouts on the right.
   *
   * In vertical orientation, the nodes of the children are arranged from top to
   * bottom.
   *
   * # Accessibility
   *
   * Until GTK 4.10, `GtkCenterBox` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   *
   * Starting from GTK 4.12, `GtkCenterBox` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
   * @class
   */
  class CenterBox extends Widget {
    // Own properties of Gtk-4.0.Gtk.CenterBox

    static name: string

    // Constructors of Gtk-4.0.Gtk.CenterBox

    constructor(config?: CenterBox.ConstructorProperties)
    /**
     * Creates a new `GtkCenterBox`.
     * @constructor
     * @returns the new `GtkCenterBox`.
     */
    constructor()
    /**
     * Creates a new `GtkCenterBox`.
     * @constructor
     * @returns the new `GtkCenterBox`.
     */
    static new(): CenterBox
    _init(config?: CenterBox.ConstructorProperties): void
  }

  module CenterLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends LayoutManager.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CenterLayout

      /**
       * Whether to shrink the center widget after other children.
       *
       * By default, when there's no space to give all three children their
       * natural widths, the start and end widgets start shrinking and the
       * center child keeps natural width until they reach minimum width.
       *
       * If set to `FALSE`, start and end widgets keep natural width and the
       * center widget starts shrinking instead.
       */
      shrink_center_last?: boolean | null
    }
  }

  interface CenterLayout {
    // Own properties of Gtk-4.0.Gtk.CenterLayout

    /**
     * Whether to shrink the center widget after other children.
     *
     * By default, when there's no space to give all three children their
     * natural widths, the start and end widgets start shrinking and the
     * center child keeps natural width until they reach minimum width.
     *
     * If set to `FALSE`, start and end widgets keep natural width and the
     * center widget starts shrinking instead.
     */
    shrinkCenterLast: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CenterLayout

    /**
     * Returns the baseline position of the layout.
     * @returns The current baseline position of @self.
     */
    getBaselinePosition(): BaselinePosition
    /**
     * Returns the center widget of the layout.
     * @returns the current center widget of @self
     */
    getCenterWidget(): Widget | null
    /**
     * Returns the end widget of the layout.
     * @returns the current end widget of @self
     */
    getEndWidget(): Widget | null
    /**
     * Gets the current orienration of the layout manager.
     * @returns The current orientation of @self
     */
    getOrientation(): Orientation
    /**
     * Gets whether `self` shrinks the center widget after other children.
     * @returns whether to shrink the center widget after others
     */
    getShrinkCenterLast(): boolean
    /**
     * Returns the start widget of the layout.
     * @returns The current start widget of @self
     */
    getStartWidget(): Widget | null
    /**
     * Sets the new baseline position of `self`
     * @param baselinePosition the new baseline position
     */
    setBaselinePosition(baselinePosition: BaselinePosition): void
    /**
     * Sets the new center widget of `self`.
     *
     * To remove the existing center widget, pass %NULL.
     * @param widget the new center widget
     */
    setCenterWidget(widget: Widget | null): void
    /**
     * Sets the new end widget of `self`.
     *
     * To remove the existing center widget, pass %NULL.
     * @param widget the new end widget
     */
    setEndWidget(widget: Widget | null): void
    /**
     * Sets the orientation of `self`.
     * @param orientation the new orientation
     */
    setOrientation(orientation: Orientation): void
    /**
     * Sets whether to shrink the center widget after other children.
     *
     * By default, when there's no space to give all three children their
     * natural widths, the start and end widgets start shrinking and the
     * center child keeps natural width until they reach minimum width.
     *
     * If set to `FALSE`, start and end widgets keep natural width and the
     * center widget starts shrinking instead.
     * @param shrinkCenterLast whether to shrink the center widget after others
     */
    setShrinkCenterLast(shrinkCenterLast: boolean): void
    /**
     * Sets the new start widget of `self`.
     *
     * To remove the existing start widget, pass %NULL.
     * @param widget the new start widget
     */
    setStartWidget(widget: Widget | null): void

    // Class property signals of Gtk-4.0.Gtk.CenterLayout

    connect(
      sigName: "notify::shrink-center-last",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shrink-center-last",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shrink-center-last",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shrink-center-last",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shrink-center-last", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkCenterLayout` is a layout manager that manages up to three children.
   *
   * The start widget is allocated at the start of the layout (left in
   * left-to-right locales and right in right-to-left ones), and the end
   * widget at the end.
   *
   * The center widget is centered regarding the full width of the layout's.
   * @class
   */
  class CenterLayout extends LayoutManager {
    // Own properties of Gtk-4.0.Gtk.CenterLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.CenterLayout

    constructor(config?: CenterLayout.ConstructorProperties)
    /**
     * Creates a new `GtkCenterLayout`.
     * @constructor
     * @returns the newly created `GtkCenterLayout`
     */
    constructor()
    /**
     * Creates a new `GtkCenterLayout`.
     * @constructor
     * @returns the newly created `GtkCenterLayout`
     */
    static new(): CenterLayout
    _init(config?: CenterLayout.ConstructorProperties): void
  }

  module CheckButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `toggled`
     */
    interface ToggledSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Actionable.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.CheckButton

      /**
       * If the check button is active.
       *
       * Setting `active` to %TRUE will add the `:checked:` state to both
       * the check button and the indicator CSS node.
       */
      active?: boolean | null
      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * The check button whose group this widget belongs to.
       */
      group?: CheckButton | null
      /**
       * If the check button is in an “in between” state.
       *
       * The inconsistent state only affects visual appearance,
       * not the semantics of the button.
       */
      inconsistent?: boolean | null
      /**
       * Text of the label inside the check button, if it contains a label widget.
       */
      label?: string | null
      /**
       * If set, an underline in the text indicates that the following
       * character is to be used as mnemonic.
       */
      use_underline?: boolean | null
    }
  }

  interface CheckButton
    extends Accessible,
      Actionable,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.CheckButton

    /**
     * If the check button is active.
     *
     * Setting `active` to %TRUE will add the `:checked:` state to both
     * the check button and the indicator CSS node.
     */
    active: boolean
    /**
     * The child widget.
     */
    child: Widget
    /**
     * The check button whose group this widget belongs to.
     */
    group: CheckButton
    /**
     * If the check button is in an “in between” state.
     *
     * The inconsistent state only affects visual appearance,
     * not the semantics of the button.
     */
    inconsistent: boolean
    /**
     * Text of the label inside the check button, if it contains a label widget.
     */
    label: string | null
    /**
     * If set, an underline in the text indicates that the following
     * character is to be used as mnemonic.
     */
    useUnderline: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.CheckButton

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.CheckButton

    /**
     * Returns whether the check button is active.
     * @returns whether the check button is active
     */
    getActive(): boolean
    /**
     * Gets the child widget of `button` or `NULL` if [property`CheckButton:`label] is set.
     * @returns the child widget of @button
     */
    getChild(): Widget | null
    /**
     * Returns whether the check button is in an inconsistent state.
     * @returns %TRUE if @check_button is currently in an inconsistent state
     */
    getInconsistent(): boolean
    /**
     * Returns the label of the check button or `NULL` if [property`CheckButton:`child] is set.
     * @returns The label @self shows next   to the indicator. If no label is shown, %NULL will be returned.
     */
    getLabel(): string | null
    /**
     * Returns whether underlines in the label indicate mnemonics.
     * @returns The value of the [property@Gtk.CheckButton:use-underline] property.   See [method@Gtk.CheckButton.set_use_underline] for details on how to set   a new value.
     */
    getUseUnderline(): boolean
    /**
     * Changes the check buttons active state.
     * @param setting the new value to set
     */
    setActive(setting: boolean): void
    /**
     * Sets the child widget of `button`.
     *
     * Note that by using this API, you take full responsibility for setting
     * up the proper accessibility label and description information for `button`.
     * Most likely, you'll either set the accessibility label or description
     * for `button` explicitly, or you'll set a labelled-by or described-by
     * relations from `child` to `button`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Adds `self` to the group of `group`.
     *
     * In a group of multiple check buttons, only one button can be active
     * at a time. The behavior of a checkbutton in a group is also commonly
     * known as a *radio button*.
     *
     * Setting the group of a check button also changes the css name of the
     * indicator widget's CSS node to 'radio'.
     *
     * Setting up groups in a cycle leads to undefined behavior.
     *
     * Note that the same effect can be achieved via the [iface`Gtk`.Actionable]
     * API, by using the same action with parameter type and state type 's'
     * for all buttons in the group, and giving each button its own target
     * value.
     * @param group another `GtkCheckButton` to   form a group with
     */
    setGroup(group: CheckButton | null): void
    /**
     * Sets the `GtkCheckButton` to inconsistent state.
     *
     * You should turn off the inconsistent state again if the user checks
     * the check button. This has to be done manually.
     * @param inconsistent %TRUE if state is inconsistent
     */
    setInconsistent(inconsistent: boolean): void
    /**
     * Sets the text of `self`.
     *
     * If [property`Gtk`.CheckButton:use-underline] is %TRUE, an underscore
     * in `label` is interpreted as mnemonic indicator, see
     * [method`Gtk`.CheckButton.set_use_underline] for details on this behavior.
     * @param label The text shown next to the indicator, or %NULL   to show no text
     */
    setLabel(label: string | null): void
    /**
     * Sets whether underlines in the label indicate mnemonics.
     *
     * If `setting` is %TRUE, an underscore character in `self'`s label
     * indicates a mnemonic accelerator key. This behavior is similar
     * to [property`Gtk`.Label:use-underline].
     * @param setting the new value to set
     */
    setUseUnderline(setting: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.CheckButton

    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean
    toggled(): void

    // Own signals of Gtk-4.0.Gtk.CheckButton

    connect(
      sigName: "activate",
      callback: CheckButton.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: CheckButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: CheckButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: CheckButton.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "toggled",
      callback: CheckButton.ToggledSignalCallback
    ): number
    on(
      sigName: "toggled",
      callback: CheckButton.ToggledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggled",
      callback: CheckButton.ToggledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggled",
      callback: CheckButton.ToggledSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggled", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.CheckButton

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::group", ...args: any[]): void
    connect(
      sigName: "notify::inconsistent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inconsistent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inconsistent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inconsistent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inconsistent", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-target", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkCheckButton` places a label next to an indicator.
   *
   * ![Example GtkCheckButtons](check-button.png)
   *
   * A `GtkCheckButton` is created by calling either [ctor`Gtk`.CheckButton.new]
   * or [ctor`Gtk`.CheckButton.new_with_label].
   *
   * The state of a `GtkCheckButton` can be set specifically using
   * [method`Gtk`.CheckButton.set_active], and retrieved using
   * [method`Gtk`.CheckButton.get_active].
   *
   * # Inconsistent state
   *
   * In addition to "on" and "off", check buttons can be an
   * "in between" state that is neither on nor off. This can be used
   * e.g. when the user has selected a range of elements (such as some
   * text or spreadsheet cells) that are affected by a check button,
   * and the current values in that range are inconsistent.
   *
   * To set a `GtkCheckButton` to inconsistent state, use
   * [method`Gtk`.CheckButton.set_inconsistent].
   *
   * # Grouping
   *
   * Check buttons can be grouped together, to form mutually exclusive
   * groups - only one of the buttons can be toggled at a time, and toggling
   * another one will switch the currently toggled one off.
   *
   * Grouped check buttons use a different indicator, and are commonly referred
   * to as *radio buttons*.
   *
   * ![Example GtkCheckButtons](radio-button.png)
   *
   * To add a `GtkCheckButton` to a group, use [method`Gtk`.CheckButton.set_group].
   *
   * When the code must keep track of the state of a group of radio buttons, it
   * is recommended to keep track of such state through a stateful
   * `GAction` with a target for each button. Using the `toggled` signals to keep
   * track of the group changes and state is discouraged.
   *
   * # CSS nodes
   *
   * ```
   * checkbutton[.text-button]
   * ├── check
   * ╰── [label]
   * ```
   *
   * A `GtkCheckButton` has a main node with name checkbutton. If the
   * [property`Gtk`.CheckButton:label] or [property`Gtk`.CheckButton:child]
   * properties are set, it contains a child widget. The indicator node
   * is named check when no group is set, and radio if the checkbutton
   * is grouped together with other checkbuttons.
   *
   * # Accessibility
   *
   * `GtkCheckButton` uses the %GTK_ACCESSIBLE_ROLE_CHECKBOX role.
   * @class
   */
  class CheckButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.CheckButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.CheckButton

    constructor(config?: CheckButton.ConstructorProperties)
    /**
     * Creates a new `GtkCheckButton`.
     * @constructor
     * @returns a new `GtkCheckButton`
     */
    constructor()
    /**
     * Creates a new `GtkCheckButton`.
     * @constructor
     * @returns a new `GtkCheckButton`
     */
    static new(): CheckButton
    /**
     * Creates a new `GtkCheckButton` with the given text.
     * @constructor
     * @param label the text for the check button.
     * @returns a new `GtkCheckButton`
     */
    static newWithLabel(label: string | null): CheckButton
    /**
     * Creates a new `GtkCheckButton` with the given text and a mnemonic.
     * @constructor
     * @param label The text of the button, with an underscore   in front of the mnemonic character
     * @returns a new `GtkCheckButton`
     */
    static newWithMnemonic(label: string | null): CheckButton
    _init(config?: CheckButton.ConstructorProperties): void
  }

  interface ClosureExpression {}

  /**
   * An expression using a custom `GClosure` to compute the value from
   * its parameters.
   * @class
   */
  class ClosureExpression extends Expression {
    // Own properties of Gtk-4.0.Gtk.ClosureExpression

    static name: string

    // Constructors of Gtk-4.0.Gtk.ClosureExpression

    /**
     * Creates a `GtkExpression` that calls `closure` when it is evaluated.
     *
     * `closure` is called with the `this` object and the results of evaluating
     * the `params` expressions.
     * @constructor
     * @param valueType the type of the value that this expression evaluates to
     * @param closure closure to call when evaluating this expression. If closure is floating, it is adopted
     * @param params expressions for each parameter
     * @returns a new `GtkExpression`
     */
    constructor(
      valueType: GObject.GType,
      closure: GObject.TClosure,
      params: Expression[] | null
    )
    /**
     * Creates a `GtkExpression` that calls `closure` when it is evaluated.
     *
     * `closure` is called with the `this` object and the results of evaluating
     * the `params` expressions.
     * @constructor
     * @param valueType the type of the value that this expression evaluates to
     * @param closure closure to call when evaluating this expression. If closure is floating, it is adopted
     * @param params expressions for each parameter
     * @returns a new `GtkExpression`
     */
    static new(
      valueType: GObject.GType,
      closure: GObject.TClosure,
      params: Expression[] | null
    ): ClosureExpression
  }

  module ColorButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `color-set`
     */
    interface ColorSetSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ColorChooser.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColorButton

      /**
       * Whether the color chooser dialog should be modal.
       */
      modal?: boolean | null
      /**
       * Whether the color chooser should open in editor mode.
       *
       * This property should be used in cases where the palette
       * in the editor would be redundant, such as when the color
       * button is already part of a palette.
       */
      show_editor?: boolean | null
      /**
       * The title of the color chooser dialog
       */
      title?: string | null
    }
  }

  interface ColorButton
    extends Accessible,
      Buildable,
      ColorChooser,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ColorButton

    /**
     * Whether the color chooser dialog should be modal.
     */
    modal: boolean
    /**
     * Whether the color chooser should open in editor mode.
     *
     * This property should be used in cases where the palette
     * in the editor would be redundant, such as when the color
     * button is already part of a palette.
     */
    showEditor: boolean
    /**
     * The title of the color chooser dialog
     */
    title: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColorButton

    /**
     * Gets whether the dialog is modal.
     * @returns %TRUE if the dialog is modal
     */
    getModal(): boolean
    /**
     * Gets the title of the color chooser dialog.
     * @returns An internal string, do not free the return value
     */
    getTitle(): string
    /**
     * Sets whether the dialog should be modal.
     * @param modal %TRUE to make the dialog modal
     */
    setModal(modal: boolean): void
    /**
     * Sets the title for the color chooser dialog.
     * @param title String containing new window title
     */
    setTitle(title: string): void

    // Own signals of Gtk-4.0.Gtk.ColorButton

    connect(
      sigName: "activate",
      callback: ColorButton.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: ColorButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: ColorButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: ColorButton.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "color-set",
      callback: ColorButton.ColorSetSignalCallback
    ): number
    on(
      sigName: "color-set",
      callback: ColorButton.ColorSetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "color-set",
      callback: ColorButton.ColorSetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "color-set",
      callback: ColorButton.ColorSetSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "color-set", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ColorButton

    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-editor", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: "notify::rgba", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rgba", ...args: any[]): void
    connect(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-alpha", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkColorButton` allows to open a color chooser dialog to change
   * the color.
   *
   * ![An example GtkColorButton](color-button.png)
   *
   * It is suitable widget for selecting a color in a preference dialog.
   *
   * # CSS nodes
   *
   * ```
   * colorbutton
   * ╰── button.color
   *     ╰── [content]
   * ```
   *
   * `GtkColorButton` has a single CSS node with name colorbutton which
   * contains a button node. To differentiate it from a plain `GtkButton`,
   * it gets the .color style class.
   * @class
   */
  class ColorButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.ColorButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColorButton

    constructor(config?: ColorButton.ConstructorProperties)
    /**
     * Creates a new color button.
     *
     * This returns a widget in the form of a small button containing
     * a swatch representing the current selected color. When the button
     * is clicked, a color chooser dialog will open, allowing the user
     * to select a color. The swatch will be updated to reflect the new
     * color when the user finishes.
     * @constructor
     * @returns a new color button
     */
    constructor()
    /**
     * Creates a new color button.
     *
     * This returns a widget in the form of a small button containing
     * a swatch representing the current selected color. When the button
     * is clicked, a color chooser dialog will open, allowing the user
     * to select a color. The swatch will be updated to reflect the new
     * color when the user finishes.
     * @constructor
     * @returns a new color button
     */
    static new(): ColorButton
    /**
     * Creates a new color button showing the given color.
     * @constructor
     * @param rgba A `GdkRGBA` to set the current color with
     * @returns a new color button
     */
    static newWithRgba(rgba: Gdk.RGBA): ColorButton
    _init(config?: ColorButton.ConstructorProperties): void
  }

  module ColorChooserDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ColorChooser.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Dialog.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColorChooserDialog

      show_editor?: boolean | null
    }
  }

  interface ColorChooserDialog
    extends Accessible,
      Buildable,
      ColorChooser,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.ColorChooserDialog

    showEditor: boolean
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void
    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @virtual
     */
    close(): void

    // Overloads of close

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void

    // Class property signals of Gtk-4.0.Gtk.ColorChooserDialog

    connect(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-editor", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: "notify::rgba", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rgba", ...args: any[]): void
    connect(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-alpha", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A dialog for choosing a color.
   *
   * ![An example GtkColorChooserDialog](colorchooser.png)
   *
   * `GtkColorChooserDialog` implements the [iface`Gtk`.ColorChooser] interface
   * and does not provide much API of its own.
   *
   * To create a `GtkColorChooserDialog`, use [ctor`Gtk`.ColorChooserDialog.new].
   *
   * To change the initially selected color, use
   * [method`Gtk`.ColorChooser.set_rgba]. To get the selected color use
   * [method`Gtk`.ColorChooser.get_rgba].
   *
   * `GtkColorChooserDialog` has been deprecated in favor of [class`Gtk`.ColorDialog].
   *
   * ## CSS nodes
   *
   * `GtkColorChooserDialog` has a single CSS node with the name `window` and style
   * class `.colorchooser`.
   * @class
   */
  class ColorChooserDialog extends Dialog {
    // Own properties of Gtk-4.0.Gtk.ColorChooserDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColorChooserDialog

    constructor(config?: ColorChooserDialog.ConstructorProperties)
    /**
     * Creates a new `GtkColorChooserDialog`.
     * @constructor
     * @param title Title of the dialog
     * @param parent Transient parent of the dialog
     * @returns a new `GtkColorChooserDialog`
     */
    constructor(title: string | null, parent: Window | null)
    /**
     * Creates a new `GtkColorChooserDialog`.
     * @constructor
     * @param title Title of the dialog
     * @param parent Transient parent of the dialog
     * @returns a new `GtkColorChooserDialog`
     */
    static new(title: string | null, parent: Window | null): ColorChooserDialog

    // Overloads of new

    /**
     * Creates a new dialog box.
     *
     * Widgets should not be packed into the `GtkWindow`
     * directly, but into the `content_area` and `action_area,`
     * as described above.
     * @constructor
     * @returns the new dialog as a `GtkWidget`
     */
    static new(): Dialog
    _init(config?: ColorChooserDialog.ConstructorProperties): void
  }

  module ColorChooserWidget {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ColorChooser.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColorChooserWidget

      /**
       * %TRUE when the color chooser is showing the single-color editor.
       *
       * It can be set to switch the color chooser into single-color editing mode.
       */
      show_editor?: boolean | null
    }
  }

  interface ColorChooserWidget
    extends Accessible,
      Buildable,
      ColorChooser,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ColorChooserWidget

    /**
     * %TRUE when the color chooser is showing the single-color editor.
     *
     * It can be set to switch the color chooser into single-color editing mode.
     */
    showEditor: boolean
    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.ColorChooserWidget

    connect(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-editor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-editor", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: "notify::rgba", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rgba", ...args: any[]): void
    connect(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-alpha",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-alpha", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkColorChooserWidget` widget lets the user select a color.
   *
   * By default, the chooser presents a predefined palette of colors,
   * plus a small number of settable custom colors. It is also possible
   * to select a different color with the single-color editor.
   *
   * To enter the single-color editing mode, use the context menu of any
   * color of the palette, or use the '+' button to add a new custom color.
   *
   * The chooser automatically remembers the last selection, as well
   * as custom colors.
   *
   * To create a `GtkColorChooserWidget`, use [ctor`Gtk`.ColorChooserWidget.new].
   *
   * To change the initially selected color, use
   * [method`Gtk`.ColorChooser.set_rgba]. To get the selected color use
   * [method`Gtk`.ColorChooser.get_rgba].
   *
   * The `GtkColorChooserWidget` is used in the [class`Gtk`.ColorChooserDialog]
   * to provide a dialog for selecting colors.
   *
   * # CSS names
   *
   * `GtkColorChooserWidget` has a single CSS node with name colorchooser.
   * @class
   */
  class ColorChooserWidget extends Widget {
    // Own properties of Gtk-4.0.Gtk.ColorChooserWidget

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColorChooserWidget

    constructor(config?: ColorChooserWidget.ConstructorProperties)
    /**
     * Creates a new `GtkColorChooserWidget`.
     * @constructor
     * @returns a new `GtkColorChooserWidget`
     */
    constructor()
    /**
     * Creates a new `GtkColorChooserWidget`.
     * @constructor
     * @returns a new `GtkColorChooserWidget`
     */
    static new(): ColorChooserWidget
    _init(config?: ColorChooserWidget.ConstructorProperties): void
  }

  module ColorDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColorDialog

      /**
       * Whether the color chooser dialog is modal.
       */
      modal?: boolean | null
      /**
       * A title that may be shown on the color chooser
       * dialog that is presented by [method`Gtk`.ColorDialog.choose_rgba].
       */
      title?: string | null
      /**
       * Whether colors may have alpha (translucency).
       *
       * When with-alpha is %FALSE, the color that is selected
       * will be forced to have alpha == 1.
       */
      with_alpha?: boolean | null
    }
  }

  interface ColorDialog {
    // Own properties of Gtk-4.0.Gtk.ColorDialog

    /**
     * Whether the color chooser dialog is modal.
     */
    modal: boolean
    /**
     * A title that may be shown on the color chooser
     * dialog that is presented by [method`Gtk`.ColorDialog.choose_rgba].
     */
    title: string | null
    /**
     * Whether colors may have alpha (translucency).
     *
     * When with-alpha is %FALSE, the color that is selected
     * will be forced to have alpha == 1.
     */
    withAlpha: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColorDialog

    /**
     * This function initiates a color choice operation by
     * presenting a color chooser dialog to the user.
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.ColorDialog.choose_rgba_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param initialColor the color to select initially
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    chooseRgba(
      parent: Window | null,
      initialColor: Gdk.RGBA | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.ColorDialog.choose_rgba] call and
     * returns the resulting color.
     * @param result a `GAsyncResult`
     * @returns the selected color, or   `NULL` and @error is set
     */
    chooseRgbaFinish(result: Gio.AsyncResult): Gdk.RGBA | null
    /**
     * Returns whether the color chooser dialog
     * blocks interaction with the parent window
     * while it is presented.
     * @returns `TRUE` if the color chooser dialog is modal
     */
    getModal(): boolean
    /**
     * Returns the title that will be shown on the
     * color chooser dialog.
     * @returns the title
     */
    getTitle(): string
    /**
     * Returns whether colors may have alpha.
     * @returns `TRUE` if colors may have alpha
     */
    getWithAlpha(): boolean
    /**
     * Sets whether the color chooser dialog
     * blocks interaction with the parent window
     * while it is presented.
     * @param modal the new value
     */
    setModal(modal: boolean): void
    /**
     * Sets the title that will be shown on the
     * color chooser dialog.
     * @param title the new title
     */
    setTitle(title: string): void
    /**
     * Sets whether colors may have alpha.
     * @param withAlpha the new value
     */
    setWithAlpha(withAlpha: boolean): void

    // Class property signals of Gtk-4.0.Gtk.ColorDialog

    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::with-alpha",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::with-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::with-alpha",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::with-alpha",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::with-alpha", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkColorDialog` object collects the arguments that
   * are needed to present a color chooser dialog to the
   * user, such as a title for the dialog and whether it
   * should be modal.
   *
   * The dialog is shown with the [method`Gtk`.ColorDialog.choose_rgba]
   * function. This API follows the GIO async pattern, and the
   * result can be obtained by calling
   * [method`Gtk`.ColorDialog.choose_rgba_finish].
   *
   * See [class`Gtk`.ColorDialogButton] for a convenient control
   * that uses `GtkColorDialog` and presents the results.
   * @class
   */
  class ColorDialog extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ColorDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColorDialog

    constructor(config?: ColorDialog.ConstructorProperties)
    /**
     * Creates a new `GtkColorDialog` object.
     * @constructor
     * @returns the new `GtkColorDialog`
     */
    constructor()
    /**
     * Creates a new `GtkColorDialog` object.
     * @constructor
     * @returns the new `GtkColorDialog`
     */
    static new(): ColorDialog
    _init(config?: ColorDialog.ConstructorProperties): void
  }

  module ColorDialogButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColorDialogButton

      /**
       * The `GtkColorDialog` that contains parameters for
       * the color chooser dialog.
       */
      dialog?: ColorDialog | null
      /**
       * The selected color.
       *
       * This property can be set to give the button its initial
       * color, and it will be updated to reflect the users choice
       * in the color chooser dialog.
       *
       * Listen to `notify::rgba` to get informed about changes
       * to the buttons color.
       */
      rgba?: Gdk.RGBA | null
    }
  }

  interface ColorDialogButton extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ColorDialogButton

    /**
     * The `GtkColorDialog` that contains parameters for
     * the color chooser dialog.
     */
    dialog: ColorDialog
    /**
     * The selected color.
     *
     * This property can be set to give the button its initial
     * color, and it will be updated to reflect the users choice
     * in the color chooser dialog.
     *
     * Listen to `notify::rgba` to get informed about changes
     * to the buttons color.
     */
    rgba: Gdk.RGBA
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColorDialogButton

    /**
     * Returns the `GtkColorDialog` of `self`.
     * @returns the `GtkColorDialog`
     */
    getDialog(): ColorDialog | null
    /**
     * Returns the color of the button.
     *
     * This function is what should be used to obtain
     * the color that was chosen by the user. To get
     * informed about changes, listen to "notify::rgba".
     * @returns the color
     */
    getRgba(): Gdk.RGBA
    /**
     * Sets a `GtkColorDialog` object to use for
     * creating the color chooser dialog that is
     * presented when the user clicks the button.
     * @param dialog the new `GtkColorDialog`
     */
    setDialog(dialog: ColorDialog): void
    /**
     * Sets the color of the button.
     * @param color the new color
     */
    setRgba(color: Gdk.RGBA): void

    // Own signals of Gtk-4.0.Gtk.ColorDialogButton

    connect(
      sigName: "activate",
      callback: ColorDialogButton.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: ColorDialogButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: ColorDialogButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: ColorDialogButton.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ColorDialogButton

    connect(
      sigName: "notify::dialog",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::dialog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::dialog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::dialog",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::dialog", ...args: any[]): void
    connect(sigName: "notify::rgba", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rgba", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkColorDialogButton` is a wrapped around a [class`Gtk`.ColorDialog]
   * and allows to open a color chooser dialog to change the color.
   *
   * ![An example GtkColorDialogButton](color-button.png)
   *
   * It is suitable widget for selecting a color in a preference dialog.
   *
   * # CSS nodes
   *
   * ```
   * colorbutton
   * ╰── button.color
   *     ╰── [content]
   * ```
   *
   * `GtkColorDialogButton` has a single CSS node with name colorbutton which
   * contains a button node. To differentiate it from a plain `GtkButton`,
   * it gets the .color style class.
   * @class
   */
  class ColorDialogButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.ColorDialogButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColorDialogButton

    constructor(config?: ColorDialogButton.ConstructorProperties)
    /**
     * Creates a new `GtkColorDialogButton` with the
     * given `GtkColorDialog`.
     *
     * You can pass `NULL` to this function and set a `GtkColorDialog`
     * later. The button will be insensitive until that happens.
     * @constructor
     * @param dialog the `GtkColorDialog` to use
     * @returns the new `GtkColorDialogButton`
     */
    constructor(dialog: ColorDialog | null)
    /**
     * Creates a new `GtkColorDialogButton` with the
     * given `GtkColorDialog`.
     *
     * You can pass `NULL` to this function and set a `GtkColorDialog`
     * later. The button will be insensitive until that happens.
     * @constructor
     * @param dialog the `GtkColorDialog` to use
     * @returns the new `GtkColorDialogButton`
     */
    static new(dialog: ColorDialog | null): ColorDialogButton
    _init(config?: ColorDialogButton.ConstructorProperties): void
  }

  module ColumnView {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (position: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Scrollable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColumnView

      /**
       * Allow rubberband selection.
       */
      enable_rubberband?: boolean | null
      /**
       * Factory for creating header widgets.
       */
      header_factory?: ListItemFactory | null
      /**
       * Model for the items displayed.
       */
      model?: SelectionModel | null
      /**
       * Whether columns are reorderable.
       */
      reorderable?: boolean | null
      /**
       * The factory used for configuring rows.
       */
      row_factory?: ListItemFactory | null
      /**
       * Show separators between columns.
       */
      show_column_separators?: boolean | null
      /**
       * Show separators between rows.
       */
      show_row_separators?: boolean | null
      /**
       * Activate rows on single click and select them on hover.
       */
      single_click_activate?: boolean | null
      /**
       * Behavior of the <kbd>Tab</kbd> key
       */
      tab_behavior?: ListTabBehavior | null
    }
  }

  interface ColumnView
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Scrollable {
    // Own properties of Gtk-4.0.Gtk.ColumnView

    /**
     * The list of columns.
     */
    readonly columns: Gio.ListModel
    /**
     * Allow rubberband selection.
     */
    enableRubberband: boolean
    /**
     * Factory for creating header widgets.
     */
    headerFactory: ListItemFactory
    /**
     * Model for the items displayed.
     */
    model: SelectionModel
    /**
     * Whether columns are reorderable.
     */
    reorderable: boolean
    /**
     * The factory used for configuring rows.
     */
    rowFactory: ListItemFactory
    /**
     * Show separators between columns.
     */
    showColumnSeparators: boolean
    /**
     * Show separators between rows.
     */
    showRowSeparators: boolean
    /**
     * Activate rows on single click and select them on hover.
     */
    singleClickActivate: boolean
    /**
     * Sorter with the sorting choices of the user.
     */
    readonly sorter: Sorter
    /**
     * Behavior of the <kbd>Tab</kbd> key
     */
    tabBehavior: ListTabBehavior
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColumnView

    /**
     * Appends the `column` to the end of the columns in `self`.
     * @param column a `GtkColumnViewColumn` that hasn't been added to a   `GtkColumnView` yet
     */
    appendColumn(column: ColumnViewColumn): void
    /**
     * Gets the list of columns in this column view.
     *
     * This list is constant over the lifetime of `self` and can be used to
     * monitor changes to the columns of `self` by connecting to the
     * ::items-changed signal.
     * @returns The list managing the columns
     */
    getColumns(): Gio.ListModel
    /**
     * Returns whether rows can be selected by dragging with the mouse.
     * @returns %TRUE if rubberband selection is enabled
     */
    getEnableRubberband(): boolean
    /**
     * Gets the factory that's currently used to populate section headers.
     * @returns The factory in use
     */
    getHeaderFactory(): ListItemFactory | null
    /**
     * Gets the model that's currently used to read the items displayed.
     * @returns The model in use
     */
    getModel(): SelectionModel | null
    /**
     * Returns whether columns are reorderable.
     * @returns %TRUE if columns are reorderable
     */
    getReorderable(): boolean
    /**
     * Gets the factory set via [method`Gtk`.ColumnView.set_row_factory].
     * @returns The factory
     */
    getRowFactory(): ListItemFactory | null
    /**
     * Returns whether the list should show separators
     * between columns.
     * @returns %TRUE if the list shows column separators
     */
    getShowColumnSeparators(): boolean
    /**
     * Returns whether the list should show separators
     * between rows.
     * @returns %TRUE if the list shows separators
     */
    getShowRowSeparators(): boolean
    /**
     * Returns whether rows will be activated on single click and
     * selected on hover.
     * @returns %TRUE if rows are activated on single click
     */
    getSingleClickActivate(): boolean
    /**
     * Returns a special sorter that reflects the users sorting
     * choices in the column view.
     *
     * To allow users to customizable sorting by clicking on column
     * headers, this sorter needs to be set on the sort model underneath
     * the model that is displayed by the view.
     *
     * See [method`Gtk`.ColumnViewColumn.set_sorter] for setting up
     * per-column sorting.
     *
     * Here is an example:
     * ```c
     * gtk_column_view_column_set_sorter (column, sorter);
     * gtk_column_view_append_column (view, column);
     * sorter = g_object_ref (gtk_column_view_get_sorter (view)));
     * model = gtk_sort_list_model_new (store, sorter);
     * selection = gtk_no_selection_new (model);
     * gtk_column_view_set_model (view, selection);
     * ```
     * @returns the `GtkSorter` of @self
     */
    getSorter(): Sorter | null
    /**
     * Gets the behavior set for the <kbd>Tab</kbd> key.
     * @returns The behavior of the <kbd>Tab</kbd> key
     */
    getTabBehavior(): ListTabBehavior
    /**
     * Inserts a column at the given position in the columns of `self`.
     *
     * If `column` is already a column of `self,` it will be repositioned.
     * @param position the position to insert `column` at
     * @param column the `GtkColumnViewColumn` to insert
     */
    insertColumn(position: number, column: ColumnViewColumn): void
    /**
     * Removes the `column` from the list of columns of `self`.
     * @param column a `GtkColumnViewColumn` that's part of `self`
     */
    removeColumn(column: ColumnViewColumn): void
    /**
     * Scroll to the row at the given position - or cell if a column is
     * given - and performs the actions specified in `flags`.
     *
     * This function works no matter if the listview is shown or focused.
     * If it isn't, then the changes will take effect once that happens.
     * @param pos position of the item
     * @param column The column to scroll to   or %NULL to not scroll columns.
     * @param flags actions to perform
     * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
     */
    scrollTo(
      pos: number,
      column: ColumnViewColumn | null,
      flags: ListScrollFlags,
      scroll: ScrollInfo | null
    ): void
    /**
     * Sets whether selections can be changed by dragging with the mouse.
     * @param enableRubberband %TRUE to enable rubberband selection
     */
    setEnableRubberband(enableRubberband: boolean): void
    /**
     * Sets the `GtkListItemFactory` to use for populating the
     * [class`Gtk`.ListHeader] objects used in section headers.
     *
     * If this factory is set to %NULL, the list will not show
     * section headers.
     * @param factory the factory to use
     */
    setHeaderFactory(factory: ListItemFactory | null): void
    /**
     * Sets the model to use.
     *
     * This must be a [iface`Gtk`.SelectionModel].
     * @param model the model to use
     */
    setModel(model: SelectionModel | null): void
    /**
     * Sets whether columns should be reorderable by dragging.
     * @param reorderable whether columns should be reorderable
     */
    setReorderable(reorderable: boolean): void
    /**
     * Sets the factory used for configuring rows. The factory must be for configuring
     * [class`Gtk`.ColumnViewRow] objects.
     *
     * If this factory is not set - which is the default - then the defaults will be used.
     *
     * This factory is not used to set the widgets displayed in the individual cells. For
     * that see [method`GtkColumnViewColumn`.set_factory] and [class`GtkColumnViewCell]`.
     * @param factory The row factory
     */
    setRowFactory(factory: ListItemFactory | null): void
    /**
     * Sets whether the list should show separators
     * between columns.
     * @param showColumnSeparators %TRUE to show column separators
     */
    setShowColumnSeparators(showColumnSeparators: boolean): void
    /**
     * Sets whether the list should show separators
     * between rows.
     * @param showRowSeparators %TRUE to show row separators
     */
    setShowRowSeparators(showRowSeparators: boolean): void
    /**
     * Sets whether rows should be activated on single click and
     * selected on hover.
     * @param singleClickActivate %TRUE to activate items on single click
     */
    setSingleClickActivate(singleClickActivate: boolean): void
    /**
     * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
     * @param tabBehavior The desired tab behavior
     */
    setTabBehavior(tabBehavior: ListTabBehavior): void
    /**
     * Sets the sorting of the view.
     *
     * This function should be used to set up the initial sorting.
     * At runtime, users can change the sorting of a column view
     * by clicking on the list headers.
     *
     * This call only has an effect if the sorter returned by
     * [method`Gtk`.ColumnView.get_sorter] is set on a sort model,
     * and [method`Gtk`.ColumnViewColumn.set_sorter] has been called
     * on `column` to associate a sorter with the column.
     *
     * If `column` is %NULL, the view will be unsorted.
     * @param column the `GtkColumnViewColumn` to sort by
     * @param direction the direction to sort in
     */
    sortByColumn(column: ColumnViewColumn | null, direction: SortType): void

    // Own signals of Gtk-4.0.Gtk.ColumnView

    connect(
      sigName: "activate",
      callback: ColumnView.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: ColumnView.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: ColumnView.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: ColumnView.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ColumnView

    connect(
      sigName: "notify::columns",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::columns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::columns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::columns",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::columns", ...args: any[]): void
    connect(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-rubberband", ...args: any[]): void
    connect(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::header-factory", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::reorderable", ...args: any[]): void
    connect(
      sigName: "notify::row-factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::row-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row-factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row-factory", ...args: any[]): void
    connect(
      sigName: "notify::show-column-separators",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-column-separators",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-column-separators",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-column-separators",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-column-separators", ...args: any[]): void
    connect(
      sigName: "notify::show-row-separators",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-row-separators",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-row-separators",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-row-separators",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-row-separators", ...args: any[]): void
    connect(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::single-click-activate", ...args: any[]): void
    connect(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sorter", ...args: any[]): void
    connect(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tab-behavior", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkColumnView` presents a large dynamic list of items using multiple columns
   * with headers.
   *
   * `GtkColumnView` uses the factories of its columns to generate a cell widget for
   * each column, for each visible item and displays them together as the row for
   * this item.
   *
   * The [property`Gtk`.ColumnView:show-row-separators] and
   * [property`Gtk`.ColumnView:show-column-separators] properties offer a simple way
   * to display separators between the rows or columns.
   *
   * `GtkColumnView` allows the user to select items according to the selection
   * characteristics of the model. For models that allow multiple selected items,
   * it is possible to turn on *rubberband selection*, using
   * [property`Gtk`.ColumnView:enable-rubberband].
   *
   * The column view supports sorting that can be customized by the user by
   * clicking on column headers. To set this up, the `GtkSorter` returned by
   * [method`Gtk`.ColumnView.get_sorter] must be attached to a sort model for the
   * data that the view is showing, and the columns must have sorters attached to
   * them by calling [method`Gtk`.ColumnViewColumn.set_sorter]. The initial sort
   * order can be set with [method`Gtk`.ColumnView.sort_by_column].
   *
   * The column view also supports interactive resizing and reordering of
   * columns, via Drag-and-Drop of the column headers. This can be enabled or
   * disabled with the [property`Gtk`.ColumnView:reorderable] and
   * [property`Gtk`.ColumnViewColumn:resizable] properties.
   *
   * To learn more about the list widget framework, see the
   * [overview](section-list-widget.html).
   *
   * # CSS nodes
   *
   * ```
   * columnview[.column-separators][.rich-list][.navigation-sidebar][.data-table]
   * ├── header
   * │   ├── <column header>
   * ┊   ┊
   * │   ╰── <column header>
   * │
   * ├── listview
   * │
   * ┊
   * ╰── [rubberband]
   * ```
   *
   * `GtkColumnView` uses a single CSS node named columnview. It may carry the
   * .column-separators style class, when [property`Gtk`.ColumnView:show-column-separators]
   * property is set. Header widgets appear below a node with name header.
   * The rows are contained in a `GtkListView` widget, so there is a listview
   * node with the same structure as for a standalone `GtkListView` widget.
   * If [property`Gtk`.ColumnView:show-row-separators] is set, it will be passed
   * on to the list view, causing its CSS node to carry the .separators style class.
   * For rubberband selection, a node with name rubberband is used.
   *
   * The main columnview node may also carry style classes to select
   * the style of [list presentation](section-list-widget.html#list-styles):
   * .rich-list, .navigation-sidebar or .data-table.
   *
   * # Accessibility
   *
   * `GtkColumnView` uses the %GTK_ACCESSIBLE_ROLE_TREE_GRID role, header title
   * widgets are using the %GTK_ACCESSIBLE_ROLE_COLUMN_HEADER role. The row widgets
   * are using the %GTK_ACCESSIBLE_ROLE_ROW role, and individual cells are using
   * the %GTK_ACCESSIBLE_ROLE_GRID_CELL role
   * @class
   */
  class ColumnView extends Widget {
    // Own properties of Gtk-4.0.Gtk.ColumnView

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColumnView

    constructor(config?: ColumnView.ConstructorProperties)
    /**
     * Creates a new `GtkColumnView`.
     *
     * You most likely want to call [method`Gtk`.ColumnView.append_column]
     * to add columns next.
     * @constructor
     * @param model the list model to use
     * @returns a new `GtkColumnView`
     */
    constructor(model: SelectionModel | null)
    /**
     * Creates a new `GtkColumnView`.
     *
     * You most likely want to call [method`Gtk`.ColumnView.append_column]
     * to add columns next.
     * @constructor
     * @param model the list model to use
     * @returns a new `GtkColumnView`
     */
    static new(model: SelectionModel | null): ColumnView
    _init(config?: ColumnView.ConstructorProperties): void
  }

  module ColumnViewCell {
    // Constructor properties interface

    interface ConstructorProperties extends ListItem.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColumnViewCell

      /**
       * Widget used for display.
       */
      child?: Widget | null
      /**
       * If the item can be focused with the keyboard.
       */
      focusable?: boolean | null
    }
  }

  interface ColumnViewCell {
    // Own properties of Gtk-4.0.Gtk.ColumnViewCell

    /**
     * Widget used for display.
     */
    child: Widget
    /**
     * If the item can be focused with the keyboard.
     */
    focusable: boolean
    /**
     * Displayed item.
     */
    readonly item: GObject.Object
    /**
     * Position of the item.
     */
    readonly position: number
    /**
     * If the item is currently selected.
     */
    readonly selected: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColumnViewCell

    /**
     * Gets the child previously set via gtk_column_view_cell_set_child() or
     * %NULL if none was set.
     * @returns The child
     */
    getChild(): Widget | null
    /**
     * Checks if a list item has been set to be focusable via
     * gtk_column_view_cell_set_focusable().
     * @returns %TRUE if the item is focusable
     */
    getFocusable(): boolean
    /**
     * Gets the model item that associated with `self`.
     *
     * If `self` is unbound, this function returns %NULL.
     * @returns The item displayed
     */
    getItem(): GObject.Object | null
    /**
     * Gets the position in the model that `self` currently displays.
     *
     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
     * @returns The position of this item
     */
    getPosition(): number
    /**
     * Checks if the item is displayed as selected.
     *
     * The selected state is maintained by the liste widget and its model
     * and cannot be set otherwise.
     * @returns %TRUE if the item is selected.
     */
    getSelected(): boolean
    /**
     * Sets the child to be used for this listitem.
     *
     * This function is typically called by applications when
     * setting up a listitem so that the widget can be reused when
     * binding it multiple times.
     * @param child The list item's child or %NULL to unset
     */
    setChild(child: Widget | null): void
    /**
     * Sets `self` to be focusable.
     *
     * If an item is focusable, it can be focused using the keyboard.
     * This works similar to [method`Gtk`.Widget.set_focusable].
     *
     * Note that if items are not focusable, the keyboard cannot be used to activate
     * them and selecting only works if one of the listitem's children is focusable.
     *
     * By default, list items are focusable.
     * @param focusable if the item should be focusable
     */
    setFocusable(focusable: boolean): void

    // Class property signals of Gtk-4.0.Gtk.ColumnViewCell

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(sigName: "notify::item", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item", ...args: any[]): void
    connect(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position", ...args: any[]): void
    connect(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-description", ...args: any[]): void
    connect(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-label", ...args: any[]): void
    connect(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activatable", ...args: any[]): void
    connect(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selectable", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkColumnViewCell` is used by [class`Gtk`.ColumnViewColumn] to represent items
   * in a cell in [class`Gtk`.ColumnView].
   *
   * The `GtkColumnViewCell`s are managed by the columnview widget (with its factory)
   * and cannot be created by applications, but they need to be populated
   * by application code. This is done by calling [method`Gtk`.ColumnViewCell.set_child].
   *
   * `GtkColumnViewCell`s exist in 2 stages:
   *
   * 1. The unbound stage where the listitem is not currently connected to
   *    an item in the list. In that case, the [property`Gtk`.ColumnViewCell:item]
   *    property is set to %NULL.
   *
   * 2. The bound stage where the listitem references an item from the list.
   *    The [property`Gtk`.ColumnViewCell:item] property is not %NULL.
   * @class
   */
  class ColumnViewCell extends ListItem {
    // Own properties of Gtk-4.0.Gtk.ColumnViewCell

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColumnViewCell

    constructor(config?: ColumnViewCell.ConstructorProperties)
    _init(config?: ColumnViewCell.ConstructorProperties): void
  }

  module ColumnViewColumn {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColumnViewColumn

      /**
       * Column gets share of extra width allocated to the view.
       */
      expand?: boolean | null
      /**
       * Factory for populating list items.
       */
      factory?: ListItemFactory | null
      /**
       * If not -1, this is the width that the column is allocated,
       * regardless of the size of its content.
       */
      fixed_width?: number | null
      /**
       * Menu model used to create the context menu for the column header.
       */
      header_menu?: Gio.MenuModel | null
      /**
       * An ID for the column.
       *
       * GTK is not currently using the ID for anything, but
       * it can be used by applications when saving column view
       * configurations.
       *
       * It is up to applications to ensure uniqueness of IDs.
       */
      id?: string | null
      /**
       * Whether this column is resizable.
       */
      resizable?: boolean | null
      /**
       * Sorter for sorting items according to this column.
       */
      sorter?: Sorter | null
      /**
       * Title displayed in the header.
       */
      title?: string | null
      /**
       * Whether this column is visible.
       */
      visible?: boolean | null
    }
  }

  interface ColumnViewColumn {
    // Own properties of Gtk-4.0.Gtk.ColumnViewColumn

    /**
     * The `GtkColumnView` this column is a part of.
     */
    readonly columnView: ColumnView
    /**
     * Column gets share of extra width allocated to the view.
     */
    expand: boolean
    /**
     * Factory for populating list items.
     */
    factory: ListItemFactory
    /**
     * If not -1, this is the width that the column is allocated,
     * regardless of the size of its content.
     */
    fixedWidth: number
    /**
     * Menu model used to create the context menu for the column header.
     */
    headerMenu: Gio.MenuModel
    /**
     * An ID for the column.
     *
     * GTK is not currently using the ID for anything, but
     * it can be used by applications when saving column view
     * configurations.
     *
     * It is up to applications to ensure uniqueness of IDs.
     */
    id: string | null
    /**
     * Whether this column is resizable.
     */
    resizable: boolean
    /**
     * Sorter for sorting items according to this column.
     */
    sorter: Sorter
    /**
     * Title displayed in the header.
     */
    title: string | null
    /**
     * Whether this column is visible.
     */
    visible: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColumnViewColumn

    /**
     * Gets the column view that's currently displaying this column.
     *
     * If `self` has not been added to a column view yet, %NULL is returned.
     * @returns The column view displaying @self.
     */
    getColumnView(): ColumnView | null
    /**
     * Returns whether this column should expand.
     * @returns %TRUE if this column expands
     */
    getExpand(): boolean
    /**
     * Gets the factory that's currently used to populate list items for
     * this column.
     * @returns The factory in use
     */
    getFactory(): ListItemFactory | null
    /**
     * Gets the fixed width of the column.
     * @returns the fixed with of the column
     */
    getFixedWidth(): number
    /**
     * Gets the menu model that is used to create the context menu
     * for the column header.
     * @returns the `GMenuModel`
     */
    getHeaderMenu(): Gio.MenuModel | null
    /**
     * Returns the ID set with gtk_column_view_column_set_id().
     * @returns The column's ID
     */
    getId(): string | null
    /**
     * Returns whether this column is resizable.
     * @returns %TRUE if this column is resizable
     */
    getResizable(): boolean
    /**
     * Returns the sorter that is associated with the column.
     * @returns the `GtkSorter` of @self
     */
    getSorter(): Sorter | null
    /**
     * Returns the title set with gtk_column_view_column_set_title().
     * @returns The column's title
     */
    getTitle(): string | null
    /**
     * Returns whether this column is visible.
     * @returns %TRUE if this column is visible
     */
    getVisible(): boolean
    /**
     * Sets the column to take available extra space.
     *
     * The extra space is shared equally amongst all columns that
     * have the expand set to %TRUE.
     * @param expand %TRUE if this column should expand to fill available sace
     */
    setExpand(expand: boolean): void
    /**
     * Sets the `GtkListItemFactory` to use for populating list items for this
     * column.
     * @param factory the factory to use
     */
    setFactory(factory: ListItemFactory | null): void
    /**
     * If `fixed_width` is not -1, sets the fixed width of `column;`
     * otherwise unsets it.
     *
     * Setting a fixed width overrides the automatically calculated
     * width. Interactive resizing also sets the “fixed-width” property.
     * @param fixedWidth the new fixed width, or -1
     */
    setFixedWidth(fixedWidth: number): void
    /**
     * Sets the menu model that is used to create the context menu
     * for the column header.
     * @param menu a `GMenuModel`
     */
    setHeaderMenu(menu: Gio.MenuModel | null): void
    /**
     * Sets the id of this column.
     *
     * GTK makes no use of this, but applications can use it when
     * storing column view configuration.
     *
     * It is up to callers to ensure uniqueness of IDs.
     * @param id ID to use for this column
     */
    setId(id: string | null): void
    /**
     * Sets whether this column should be resizable by dragging.
     * @param resizable whether this column should be resizable
     */
    setResizable(resizable: boolean): void
    /**
     * Associates a sorter with the column.
     *
     * If `sorter` is %NULL, the column will not let users change
     * the sorting by clicking on its header.
     *
     * This sorter can be made active by clicking on the column
     * header, or by calling [method`Gtk`.ColumnView.sort_by_column].
     *
     * See [method`Gtk`.ColumnView.get_sorter] for the necessary steps
     * for setting up customizable sorting for [class`Gtk`.ColumnView].
     * @param sorter the `GtkSorter` to associate with `column`
     */
    setSorter(sorter: Sorter | null): void
    /**
     * Sets the title of this column.
     *
     * The title is displayed in the header of a `GtkColumnView`
     * for this column and is therefore user-facing text that should
     * be translated.
     * @param title Title to use for this column
     */
    setTitle(title: string | null): void
    /**
     * Sets whether this column should be visible in views.
     * @param visible whether this column should be visible
     */
    setVisible(visible: boolean): void

    // Class property signals of Gtk-4.0.Gtk.ColumnViewColumn

    connect(
      sigName: "notify::column-view",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column-view",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column-view",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column-view",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column-view", ...args: any[]): void
    connect(
      sigName: "notify::expand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expand", ...args: any[]): void
    connect(
      sigName: "notify::factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::factory", ...args: any[]): void
    connect(
      sigName: "notify::fixed-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fixed-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fixed-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fixed-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fixed-width", ...args: any[]): void
    connect(
      sigName: "notify::header-menu",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::header-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::header-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::header-menu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::header-menu", ...args: any[]): void
    connect(sigName: "notify::id", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::id", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sorter", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkColumnViewColumn` represents the columns being added to a `GtkColumnView`.
   *
   * The main ingredient for a `GtkColumnViewColumn` is the `GtkListItemFactory`
   * that tells the columnview how to create cells for this column from items in
   * the model.
   *
   * Columns have a title, and can optionally have a header menu set
   * with [method`Gtk`.ColumnViewColumn.set_header_menu].
   *
   * A sorter can be associated with a column using
   * [method`Gtk`.ColumnViewColumn.set_sorter], to let users influence sorting
   * by clicking on the column header.
   * @class
   */
  class ColumnViewColumn extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ColumnViewColumn

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColumnViewColumn

    constructor(config?: ColumnViewColumn.ConstructorProperties)
    /**
     * Creates a new `GtkColumnViewColumn` that uses the given `factory` for
     * mapping items to widgets.
     *
     * You most likely want to call [method`Gtk`.ColumnView.append_column] next.
     *
     * The function takes ownership of the argument, so you can write code like:
     *
     * ```c
     * column = gtk_column_view_column_new (_("Name"),
     *   gtk_builder_list_item_factory_new_from_resource ("/name.ui"));
     * ```
     * @constructor
     * @param title Title to use for this column
     * @param factory The factory to populate items with
     * @returns a new `GtkColumnViewColumn` using the given @factory
     */
    constructor(title: string | null, factory: ListItemFactory | null)
    /**
     * Creates a new `GtkColumnViewColumn` that uses the given `factory` for
     * mapping items to widgets.
     *
     * You most likely want to call [method`Gtk`.ColumnView.append_column] next.
     *
     * The function takes ownership of the argument, so you can write code like:
     *
     * ```c
     * column = gtk_column_view_column_new (_("Name"),
     *   gtk_builder_list_item_factory_new_from_resource ("/name.ui"));
     * ```
     * @constructor
     * @param title Title to use for this column
     * @param factory The factory to populate items with
     * @returns a new `GtkColumnViewColumn` using the given @factory
     */
    static new(
      title: string | null,
      factory: ListItemFactory | null
    ): ColumnViewColumn
    _init(config?: ColumnViewColumn.ConstructorProperties): void
  }

  module ColumnViewRow {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ColumnViewRow

      /**
       * The accessible description to set on the row.
       */
      accessible_description?: string | null
      /**
       * The accessible label to set on the row.
       */
      accessible_label?: string | null
      /**
       * If the row can be activated by the user.
       */
      activatable?: boolean | null
      /**
       * If the row can be focused with the keyboard.
       */
      focusable?: boolean | null
      /**
       * If the row can be selected by the user.
       */
      selectable?: boolean | null
    }
  }

  interface ColumnViewRow {
    // Own properties of Gtk-4.0.Gtk.ColumnViewRow

    /**
     * The accessible description to set on the row.
     */
    accessibleDescription: string | null
    /**
     * The accessible label to set on the row.
     */
    accessibleLabel: string | null
    /**
     * If the row can be activated by the user.
     */
    activatable: boolean
    /**
     * If the row can be focused with the keyboard.
     */
    focusable: boolean
    /**
     * The item for this row.
     */
    readonly item: GObject.Object
    /**
     * Position of the row.
     */
    readonly position: number
    /**
     * If the row can be selected by the user.
     */
    selectable: boolean
    /**
     * If the item in the row is currently selected.
     */
    readonly selected: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColumnViewRow

    /**
     * Gets the accessible description of `self`.
     * @returns the accessible description
     */
    getAccessibleDescription(): string
    /**
     * Gets the accessible label of `self`.
     * @returns the accessible label
     */
    getAccessibleLabel(): string
    /**
     * Checks if the row has been set to be activatable via
     * gtk_column_view_row_set_activatable().
     * @returns %TRUE if the row is activatable
     */
    getActivatable(): boolean
    /**
     * Checks if a row item has been set to be focusable via
     * gtk_column_view_row_set_focusable().
     * @returns %TRUE if the row is focusable
     */
    getFocusable(): boolean
    /**
     * Gets the model item that associated with `self`.
     *
     * If `self` is unbound, this function returns %NULL.
     * @returns The item displayed
     */
    getItem(): GObject.Object | null
    /**
     * Gets the position in the model that `self` currently displays.
     *
     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
     * @returns The position of this row
     */
    getPosition(): number
    /**
     * Checks if the row has been set to be selectable via
     * gtk_column_view_row_set_selectable().
     *
     * Do not confuse this function with [method`Gtk`.ColumnViewRow.get_selected].
     * @returns %TRUE if the row is selectable
     */
    getSelectable(): boolean
    /**
     * Checks if the item is selected that this row corresponds to.
     *
     * The selected state is maintained by the list widget and its model
     * and cannot be set otherwise.
     * @returns %TRUE if the item is selected.
     */
    getSelected(): boolean
    /**
     * Sets the accessible description for the row,
     * which may be used by e.g. screen readers.
     * @param description the description
     */
    setAccessibleDescription(description: string): void
    /**
     * Sets the accessible label for the row,
     * which may be used by e.g. screen readers.
     * @param label the label
     */
    setAccessibleLabel(label: string): void
    /**
     * Sets `self` to be activatable.
     *
     * If a row is activatable, double-clicking on the row, using
     * the Return key or calling gtk_widget_activate() will activate
     * the row. Activating instructs the containing columnview to
     * emit the [signal`Gtk`.ColumnView::activate] signal.
     *
     * By default, row are activatable.
     * @param activatable if the row should be activatable
     */
    setActivatable(activatable: boolean): void
    /**
     * Sets `self` to be focusable.
     *
     * If a row is focusable, it can be focused using the keyboard.
     * This works similar to [method`Gtk`.Widget.set_focusable].
     *
     * Note that if row are not focusable, the contents of cells can still be focused if
     * they are focusable.
     *
     * By default, rows are focusable.
     * @param focusable if the row should be focusable
     */
    setFocusable(focusable: boolean): void
    /**
     * Sets `self` to be selectable.
     *
     * If a row is selectable, clicking on the row or using the keyboard
     * will try to select or unselect the row. Whether this succeeds is up to
     * the model to determine, as it is managing the selected state.
     *
     * Note that this means that making a row non-selectable has no
     * influence on the selected state at all. A non-selectable row
     * may still be selected.
     *
     * By default, rows are selectable.
     * @param selectable if the row should be selectable
     */
    setSelectable(selectable: boolean): void

    // Class property signals of Gtk-4.0.Gtk.ColumnViewRow

    connect(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-description", ...args: any[]): void
    connect(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-label", ...args: any[]): void
    connect(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activatable", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(sigName: "notify::item", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item", ...args: any[]): void
    connect(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position", ...args: any[]): void
    connect(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selectable", ...args: any[]): void
    connect(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkColumnViewRow` is used by [class`Gtk`.ColumnView] to allow configuring
   * how rows are displayed.
   *
   * It is not used to set the widgets displayed in the individual cells. For that
   * see [method`GtkColumnViewColumn`.set_factory] and [class`GtkColumnViewCell]`.
   * @class
   */
  class ColumnViewRow extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ColumnViewRow

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColumnViewRow

    constructor(config?: ColumnViewRow.ConstructorProperties)
    _init(config?: ColumnViewRow.ConstructorProperties): void
  }

  module ColumnViewSorter {
    // Constructor properties interface

    interface ConstructorProperties extends Sorter.ConstructorProperties {}
  }

  interface ColumnViewSorter {
    // Own properties of Gtk-4.0.Gtk.ColumnViewSorter

    /**
     * The primary sort column.
     *
     * The primary sort column is the one that displays the triangle
     * in a column view header.
     */
    readonly primarySortColumn: ColumnViewColumn
    /**
     * The primary sort order.
     *
     * The primary sort order determines whether the triangle displayed
     * in the column view header of the primary sort column points upwards
     * or downwards.
     */
    readonly primarySortOrder: SortType
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ColumnViewSorter

    /**
     * Returns the number of columns by which the sorter sorts.
     *
     * If the sorter of the primary sort column does not determine
     * a total order, then the secondary sorters are consulted to
     * break the ties.
     *
     * Use the [signal`Gtk`.Sorter::changed] signal to get notified
     * when the number of sort columns changes.
     * @returns the number of sort columns
     */
    getNSortColumns(): number
    /**
     * Gets the `position'`th sort column and its associated sort order.
     *
     * Use the [signal`Gtk`.Sorter::changed] signal to get notified
     * when sort columns change.
     * @param position the position of the sort column to retrieve (0 for the     primary sort column)
     * @returns the @positions sort column
     */
    getNthSortColumn(
      position: number
    ): [/* returnType */ ColumnViewColumn | null, /* sortOrder */ SortType]
    /**
     * Returns the primary sort column.
     *
     * The primary sort column is the one that displays the triangle
     * in a column view header.
     * @returns the primary sort column
     */
    getPrimarySortColumn(): ColumnViewColumn | null
    /**
     * Returns the primary sort order.
     *
     * The primary sort order determines whether the triangle displayed
     * in the column view header of the primary sort column points upwards
     * or downwards.
     *
     * If there is no primary sort column, then this function returns
     * `GTK_SORT_ASCENDING`.
     * @returns the primary sort order
     */
    getPrimarySortOrder(): SortType

    // Class property signals of Gtk-4.0.Gtk.ColumnViewSorter

    connect(
      sigName: "notify::primary-sort-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-sort-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-sort-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-sort-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-sort-column", ...args: any[]): void
    connect(
      sigName: "notify::primary-sort-order",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-sort-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-sort-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-sort-order",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-sort-order", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkColumnViewSorter` is a sorter implementation that
   * is geared towards the needs of `GtkColumnView`.
   *
   * The sorter returned by [method`Gtk`.ColumnView.get_sorter] is
   * a `GtkColumnViewSorter`.
   *
   * In column views, sorting can be configured by associating
   * sorters with columns, and users can invert sort order by clicking
   * on column headers. The API of `GtkColumnViewSorter` is designed
   * to allow saving and restoring this configuration.
   *
   * If you are only interested in the primary sort column (i.e. the
   * column where a sort indicator is shown in the header), then
   * you can just look at [property`Gtk`.ColumnViewSorter:primary-sort-column]
   * and [property`Gtk`.ColumnViewSorter:primary-sort-order].
   *
   * If you want to store the full sort configuration, including
   * secondary sort columns that are used for tie breaking, then
   * you can use [method`Gtk`.ColumnViewSorter.get_nth_sort_column].
   * To get notified about changes, use [signal`Gtk`.Sorter::changed].
   *
   * To restore a saved sort configuration on a `GtkColumnView`,
   * use code like:
   *
   * ```
   * sorter = gtk_column_view_get_sorter (view);
   * for (i = gtk_column_view_sorter_get_n_sort_columns (sorter) - 1; i >= 0; i--)
   *   {
   *     column = gtk_column_view_sorter_get_nth_sort_column (sorter, i, &order);
   *     gtk_column_view_sort_by_column (view, column, order);
   *   }
   * ```
   * @class
   */
  class ColumnViewSorter extends Sorter {
    // Own properties of Gtk-4.0.Gtk.ColumnViewSorter

    static name: string

    // Constructors of Gtk-4.0.Gtk.ColumnViewSorter

    constructor(config?: ColumnViewSorter.ConstructorProperties)
    _init(config?: ColumnViewSorter.ConstructorProperties): void
  }

  module ComboBox {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `format-entry-text`
     */
    interface FormatEntryTextSignalCallback {
      (path: string | null): string | null
    }

    /**
     * Signal callback interface for `move-active`
     */
    interface MoveActiveSignalCallback {
      (scrollType: ScrollType): void
    }

    /**
     * Signal callback interface for `popdown`
     */
    interface PopdownSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `popup`
     */
    interface PopupSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        CellEditable.ConstructorProperties,
        CellLayout.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ComboBox

      /**
       * The item which is currently active.
       *
       * If the model is a non-flat treemodel, and the active item is not an
       * immediate child of the root of the tree, this property has the value
       * `gtk_tree_path_get_indices (path)[0]`, where `path` is the
       * [struct`Gtk`.TreePath] of the active item.
       */
      active?: number | null
      /**
       * The value of the ID column of the active row.
       */
      active_id?: string | null
      /**
       * Whether the dropdown button is sensitive when
       * the model is empty.
       */
      button_sensitivity?: SensitivityType | null
      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * The model column to associate with strings from the entry.
       *
       * This is property only relevant if the combo was created with
       * [property`Gtk`.ComboBox:has-entry] is %TRUE.
       */
      entry_text_column?: number | null
      /**
       * Whether the combo box has an entry.
       */
      has_entry?: boolean | null
      /**
       * The `has-frame` property controls whether a frame is drawn around the entry.
       */
      has_frame?: boolean | null
      /**
       * The model column that provides string IDs for the values
       * in the model, if != -1.
       */
      id_column?: number | null
      /**
       * The model from which the combo box takes its values.
       */
      model?: TreeModel | null
      /**
       * Whether the popup's width should be a fixed width matching the
       * allocated width of the combo box.
       */
      popup_fixed_width?: boolean | null
    }
  }

  interface ComboBox
    extends Accessible,
      Buildable,
      CellEditable,
      CellLayout,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ComboBox

    /**
     * The item which is currently active.
     *
     * If the model is a non-flat treemodel, and the active item is not an
     * immediate child of the root of the tree, this property has the value
     * `gtk_tree_path_get_indices (path)[0]`, where `path` is the
     * [struct`Gtk`.TreePath] of the active item.
     */
    active: number
    /**
     * The value of the ID column of the active row.
     */
    activeId: string | null
    /**
     * Whether the dropdown button is sensitive when
     * the model is empty.
     */
    buttonSensitivity: SensitivityType
    /**
     * The child widget.
     */
    child: Widget
    /**
     * The model column to associate with strings from the entry.
     *
     * This is property only relevant if the combo was created with
     * [property`Gtk`.ComboBox:has-entry] is %TRUE.
     */
    entryTextColumn: number
    /**
     * Whether the combo box has an entry.
     */
    readonly hasEntry: boolean
    /**
     * The `has-frame` property controls whether a frame is drawn around the entry.
     */
    hasFrame: boolean
    /**
     * The model column that provides string IDs for the values
     * in the model, if != -1.
     */
    idColumn: number
    /**
     * The model from which the combo box takes its values.
     */
    model: TreeModel
    /**
     * Whether the popup's width should be a fixed width matching the
     * allocated width of the combo box.
     */
    popupFixedWidth: boolean
    /**
     * Whether the combo boxes dropdown is popped up.
     *
     * Note that this property is mainly useful, because
     * it allows you to connect to notify::popup-shown.
     */
    readonly popupShown: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.ComboBox

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.ComboBox

    /**
     * Returns the index of the currently active item.
     *
     * If the model is a non-flat treemodel, and the active item is not
     * an immediate child of the root of the tree, this function returns
     * `gtk_tree_path_get_indices (path)[0]`, where `path` is the
     * [struct`Gtk`.TreePath] of the active item.
     * @returns An integer which is the index of the currently active item,   or -1 if there’s no active item
     */
    getActive(): number
    /**
     * Returns the ID of the active row of `combo_box`.
     *
     * This value is taken from the active row and the column specified
     * by the [property`Gtk`.ComboBox:id-column] property of `combo_box`
     * (see [method`Gtk`.ComboBox.set_id_column]).
     *
     * The returned value is an interned string which means that you can
     * compare the pointer by value to other interned strings and that you
     * must not free it.
     *
     * If the [property`Gtk`.ComboBox:id-column] property of `combo_box` is
     * not set, or if no row is active, or if the active row has a %NULL
     * ID value, then %NULL is returned.
     * @returns the ID of the active row
     */
    getActiveId(): string | null
    /**
     * Sets `iter` to point to the currently active item.
     *
     * If no item is active, `iter` is left unchanged.
     * @returns %TRUE if @iter was set, %FALSE otherwise
     */
    getActiveIter(): [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Returns whether the combo box sets the dropdown button
     * sensitive or not when there are no items in the model.
     * @returns %GTK_SENSITIVITY_ON if the dropdown button   is sensitive when the model is empty, %GTK_SENSITIVITY_OFF   if the button is always insensitive or %GTK_SENSITIVITY_AUTO   if it is only sensitive as long as the model has one item to   be selected.
     */
    getButtonSensitivity(): SensitivityType
    /**
     * Gets the child widget of `combo_box`.
     * @returns the child widget of @combo_box
     */
    getChild(): Widget | null
    /**
     * Returns the column which `combo_box` is using to get the strings
     * from to display in the internal entry.
     * @returns A column in the data source model of @combo_box.
     */
    getEntryTextColumn(): number
    /**
     * Returns whether the combo box has an entry.
     * @returns whether there is an entry in @combo_box.
     */
    getHasEntry(): boolean
    /**
     * Returns the column which `combo_box` is using to get string IDs
     * for values from.
     * @returns A column in the data source model of @combo_box.
     */
    getIdColumn(): number
    /**
     * Returns the `GtkTreeModel` of `combo_box`.
     * @returns A `GtkTreeModel` which was passed   during construction.
     */
    getModel(): TreeModel | null
    /**
     * Gets whether the popup uses a fixed width.
     * @returns %TRUE if the popup uses a fixed width
     */
    getPopupFixedWidth(): boolean
    /**
     * Hides the menu or dropdown list of `combo_box`.
     *
     * This function is mostly intended for use by accessibility technologies;
     * applications should have little use for it.
     */
    popdown(): void
    /**
     * Pops up the menu or dropdown list of `combo_box`.
     *
     * This function is mostly intended for use by accessibility technologies;
     * applications should have little use for it.
     *
     * Before calling this, `combo_box` must be mapped, or nothing will happen.
     */
    popup(): void
    /**
     * Pops up the menu of `combo_box`.
     *
     * Note that currently this does not do anything with the device, as it was
     * previously only used for list-mode combo boxes, and those were removed
     * in GTK 4. However, it is retained in case similar functionality is added
     * back later.
     * @param device a `GdkDevice`
     */
    popupForDevice(device: Gdk.Device): void
    /**
     * Sets the active item of `combo_box` to be the item at `index`.
     * @param index An index in the model passed during construction,   or -1 to have no active item
     */
    setActive(index: number): void
    /**
     * Changes the active row of `combo_box` to the one that has an ID equal to
     * `active_id`.
     *
     * If `active_id` is %NULL, the active row is unset. Rows having
     * a %NULL ID string cannot be made active by this function.
     *
     * If the [property`Gtk`.ComboBox:id-column] property of `combo_box` is
     * unset or if no row has the given ID then the function does nothing
     * and returns %FALSE.
     * @param activeId the ID of the row to select
     * @returns %TRUE if a row with a matching ID was found. If a %NULL   @active_id was given to unset the active row, the function   always returns %TRUE.
     */
    setActiveId(activeId: string | null): boolean
    /**
     * Sets the current active item to be the one referenced by `iter`.
     *
     * If `iter` is %NULL, the active item is unset.
     * @param iter The `GtkTreeIter`
     */
    setActiveIter(iter: TreeIter | null): void
    /**
     * Sets whether the dropdown button of the combo box should update
     * its sensitivity depending on the model contents.
     * @param sensitivity specify the sensitivity of the dropdown button
     */
    setButtonSensitivity(sensitivity: SensitivityType): void
    /**
     * Sets the child widget of `combo_box`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets the model column which `combo_box` should use to get strings
     * from to be `text_column`.
     *
     * For this column no separate
     * [class`Gtk`.CellRenderer] is needed.
     *
     * The column `text_column` in the model of `combo_box` must be of
     * type %G_TYPE_STRING.
     *
     * This is only relevant if `combo_box` has been created with
     * [property`Gtk`.ComboBox:has-entry] as %TRUE.
     * @param textColumn A column in `model` to get the strings from for   the internal entry
     */
    setEntryTextColumn(textColumn: number): void
    /**
     * Sets the model column which `combo_box` should use to get string IDs
     * for values from.
     *
     * The column `id_column` in the model of `combo_box` must be of type
     * %G_TYPE_STRING.
     * @param idColumn A column in `model` to get string IDs for values from
     */
    setIdColumn(idColumn: number): void
    /**
     * Sets the model used by `combo_box` to be `model`.
     *
     * Will unset a previously set model (if applicable). If model is %NULL,
     * then it will unset the model.
     *
     * Note that this function does not clear the cell renderers, you have to
     * call [method`Gtk`.CellLayout.clear] yourself if you need to set up different
     * cell renderers for the new model.
     * @param model A `GtkTreeModel`
     */
    setModel(model: TreeModel | null): void
    /**
     * Specifies whether the popup’s width should be a fixed width.
     *
     * If `fixed` is %TRUE, the popup's width is set to match the
     * allocated width of the combo box.
     * @param fixed whether to use a fixed popup width
     */
    setPopupFixedWidth(fixed: boolean): void
    /**
     * Sets the row separator function, which is used to determine
     * whether a row should be drawn as a separator.
     *
     * If the row separator function is %NULL, no separators are drawn.
     * This is the default value.
     * @param func a `GtkTreeViewRowSeparatorFunc`
     */
    setRowSeparatorFunc(func: TreeViewRowSeparatorFunc | null): void

    // Own virtual methods of Gtk-4.0.Gtk.ComboBox

    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean
    /**
     * Signal is emitted when the active item is changed.
     * @virtual
     */
    changed(): void
    /**
     * Signal which allows you to change how the text
     *    displayed in a combo box’s entry is displayed.
     * @virtual
     * @param path
     */
    formatEntryText(path: string): string | null

    // Own signals of Gtk-4.0.Gtk.ComboBox

    connect(
      sigName: "activate",
      callback: ComboBox.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: ComboBox.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: ComboBox.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: ComboBox.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "changed",
      callback: ComboBox.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: ComboBox.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: ComboBox.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: ComboBox.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "format-entry-text",
      callback: ComboBox.FormatEntryTextSignalCallback
    ): number
    on(
      sigName: "format-entry-text",
      callback: ComboBox.FormatEntryTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "format-entry-text",
      callback: ComboBox.FormatEntryTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "format-entry-text",
      callback: ComboBox.FormatEntryTextSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "format-entry-text", ...args: any[]): void
    connect(
      sigName: "move-active",
      callback: ComboBox.MoveActiveSignalCallback
    ): number
    on(
      sigName: "move-active",
      callback: ComboBox.MoveActiveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-active",
      callback: ComboBox.MoveActiveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-active",
      callback: ComboBox.MoveActiveSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "move-active", ...args: any[]): void
    connect(
      sigName: "popdown",
      callback: ComboBox.PopdownSignalCallback
    ): number
    on(
      sigName: "popdown",
      callback: ComboBox.PopdownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "popdown",
      callback: ComboBox.PopdownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "popdown",
      callback: ComboBox.PopdownSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "popdown", ...args: any[]): void
    connect(sigName: "popup", callback: ComboBox.PopupSignalCallback): number
    on(
      sigName: "popup",
      callback: ComboBox.PopupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "popup",
      callback: ComboBox.PopupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "popup",
      callback: ComboBox.PopupSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "popup", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ComboBox

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::active-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active-id", ...args: any[]): void
    connect(
      sigName: "notify::button-sensitivity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button-sensitivity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button-sensitivity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button-sensitivity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button-sensitivity", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::entry-text-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::entry-text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::entry-text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::entry-text-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::entry-text-column", ...args: any[]): void
    connect(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-entry", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::id-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::id-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::id-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::id-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::id-column", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::popup-fixed-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::popup-fixed-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::popup-fixed-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::popup-fixed-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::popup-fixed-width", ...args: any[]): void
    connect(
      sigName: "notify::popup-shown",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::popup-shown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::popup-shown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::popup-shown",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::popup-shown", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing-canceled", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkComboBox` is a widget that allows the user to choose from a list of
   * valid choices.
   *
   * ![An example GtkComboBox](combo-box.png)
   *
   * The `GtkComboBox` displays the selected choice; when activated, the
   * `GtkComboBox` displays a popup which allows the user to make a new choice.
   *
   * The `GtkComboBox` uses the model-view pattern; the list of valid choices
   * is specified in the form of a tree model, and the display of the choices
   * can be adapted to the data in the model by using cell renderers, as you
   * would in a tree view. This is possible since `GtkComboBox` implements the
   * [iface`Gtk`.CellLayout] interface. The tree model holding the valid
   * choices is not restricted to a flat list, it can be a real tree, and the
   * popup will reflect the tree structure.
   *
   * To allow the user to enter values not in the model, the
   * [property`Gtk`.ComboBox:has-entry] property allows the `GtkComboBox` to
   * contain a [class`Gtk`.Entry]. This entry can be accessed by calling
   * [method`Gtk`.ComboBox.get_child] on the combo box.
   *
   * For a simple list of textual choices, the model-view API of `GtkComboBox`
   * can be a bit overwhelming. In this case, [class`Gtk`.ComboBoxText] offers
   * a simple alternative. Both `GtkComboBox` and `GtkComboBoxText` can contain
   * an entry.
   *
   * ## CSS nodes
   *
   * ```
   * combobox
   * ├── box.linked
   * │   ╰── button.combo
   * │       ╰── box
   * │           ├── cellview
   * │           ╰── arrow
   * ╰── window.popup
   * ```
   *
   * A normal combobox contains a box with the .linked class, a button
   * with the .combo class and inside those buttons, there are a cellview and
   * an arrow.
   *
   * ```
   * combobox
   * ├── box.linked
   * │   ├── entry.combo
   * │   ╰── button.combo
   * │       ╰── box
   * │           ╰── arrow
   * ╰── window.popup
   * ```
   *
   * A `GtkComboBox` with an entry has a single CSS node with name combobox.
   * It contains a box with the .linked class. That box contains an entry and
   * a button, both with the .combo class added. The button also contains another
   * node with name arrow.
   *
   * ## Accessibility
   *
   * `GtkComboBox` uses the %GTK_ACCESSIBLE_ROLE_COMBO_BOX role.
   * @class
   */
  class ComboBox extends Widget {
    // Own properties of Gtk-4.0.Gtk.ComboBox

    static name: string

    // Constructors of Gtk-4.0.Gtk.ComboBox

    constructor(config?: ComboBox.ConstructorProperties)
    /**
     * Creates a new empty `GtkComboBox`.
     * @constructor
     * @returns A new `GtkComboBox`
     */
    constructor()
    /**
     * Creates a new empty `GtkComboBox`.
     * @constructor
     * @returns A new `GtkComboBox`
     */
    static new(): ComboBox
    /**
     * Creates a new empty `GtkComboBox` with an entry.
     *
     * In order to use a combo box with entry, you need to tell it
     * which column of the model contains the text for the entry
     * by calling [method`Gtk`.ComboBox.set_entry_text_column].
     * @constructor
     * @returns A new `GtkComboBox`
     */
    static newWithEntry(): ComboBox
    /**
     * Creates a new `GtkComboBox` with a model.
     * @constructor
     * @param model a `GtkTreeModel`
     * @returns A new `GtkComboBox`
     */
    static newWithModel(model: TreeModel): ComboBox
    /**
     * Creates a new empty `GtkComboBox` with an entry and a model.
     *
     * See also [ctor`Gtk`.ComboBox.new_with_entry].
     * @constructor
     * @param model A `GtkTreeModel`
     * @returns A new `GtkComboBox`
     */
    static newWithModelAndEntry(model: TreeModel): ComboBox
    _init(config?: ComboBox.ConstructorProperties): void
  }

  module ComboBoxText {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        CellEditable.ConstructorProperties,
        CellLayout.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        ComboBox.ConstructorProperties {}
  }

  interface ComboBoxText
    extends Accessible,
      Buildable,
      CellEditable,
      CellLayout,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ComboBoxText

    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.ComboBoxText

    /**
     * Appends `text` to the list of strings stored in `combo_box`.
     *
     * If `id` is non-%NULL then it is used as the ID of the row.
     *
     * This is the same as calling [method`Gtk`.ComboBoxText.insert]
     * with a position of -1.
     * @param id a string ID for this value
     * @param text A string
     */
    append(id: string | null, text: string): void
    /**
     * Appends `text` to the list of strings stored in `combo_box`.
     *
     * This is the same as calling [method`Gtk`.ComboBoxText.insert_text]
     * with a position of -1.
     * @param text A string
     */
    appendText(text: string): void
    /**
     * Returns the currently active string in `combo_box`.
     *
     * If no row is currently selected, %NULL is returned.
     * If `combo_box` contains an entry, this function will
     * return its contents (which will not necessarily
     * be an item from the list).
     * @returns a newly allocated   string containing the currently active text.   Must be freed with g_free().
     */
    getActiveText(): string | null
    /**
     * Inserts `text` at `position` in the list of strings stored in `combo_box`.
     *
     * If `id` is non-%NULL then it is used as the ID of the row.
     * See [property`Gtk`.ComboBox:id-column].
     *
     * If `position` is negative then `text` is appended.
     * @param position An index to insert `text`
     * @param id a string ID for this value
     * @param text A string to display
     */
    insert(position: number, id: string | null, text: string): void
    /**
     * Inserts `text` at `position` in the list of strings stored in `combo_box`.
     *
     * If `position` is negative then `text` is appended.
     *
     * This is the same as calling [method`Gtk`.ComboBoxText.insert]
     * with a %NULL ID string.
     * @param position An index to insert `text`
     * @param text A string
     */
    insertText(position: number, text: string): void
    /**
     * Prepends `text` to the list of strings stored in `combo_box`.
     *
     * If `id` is non-%NULL then it is used as the ID of the row.
     *
     * This is the same as calling [method`Gtk`.ComboBoxText.insert]
     * with a position of 0.
     * @param id a string ID for this value
     * @param text a string
     */
    prepend(id: string | null, text: string): void
    /**
     * Prepends `text` to the list of strings stored in `combo_box`.
     *
     * This is the same as calling [method`Gtk`.ComboBoxText.insert_text]
     * with a position of 0.
     * @param text A string
     */
    prependText(text: string): void
    /**
     * Removes the string at `position` from `combo_box`.
     * @param position Index of the item to remove
     */
    remove(position: number): void
    /**
     * Removes all the text entries from the combo box.
     */
    removeAll(): void

    // Conflicting methods

    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean
    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean

    // Class property signals of Gtk-4.0.Gtk.ComboBoxText

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::active-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active-id", ...args: any[]): void
    connect(
      sigName: "notify::button-sensitivity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button-sensitivity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button-sensitivity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button-sensitivity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button-sensitivity", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::entry-text-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::entry-text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::entry-text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::entry-text-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::entry-text-column", ...args: any[]): void
    connect(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-entry",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-entry", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::id-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::id-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::id-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::id-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::id-column", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::popup-fixed-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::popup-fixed-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::popup-fixed-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::popup-fixed-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::popup-fixed-width", ...args: any[]): void
    connect(
      sigName: "notify::popup-shown",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::popup-shown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::popup-shown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::popup-shown",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::popup-shown", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing-canceled", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkComboBoxText` is a simple variant of `GtkComboBox` for text-only
   * use cases.
   *
   * ![An example GtkComboBoxText](combo-box-text.png)
   *
   * `GtkComboBoxText` hides the model-view complexity of `GtkComboBox`.
   *
   * To create a `GtkComboBoxText`, use [ctor`Gtk`.ComboBoxText.new] or
   * [ctor`Gtk`.ComboBoxText.new_with_entry].
   *
   * You can add items to a `GtkComboBoxText` with
   * [method`Gtk`.ComboBoxText.append_text],
   * [method`Gtk`.ComboBoxText.insert_text] or
   * [method`Gtk`.ComboBoxText.prepend_text] and remove options with
   * [method`Gtk`.ComboBoxText.remove].
   *
   * If the `GtkComboBoxText` contains an entry (via the
   * [property`Gtk`.ComboBox:has-entry] property), its contents can be retrieved
   * using [method`Gtk`.ComboBoxText.get_active_text].
   *
   * You should not call [method`Gtk`.ComboBox.set_model] or attempt to pack more
   * cells into this combo box via its [iface`Gtk`.CellLayout] interface.
   *
   * ## GtkComboBoxText as GtkBuildable
   *
   * The `GtkComboBoxText` implementation of the `GtkBuildable` interface supports
   * adding items directly using the `<items>` element and specifying `<item>`
   * elements for each item. Each `<item>` element can specify the “id”
   * corresponding to the appended text and also supports the regular
   * translation attributes “translatable”, “context” and “comments”.
   *
   * Here is a UI definition fragment specifying `GtkComboBoxText` items:
   * ```xml
   * <object class="GtkComboBoxText">
   *   <items>
   *     <item translatable="yes" id="factory">Factory</item>
   *     <item translatable="yes" id="home">Home</item>
   *     <item translatable="yes" id="subway">Subway</item>
   *   </items>
   * </object>
   * ```
   *
   * ## CSS nodes
   *
   * ```
   * combobox
   * ╰── box.linked
   *     ├── entry.combo
   *     ├── button.combo
   *     ╰── window.popup
   * ```
   *
   * `GtkComboBoxText` has a single CSS node with name combobox. It adds
   * the style class .combo to the main CSS nodes of its entry and button
   * children, and the .linked class to the node of its internal box.
   * @class
   */
  class ComboBoxText extends ComboBox {
    // Own properties of Gtk-4.0.Gtk.ComboBoxText

    static name: string

    // Constructors of Gtk-4.0.Gtk.ComboBoxText

    constructor(config?: ComboBoxText.ConstructorProperties)
    /**
     * Creates a new `GtkComboBoxText`.
     * @constructor
     * @returns A new `GtkComboBoxText`
     */
    constructor()
    /**
     * Creates a new `GtkComboBoxText`.
     * @constructor
     * @returns A new `GtkComboBoxText`
     */
    static new(): ComboBoxText
    /**
     * Creates a new `GtkComboBoxText` with an entry.
     * @constructor
     * @returns a new `GtkComboBoxText`
     */
    static newWithEntry(): ComboBoxText
    _init(config?: ComboBoxText.ConstructorProperties): void
  }

  interface ConstantExpression {
    // Owm methods of Gtk-4.0.Gtk.ConstantExpression

    /**
     * Gets the value that a constant expression evaluates to.
     * @returns the value
     */
    getValue(): any
  }

  /**
   * A constant value in a `GtkExpression`.
   * @class
   */
  class ConstantExpression extends Expression {
    // Own properties of Gtk-4.0.Gtk.ConstantExpression

    static name: string

    // Constructors of Gtk-4.0.Gtk.ConstantExpression

    /**
     * Creates an expression that always evaluates to the given `value`.
     * @constructor
     * @param value a `GValue`
     * @returns a new `GtkExpression`
     */
    static newForValue(value: any): ConstantExpression
  }

  module Constraint {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Constraint

      /**
       * The constant value to be added to the [property`Gtk`.Constraint:source-attribute].
       */
      constant?: number | null
      /**
       * The multiplication factor to be applied to
       * the [property`Gtk`.Constraint:source-attribute].
       */
      multiplier?: number | null
      /**
       * The order relation between the terms of the constraint.
       */
      relation?: ConstraintRelation | null
      /**
       * The source of the constraint.
       *
       * The constraint will set the [property`Gtk`.Constraint:target-attribute]
       * property of the target using the [property`Gtk`.Constraint:source-attribute]
       * property of the source.
       */
      source?: ConstraintTarget | null
      /**
       * The attribute of the [property`Gtk`.Constraint:source] read by the
       * constraint.
       */
      source_attribute?: ConstraintAttribute | null
      /**
       * The strength of the constraint.
       *
       * The strength can be expressed either using one of the symbolic values
       * of the [enum`Gtk`.ConstraintStrength] enumeration, or any positive integer
       * value.
       */
      strength?: number | null
      /**
       * The target of the constraint.
       *
       * The constraint will set the [property`Gtk`.Constraint:target-attribute]
       * property of the target using the [property`Gtk`.Constraint:source-attribute]
       * property of the source widget.
       */
      target?: ConstraintTarget | null
      /**
       * The attribute of the [property`Gtk`.Constraint:target] set by the constraint.
       */
      target_attribute?: ConstraintAttribute | null
    }
  }

  interface Constraint {
    // Own properties of Gtk-4.0.Gtk.Constraint

    /**
     * The constant value to be added to the [property`Gtk`.Constraint:source-attribute].
     */
    readonly constant: number
    /**
     * The multiplication factor to be applied to
     * the [property`Gtk`.Constraint:source-attribute].
     */
    readonly multiplier: number
    /**
     * The order relation between the terms of the constraint.
     */
    readonly relation: ConstraintRelation
    /**
     * The source of the constraint.
     *
     * The constraint will set the [property`Gtk`.Constraint:target-attribute]
     * property of the target using the [property`Gtk`.Constraint:source-attribute]
     * property of the source.
     */
    readonly source: ConstraintTarget
    /**
     * The attribute of the [property`Gtk`.Constraint:source] read by the
     * constraint.
     */
    readonly sourceAttribute: ConstraintAttribute
    /**
     * The strength of the constraint.
     *
     * The strength can be expressed either using one of the symbolic values
     * of the [enum`Gtk`.ConstraintStrength] enumeration, or any positive integer
     * value.
     */
    readonly strength: number
    /**
     * The target of the constraint.
     *
     * The constraint will set the [property`Gtk`.Constraint:target-attribute]
     * property of the target using the [property`Gtk`.Constraint:source-attribute]
     * property of the source widget.
     */
    readonly target: ConstraintTarget
    /**
     * The attribute of the [property`Gtk`.Constraint:target] set by the constraint.
     */
    readonly targetAttribute: ConstraintAttribute
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Constraint

    /**
     * Retrieves the constant factor added to the source attributes' value.
     * @returns a constant factor
     */
    getConstant(): number
    /**
     * Retrieves the multiplication factor applied to the source
     * attribute's value.
     * @returns a multiplication factor
     */
    getMultiplier(): number
    /**
     * The order relation between the terms of the constraint.
     * @returns a relation type
     */
    getRelation(): ConstraintRelation
    /**
     * Retrieves the [iface`Gtk`.ConstraintTarget] used as the source for the
     * constraint.
     *
     * If the source is set to `NULL` at creation, the constraint will use
     * the widget using the [class`Gtk`.ConstraintLayout] as the source.
     * @returns the source of the constraint
     */
    getSource(): ConstraintTarget | null
    /**
     * Retrieves the attribute of the source to be read by the constraint.
     * @returns the source's attribute
     */
    getSourceAttribute(): ConstraintAttribute
    /**
     * Retrieves the strength of the constraint.
     * @returns the strength value
     */
    getStrength(): number
    /**
     * Retrieves the [iface`Gtk`.ConstraintTarget] used as the target for
     * the constraint.
     *
     * If the targe is set to `NULL` at creation, the constraint will use
     * the widget using the [class`Gtk`.ConstraintLayout] as the target.
     * @returns a `GtkConstraintTarget`
     */
    getTarget(): ConstraintTarget | null
    /**
     * Retrieves the attribute of the target to be set by the constraint.
     * @returns the target's attribute
     */
    getTargetAttribute(): ConstraintAttribute
    /**
     * Checks whether the constraint is attached to a [class`Gtk`.ConstraintLayout],
     * and it is contributing to the layout.
     * @returns `TRUE` if the constraint is attached
     */
    isAttached(): boolean
    /**
     * Checks whether the constraint describes a relation between an attribute
     * on the [property`Gtk`.Constraint:target] and a constant value.
     * @returns `TRUE` if the constraint is a constant relation
     */
    isConstant(): boolean
    /**
     * Checks whether the constraint is a required relation for solving the
     * constraint layout.
     * @returns %TRUE if the constraint is required
     */
    isRequired(): boolean

    // Class property signals of Gtk-4.0.Gtk.Constraint

    connect(
      sigName: "notify::constant",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::constant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::constant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::constant",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::constant", ...args: any[]): void
    connect(
      sigName: "notify::multiplier",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::multiplier",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::multiplier",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::multiplier",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::multiplier", ...args: any[]): void
    connect(
      sigName: "notify::relation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::relation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::relation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::relation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::relation", ...args: any[]): void
    connect(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::source",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::source",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::source", ...args: any[]): void
    connect(
      sigName: "notify::source-attribute",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::source-attribute",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::source-attribute",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::source-attribute",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::source-attribute", ...args: any[]): void
    connect(
      sigName: "notify::strength",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strength",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strength",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strength",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strength", ...args: any[]): void
    connect(
      sigName: "notify::target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::target", ...args: any[]): void
    connect(
      sigName: "notify::target-attribute",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::target-attribute",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::target-attribute",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::target-attribute",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::target-attribute", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkConstraint` describes a constraint between attributes of two widgets,
   *  expressed as a linear equation.
   *
   * The typical equation for a constraint is:
   *
   * ```
   *   target.target_attr = source.source_attr × multiplier + constant
   * ```
   *
   * Each `GtkConstraint` is part of a system that will be solved by a
   * [class`Gtk`.ConstraintLayout] in order to allocate and position each
   * child widget or guide.
   *
   * The source and target, as well as their attributes, of a `GtkConstraint`
   * instance are immutable after creation.
   * @class
   */
  class Constraint extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Constraint

    static name: string

    // Constructors of Gtk-4.0.Gtk.Constraint

    constructor(config?: Constraint.ConstructorProperties)
    /**
     * Creates a new constraint representing a relation between a layout
     * attribute on a source and a layout attribute on a target.
     * @constructor
     * @param target the target of the constraint
     * @param targetAttribute the attribute of `target` to be set
     * @param relation the relation equivalence between `target_attribute` and `source_attribute`
     * @param source the source of the constraint
     * @param sourceAttribute the attribute of `source` to be read
     * @param multiplier a multiplication factor to be applied to `source_attribute`
     * @param constant a constant factor to be added to `source_attribute`
     * @param strength the strength of the constraint
     * @returns the newly created constraint
     */
    constructor(
      target: ConstraintTarget | null,
      targetAttribute: ConstraintAttribute,
      relation: ConstraintRelation,
      source: ConstraintTarget | null,
      sourceAttribute: ConstraintAttribute,
      multiplier: number,
      constant: number,
      strength: number
    )
    /**
     * Creates a new constraint representing a relation between a layout
     * attribute on a source and a layout attribute on a target.
     * @constructor
     * @param target the target of the constraint
     * @param targetAttribute the attribute of `target` to be set
     * @param relation the relation equivalence between `target_attribute` and `source_attribute`
     * @param source the source of the constraint
     * @param sourceAttribute the attribute of `source` to be read
     * @param multiplier a multiplication factor to be applied to `source_attribute`
     * @param constant a constant factor to be added to `source_attribute`
     * @param strength the strength of the constraint
     * @returns the newly created constraint
     */
    static new(
      target: ConstraintTarget | null,
      targetAttribute: ConstraintAttribute,
      relation: ConstraintRelation,
      source: ConstraintTarget | null,
      sourceAttribute: ConstraintAttribute,
      multiplier: number,
      constant: number,
      strength: number
    ): Constraint
    /**
     * Creates a new constraint representing a relation between a layout
     * attribute on a target and a constant value.
     * @constructor
     * @param target a the target of the constraint
     * @param targetAttribute the attribute of `target` to be set
     * @param relation the relation equivalence between `target_attribute` and `constant`
     * @param constant a constant factor to be set on `target_attribute`
     * @param strength the strength of the constraint
     * @returns the newly created constraint
     */
    static newConstant(
      target: ConstraintTarget | null,
      targetAttribute: ConstraintAttribute,
      relation: ConstraintRelation,
      constant: number,
      strength: number
    ): Constraint
    _init(config?: Constraint.ConstructorProperties): void
  }

  module ConstraintGuide {
    // Constructor properties interface

    interface ConstructorProperties
      extends ConstraintTarget.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ConstraintGuide

      /**
       * The maximum height of the guide.
       */
      max_height?: number | null
      /**
       * The maximum width of the guide.
       */
      max_width?: number | null
      /**
       * The minimum height of the guide.
       */
      min_height?: number | null
      /**
       * The minimum width of the guide.
       */
      min_width?: number | null
      /**
       * A name that identifies the `GtkConstraintGuide`, for debugging.
       */
      name?: string | null
      /**
       * The preferred, or natural, height of the guide.
       */
      nat_height?: number | null
      /**
       * The preferred, or natural, width of the guide.
       */
      nat_width?: number | null
      /**
       * The `GtkConstraintStrength` to be used for the constraint on
       * the natural size of the guide.
       */
      strength?: ConstraintStrength | null
    }
  }

  interface ConstraintGuide extends ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ConstraintGuide

    /**
     * The maximum height of the guide.
     */
    maxHeight: number
    /**
     * The maximum width of the guide.
     */
    maxWidth: number
    /**
     * The minimum height of the guide.
     */
    minHeight: number
    /**
     * The minimum width of the guide.
     */
    minWidth: number
    /**
     * A name that identifies the `GtkConstraintGuide`, for debugging.
     */
    name: string | null
    /**
     * The preferred, or natural, height of the guide.
     */
    natHeight: number
    /**
     * The preferred, or natural, width of the guide.
     */
    natWidth: number
    /**
     * The `GtkConstraintStrength` to be used for the constraint on
     * the natural size of the guide.
     */
    strength: ConstraintStrength
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ConstraintGuide

    /**
     * Gets the maximum size of `guide`.
     */
    getMaxSize(): [/* width */ number, /* height */ number]
    /**
     * Gets the minimum size of `guide`.
     */
    getMinSize(): [/* width */ number, /* height */ number]
    /**
     * Retrieves the name set using gtk_constraint_guide_set_name().
     * @returns the name of the guide
     */
    getName(): string | null
    /**
     * Gets the natural size of `guide`.
     */
    getNatSize(): [/* width */ number, /* height */ number]
    /**
     * Retrieves the strength set using gtk_constraint_guide_set_strength().
     * @returns the strength of the constraint on the natural size
     */
    getStrength(): ConstraintStrength
    /**
     * Sets the maximum size of `guide`.
     *
     * If `guide` is attached to a `GtkConstraintLayout`,
     * the constraints will be updated to reflect the new size.
     * @param width the new maximum width, or -1 to not change it
     * @param height the new maximum height, or -1 to not change it
     */
    setMaxSize(width: number, height: number): void
    /**
     * Sets the minimum size of `guide`.
     *
     * If `guide` is attached to a `GtkConstraintLayout`,
     * the constraints will be updated to reflect the new size.
     * @param width the new minimum width, or -1 to not change it
     * @param height the new minimum height, or -1 to not change it
     */
    setMinSize(width: number, height: number): void
    /**
     * Sets a name for the given `GtkConstraintGuide`.
     *
     * The name is useful for debugging purposes.
     * @param name a name for the `guide`
     */
    setName(name: string | null): void
    /**
     * Sets the natural size of `guide`.
     *
     * If `guide` is attached to a `GtkConstraintLayout`,
     * the constraints will be updated to reflect the new size.
     * @param width the new natural width, or -1 to not change it
     * @param height the new natural height, or -1 to not change it
     */
    setNatSize(width: number, height: number): void
    /**
     * Sets the strength of the constraint on the natural size of the
     * given `GtkConstraintGuide`.
     * @param strength the strength of the constraint
     */
    setStrength(strength: ConstraintStrength): void

    // Class property signals of Gtk-4.0.Gtk.ConstraintGuide

    connect(
      sigName: "notify::max-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-height", ...args: any[]): void
    connect(
      sigName: "notify::max-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width", ...args: any[]): void
    connect(
      sigName: "notify::min-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-height", ...args: any[]): void
    connect(
      sigName: "notify::min-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-width", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::nat-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::nat-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::nat-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::nat-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::nat-height", ...args: any[]): void
    connect(
      sigName: "notify::nat-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::nat-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::nat-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::nat-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::nat-width", ...args: any[]): void
    connect(
      sigName: "notify::strength",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strength",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strength",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strength",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strength", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkConstraintGuide` is an invisible layout element in a
   * `GtkConstraintLayout`.
   *
   * The `GtkConstraintLayout` treats guides like widgets. They
   * can be used as the source or target of a `GtkConstraint`.
   *
   * Guides have a minimum, maximum and natural size. Depending
   * on the constraints that are applied, they can act like a
   * guideline that widgets can be aligned to, or like *flexible
   * space*.
   *
   * Unlike a `GtkWidget`, a `GtkConstraintGuide` will not be drawn.
   * @class
   */
  class ConstraintGuide extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ConstraintGuide

    static name: string

    // Constructors of Gtk-4.0.Gtk.ConstraintGuide

    constructor(config?: ConstraintGuide.ConstructorProperties)
    /**
     * Creates a new `GtkConstraintGuide` object.
     * @constructor
     * @returns a new `GtkConstraintGuide` object.
     */
    constructor()
    /**
     * Creates a new `GtkConstraintGuide` object.
     * @constructor
     * @returns a new `GtkConstraintGuide` object.
     */
    static new(): ConstraintGuide
    _init(config?: ConstraintGuide.ConstructorProperties): void
  }

  module ConstraintLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        LayoutManager.ConstructorProperties {}
  }

  interface ConstraintLayout extends Buildable {
    // Own properties of Gtk-4.0.Gtk.ConstraintLayout

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ConstraintLayout

    /**
     * Adds a constraint to the layout manager.
     *
     * The [property`Gtk`.Constraint:source] and [property`Gtk`.Constraint:target]
     * properties of `constraint` can be:
     *
     *  - set to `NULL` to indicate that the constraint refers to the
     *    widget using `layout`
     *  - set to the [class`Gtk`.Widget] using `layout`
     *  - set to a child of the [class`Gtk`.Widget] using `layout`
     *  - set to a [class`Gtk`.ConstraintGuide] that is part of `layout`
     *
     * The `layout` acquires the ownership of `constraint` after calling
     * this function.
     * @param constraint a [class`Gtk`.Constraint]
     */
    addConstraint(constraint: Constraint): void
    /**
     * Creates a list of constraints from a VFL description.
     *
     * The Visual Format Language, VFL, is based on Apple's AutoLayout [VFL](https://developer.apple.com/library/content/documentation/UserExperience/Conceptual/AutolayoutPG/VisualFormatLanguage.html).
     *
     * The `views` dictionary is used to match [iface`Gtk`.ConstraintTarget]
     * instances to the symbolic view name inside the VFL.
     *
     * The VFL grammar is:
     *
     * ```
     *        <visualFormatString> = (<orientation>)?
     *                               (<superview><connection>)?
     *                               <view>(<connection><view>)*
     *                               (<connection><superview>)?
     *               <orientation> = 'H' | 'V'
     *                 <superview> = '|'
     *                <connection> = '' | '-' <predicateList> '-' | '-'
     *             <predicateList> = <simplePredicate> | <predicateListWithParens>
     *           <simplePredicate> = <metricName> | <positiveNumber>
     *   <predicateListWithParens> = '(' <predicate> (',' <predicate>)* ')'
     *                 <predicate> = (<relation>)? <objectOfPredicate> (<operatorList>)? ('`'` <priority>)?
     *                  <relation> = '==' | '<=' | '>='
     *         <objectOfPredicate> = <constant> | <viewName> | ('.' <attributeName>)?
     *                  <priority> = <positiveNumber> | 'required' | 'strong' | 'medium' | 'weak'
     *                  <constant> = <number>
     *              <operatorList> = (<multiplyOperator>)? (<addOperator>)?
     *          <multiplyOperator> = [ '*' | '/' ] <positiveNumber>
     *               <addOperator> = [ '+' | '-' ] <positiveNumber>
     *                  <viewName> = [A-Za-z_]([A-Za-z0-9_]*) // A C identifier
     *                <metricName> = [A-Za-z_]([A-Za-z0-9_]*) // A C identifier
     *             <attributeName> = 'top' | 'bottom' | 'left' | 'right' | 'width' | 'height' |
     *                               'start' | 'end' | 'centerX' | 'centerY' | 'baseline'
     *            <positiveNumber> // A positive real number parseable by g_ascii_strtod()
     *                    <number> // A real number parseable by g_ascii_strtod()
     * ```
     *
     * **Note**: The VFL grammar used by GTK is slightly different than the one
     * defined by Apple, as it can use symbolic values for the constraint's
     * strength instead of numeric values; additionally, GTK allows adding
     * simple arithmetic operations inside predicates.
     *
     * Examples of VFL descriptions are:
     *
     * ```
     *   // Default spacing
     *   [button]-[textField]
     *
     *   // Width constraint
     *   [button(>=50)]
     *
     *   // Connection to super view
     *   |-50-[purpleBox]-50-|
     *
     *   // Vertical layout
     *   V:[topField]-10-[bottomField]
     *
     *   // Flush views
     *   [maroonView][blueView]
     *
     *   // Priority
     *   [button(100`strong)`]
     *
     *   // Equal widths
     *   [button1(==button2)]
     *
     *   // Multiple predicates
     *   [flexibleButton(>=70,<=100)]
     *
     *   // A complete line of layout
     *   |-[find]-[findNext]-[findField(>=20)]-|
     *
     *   // Operators
     *   [button1(button2 / 3 + 50)]
     *
     *   // Named attributes
     *   [button1(==button2.height)]
     * ```
     * @param lines an array of Visual Format Language lines   defining a set of constraints
     * @param hspacing default horizontal spacing value, or -1 for the fallback value
     * @param vspacing default vertical spacing value, or -1 for the fallback value
     * @param views a dictionary of `[ name, target ]`   pairs; the `name` keys map to the view names in the VFL lines, while   the `target` values map to children of the widget using a `GtkConstraintLayout`,   or guides
     * @returns the list of   [class@Gtk.Constraint] instances that were added to the layout
     */
    addConstraintsFromDescription(
      lines: string[],
      hspacing: number,
      vspacing: number,
      views: GLib.HashTable
    ): Constraint[]
    /**
     * Adds a guide to `layout`.
     *
     * A guide can be used as the source or target of constraints,
     * like a widget, but it is not visible.
     *
     * The `layout` acquires the ownership of `guide` after calling
     * this function.
     * @param guide a [class`Gtk`.ConstraintGuide] object
     */
    addGuide(guide: ConstraintGuide): void
    /**
     * Returns a `GListModel` to track the constraints that are
     * part of the layout.
     *
     * Calling this function will enable extra internal bookkeeping
     * to track constraints and emit signals on the returned listmodel.
     * It may slow down operations a lot.
     *
     * Applications should try hard to avoid calling this function
     * because of the slowdowns.
     * @returns a   `GListModel` tracking the layout's constraints
     */
    observeConstraints(): Gio.ListModel
    /**
     * Returns a `GListModel` to track the guides that are
     * part of the layout.
     *
     * Calling this function will enable extra internal bookkeeping
     * to track guides and emit signals on the returned listmodel.
     * It may slow down operations a lot.
     *
     * Applications should try hard to avoid calling this function
     * because of the slowdowns.
     * @returns a   `GListModel` tracking the layout's guides
     */
    observeGuides(): Gio.ListModel
    /**
     * Removes all constraints from the layout manager.
     */
    removeAllConstraints(): void
    /**
     * Removes `constraint` from the layout manager,
     * so that it no longer influences the layout.
     * @param constraint a [class`Gtk`.Constraint]
     */
    removeConstraint(constraint: Constraint): void
    /**
     * Removes `guide` from the layout manager,
     * so that it no longer influences the layout.
     * @param guide a [class`Gtk`.ConstraintGuide] object
     */
    removeGuide(guide: ConstraintGuide): void

    // Class property signals of Gtk-4.0.Gtk.ConstraintLayout

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A layout manager using constraints to describe relations between widgets.
   *
   * `GtkConstraintLayout` is a layout manager that uses relations between
   * widget attributes, expressed via [class`Gtk`.Constraint] instances, to
   * measure and allocate widgets.
   *
   * ### How do constraints work
   *
   * Constraints are objects defining the relationship between attributes
   * of a widget; you can read the description of the [class`Gtk`.Constraint]
   * class to have a more in depth definition.
   *
   * By taking multiple constraints and applying them to the children of
   * a widget using `GtkConstraintLayout`, it's possible to describe
   * complex layout policies; each constraint applied to a child or to the parent
   * widgets contributes to the full description of the layout, in terms of
   * parameters for resolving the value of each attribute.
   *
   * It is important to note that a layout is defined by the totality of
   * constraints; removing a child, or a constraint, from an existing layout
   * without changing the remaining constraints may result in an unstable
   * or unsolvable layout.
   *
   * Constraints have an implicit "reading order"; you should start describing
   * each edge of each child, as well as their relationship with the parent
   * container, from the top left (or top right, in RTL languages), horizontally
   * first, and then vertically.
   *
   * A constraint-based layout with too few constraints can become "unstable",
   * that is: have more than one solution. The behavior of an unstable layout
   * is undefined.
   *
   * A constraint-based layout with conflicting constraints may be unsolvable,
   * and lead to an unstable layout. You can use the [property`Gtk`.Constraint:strength]
   * property of [class`Gtk`.Constraint] to "nudge" the layout towards a solution.
   *
   * ### GtkConstraintLayout as GtkBuildable
   *
   * `GtkConstraintLayout` implements the [iface`Gtk`.Buildable] interface and
   * has a custom "constraints" element which allows describing constraints in
   * a [class`Gtk`.Builder] UI file.
   *
   * An example of a UI definition fragment specifying a constraint:
   *
   * ```xml
   *   <object class="GtkConstraintLayout">
   *     <constraints>
   *       <constraint target="button" target-attribute="start"
   *                   relation="eq"
   *                   source="super" source-attribute="start"
   *                   constant="12"
   *                   strength="required" />
   *       <constraint target="button" target-attribute="width"
   *                   relation="ge"
   *                   constant="250"
   *                   strength="strong" />
   *     </constraints>
   *   </object>
   * ```
   *
   * The definition above will add two constraints to the GtkConstraintLayout:
   *
   *  - a required constraint between the leading edge of "button" and
   *    the leading edge of the widget using the constraint layout, plus
   *    12 pixels
   *  - a strong, constant constraint making the width of "button" greater
   *    than, or equal to 250 pixels
   *
   * The "target" and "target-attribute" attributes are required.
   *
   * The "source" and "source-attribute" attributes of the "constraint"
   * element are optional; if they are not specified, the constraint is
   * assumed to be a constant.
   *
   * The "relation" attribute is optional; if not specified, the constraint
   * is assumed to be an equality.
   *
   * The "strength" attribute is optional; if not specified, the constraint
   * is assumed to be required.
   *
   * The "source" and "target" attributes can be set to "super" to indicate
   * that the constraint target is the widget using the GtkConstraintLayout.
   *
   * There can be "constant" and "multiplier" attributes.
   *
   * Additionally, the "constraints" element can also contain a description
   * of the `GtkConstraintGuides` used by the layout:
   *
   * ```xml
   *   <constraints>
   *     <guide min-width="100" max-width="500" name="hspace"/>
   *     <guide min-height="64" nat-height="128" name="vspace" strength="strong"/>
   *   </constraints>
   * ```
   *
   * The "guide" element has the following optional attributes:
   *
   *   - "min-width", "nat-width", and "max-width", describe the minimum,
   *     natural, and maximum width of the guide, respectively
   *   - "min-height", "nat-height", and "max-height", describe the minimum,
   *     natural, and maximum height of the guide, respectively
   *   - "strength" describes the strength of the constraint on the natural
   *     size of the guide; if not specified, the constraint is assumed to
   *     have a medium strength
   *   - "name" describes a name for the guide, useful when debugging
   *
   * ### Using the Visual Format Language
   *
   * Complex constraints can be described using a compact syntax called VFL,
   * or *Visual Format Language*.
   *
   * The Visual Format Language describes all the constraints on a row or
   * column, typically starting from the leading edge towards the trailing
   * one. Each element of the layout is composed by "views", which identify
   * a [iface`Gtk`.ConstraintTarget].
   *
   * For instance:
   *
   * ```
   *   [button]-[textField]
   * ```
   *
   * Describes a constraint that binds the trailing edge of "button" to the
   * leading edge of "textField", leaving a default space between the two.
   *
   * Using VFL is also possible to specify predicates that describe constraints
   * on attributes like width and height:
   *
   * ```
   *   // Width must be greater than, or equal to 50
   *   [button(>=50)]
   *
   *   // Width of button1 must be equal to width of button2
   *   [button1(==button2)]
   * ```
   *
   * The default orientation for a VFL description is horizontal, unless
   * otherwise specified:
   *
   * ```
   *   // horizontal orientation, default attribute: width
   *   H:[button(>=150)]
   *
   *   // vertical orientation, default attribute: height
   *   V:[button1(==button2)]
   * ```
   *
   * It's also possible to specify multiple predicates, as well as their
   * strength:
   *
   * ```
   *   // minimum width of button must be 150
   *   // natural width of button can be 250
   *   [button(>=150`required,` ==250`medium)`]
   * ```
   *
   * Finally, it's also possible to use simple arithmetic operators:
   *
   * ```
   *   // width of button1 must be equal to width of button2
   *   // divided by 2 plus 12
   *   [button1(button2 / 2 + 12)]
   * ```
   * @class
   */
  class ConstraintLayout extends LayoutManager {
    // Own properties of Gtk-4.0.Gtk.ConstraintLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.ConstraintLayout

    constructor(config?: ConstraintLayout.ConstructorProperties)
    /**
     * Creates a new `GtkConstraintLayout` layout manager.
     * @constructor
     * @returns the newly created `GtkConstraintLayout`
     */
    constructor()
    /**
     * Creates a new `GtkConstraintLayout` layout manager.
     * @constructor
     * @returns the newly created `GtkConstraintLayout`
     */
    static new(): ConstraintLayout
    _init(config?: ConstraintLayout.ConstructorProperties): void
  }

  module ConstraintLayoutChild {
    // Constructor properties interface

    interface ConstructorProperties extends LayoutChild.ConstructorProperties {}
  }

  interface ConstraintLayoutChild {
    // Own properties of Gtk-4.0.Gtk.ConstraintLayoutChild

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.ConstraintLayoutChild

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child-widget", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkLayoutChild` subclass for children in a `GtkConstraintLayout`.
   * @class
   */
  class ConstraintLayoutChild extends LayoutChild {
    // Own properties of Gtk-4.0.Gtk.ConstraintLayoutChild

    static name: string

    // Constructors of Gtk-4.0.Gtk.ConstraintLayoutChild

    constructor(config?: ConstraintLayoutChild.ConstructorProperties)
    _init(config?: ConstraintLayoutChild.ConstructorProperties): void
  }

  module CssProvider {
    // Signal callback interfaces

    /**
     * Signal callback interface for `parsing-error`
     */
    interface ParsingErrorSignalCallback {
      (section: CssSection, error: GLib.Error): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends StyleProvider.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface CssProvider extends StyleProvider {
    // Own properties of Gtk-4.0.Gtk.CssProvider

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.CssProvider

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.CssProvider

    /**
     * Loads `data` into `css_provider`.
     *
     * This clears any previously loaded information.
     * @param data `GBytes` containing the data to load
     */
    loadFromBytes(data: any): void
    /**
     * Loads `data` into `css_provider`.
     *
     * This clears any previously loaded information.
     * @param data CSS data to be parsed
     * @param length the length of `data` in bytes, or -1 for NUL terminated strings
     */
    loadFromData(data: string, length: number): void
    /**
     * Loads the data contained in `file` into `css_provider`.
     *
     * This clears any previously loaded information.
     * @param file `GFile` pointing to a file to load
     */
    loadFromFile(file: Gio.File): void
    /**
     * Loads the data contained in `path` into `css_provider`.
     *
     * This clears any previously loaded information.
     * @param path the path of a filename to load, in the GLib filename encoding
     */
    loadFromPath(path: string): void
    /**
     * Loads the data contained in the resource at `resource_path` into
     * the `css_provider`.
     *
     * This clears any previously loaded information.
     * @param resourcePath a `GResource` resource path
     */
    loadFromResource(resourcePath: string): void
    /**
     * Loads `string` into `css_provider`.
     *
     * This clears any previously loaded information.
     * @param string the CSS to load
     */
    loadFromString(string: string): void
    /**
     * Loads a theme from the usual theme paths.
     *
     * The actual process of finding the theme might change between
     * releases, but it is guaranteed that this function uses the same
     * mechanism to load the theme that GTK uses for loading its own theme.
     * @param name A theme name
     * @param variant variant to load, for example, "dark", or   %NULL for the default
     */
    loadNamed(name: string, variant: string | null): void
    /**
     * Converts the `provider` into a string representation in CSS
     * format.
     *
     * Using [method`Gtk`.CssProvider.load_from_string] with the return
     * value from this function on a new provider created with
     * [ctor`Gtk`.CssProvider.new] will basically create a duplicate
     * of this `provider`.
     * @returns a new string representing the @provider.
     */
    toString(): string | null

    // Own signals of Gtk-4.0.Gtk.CssProvider

    connect(
      sigName: "parsing-error",
      callback: CssProvider.ParsingErrorSignalCallback
    ): number
    on(
      sigName: "parsing-error",
      callback: CssProvider.ParsingErrorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "parsing-error",
      callback: CssProvider.ParsingErrorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "parsing-error",
      callback: CssProvider.ParsingErrorSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "parsing-error", error: GLib.Error, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.CssProvider

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkCssProvider` is an object implementing the `GtkStyleProvider` interface
   * for CSS.
   *
   * It is able to parse CSS-like input in order to style widgets.
   *
   * An application can make GTK parse a specific CSS style sheet by calling
   * [method`Gtk`.CssProvider.load_from_file] or
   * [method`Gtk`.CssProvider.load_from_resource]
   * and adding the provider with [method`Gtk`.StyleContext.add_provider] or
   * [func`Gtk`.StyleContext.add_provider_for_display].
   *
   * In addition, certain files will be read when GTK is initialized.
   * First, the file `$XDG_CONFIG_HOME/gtk-4.0/gtk.css` is loaded if it
   * exists. Then, GTK loads the first existing file among
   * `XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
   * `$HOME/.themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
   * `$XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk-VARIANT.css` and
   * `DATADIR/share/themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
   * where `THEME` is the name of the current theme (see the
   * [property`Gtk`.Settings:gtk-theme-name] setting), `VARIANT` is the
   * variant to load (see the
   * [property`Gtk`.Settings:gtk-application-prefer-dark-theme] setting),
   * `DATADIR` is the prefix configured when GTK was compiled (unless
   * overridden by the `GTK_DATA_PREFIX` environment variable), and
   * `VERSION` is the GTK version number. If no file is found for the
   * current version, GTK tries older versions all the way back to 4.0.
   *
   * To track errors while loading CSS, connect to the
   * [signal`Gtk`.CssProvider::parsing-error] signal.
   * @class
   */
  class CssProvider extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.CssProvider

    static name: string

    // Constructors of Gtk-4.0.Gtk.CssProvider

    constructor(config?: CssProvider.ConstructorProperties)
    /**
     * Returns a newly created `GtkCssProvider`.
     * @constructor
     * @returns A new `GtkCssProvider`
     */
    constructor()
    /**
     * Returns a newly created `GtkCssProvider`.
     * @constructor
     * @returns A new `GtkCssProvider`
     */
    static new(): CssProvider
    _init(config?: CssProvider.ConstructorProperties): void
  }

  module CustomFilter {
    // Constructor properties interface

    interface ConstructorProperties extends Filter.ConstructorProperties {}
  }

  interface CustomFilter {
    // Own properties of Gtk-4.0.Gtk.CustomFilter

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CustomFilter

    /**
     * Sets the function used for filtering items.
     *
     * If `match_func` is %NULL, the filter matches all items.
     *
     * If the filter func changes its filtering behavior,
     * gtk_filter_changed() needs to be called.
     *
     * If a previous function was set, its `user_destroy` will be
     * called now.
     * @param matchFunc function to filter items
     */
    setFilterFunc(matchFunc: CustomFilterFunc | null): void

    // Class property signals of Gtk-4.0.Gtk.CustomFilter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkCustomFilter` determines whether to include items with a callback.
   * @class
   */
  class CustomFilter extends Filter {
    // Own properties of Gtk-4.0.Gtk.CustomFilter

    static name: string

    // Constructors of Gtk-4.0.Gtk.CustomFilter

    constructor(config?: CustomFilter.ConstructorProperties)
    /**
     * Creates a new filter using the given `match_func` to filter
     * items.
     *
     * If `match_func` is %NULL, the filter matches all items.
     *
     * If the filter func changes its filtering behavior,
     * gtk_filter_changed() needs to be called.
     * @constructor
     * @param matchFunc function to filter items
     * @returns a new `GtkCustomFilter`
     */
    constructor(matchFunc: CustomFilterFunc | null)
    /**
     * Creates a new filter using the given `match_func` to filter
     * items.
     *
     * If `match_func` is %NULL, the filter matches all items.
     *
     * If the filter func changes its filtering behavior,
     * gtk_filter_changed() needs to be called.
     * @constructor
     * @param matchFunc function to filter items
     * @returns a new `GtkCustomFilter`
     */
    static new(matchFunc: CustomFilterFunc | null): CustomFilter
    _init(config?: CustomFilter.ConstructorProperties): void
  }

  module CustomLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends LayoutManager.ConstructorProperties {}
  }

  interface CustomLayout {
    // Own properties of Gtk-4.0.Gtk.CustomLayout

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.CustomLayout

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkCustomLayout` uses closures for size negotiation.
   *
   * A `GtkCustomLayout `uses closures matching to the old `GtkWidget`
   * virtual functions for size negotiation, as a convenience API to
   * ease the porting towards the corresponding `GtkLayoutManager
   * virtual functions.
   * @class
   */
  class CustomLayout extends LayoutManager {
    // Own properties of Gtk-4.0.Gtk.CustomLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.CustomLayout

    constructor(config?: CustomLayout.ConstructorProperties)
    /**
     * Creates a new legacy layout manager.
     *
     * Legacy layout managers map to the old `GtkWidget` size negotiation
     * virtual functions, and are meant to be used during the transition
     * from layout containers to layout manager delegates.
     * @constructor
     * @param requestMode a function to retrieve   the `GtkSizeRequestMode` of the widget using the layout; the   default request mode is %GTK_SIZE_REQUEST_CONSTANT_SIZE
     * @param measure a function to measure the widget using the layout manager
     * @param allocate a function to allocate the children of the widget using   the layout manager
     * @returns the newly created `GtkCustomLayout`
     */
    constructor(
      requestMode: CustomRequestModeFunc | null,
      measure: CustomMeasureFunc,
      allocate: CustomAllocateFunc
    )
    /**
     * Creates a new legacy layout manager.
     *
     * Legacy layout managers map to the old `GtkWidget` size negotiation
     * virtual functions, and are meant to be used during the transition
     * from layout containers to layout manager delegates.
     * @constructor
     * @param requestMode a function to retrieve   the `GtkSizeRequestMode` of the widget using the layout; the   default request mode is %GTK_SIZE_REQUEST_CONSTANT_SIZE
     * @param measure a function to measure the widget using the layout manager
     * @param allocate a function to allocate the children of the widget using   the layout manager
     * @returns the newly created `GtkCustomLayout`
     */
    static new(
      requestMode: CustomRequestModeFunc | null,
      measure: CustomMeasureFunc,
      allocate: CustomAllocateFunc
    ): CustomLayout
    _init(config?: CustomLayout.ConstructorProperties): void
  }

  module CustomSorter {
    // Constructor properties interface

    interface ConstructorProperties extends Sorter.ConstructorProperties {}
  }

  interface CustomSorter {
    // Own properties of Gtk-4.0.Gtk.CustomSorter

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.CustomSorter

    /**
     * Sets (or unsets) the function used for sorting items.
     *
     * If `sort_func` is %NULL, all items are considered equal.
     *
     * If the sort func changes its sorting behavior,
     * gtk_sorter_changed() needs to be called.
     *
     * If a previous function was set, its `user_destroy` will be
     * called now.
     * @param sortFunc function to sort items
     */
    setSortFunc(sortFunc: GLib.CompareDataFunc | null): void

    // Class property signals of Gtk-4.0.Gtk.CustomSorter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkCustomSorter` is a `GtkSorter` implementation that sorts via a callback
   * function.
   * @class
   */
  class CustomSorter extends Sorter {
    // Own properties of Gtk-4.0.Gtk.CustomSorter

    static name: string

    // Constructors of Gtk-4.0.Gtk.CustomSorter

    constructor(config?: CustomSorter.ConstructorProperties)
    /**
     * Creates a new `GtkSorter` that works by calling
     * `sort_func` to compare items.
     *
     * If `sort_func` is %NULL, all items are considered equal.
     * @constructor
     * @param sortFunc the `GCompareDataFunc` to use for sorting
     * @returns a new `GtkCustomSorter`
     */
    constructor(sortFunc: GLib.CompareDataFunc | null)
    /**
     * Creates a new `GtkSorter` that works by calling
     * `sort_func` to compare items.
     *
     * If `sort_func` is %NULL, all items are considered equal.
     * @constructor
     * @param sortFunc the `GCompareDataFunc` to use for sorting
     * @returns a new `GtkCustomSorter`
     */
    static new(sortFunc: GLib.CompareDataFunc | null): CustomSorter
    _init(config?: CustomSorter.ConstructorProperties): void
  }

  module Dialog {
    // Signal callback interfaces

    /**
     * Signal callback interface for `close`
     */
    interface CloseSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `response`
     */
    interface ResponseSignalCallback {
      (responseId: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Window.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Dialog

      /**
       * %TRUE if the dialog uses a headerbar for action buttons
       * instead of the action-area.
       *
       * For technical reasons, this property is declared as an integer
       * property, but you should only set it to %TRUE or %FALSE.
       *
       * ## Creating a dialog with headerbar
       *
       * Builtin `GtkDialog` subclasses such as [class`Gtk`.ColorChooserDialog]
       * set this property according to platform conventions (using the
       * [property`Gtk`.Settings:gtk-dialogs-use-header] setting).
       *
       * Here is how you can achieve the same:
       *
       * ```c
       * g_object_get (settings, "gtk-dialogs-use-header", &header, NULL);
       * dialog = g_object_new (GTK_TYPE_DIALOG, header, TRUE, NULL);
       * ```
       */
      use_header_bar?: number | null
    }
  }

  interface Dialog
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.Dialog

    /**
     * %TRUE if the dialog uses a headerbar for action buttons
     * instead of the action-area.
     *
     * For technical reasons, this property is declared as an integer
     * property, but you should only set it to %TRUE or %FALSE.
     *
     * ## Creating a dialog with headerbar
     *
     * Builtin `GtkDialog` subclasses such as [class`Gtk`.ColorChooserDialog]
     * set this property according to platform conventions (using the
     * [property`Gtk`.Settings:gtk-dialogs-use-header] setting).
     *
     * Here is how you can achieve the same:
     *
     * ```c
     * g_object_get (settings, "gtk-dialogs-use-header", &header, NULL);
     * dialog = g_object_new (GTK_TYPE_DIALOG, header, TRUE, NULL);
     * ```
     */
    readonly useHeaderBar: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Dialog

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.Dialog

    /**
     * Adds an activatable widget to the action area of a `GtkDialog`.
     *
     * GTK connects a signal handler that will emit the
     * [signal`Gtk`.Dialog::response] signal on the dialog when the widget
     * is activated. The widget is appended to the end of the dialog’s action
     * area.
     *
     * If you want to add a non-activatable widget, simply pack it into
     * the `action_area` field of the `GtkDialog` struct.
     * @param child an activatable widget
     * @param responseId response ID for `child`
     */
    addActionWidget(child: Widget, responseId: number): void
    /**
     * Adds a button with the given text.
     *
     * GTK arranges things so that clicking the button will emit the
     * [signal`Gtk`.Dialog::response] signal with the given `response_id`.
     * The button is appended to the end of the dialog’s action area.
     * The button widget is returned, but usually you don’t need it.
     * @param buttonText text of button
     * @param responseId response ID for the button
     * @returns the `GtkButton` widget that was added
     */
    addButton(buttonText: string, responseId: number): Widget
    /**
     * Returns the content area of `dialog`.
     * @returns the content area `GtkBox`.
     */
    getContentArea(): Box
    /**
     * Returns the header bar of `dialog`.
     *
     * Note that the headerbar is only used by the dialog if the
     * [property`Gtk`.Dialog:use-header-bar] property is %TRUE.
     * @returns the header bar
     */
    getHeaderBar(): HeaderBar
    /**
     * Gets the response id of a widget in the action area
     * of a dialog.
     * @param widget a widget in the action area of `dialog`
     * @returns the response id of @widget, or %GTK_RESPONSE_NONE  if @widget doesn’t have a response id set.
     */
    getResponseForWidget(widget: Widget): number
    /**
     * Gets the widget button that uses the given response ID in the action area
     * of a dialog.
     * @param responseId the response ID used by the `dialog` widget
     * @returns the @widget button that uses the given   @response_id
     */
    getWidgetForResponse(responseId: number): Widget | null
    // Has conflict: response(responseId: number): void
    /**
     * Sets the default widget for the dialog based on the response ID.
     *
     * Pressing “Enter” normally activates the default widget.
     * @param responseId a response ID
     */
    setDefaultResponse(responseId: number): void
    /**
     * A convenient way to sensitize/desensitize dialog buttons.
     *
     * Calls `gtk_widget_set_sensitive (widget, `setting)``
     * for each widget in the dialog’s action area with the given `response_id`.
     * @param responseId a response ID
     * @param setting %TRUE for sensitive
     */
    setResponseSensitive(responseId: number, setting: boolean): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Own virtual methods of Gtk-4.0.Gtk.Dialog

    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @virtual
     */
    close(): void

    // Overloads of close

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Emits the ::response signal with the given response ID.
     *
     * Used to indicate that the user has responded to the dialog in some way.
     * @virtual
     * @param responseId response ID
     */
    response(responseId: number): void

    // Own signals of Gtk-4.0.Gtk.Dialog

    connect(sigName: "close", callback: Dialog.CloseSignalCallback): number
    on(
      sigName: "close",
      callback: Dialog.CloseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "close",
      callback: Dialog.CloseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "close",
      callback: Dialog.CloseSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "close", ...args: any[]): void
    connect(
      sigName: "response",
      callback: Dialog.ResponseSignalCallback
    ): number
    on(
      sigName: "response",
      callback: Dialog.ResponseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "response",
      callback: Dialog.ResponseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "response",
      callback: Dialog.ResponseSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "response", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Dialog

    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Dialogs are a convenient way to prompt the user for a small amount
   * of input.
   *
   * ![An example GtkDialog](dialog.png)
   *
   * Typical uses are to display a message, ask a question, or anything else
   * that does not require extensive effort on the user’s part.
   *
   * The main area of a `GtkDialog` is called the "content area", and is yours
   * to populate with widgets such a `GtkLabel` or `GtkEntry`, to present
   * your information, questions, or tasks to the user.
   *
   * In addition, dialogs allow you to add "action widgets". Most commonly,
   * action widgets are buttons. Depending on the platform, action widgets may
   * be presented in the header bar at the top of the window, or at the bottom
   * of the window. To add action widgets, create your `GtkDialog` using
   * [ctor`Gtk`.Dialog.new_with_buttons], or use
   * [method`Gtk`.Dialog.add_button], [method`Gtk`.Dialog.add_buttons],
   * or [method`Gtk`.Dialog.add_action_widget].
   *
   * `GtkDialogs` uses some heuristics to decide whether to add a close
   * button to the window decorations. If any of the action buttons use
   * the response ID %GTK_RESPONSE_CLOSE or %GTK_RESPONSE_CANCEL, the
   * close button is omitted.
   *
   * Clicking a button that was added as an action widget will emit the
   * [signal`Gtk`.Dialog::response] signal with a response ID that you specified.
   * GTK will never assign a meaning to positive response IDs; these are
   * entirely user-defined. But for convenience, you can use the response
   * IDs in the [enum`Gtk`.ResponseType] enumeration (these all have values
   * less than zero). If a dialog receives a delete event, the
   * [signal`Gtk`.Dialog::response] signal will be emitted with the
   * %GTK_RESPONSE_DELETE_EVENT response ID.
   *
   * Dialogs are created with a call to [ctor`Gtk`.Dialog.new] or
   * [ctor`Gtk`.Dialog.new_with_buttons]. The latter is recommended; it allows
   * you to set the dialog title, some convenient flags, and add buttons.
   *
   * A “modal” dialog (that is, one which freezes the rest of the application
   * from user input), can be created by calling [method`Gtk`.Window.set_modal]
   * on the dialog. When using [ctor`Gtk`.Dialog.new_with_buttons], you can also
   * pass the %GTK_DIALOG_MODAL flag to make a dialog modal.
   *
   * For the simple dialog in the following example, a [class`Gtk`.MessageDialog]
   * would save some effort. But you’d need to create the dialog contents manually
   * if you had more than a simple message in the dialog.
   *
   * An example for simple `GtkDialog` usage:
   *
   * ```c
   * // Function to open a dialog box with a message
   * void
   * quick_message (GtkWindow *parent, char *message)
   * {
   *  GtkWidget *dialog, *label, *content_area;
   *  GtkDialogFlags flags;
   *
   *  // Create the widgets
   *  flags = GTK_DIALOG_DESTROY_WITH_PARENT;
   *  dialog = gtk_dialog_new_with_buttons ("Message",
   *                                        parent,
   *                                        flags,
   *                                        _("_OK"),
   *                                        GTK_RESPONSE_NONE,
   *                                        NULL);
   *  content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
   *  label = gtk_label_new (message);
   *
   *  // Ensure that the dialog box is destroyed when the user responds
   *
   *  g_signal_connect_swapped (dialog,
   *                            "response",
   *                            G_CALLBACK (gtk_window_destroy),
   *                            dialog);
   *
   *  // Add the label, and show everything we’ve added
   *
   *  gtk_box_append (GTK_BOX (content_area), label);
   *  gtk_widget_show (dialog);
   * }
   * ```
   *
   * # GtkDialog as GtkBuildable
   *
   * The `GtkDialog` implementation of the `GtkBuildable` interface exposes the
   * `content_area` as an internal child with the name “content_area”.
   *
   * `GtkDialog` supports a custom `<action-widgets>` element, which can contain
   * multiple `<action-widget>` elements. The “response” attribute specifies a
   * numeric response, and the content of the element is the id of widget
   * (which should be a child of the dialogs `action_area)`. To mark a response
   * as default, set the “default” attribute of the `<action-widget>` element
   * to true.
   *
   * `GtkDialog` supports adding action widgets by specifying “action” as
   * the “type” attribute of a `<child>` element. The widget will be added
   * either to the action area or the headerbar of the dialog, depending
   * on the “use-header-bar” property. The response id has to be associated
   * with the action widget using the `<action-widgets>` element.
   *
   * An example of a `GtkDialog` UI definition fragment:
   *
   * ```xml
   * <object class="GtkDialog" id="dialog1">
   *   <child type="action">
   *     <object class="GtkButton" id="button_cancel"/>
   *   </child>
   *   <child type="action">
   *     <object class="GtkButton" id="button_ok">
   *     </object>
   *   </child>
   *   <action-widgets>
   *     <action-widget response="cancel">button_cancel</action-widget>
   *     <action-widget response="ok" default="true">button_ok</action-widget>
   *   </action-widgets>
   * </object>
   * ```
   *
   * # Accessibility
   *
   * `GtkDialog` uses the %GTK_ACCESSIBLE_ROLE_DIALOG role.
   * @class
   */
  class Dialog extends Window {
    // Own properties of Gtk-4.0.Gtk.Dialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.Dialog

    constructor(config?: Dialog.ConstructorProperties)
    /**
     * Creates a new dialog box.
     *
     * Widgets should not be packed into the `GtkWindow`
     * directly, but into the `content_area` and `action_area,`
     * as described above.
     * @constructor
     * @returns the new dialog as a `GtkWidget`
     */
    constructor()
    /**
     * Creates a new dialog box.
     *
     * Widgets should not be packed into the `GtkWindow`
     * directly, but into the `content_area` and `action_area,`
     * as described above.
     * @constructor
     * @returns the new dialog as a `GtkWidget`
     */
    static new(): Dialog
    _init(config?: Dialog.ConstructorProperties): void
  }

  module DirectoryList {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.DirectoryList

      /**
       * The attributes to query.
       */
      attributes?: string | null
      /**
       * File to query.
       */
      file?: Gio.File | null
      /**
       * Priority used when loading.
       */
      io_priority?: number | null
      /**
       * %TRUE if the directory is monitored for changed.
       */
      monitored?: boolean | null
    }
  }

  interface DirectoryList extends Gio.ListModel {
    // Own properties of Gtk-4.0.Gtk.DirectoryList

    /**
     * The attributes to query.
     */
    attributes: string | null
    /**
     * Error encountered while loading files.
     */
    readonly error: GLib.Error
    /**
     * File to query.
     */
    file: Gio.File
    /**
     * Priority used when loading.
     */
    ioPriority: number
    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * %TRUE if files are being loaded.
     */
    readonly loading: boolean
    /**
     * %TRUE if the directory is monitored for changed.
     */
    monitored: boolean
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.DirectoryList

    /**
     * Gets the attributes queried on the children.
     * @returns The queried attributes
     */
    getAttributes(): string | null
    /**
     * Gets the loading error, if any.
     *
     * If an error occurs during the loading process, the loading process
     * will finish and this property allows querying the error that happened.
     * This error will persist until a file is loaded again.
     *
     * An error being set does not mean that no files were loaded, and all
     * successfully queried files will remain in the list.
     * @returns The loading error or %NULL if   loading finished successfully
     */
    getError(): GLib.Error | null
    /**
     * Gets the file whose children are currently enumerated.
     * @returns The file whose children are enumerated
     */
    getFile(): Gio.File | null
    /**
     * Gets the IO priority set via gtk_directory_list_set_io_priority().
     * @returns The IO priority.
     */
    getIoPriority(): number
    /**
     * Returns whether the directory list is monitoring
     * the directory for changes.
     * @returns %TRUE if the directory is monitored
     */
    getMonitored(): boolean
    /**
     * Returns %TRUE if the children enumeration is currently in
     * progress.
     *
     * Files will be added to `self` from time to time while loading is
     * going on. The order in which are added is undefined and may change
     * in between runs.
     * @returns %TRUE if @self is loading
     */
    isLoading(): boolean
    /**
     * Sets the `attributes` to be enumerated and starts the enumeration.
     *
     * If `attributes` is %NULL, the list of file infos will still be created, it will just
     * not contain any extra attributes.
     * @param attributes the attributes to enumerate
     */
    setAttributes(attributes: string | null): void
    /**
     * Sets the `file` to be enumerated and starts the enumeration.
     *
     * If `file` is %NULL, the result will be an empty list.
     * @param file the `GFile` to be enumerated
     */
    setFile(file: Gio.File | null): void
    /**
     * Sets the IO priority to use while loading directories.
     *
     * Setting the priority while `self` is loading will reprioritize the
     * ongoing load as soon as possible.
     *
     * The default IO priority is %G_PRIORITY_DEFAULT, which is higher than
     * the GTK redraw priority. If you are loading a lot of directories in
     * parallel, lowering it to something like %G_PRIORITY_DEFAULT_IDLE
     * may increase responsiveness.
     * @param ioPriority IO priority to use
     */
    setIoPriority(ioPriority: number): void
    /**
     * Sets whether the directory list will monitor the directory
     * for changes.
     *
     * If monitoring is enabled, the ::items-changed signal will
     * be emitted when the directory contents change.
     *
     *
     * When monitoring is turned on after the initial creation
     * of the directory list, the directory is reloaded to avoid
     * missing files that appeared between the initial loading
     * and when monitoring was turned on.
     * @param monitored %TRUE to monitor the directory for changes
     */
    setMonitored(monitored: boolean): void

    // Class property signals of Gtk-4.0.Gtk.DirectoryList

    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::error",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::error",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::error",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::error",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::error", ...args: any[]): void
    connect(sigName: "notify::file", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file", ...args: any[]): void
    connect(
      sigName: "notify::io-priority",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::io-priority",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::io-priority",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::io-priority",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::io-priority", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::loading",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::loading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::loading",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::loading",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::loading", ...args: any[]): void
    connect(
      sigName: "notify::monitored",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::monitored",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::monitored",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::monitored",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::monitored", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkDirectoryList` is a list model that wraps g_file_enumerate_children_async().
   *
   * It presents a `GListModel` and fills it asynchronously with the `GFileInfo`s
   * returned from that function.
   *
   * Enumeration will start automatically when the
   * [property`Gtk`.DirectoryList:file] property is set.
   *
   * While the `GtkDirectoryList` is being filled, the
   * [property`Gtk`.DirectoryList:loading] property will be set to %TRUE. You can
   * listen to that property if you want to show information like a `GtkSpinner`
   * or a "Loading..." text.
   *
   * If loading fails at any point, the [property`Gtk`.DirectoryList:error]
   * property will be set to give more indication about the failure.
   *
   * The `GFileInfo`s returned from a `GtkDirectoryList` have the "standard::file"
   * attribute set to the `GFile` they refer to. This way you can get at the file
   * that is referred to in the same way you would via g_file_enumerator_get_child().
   * This means you do not need access to the `GtkDirectoryList`, but can access
   * the `GFile` directly from the `GFileInfo` when operating with a `GtkListView`
   * or similar.
   * @class
   */
  class DirectoryList extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.DirectoryList

    static name: string

    // Constructors of Gtk-4.0.Gtk.DirectoryList

    constructor(config?: DirectoryList.ConstructorProperties)
    /**
     * Creates a new `GtkDirectoryList`.
     *
     * The `GtkDirectoryList` is querying the given `file`
     * with the given `attributes`.
     * @constructor
     * @param attributes The attributes to query with
     * @param file The file to query
     * @returns a new `GtkDirectoryList`
     */
    constructor(attributes: string | null, file: Gio.File | null)
    /**
     * Creates a new `GtkDirectoryList`.
     *
     * The `GtkDirectoryList` is querying the given `file`
     * with the given `attributes`.
     * @constructor
     * @param attributes The attributes to query with
     * @param file The file to query
     * @returns a new `GtkDirectoryList`
     */
    static new(attributes: string | null, file: Gio.File | null): DirectoryList
    _init(config?: DirectoryList.ConstructorProperties): void
  }

  module DragIcon {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.DragIcon

      /**
       * The widget to display as drag icon.
       */
      child?: Widget | null
    }
  }

  interface DragIcon
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root {
    // Own properties of Gtk-4.0.Gtk.DragIcon

    /**
     * The widget to display as drag icon.
     */
    child: Widget
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.DragIcon

    /**
     * Gets the widget currently used as drag icon.
     * @returns The drag icon
     */
    getChild(): Widget | null
    /**
     * Sets the widget to display as the drag icon.
     * @param child a `GtkWidget`
     */
    setChild(child: Widget | null): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void

    // Class property signals of Gtk-4.0.Gtk.DragIcon

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkDragIcon` is a `GtkRoot` implementation for drag icons.
   *
   * A drag icon moves with the pointer during a Drag-and-Drop operation
   * and is destroyed when the drag ends.
   *
   * To set up a drag icon and associate it with an ongoing drag operation,
   * use [func`Gtk`.DragIcon.get_for_drag] to get the icon for a drag. You can
   * then use it like any other widget and use [method`Gtk`.DragIcon.set_child]
   * to set whatever widget should be used for the drag icon.
   *
   * Keep in mind that drag icons do not allow user input.
   * @class
   */
  class DragIcon extends Widget {
    // Own properties of Gtk-4.0.Gtk.DragIcon

    static name: string

    // Constructors of Gtk-4.0.Gtk.DragIcon

    constructor(config?: DragIcon.ConstructorProperties)
    _init(config?: DragIcon.ConstructorProperties): void
    /**
     * Creates a widget that can be used as a drag icon for the given
     * `value`.
     *
     * Supported types include strings, `GdkRGBA` and `GtkTextBuffer`.
     * If GTK does not know how to create a widget for a given value,
     * it will return %NULL.
     *
     * This method is used to set the default drag icon on drag-and-drop
     * operations started by `GtkDragSource`, so you don't need to set
     * a drag icon using this function there.
     * @param value a `GValue`
     * @returns A new `GtkWidget`   for displaying @value as a drag icon.
     */
    static createWidgetForValue(value: any): Widget | null
    /**
     * Gets the `GtkDragIcon` in use with `drag`.
     *
     * If no drag icon exists yet, a new one will be created
     * and shown.
     * @param drag a `GdkDrag`
     * @returns the `GtkDragIcon`
     */
    static getForDrag(drag: Gdk.Drag): Widget
    /**
     * Creates a `GtkDragIcon` that shows `paintable,` and associates
     * it with the drag operation.
     *
     * The hotspot position on the paintable is aligned with the
     * hotspot of the cursor.
     * @param drag a `GdkDrag`
     * @param paintable a `GdkPaintable` to display
     * @param hotX X coordinate of the hotspot
     * @param hotY Y coordinate of the hotspot
     */
    static setFromPaintable(
      drag: Gdk.Drag,
      paintable: Gdk.Paintable,
      hotX: number,
      hotY: number
    ): void
  }

  module DragSource {
    // Signal callback interfaces

    /**
     * Signal callback interface for `drag-begin`
     */
    interface DragBeginSignalCallback {
      (drag: Gdk.Drag): void
    }

    /**
     * Signal callback interface for `drag-cancel`
     */
    interface DragCancelSignalCallback {
      (drag: Gdk.Drag, reason: Gdk.DragCancelReason): boolean
    }

    /**
     * Signal callback interface for `drag-end`
     */
    interface DragEndSignalCallback {
      (drag: Gdk.Drag, deleteData: boolean): void
    }

    /**
     * Signal callback interface for `prepare`
     */
    interface PrepareSignalCallback {
      (x: number, y: number): Gdk.ContentProvider | null
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GestureSingle.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.DragSource

      /**
       * The actions that are supported by drag operations from the source.
       *
       * Note that you must handle the [signal`Gtk`.DragSource::drag-end] signal
       * if the actions include %GDK_ACTION_MOVE.
       */
      actions?: Gdk.DragAction | null
      /**
       * The data that is offered by drag operations from this source.
       */
      content?: Gdk.ContentProvider | null
    }
  }

  interface DragSource {
    // Own properties of Gtk-4.0.Gtk.DragSource

    /**
     * The actions that are supported by drag operations from the source.
     *
     * Note that you must handle the [signal`Gtk`.DragSource::drag-end] signal
     * if the actions include %GDK_ACTION_MOVE.
     */
    actions: Gdk.DragAction
    /**
     * The data that is offered by drag operations from this source.
     */
    content: Gdk.ContentProvider
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.DragSource

    /**
     * Cancels a currently ongoing drag operation.
     */
    dragCancel(): void
    /**
     * Gets the actions that are currently set on the `GtkDragSource`.
     * @returns the actions set on @source
     */
    getActions(): Gdk.DragAction
    /**
     * Gets the current content provider of a `GtkDragSource`.
     * @returns the `GdkContentProvider` of @source
     */
    getContent(): Gdk.ContentProvider | null
    /**
     * Returns the underlying `GdkDrag` object for an ongoing drag.
     * @returns the `GdkDrag` of the current   drag operation
     */
    getDrag(): Gdk.Drag | null
    /**
     * Sets the actions on the `GtkDragSource`.
     *
     * During a DND operation, the actions are offered to potential
     * drop targets. If `actions` include %GDK_ACTION_MOVE, you need
     * to listen to the [signal`Gtk`.DragSource::drag-end] signal and
     * handle `delete_data` being %TRUE.
     *
     * This function can be called before a drag is started,
     * or in a handler for the [signal`Gtk`.DragSource::prepare] signal.
     * @param actions the actions to offer
     */
    setActions(actions: Gdk.DragAction): void
    /**
     * Sets a content provider on a `GtkDragSource`.
     *
     * When the data is requested in the cause of a DND operation,
     * it will be obtained from the content provider.
     *
     * This function can be called before a drag is started,
     * or in a handler for the [signal`Gtk`.DragSource::prepare] signal.
     *
     * You may consider setting the content provider back to
     * %NULL in a [signal`Gtk`.DragSource::drag-end] signal handler.
     * @param content a `GdkContentProvider`
     */
    setContent(content: Gdk.ContentProvider | null): void
    /**
     * Sets a paintable to use as icon during DND operations.
     *
     * The hotspot coordinates determine the point on the icon
     * that gets aligned with the hotspot of the cursor.
     *
     * If `paintable` is %NULL, a default icon is used.
     *
     * This function can be called before a drag is started, or in
     * a [signal`Gtk`.DragSource::prepare] or
     * [signal`Gtk`.DragSource::drag-begin] signal handler.
     * @param paintable the `GdkPaintable` to use as icon
     * @param hotX the hotspot X coordinate on the icon
     * @param hotY the hotspot Y coordinate on the icon
     */
    setIcon(paintable: Gdk.Paintable | null, hotX: number, hotY: number): void

    // Own signals of Gtk-4.0.Gtk.DragSource

    connect(
      sigName: "drag-begin",
      callback: DragSource.DragBeginSignalCallback
    ): number
    on(
      sigName: "drag-begin",
      callback: DragSource.DragBeginSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-begin",
      callback: DragSource.DragBeginSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-begin",
      callback: DragSource.DragBeginSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drag-begin", ...args: any[]): void
    connect(
      sigName: "drag-cancel",
      callback: DragSource.DragCancelSignalCallback
    ): number
    on(
      sigName: "drag-cancel",
      callback: DragSource.DragCancelSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-cancel",
      callback: DragSource.DragCancelSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-cancel",
      callback: DragSource.DragCancelSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "drag-cancel",
      reason: Gdk.DragCancelReason,
      ...args: any[]
    ): void
    connect(
      sigName: "drag-end",
      callback: DragSource.DragEndSignalCallback
    ): number
    on(
      sigName: "drag-end",
      callback: DragSource.DragEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-end",
      callback: DragSource.DragEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-end",
      callback: DragSource.DragEndSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drag-end", deleteData: boolean, ...args: any[]): void
    connect(
      sigName: "prepare",
      callback: DragSource.PrepareSignalCallback
    ): number
    on(
      sigName: "prepare",
      callback: DragSource.PrepareSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "prepare",
      callback: DragSource.PrepareSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "prepare",
      callback: DragSource.PrepareSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "prepare", y: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.DragSource

    connect(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::actions", ...args: any[]): void
    connect(
      sigName: "notify::content",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button", ...args: any[]): void
    connect(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exclusive", ...args: any[]): void
    connect(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::touch-only", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkDragSource` is an event controller to initiate Drag-And-Drop operations.
   *
   * `GtkDragSource` can be set up with the necessary
   * ingredients for a DND operation ahead of time. This includes
   * the source for the data that is being transferred, in the form
   * of a [class`Gdk`.ContentProvider], the desired action, and the icon to
   * use during the drag operation. After setting it up, the drag
   * source must be added to a widget as an event controller, using
   * [method`Gtk`.Widget.add_controller].
   *
   * ```c
   * static void
   * my_widget_init (MyWidget *self)
   * {
   *   GtkDragSource *drag_source = gtk_drag_source_new ();
   *
   *   g_signal_connect (drag_source, "prepare", G_CALLBACK (on_drag_prepare), self);
   *   g_signal_connect (drag_source, "drag-begin", G_CALLBACK (on_drag_begin), self);
   *
   *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (drag_source));
   * }
   * ```
   *
   * Setting up the content provider and icon ahead of time only makes
   * sense when the data does not change. More commonly, you will want
   * to set them up just in time. To do so, `GtkDragSource` has
   * [signal`Gtk`.DragSource::prepare] and [signal`Gtk`.DragSource::drag-begin]
   * signals.
   *
   * The ::prepare signal is emitted before a drag is started, and
   * can be used to set the content provider and actions that the
   * drag should be started with.
   *
   * ```c
   * static GdkContentProvider *
   * on_drag_prepare (GtkDragSource *source,
   *                  double         x,
   *                  double         y,
   *                  MyWidget      *self)
   * {
   *   // This widget supports two types of content: GFile objects
   *   // and GdkPixbuf objects; GTK will handle the serialization
   *   // of these types automatically
   *   GFile *file = my_widget_get_file (self);
   *   GdkPixbuf *pixbuf = my_widget_get_pixbuf (self);
   *
   *   return gdk_content_provider_new_union ((GdkContentProvider *[2]) {
   *       gdk_content_provider_new_typed (G_TYPE_FILE, file),
   *       gdk_content_provider_new_typed (GDK_TYPE_PIXBUF, pixbuf),
   *     }, 2);
   * }
   * ```
   *
   * The ::drag-begin signal is emitted after the `GdkDrag` object has
   * been created, and can be used to set up the drag icon.
   *
   * ```c
   * static void
   * on_drag_begin (GtkDragSource *source,
   *                GdkDrag       *drag,
   *                MyWidget      *self)
   * {
   *   // Set the widget as the drag icon
   *   GdkPaintable *paintable = gtk_widget_paintable_new (GTK_WIDGET (self));
   *   gtk_drag_source_set_icon (source, paintable, 0, 0);
   *   g_object_unref (paintable);
   * }
   * ```
   *
   * During the DND operation, `GtkDragSource` emits signals that
   * can be used to obtain updates about the status of the operation,
   * but it is not normally necessary to connect to any signals,
   * except for one case: when the supported actions include
   * %GDK_ACTION_MOVE, you need to listen for the
   * [signal`Gtk`.DragSource::drag-end] signal and delete the
   * data after it has been transferred.
   * @class
   */
  class DragSource extends GestureSingle {
    // Own properties of Gtk-4.0.Gtk.DragSource

    static name: string

    // Constructors of Gtk-4.0.Gtk.DragSource

    constructor(config?: DragSource.ConstructorProperties)
    /**
     * Creates a new `GtkDragSource` object.
     * @constructor
     * @returns the new `GtkDragSource`
     */
    constructor()
    /**
     * Creates a new `GtkDragSource` object.
     * @constructor
     * @returns the new `GtkDragSource`
     */
    static new(): DragSource
    _init(config?: DragSource.ConstructorProperties): void
  }

  module DrawingArea {
    // Signal callback interfaces

    /**
     * Signal callback interface for `resize`
     */
    interface ResizeSignalCallback {
      (width: number, height: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.DrawingArea

      /**
       * The content height.
       */
      content_height?: number | null
      /**
       * The content width.
       */
      content_width?: number | null
    }
  }

  interface DrawingArea extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.DrawingArea

    /**
     * The content height.
     */
    contentHeight: number
    /**
     * The content width.
     */
    contentWidth: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.DrawingArea

    widget: Widget

    // Owm methods of Gtk-4.0.Gtk.DrawingArea

    /**
     * Retrieves the content height of the `GtkDrawingArea`.
     * @returns The height requested for content of the drawing area
     */
    getContentHeight(): number
    /**
     * Retrieves the content width of the `GtkDrawingArea`.
     * @returns The width requested for content of the drawing area
     */
    getContentWidth(): number
    /**
     * Sets the desired height of the contents of the drawing area.
     *
     * Note that because widgets may be allocated larger sizes than they
     * requested, it is possible that the actual height passed to your draw
     * function is larger than the height set here. You can use
     * [method`Gtk`.Widget.set_valign] to avoid that.
     *
     * If the height is set to 0 (the default), the drawing area may disappear.
     * @param height the height of contents
     */
    setContentHeight(height: number): void
    /**
     * Sets the desired width of the contents of the drawing area.
     *
     * Note that because widgets may be allocated larger sizes than they
     * requested, it is possible that the actual width passed to your draw
     * function is larger than the width set here. You can use
     * [method`Gtk`.Widget.set_halign] to avoid that.
     *
     * If the width is set to 0 (the default), the drawing area may disappear.
     * @param width the width of contents
     */
    setContentWidth(width: number): void
    /**
     * Setting a draw function is the main thing you want to do when using
     * a drawing area.
     *
     * The draw function is called whenever GTK needs to draw the contents
     * of the drawing area to the screen.
     *
     * The draw function will be called during the drawing stage of GTK.
     * In the drawing stage it is not allowed to change properties of any
     * GTK widgets or call any functions that would cause any properties
     * to be changed. You should restrict yourself exclusively to drawing
     * your contents in the draw function.
     *
     * If what you are drawing does change, call [method`Gtk`.Widget.queue_draw]
     * on the drawing area. This will cause a redraw and will call `draw_func` again.
     * @param drawFunc callback that lets you draw   the drawing area's contents
     */
    setDrawFunc(drawFunc: DrawingAreaDrawFunc | null): void

    // Own virtual methods of Gtk-4.0.Gtk.DrawingArea

    resize(width: number, height: number): void

    // Own signals of Gtk-4.0.Gtk.DrawingArea

    connect(
      sigName: "resize",
      callback: DrawingArea.ResizeSignalCallback
    ): number
    on(
      sigName: "resize",
      callback: DrawingArea.ResizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "resize",
      callback: DrawingArea.ResizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "resize",
      callback: DrawingArea.ResizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "resize", height: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.DrawingArea

    connect(
      sigName: "notify::content-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content-height", ...args: any[]): void
    connect(
      sigName: "notify::content-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content-width", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkDrawingArea` is a widget that allows drawing with cairo.
   *
   * ![An example GtkDrawingArea](drawingarea.png)
   *
   * It’s essentially a blank widget; you can draw on it. After
   * creating a drawing area, the application may want to connect to:
   *
   * - The [signal`Gtk`.Widget::realize] signal to take any necessary actions
   *   when the widget is instantiated on a particular display.
   *   (Create GDK resources in response to this signal.)
   *
   * - The [signal`Gtk`.DrawingArea::resize] signal to take any necessary
   *   actions when the widget changes size.
   *
   * - Call [method`Gtk`.DrawingArea.set_draw_func] to handle redrawing the
   *   contents of the widget.
   *
   * The following code portion demonstrates using a drawing
   * area to display a circle in the normal widget foreground
   * color.
   *
   * ## Simple GtkDrawingArea usage
   *
   * ```c
   * static void
   * draw_function (GtkDrawingArea *area,
   *                cairo_t        *cr,
   *                int             width,
   *                int             height,
   *                gpointer        data)
   * {
   *   GdkRGBA color;
   *
   *   cairo_arc (cr,
   *              width / 2.0, height / 2.0,
   *              MIN (width, height) / 2.0,
   *              0, 2 * G_PI);
   *
   *   gtk_widget_get_color (GTK_WIDGET (area),
   *                         &color);
   *   gdk_cairo_set_source_rgba (cr, &color);
   *
   *   cairo_fill (cr);
   * }
   *
   * int
   * main (int argc, char **argv)
   * {
   *   gtk_init ();
   *
   *   GtkWidget *area = gtk_drawing_area_new ();
   *   gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (area), 100);
   *   gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (area), 100);
   *   gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (area),
   *                                   draw_function,
   *                                   NULL, NULL);
   *   return 0;
   * }
   * ```
   *
   * The draw function is normally called when a drawing area first comes
   * onscreen, or when it’s covered by another window and then uncovered.
   * You can also force a redraw by adding to the “damage region” of the
   * drawing area’s window using [method`Gtk`.Widget.queue_draw].
   * This will cause the drawing area to call the draw function again.
   *
   * The available routines for drawing are documented in the
   * [Cairo documentation](https://www.cairographics.org/manual/); GDK
   * offers additional API to integrate with Cairo, like [func`Gdk`.cairo_set_source_rgba]
   * or [func`Gdk`.cairo_set_source_pixbuf].
   *
   * To receive mouse events on a drawing area, you will need to use
   * event controllers. To receive keyboard events, you will need to set
   * the “can-focus” property on the drawing area, and you should probably
   * draw some user-visible indication that the drawing area is focused.
   *
   * If you need more complex control over your widget, you should consider
   * creating your own `GtkWidget` subclass.
   * @class
   */
  class DrawingArea extends Widget {
    // Own properties of Gtk-4.0.Gtk.DrawingArea

    static name: string

    // Constructors of Gtk-4.0.Gtk.DrawingArea

    constructor(config?: DrawingArea.ConstructorProperties)
    /**
     * Creates a new drawing area.
     * @constructor
     * @returns a new `GtkDrawingArea`
     */
    constructor()
    /**
     * Creates a new drawing area.
     * @constructor
     * @returns a new `GtkDrawingArea`
     */
    static new(): DrawingArea
    _init(config?: DrawingArea.ConstructorProperties): void
  }

  module DropControllerMotion {
    // Signal callback interfaces

    /**
     * Signal callback interface for `enter`
     */
    interface EnterSignalCallback {
      (x: number, y: number): void
    }

    /**
     * Signal callback interface for `leave`
     */
    interface LeaveSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `motion`
     */
    interface MotionSignalCallback {
      (x: number, y: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {}
  }

  interface DropControllerMotion {
    // Own properties of Gtk-4.0.Gtk.DropControllerMotion

    /**
     * Whether the pointer of a Drag-and-Drop operation is in
     * the controller's widget or a descendant.
     *
     * See also [property`Gtk`.DropControllerMotion:is-pointer].
     *
     * When handling crossing events, this property is updated
     * before [signal`Gtk`.DropControllerMotion::enter], but after
     * [signal`Gtk`.DropControllerMotion::leave] is emitted.
     */
    readonly containsPointer: boolean
    /**
     * The ongoing drop operation over the controller's widget or
     * its descendant.
     *
     * If no drop operation is going on, this property returns %NULL.
     *
     * The event controller should not modify the `drop,` but it might
     * want to query its properties.
     *
     * When handling crossing events, this property is updated
     * before [signal`Gtk`.DropControllerMotion::enter], but after
     * [signal`Gtk`.DropControllerMotion::leave] is emitted.
     */
    readonly drop: Gdk.Drop
    /**
     * Whether the pointer is in the controllers widget itself,
     * as opposed to in a descendent widget.
     *
     * See also [property`Gtk`.DropControllerMotion:contains-pointer].
     *
     * When handling crossing events, this property is updated
     * before [signal`Gtk`.DropControllerMotion::enter], but after
     * [signal`Gtk`.DropControllerMotion::leave] is emitted.
     */
    readonly isPointer: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.DropControllerMotion

    /**
     * Returns the `GdkDrop` of a current Drag-and-Drop operation
     * over the widget of `self`.
     * @returns The `GdkDrop` currently   happening within @self
     */
    getDrop(): Gdk.Drop | null

    // Own signals of Gtk-4.0.Gtk.DropControllerMotion

    connect(
      sigName: "enter",
      callback: DropControllerMotion.EnterSignalCallback
    ): number
    on(
      sigName: "enter",
      callback: DropControllerMotion.EnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "enter",
      callback: DropControllerMotion.EnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "enter",
      callback: DropControllerMotion.EnterSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "enter", y: number, ...args: any[]): void
    connect(
      sigName: "leave",
      callback: DropControllerMotion.LeaveSignalCallback
    ): number
    on(
      sigName: "leave",
      callback: DropControllerMotion.LeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "leave",
      callback: DropControllerMotion.LeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "leave",
      callback: DropControllerMotion.LeaveSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "leave", ...args: any[]): void
    connect(
      sigName: "motion",
      callback: DropControllerMotion.MotionSignalCallback
    ): number
    on(
      sigName: "motion",
      callback: DropControllerMotion.MotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "motion",
      callback: DropControllerMotion.MotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "motion",
      callback: DropControllerMotion.MotionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "motion", y: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.DropControllerMotion

    connect(
      sigName: "notify::contains-pointer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::contains-pointer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::contains-pointer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::contains-pointer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::contains-pointer", ...args: any[]): void
    connect(sigName: "notify::drop", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::drop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::drop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::drop",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::drop", ...args: any[]): void
    connect(
      sigName: "notify::is-pointer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-pointer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-pointer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-pointer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-pointer", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkDropControllerMotion` is an event controller tracking
   * the pointer during Drag-and-Drop operations.
   *
   * It is modeled after [class`Gtk`.EventControllerMotion] so if you
   * have used that, this should feel really familiar.
   *
   * This controller is not able to accept drops, use [class`Gtk`.DropTarget]
   * for that purpose.
   * @class
   */
  class DropControllerMotion extends EventController {
    // Own properties of Gtk-4.0.Gtk.DropControllerMotion

    static name: string

    // Constructors of Gtk-4.0.Gtk.DropControllerMotion

    constructor(config?: DropControllerMotion.ConstructorProperties)
    /**
     * Creates a new event controller that will handle pointer motion
     * events during drag and drop.
     * @constructor
     * @returns a new `GtkDropControllerMotion`
     */
    constructor()
    /**
     * Creates a new event controller that will handle pointer motion
     * events during drag and drop.
     * @constructor
     * @returns a new `GtkDropControllerMotion`
     */
    static new(): DropControllerMotion
    _init(config?: DropControllerMotion.ConstructorProperties): void
  }

  module DropDown {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.DropDown

      /**
       * Whether to show a search entry in the popup.
       *
       * Note that search requires [property`Gtk`.DropDown:expression]
       * to be set.
       */
      enable_search?: boolean | null
      /**
       * An expression to evaluate to obtain strings to match against the search
       * term.
       *
       * See [property`Gtk`.DropDown:enable-search] for how to enable search.
       * If [property`Gtk`.DropDown:factory] is not set, the expression is also
       * used to bind strings to labels produced by a default factory.
       */
      expression?: Expression | null
      /**
       * Factory for populating list items.
       */
      factory?: ListItemFactory | null
      /**
       * The factory for creating header widgets for the popup.
       */
      header_factory?: ListItemFactory | null
      /**
       * The factory for populating list items in the popup.
       *
       * If this is not set, [property`Gtk`.DropDown:factory] is used.
       */
      list_factory?: ListItemFactory | null
      /**
       * Model for the displayed items.
       */
      model?: Gio.ListModel | null
      /**
       * The match mode for the search filter.
       */
      search_match_mode?: StringFilterMatchMode | null
      /**
       * The position of the selected item.
       *
       * If no item is selected, the property has the value
       * %GTK_INVALID_LIST_POSITION.
       */
      selected?: number | null
      /**
       * Whether to show an arrow within the GtkDropDown widget.
       */
      show_arrow?: boolean | null
    }
  }

  interface DropDown extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.DropDown

    /**
     * Whether to show a search entry in the popup.
     *
     * Note that search requires [property`Gtk`.DropDown:expression]
     * to be set.
     */
    enableSearch: boolean
    /**
     * An expression to evaluate to obtain strings to match against the search
     * term.
     *
     * See [property`Gtk`.DropDown:enable-search] for how to enable search.
     * If [property`Gtk`.DropDown:factory] is not set, the expression is also
     * used to bind strings to labels produced by a default factory.
     */
    expression: Expression
    /**
     * Factory for populating list items.
     */
    factory: ListItemFactory
    /**
     * The factory for creating header widgets for the popup.
     */
    headerFactory: ListItemFactory
    /**
     * The factory for populating list items in the popup.
     *
     * If this is not set, [property`Gtk`.DropDown:factory] is used.
     */
    listFactory: ListItemFactory
    /**
     * Model for the displayed items.
     */
    model: Gio.ListModel
    /**
     * The match mode for the search filter.
     */
    searchMatchMode: StringFilterMatchMode
    /**
     * The position of the selected item.
     *
     * If no item is selected, the property has the value
     * %GTK_INVALID_LIST_POSITION.
     */
    selected: number
    /**
     * The selected item.
     */
    readonly selectedItem: GObject.Object
    /**
     * Whether to show an arrow within the GtkDropDown widget.
     */
    showArrow: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.DropDown

    /**
     * Returns whether search is enabled.
     * @returns %TRUE if the popup includes a search entry
     */
    getEnableSearch(): boolean
    /**
     * Gets the expression set that is used to obtain strings from items.
     *
     * See [method`Gtk`.DropDown.set_expression].
     * @returns a `GtkExpression`
     */
    getExpression(): Expression | null
    /**
     * Gets the factory that's currently used to populate list items.
     *
     * The factory returned by this function is always used for the
     * item in the button. It is also used for items in the popup
     * if [property`Gtk`.DropDown:list-factory] is not set.
     * @returns The factory in use
     */
    getFactory(): ListItemFactory | null
    /**
     * Gets the factory that's currently used to create header widgets for the popup.
     * @returns The factory in use
     */
    getHeaderFactory(): ListItemFactory | null
    /**
     * Gets the factory that's currently used to populate list items in the popup.
     * @returns The factory in use
     */
    getListFactory(): ListItemFactory | null
    /**
     * Gets the model that provides the displayed items.
     * @returns The model in use
     */
    getModel(): Gio.ListModel | null
    /**
     * Returns the match mode that the search filter is using.
     * @returns the match mode of the search filter
     */
    getSearchMatchMode(): StringFilterMatchMode
    /**
     * Gets the position of the selected item.
     * @returns the position of the selected item, or %GTK_INVALID_LIST_POSITION   if not item is selected
     */
    getSelected(): number
    /**
     * Gets the selected item. If no item is selected, %NULL is returned.
     * @returns The selected item
     */
    getSelectedItem(): GObject.Object | null
    /**
     * Returns whether to show an arrow within the widget.
     * @returns %TRUE if an arrow will be shown.
     */
    getShowArrow(): boolean
    /**
     * Sets whether a search entry will be shown in the popup that
     * allows to search for items in the list.
     *
     * Note that [property`Gtk`.DropDown:expression] must be set for
     * search to work.
     * @param enableSearch whether to enable search
     */
    setEnableSearch(enableSearch: boolean): void
    /**
     * Sets the expression that gets evaluated to obtain strings from items.
     *
     * This is used for search in the popup. The expression must have
     * a value type of %G_TYPE_STRING.
     * @param expression a `GtkExpression`
     */
    setExpression(expression: Expression | null): void
    /**
     * Sets the `GtkListItemFactory` to use for populating list items.
     * @param factory the factory to use
     */
    setFactory(factory: ListItemFactory | null): void
    /**
     * Sets the `GtkListItemFactory` to use for creating header widgets for the popup.
     * @param factory the factory to use
     */
    setHeaderFactory(factory: ListItemFactory | null): void
    /**
     * Sets the `GtkListItemFactory` to use for populating list items in the popup.
     * @param factory the factory to use
     */
    setListFactory(factory: ListItemFactory | null): void
    /**
     * Sets the `GListModel` to use.
     * @param model the model to use
     */
    setModel(model: Gio.ListModel | null): void
    /**
     * Sets the match mode for the search filter.
     * @param searchMatchMode the new match mode
     */
    setSearchMatchMode(searchMatchMode: StringFilterMatchMode): void
    /**
     * Selects the item at the given position.
     * @param position the position of the item to select, or %GTK_INVALID_LIST_POSITION
     */
    setSelected(position: number): void
    /**
     * Sets whether an arrow will be displayed within the widget.
     * @param showArrow whether to show an arrow within the widget
     */
    setShowArrow(showArrow: boolean): void

    // Own signals of Gtk-4.0.Gtk.DropDown

    connect(
      sigName: "activate",
      callback: DropDown.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: DropDown.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: DropDown.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: DropDown.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.DropDown

    connect(
      sigName: "notify::enable-search",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-search",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-search",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-search",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-search", ...args: any[]): void
    connect(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expression", ...args: any[]): void
    connect(
      sigName: "notify::factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::factory", ...args: any[]): void
    connect(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::header-factory", ...args: any[]): void
    connect(
      sigName: "notify::list-factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::list-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::list-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::list-factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::list-factory", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::search-match-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::search-match-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::search-match-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::search-match-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::search-match-mode", ...args: any[]): void
    connect(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected", ...args: any[]): void
    connect(
      sigName: "notify::selected-item",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected-item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected-item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected-item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected-item", ...args: any[]): void
    connect(
      sigName: "notify::show-arrow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-arrow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-arrow", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkDropDown` is a widget that allows the user to choose an item
   * from a list of options.
   *
   * ![An example GtkDropDown](drop-down.png)
   *
   * The `GtkDropDown` displays the [selected][property`Gtk`.DropDown:selected]
   * choice.
   *
   * The options are given to `GtkDropDown` in the form of `GListModel`
   * and how the individual options are represented is determined by
   * a [class`Gtk`.ListItemFactory]. The default factory displays simple strings,
   * and adds a checkmark to the selected item in the popup.
   *
   * To set your own factory, use [method`Gtk`.DropDown.set_factory]. It is
   * possible to use a separate factory for the items in the popup, with
   * [method`Gtk`.DropDown.set_list_factory].
   *
   * `GtkDropDown` knows how to obtain strings from the items in a
   * [class`Gtk`.StringList]; for other models, you have to provide an expression
   * to find the strings via [method`Gtk`.DropDown.set_expression].
   *
   * `GtkDropDown` can optionally allow search in the popup, which is
   * useful if the list of options is long. To enable the search entry,
   * use [method`Gtk`.DropDown.set_enable_search].
   *
   * Here is a UI definition example for `GtkDropDown` with a simple model:
   *
   * ```xml
   * <object class="GtkDropDown">
   *   <property name="model">
   *     <object class="GtkStringList">
   *       <items>
   *         <item translatable="yes">Factory</item>
   *         <item translatable="yes">Home</item>
   *         <item translatable="yes">Subway</item>
   *       </items>
   *     </object>
   *   </property>
   * </object>
   * ```
   *
   * If a `GtkDropDown` is created in this manner, or with
   * [ctor`Gtk`.DropDown.new_from_strings], for instance, the object returned from
   * [method`Gtk`.DropDown.get_selected_item] will be a [class`Gtk`.StringObject].
   *
   * To learn more about the list widget framework, see the
   * [overview](section-list-widget.html).
   *
   * ## CSS nodes
   *
   * `GtkDropDown` has a single CSS node with name dropdown,
   * with the button and popover nodes as children.
   *
   * ## Accessibility
   *
   * `GtkDropDown` uses the %GTK_ACCESSIBLE_ROLE_COMBO_BOX role.
   * @class
   */
  class DropDown extends Widget {
    // Own properties of Gtk-4.0.Gtk.DropDown

    static name: string

    // Constructors of Gtk-4.0.Gtk.DropDown

    constructor(config?: DropDown.ConstructorProperties)
    /**
     * Creates a new `GtkDropDown`.
     *
     * You may want to call [method`Gtk`.DropDown.set_factory]
     * to set up a way to map its items to widgets.
     * @constructor
     * @param model the model to use
     * @param expression the expression to use
     * @returns a new `GtkDropDown`
     */
    constructor(model: Gio.ListModel | null, expression: Expression | null)
    /**
     * Creates a new `GtkDropDown`.
     *
     * You may want to call [method`Gtk`.DropDown.set_factory]
     * to set up a way to map its items to widgets.
     * @constructor
     * @param model the model to use
     * @param expression the expression to use
     * @returns a new `GtkDropDown`
     */
    static new(
      model: Gio.ListModel | null,
      expression: Expression | null
    ): DropDown
    /**
     * Creates a new `GtkDropDown` that is populated with
     * the strings.
     * @constructor
     * @param strings The strings to put in the dropdown
     * @returns a new `GtkDropDown`
     */
    static newFromStrings(strings: string[]): DropDown
    _init(config?: DropDown.ConstructorProperties): void
  }

  module DropTarget {
    // Signal callback interfaces

    /**
     * Signal callback interface for `accept`
     */
    interface AcceptSignalCallback {
      (drop: Gdk.Drop): boolean
    }

    /**
     * Signal callback interface for `drop`
     */
    interface DropSignalCallback {
      (value: any, x: number, y: number): boolean
    }

    /**
     * Signal callback interface for `enter`
     */
    interface EnterSignalCallback {
      (x: number, y: number): Gdk.DragAction
    }

    /**
     * Signal callback interface for `leave`
     */
    interface LeaveSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `motion`
     */
    interface MotionSignalCallback {
      (x: number, y: number): Gdk.DragAction
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.DropTarget

      /**
       * The `GdkDragActions` that this drop target supports.
       */
      actions?: Gdk.DragAction | null
      /**
       * The `GdkContentFormats` that determine the supported data formats.
       */
      formats?: Gdk.ContentFormats | null
      /**
       * Whether the drop data should be preloaded when the pointer is only
       * hovering over the widget but has not been released.
       *
       * Setting this property allows finer grained reaction to an ongoing
       * drop at the cost of loading more data.
       *
       * The default value for this property is %FALSE to avoid downloading
       * huge amounts of data by accident.
       *
       * For example, if somebody drags a full document of gigabytes of text
       * from a text editor across a widget with a preloading drop target,
       * this data will be downloaded, even if the data is ultimately dropped
       * elsewhere.
       *
       * For a lot of data formats, the amount of data is very small (like
       * %GDK_TYPE_RGBA), so enabling this property does not hurt at all.
       * And for local-only Drag-and-Drop operations, no data transfer is done,
       * so enabling it there is free.
       */
      preload?: boolean | null
    }
  }

  interface DropTarget {
    // Own properties of Gtk-4.0.Gtk.DropTarget

    /**
     * The `GdkDragActions` that this drop target supports.
     */
    actions: Gdk.DragAction
    /**
     * The `GdkDrop` that is currently being performed.
     */
    readonly currentDrop: Gdk.Drop
    /**
     * The `GdkContentFormats` that determine the supported data formats.
     */
    readonly formats: Gdk.ContentFormats
    /**
     * Whether the drop data should be preloaded when the pointer is only
     * hovering over the widget but has not been released.
     *
     * Setting this property allows finer grained reaction to an ongoing
     * drop at the cost of loading more data.
     *
     * The default value for this property is %FALSE to avoid downloading
     * huge amounts of data by accident.
     *
     * For example, if somebody drags a full document of gigabytes of text
     * from a text editor across a widget with a preloading drop target,
     * this data will be downloaded, even if the data is ultimately dropped
     * elsewhere.
     *
     * For a lot of data formats, the amount of data is very small (like
     * %GDK_TYPE_RGBA), so enabling this property does not hurt at all.
     * And for local-only Drag-and-Drop operations, no data transfer is done,
     * so enabling it there is free.
     */
    preload: boolean
    /**
     * The value for this drop operation.
     *
     * This is %NULL if the data has not been loaded yet or no drop
     * operation is going on.
     *
     * Data may be available before the [signal`Gtk`.DropTarget::drop]
     * signal gets emitted - for example when the [property`Gtk`.DropTarget:preload]
     * property is set. You can use the ::notify signal to be notified
     * of available data.
     */
    readonly value: any
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.DropTarget

    /**
     * Gets the actions that this drop target supports.
     * @returns the actions that this drop target supports
     */
    getActions(): Gdk.DragAction
    /**
     * Gets the currently handled drop operation.
     *
     * If no drop operation is going on, %NULL is returned.
     * @returns The current drop
     */
    getCurrentDrop(): Gdk.Drop | null
    /**
     * Gets the currently handled drop operation.
     *
     * If no drop operation is going on, %NULL is returned.
     * @returns The current drop
     */
    getDrop(): Gdk.Drop | null
    /**
     * Gets the data formats that this drop target accepts.
     *
     * If the result is %NULL, all formats are expected to be supported.
     * @returns the supported data formats
     */
    getFormats(): Gdk.ContentFormats | null
    /**
     * Gets the list of supported `GType`s that can be dropped on the target.
     *
     * If no types have been set, `NULL` will be returned.
     * @returns the `G_TYPE_INVALID`-terminated array of types included in   formats
     */
    getGtypes(): GObject.GType[] | null
    /**
     * Gets whether data should be preloaded on hover.
     * @returns %TRUE if drop data should be preloaded
     */
    getPreload(): boolean
    /**
     * Gets the current drop data, as a `GValue`.
     * @returns The current drop data
     */
    getValue(): any | null
    /**
     * Rejects the ongoing drop operation.
     *
     * If no drop operation is ongoing, i.e when [property`Gtk`.DropTarget:current-drop]
     * is %NULL, this function does nothing.
     *
     * This function should be used when delaying the decision
     * on whether to accept a drag or not until after reading
     * the data.
     */
    reject(): void
    /**
     * Sets the actions that this drop target supports.
     * @param actions the supported actions
     */
    setActions(actions: Gdk.DragAction): void
    /**
     * Sets the supported `GType`s for this drop target.
     * @param types all supported `GType`s   that can be dropped on the target
     */
    setGtypes(types: GObject.GType[] | null): void
    /**
     * Sets whether data should be preloaded on hover.
     * @param preload %TRUE to preload drop data
     */
    setPreload(preload: boolean): void

    // Own signals of Gtk-4.0.Gtk.DropTarget

    connect(
      sigName: "accept",
      callback: DropTarget.AcceptSignalCallback
    ): number
    on(
      sigName: "accept",
      callback: DropTarget.AcceptSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "accept",
      callback: DropTarget.AcceptSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "accept",
      callback: DropTarget.AcceptSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "accept", ...args: any[]): void
    connect(sigName: "drop", callback: DropTarget.DropSignalCallback): number
    on(
      sigName: "drop",
      callback: DropTarget.DropSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drop",
      callback: DropTarget.DropSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drop",
      callback: DropTarget.DropSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drop", x: number, y: number, ...args: any[]): void
    connect(sigName: "enter", callback: DropTarget.EnterSignalCallback): number
    on(
      sigName: "enter",
      callback: DropTarget.EnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "enter",
      callback: DropTarget.EnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "enter",
      callback: DropTarget.EnterSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "enter", y: number, ...args: any[]): void
    connect(sigName: "leave", callback: DropTarget.LeaveSignalCallback): number
    on(
      sigName: "leave",
      callback: DropTarget.LeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "leave",
      callback: DropTarget.LeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "leave",
      callback: DropTarget.LeaveSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "leave", ...args: any[]): void
    connect(
      sigName: "motion",
      callback: DropTarget.MotionSignalCallback
    ): number
    on(
      sigName: "motion",
      callback: DropTarget.MotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "motion",
      callback: DropTarget.MotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "motion",
      callback: DropTarget.MotionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "motion", y: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.DropTarget

    connect(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::actions", ...args: any[]): void
    connect(
      sigName: "notify::current-drop",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::current-drop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::current-drop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::current-drop",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::current-drop", ...args: any[]): void
    connect(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::formats", ...args: any[]): void
    connect(
      sigName: "notify::preload",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::preload",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::preload",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::preload",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::preload", ...args: any[]): void
    connect(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::value", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkDropTarget` is an event controller to receive Drag-and-Drop operations.
   *
   * The most basic way to use a `GtkDropTarget` to receive drops on a
   * widget is to create it via [ctor`Gtk`.DropTarget.new], passing in the
   * `GType` of the data you want to receive and connect to the
   * [signal`Gtk`.DropTarget::drop] signal to receive the data:
   *
   * ```c
   * static gboolean
   * on_drop (GtkDropTarget *target,
   *          const GValue  *value,
   *          double         x,
   *          double         y,
   *          gpointer       data)
   * {
   *   MyWidget *self = data;
   *
   *   // Call the appropriate setter depending on the type of data
   *   // that we received
   *   if (G_VALUE_HOLDS (value, G_TYPE_FILE))
   *     my_widget_set_file (self, g_value_get_object (value));
   *   else if (G_VALUE_HOLDS (value, GDK_TYPE_PIXBUF))
   *     my_widget_set_pixbuf (self, g_value_get_object (value));
   *   else
   *     return FALSE;
   *
   *   return TRUE;
   * }
   *
   * static void
   * my_widget_init (MyWidget *self)
   * {
   *   GtkDropTarget *target =
   *     gtk_drop_target_new (G_TYPE_INVALID, GDK_ACTION_COPY);
   *
   *   // This widget accepts two types of drop types: GFile objects
   *   // and GdkPixbuf objects
   *   gtk_drop_target_set_gtypes (target, (GType [2]) {
   *     G_TYPE_FILE,
   *     GDK_TYPE_PIXBUF,
   *   }, 2);
   *
   *   g_signal_connect (target, "drop", G_CALLBACK (on_drop), self);
   *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (target));
   * }
   * ```
   *
   * `GtkDropTarget` supports more options, such as:
   *
   *  * rejecting potential drops via the [signal`Gtk`.DropTarget::accept] signal
   *    and the [method`Gtk`.DropTarget.reject] function to let other drop
   *    targets handle the drop
   *  * tracking an ongoing drag operation before the drop via the
   *    [signal`Gtk`.DropTarget::enter], [signal`Gtk`.DropTarget::motion] and
   *    [signal`Gtk`.DropTarget::leave] signals
   *  * configuring how to receive data by setting the
   *    [property`Gtk`.DropTarget:preload] property and listening for its
   *    availability via the [property`Gtk`.DropTarget:value] property
   *
   * However, `GtkDropTarget` is ultimately modeled in a synchronous way
   * and only supports data transferred via `GType`. If you want full control
   * over an ongoing drop, the [class`Gtk`.DropTargetAsync] object gives you
   * this ability.
   *
   * While a pointer is dragged over the drop target's widget and the drop
   * has not been rejected, that widget will receive the
   * %GTK_STATE_FLAG_DROP_ACTIVE state, which can be used to style the widget.
   *
   * If you are not interested in receiving the drop, but just want to update
   * UI state during a Drag-and-Drop operation (e.g. switching tabs), you can
   * use [class`Gtk`.DropControllerMotion].
   * @class
   */
  class DropTarget extends EventController {
    // Own properties of Gtk-4.0.Gtk.DropTarget

    static name: string

    // Constructors of Gtk-4.0.Gtk.DropTarget

    constructor(config?: DropTarget.ConstructorProperties)
    /**
     * Creates a new `GtkDropTarget` object.
     *
     * If the drop target should support more than 1 type, pass
     * %G_TYPE_INVALID for `type` and then call
     * [method`Gtk`.DropTarget.set_gtypes].
     * @constructor
     * @param type The supported type or %G_TYPE_INVALID
     * @param actions the supported actions
     * @returns the new `GtkDropTarget`
     */
    constructor(type: GObject.GType, actions: Gdk.DragAction)
    /**
     * Creates a new `GtkDropTarget` object.
     *
     * If the drop target should support more than 1 type, pass
     * %G_TYPE_INVALID for `type` and then call
     * [method`Gtk`.DropTarget.set_gtypes].
     * @constructor
     * @param type The supported type or %G_TYPE_INVALID
     * @param actions the supported actions
     * @returns the new `GtkDropTarget`
     */
    static new(type: GObject.GType, actions: Gdk.DragAction): DropTarget
    _init(config?: DropTarget.ConstructorProperties): void
  }

  module DropTargetAsync {
    // Signal callback interfaces

    /**
     * Signal callback interface for `accept`
     */
    interface AcceptSignalCallback {
      (drop: Gdk.Drop): boolean
    }

    /**
     * Signal callback interface for `drag-enter`
     */
    interface DragEnterSignalCallback {
      (drop: Gdk.Drop, x: number, y: number): Gdk.DragAction
    }

    /**
     * Signal callback interface for `drag-leave`
     */
    interface DragLeaveSignalCallback {
      (drop: Gdk.Drop): void
    }

    /**
     * Signal callback interface for `drag-motion`
     */
    interface DragMotionSignalCallback {
      (drop: Gdk.Drop, x: number, y: number): Gdk.DragAction
    }

    /**
     * Signal callback interface for `drop`
     */
    interface DropSignalCallback {
      (drop: Gdk.Drop, x: number, y: number): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.DropTargetAsync

      /**
       * The `GdkDragActions` that this drop target supports.
       */
      actions?: Gdk.DragAction | null
      /**
       * The `GdkContentFormats` that determines the supported data formats.
       */
      formats?: Gdk.ContentFormats | null
    }
  }

  interface DropTargetAsync {
    // Own properties of Gtk-4.0.Gtk.DropTargetAsync

    /**
     * The `GdkDragActions` that this drop target supports.
     */
    actions: Gdk.DragAction
    /**
     * The `GdkContentFormats` that determines the supported data formats.
     */
    formats: Gdk.ContentFormats
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.DropTargetAsync

    /**
     * Gets the actions that this drop target supports.
     * @returns the actions that this drop target supports
     */
    getActions(): Gdk.DragAction
    /**
     * Gets the data formats that this drop target accepts.
     *
     * If the result is %NULL, all formats are expected to be supported.
     * @returns the supported data formats
     */
    getFormats(): Gdk.ContentFormats | null
    /**
     * Sets the `drop` as not accepted on this drag site.
     *
     * This function should be used when delaying the decision
     * on whether to accept a drag or not until after reading
     * the data.
     * @param drop the `GdkDrop` of an ongoing drag operation
     */
    rejectDrop(drop: Gdk.Drop): void
    /**
     * Sets the actions that this drop target supports.
     * @param actions the supported actions
     */
    setActions(actions: Gdk.DragAction): void
    /**
     * Sets the data formats that this drop target will accept.
     * @param formats the supported data formats or %NULL for any format
     */
    setFormats(formats: Gdk.ContentFormats | null): void

    // Own signals of Gtk-4.0.Gtk.DropTargetAsync

    connect(
      sigName: "accept",
      callback: DropTargetAsync.AcceptSignalCallback
    ): number
    on(
      sigName: "accept",
      callback: DropTargetAsync.AcceptSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "accept",
      callback: DropTargetAsync.AcceptSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "accept",
      callback: DropTargetAsync.AcceptSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "accept", ...args: any[]): void
    connect(
      sigName: "drag-enter",
      callback: DropTargetAsync.DragEnterSignalCallback
    ): number
    on(
      sigName: "drag-enter",
      callback: DropTargetAsync.DragEnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-enter",
      callback: DropTargetAsync.DragEnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-enter",
      callback: DropTargetAsync.DragEnterSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drag-enter", x: number, y: number, ...args: any[]): void
    connect(
      sigName: "drag-leave",
      callback: DropTargetAsync.DragLeaveSignalCallback
    ): number
    on(
      sigName: "drag-leave",
      callback: DropTargetAsync.DragLeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-leave",
      callback: DropTargetAsync.DragLeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-leave",
      callback: DropTargetAsync.DragLeaveSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drag-leave", ...args: any[]): void
    connect(
      sigName: "drag-motion",
      callback: DropTargetAsync.DragMotionSignalCallback
    ): number
    on(
      sigName: "drag-motion",
      callback: DropTargetAsync.DragMotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-motion",
      callback: DropTargetAsync.DragMotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-motion",
      callback: DropTargetAsync.DragMotionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drag-motion", x: number, y: number, ...args: any[]): void
    connect(
      sigName: "drop",
      callback: DropTargetAsync.DropSignalCallback
    ): number
    on(
      sigName: "drop",
      callback: DropTargetAsync.DropSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drop",
      callback: DropTargetAsync.DropSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drop",
      callback: DropTargetAsync.DropSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drop", x: number, y: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.DropTargetAsync

    connect(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::actions",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::actions",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::actions", ...args: any[]): void
    connect(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::formats",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::formats",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::formats", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkDropTargetAsync` is an event controller to receive Drag-and-Drop
   * operations, asynchronously.
   *
   * It is the more complete but also more complex method of handling drop
   * operations compared to [class`Gtk`.DropTarget], and you should only use
   * it if `GtkDropTarget` doesn't provide all the features you need.
   *
   * To use a `GtkDropTargetAsync` to receive drops on a widget, you create
   * a `GtkDropTargetAsync` object, configure which data formats and actions
   * you support, connect to its signals, and then attach it to the widget
   * with [method`Gtk`.Widget.add_controller].
   *
   * During a drag operation, the first signal that a `GtkDropTargetAsync`
   * emits is [signal`Gtk`.DropTargetAsync::accept], which is meant to determine
   * whether the target is a possible drop site for the ongoing drop. The
   * default handler for the ::accept signal accepts the drop if it finds
   * a compatible data format and an action that is supported on both sides.
   *
   * If it is, and the widget becomes a target, you will receive a
   * [signal`Gtk`.DropTargetAsync::drag-enter] signal, followed by
   * [signal`Gtk`.DropTargetAsync::drag-motion] signals as the pointer moves,
   * optionally a [signal`Gtk`.DropTargetAsync::drop] signal when a drop happens,
   * and finally a [signal`Gtk`.DropTargetAsync::drag-leave] signal when the
   * pointer moves off the widget.
   *
   * The ::drag-enter and ::drag-motion handler return a `GdkDragAction`
   * to update the status of the ongoing operation. The ::drop handler
   * should decide if it ultimately accepts the drop and if it does, it
   * should initiate the data transfer and finish the operation by calling
   * [method`Gdk`.Drop.finish].
   *
   * Between the ::drag-enter and ::drag-leave signals the widget is a
   * current drop target, and will receive the %GTK_STATE_FLAG_DROP_ACTIVE
   * state, which can be used by themes to style the widget as a drop target.
   * @class
   */
  class DropTargetAsync extends EventController {
    // Own properties of Gtk-4.0.Gtk.DropTargetAsync

    static name: string

    // Constructors of Gtk-4.0.Gtk.DropTargetAsync

    constructor(config?: DropTargetAsync.ConstructorProperties)
    /**
     * Creates a new `GtkDropTargetAsync` object.
     * @constructor
     * @param formats the supported data formats
     * @param actions the supported actions
     * @returns the new `GtkDropTargetAsync`
     */
    constructor(formats: Gdk.ContentFormats | null, actions: Gdk.DragAction)
    /**
     * Creates a new `GtkDropTargetAsync` object.
     * @constructor
     * @param formats the supported data formats
     * @param actions the supported actions
     * @returns the new `GtkDropTargetAsync`
     */
    static new(
      formats: Gdk.ContentFormats | null,
      actions: Gdk.DragAction
    ): DropTargetAsync
    _init(config?: DropTargetAsync.ConstructorProperties): void
  }

  module EditableLabel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Editable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.EditableLabel

      /**
       * This property is %TRUE while the widget is in edit mode.
       */
      editing?: boolean | null
    }
  }

  interface EditableLabel
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Editable {
    // Own properties of Gtk-4.0.Gtk.EditableLabel

    /**
     * This property is %TRUE while the widget is in edit mode.
     */
    editing: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.EditableLabel

    /**
     * Returns whether the label is currently in “editing mode”.
     * @returns %TRUE if @self is currently in editing mode
     */
    getEditing(): boolean
    /**
     * Switches the label into “editing mode”.
     */
    startEditing(): void
    /**
     * Switches the label out of “editing mode”.
     *
     * If `commit` is %TRUE, the resulting text is kept as the
     * [property`Gtk`.Editable:text] property value, otherwise the
     * resulting text is discarded and the label will keep its
     * previous [property`Gtk`.Editable:text] property value.
     * @param commit whether to set the edited text on the label
     */
    stopEditing(commit: boolean): void

    // Class property signals of Gtk-4.0.Gtk.EditableLabel

    connect(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-position", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-undo", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-bound", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkEditableLabel` is a label that allows users to
   * edit the text by switching to an “edit mode”.
   *
   * ![An example GtkEditableLabel](editable-label.png)
   *
   * `GtkEditableLabel` does not have API of its own, but it
   * implements the [iface`Gtk`.Editable] interface.
   *
   * The default bindings for activating the edit mode is
   * to click or press the Enter key. The default bindings
   * for leaving the edit mode are the Enter key (to save
   * the results) or the Escape key (to cancel the editing).
   *
   * # CSS nodes
   *
   * ```
   * editablelabel[.editing]
   * ╰── stack
   *     ├── label
   *     ╰── text
   * ```
   *
   * `GtkEditableLabel` has a main node with the name editablelabel.
   * When the entry is in editing mode, it gets the .editing style
   * class.
   *
   * For all the subnodes added to the text node in various situations,
   * see [class`Gtk`.Text].
   * @class
   */
  class EditableLabel extends Widget {
    // Own properties of Gtk-4.0.Gtk.EditableLabel

    static name: string

    // Constructors of Gtk-4.0.Gtk.EditableLabel

    constructor(config?: EditableLabel.ConstructorProperties)
    /**
     * Creates a new `GtkEditableLabel` widget.
     * @constructor
     * @param str the text for the label
     * @returns the new `GtkEditableLabel`
     */
    constructor(str: string)
    /**
     * Creates a new `GtkEditableLabel` widget.
     * @constructor
     * @param str the text for the label
     * @returns the new `GtkEditableLabel`
     */
    static new(str: string): EditableLabel
    _init(config?: EditableLabel.ConstructorProperties): void
  }

  module EmojiChooser {
    // Signal callback interfaces

    /**
     * Signal callback interface for `emoji-picked`
     */
    interface EmojiPickedSignalCallback {
      (text: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Popover.ConstructorProperties {}
  }

  interface EmojiChooser
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.EmojiChooser

    __gtype__: number

    // Conflicting properties

    readonly parent: Widget & Widget

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Own signals of Gtk-4.0.Gtk.EmojiChooser

    connect(
      sigName: "emoji-picked",
      callback: EmojiChooser.EmojiPickedSignalCallback
    ): number
    on(
      sigName: "emoji-picked",
      callback: EmojiChooser.EmojiPickedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "emoji-picked",
      callback: EmojiChooser.EmojiPickedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "emoji-picked",
      callback: EmojiChooser.EmojiPickedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "emoji-picked", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.EmojiChooser

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::autohide", ...args: any[]): void
    connect(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cascade-popdown", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-arrow", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pointing-to", ...args: any[]): void
    connect(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkEmojiChooser` is used by text widgets such as `GtkEntry` or
   * `GtkTextView` to let users insert Emoji characters.
   *
   * ![An example GtkEmojiChooser](emojichooser.png)
   *
   * `GtkEmojiChooser` emits the [signal`Gtk`.EmojiChooser::emoji-picked]
   * signal when an Emoji is selected.
   *
   * # CSS nodes
   *
   * ```
   * popover
   * ├── box.emoji-searchbar
   * │   ╰── entry.search
   * ╰── box.emoji-toolbar
   *     ├── button.image-button.emoji-section
   *     ├── ...
   *     ╰── button.image-button.emoji-section
   * ```
   *
   * Every `GtkEmojiChooser` consists of a main node called popover.
   * The contents of the popover are largely implementation defined
   * and supposed to inherit general styles.
   * The top searchbar used to search emoji and gets the .emoji-searchbar
   * style class itself.
   * The bottom toolbar used to switch between different emoji categories
   * consists of buttons with the .emoji-section style class and gets the
   * .emoji-toolbar style class itself.
   * @class
   */
  class EmojiChooser extends Popover {
    // Own properties of Gtk-4.0.Gtk.EmojiChooser

    static name: string

    // Constructors of Gtk-4.0.Gtk.EmojiChooser

    constructor(config?: EmojiChooser.ConstructorProperties)
    /**
     * Creates a new `GtkEmojiChooser`.
     * @constructor
     * @returns a new `GtkEmojiChooser`
     */
    constructor()
    /**
     * Creates a new `GtkEmojiChooser`.
     * @constructor
     * @returns a new `GtkEmojiChooser`
     */
    static new(): EmojiChooser
    _init(config?: EmojiChooser.ConstructorProperties): void
  }

  module Entry {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `icon-press`
     */
    interface IconPressSignalCallback {
      (iconPos: EntryIconPosition): void
    }

    /**
     * Signal callback interface for `icon-release`
     */
    interface IconReleaseSignalCallback {
      (iconPos: EntryIconPosition): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        CellEditable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Editable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Entry

      /**
       * Whether to activate the default widget when Enter is pressed.
       */
      activates_default?: boolean | null
      /**
       * A list of Pango attributes to apply to the text of the entry.
       *
       * This is mainly useful to change the size or weight of the text.
       *
       * The `PangoAttribute`'s `start_index` and `end_index` must refer to the
       * [class`Gtk`.EntryBuffer] text, i.e. without the preedit string.
       */
      attributes?: Pango.AttrList | null
      /**
       * The buffer object which actually stores the text.
       */
      buffer?: EntryBuffer | null
      /**
       * The auxiliary completion object to use with the entry.
       */
      completion?: EntryCompletion | null
      /**
       * Whether to suggest Emoji replacements for :-delimited names
       * like `:heart:`.
       */
      enable_emoji_completion?: boolean | null
      /**
       * A menu model whose contents will be appended to the context menu.
       */
      extra_menu?: Gio.MenuModel | null
      /**
       * Whether the entry should draw a frame.
       */
      has_frame?: boolean | null
      /**
       * Which IM (input method) module should be used for this entry.
       *
       * See [class`Gtk`.IMContext].
       *
       * Setting this to a non-%NULL value overrides the system-wide IM
       * module setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module]
       * property.
       */
      im_module?: string | null
      /**
       * Additional hints that allow input methods to fine-tune their behavior.
       *
       * Also see [property`Gtk`.Entry:input-purpose]
       */
      input_hints?: InputHints | null
      /**
       * The purpose of this text field.
       *
       * This property can be used by on-screen keyboards and other input
       * methods to adjust their behaviour.
       *
       * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
       * %GTK_INPUT_PURPOSE_PIN is independent from setting
       * [property`Gtk`.Entry:visibility].
       */
      input_purpose?: InputPurpose | null
      /**
       * The character to use when masking entry contents (“password mode”).
       */
      invisible_char?: number | null
      /**
       * Whether the invisible char has been set for the `GtkEntry`.
       */
      invisible_char_set?: boolean | null
      /**
       * Maximum number of characters for this entry.
       */
      max_length?: number | null
      /**
       * If text is overwritten when typing in the `GtkEntry`.
       */
      overwrite_mode?: boolean | null
      /**
       * The text that will be displayed in the `GtkEntry` when it is empty
       * and unfocused.
       */
      placeholder_text?: string | null
      /**
       * Whether the primary icon is activatable.
       *
       * GTK emits the [signal`Gtk`.Entry::icon-press] and
       * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
       * activatable icons.
       *
       * Sensitive, but non-activatable icons can be used for purely
       * informational purposes.
       */
      primary_icon_activatable?: boolean | null
      /**
       * The `GIcon` to use for the primary icon for the entry.
       */
      primary_icon_gicon?: Gio.Icon | null
      /**
       * The icon name to use for the primary icon for the entry.
       */
      primary_icon_name?: string | null
      /**
       * A `GdkPaintable` to use as the primary icon for the entry.
       */
      primary_icon_paintable?: Gdk.Paintable | null
      /**
       * Whether the primary icon is sensitive.
       *
       * An insensitive icon appears grayed out. GTK does not emit the
       * [signal`Gtk`.Entry::icon-press] and [signal`Gtk`.Entry::icon-release]
       * signals and does not allow DND from insensitive icons.
       *
       * An icon should be set insensitive if the action that would trigger
       * when clicked is currently not available.
       */
      primary_icon_sensitive?: boolean | null
      /**
       * The contents of the tooltip on the primary icon, with markup.
       *
       * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
       */
      primary_icon_tooltip_markup?: string | null
      /**
       * The contents of the tooltip on the primary icon.
       *
       * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
       */
      primary_icon_tooltip_text?: string | null
      /**
       * The current fraction of the task that's been completed.
       */
      progress_fraction?: number | null
      /**
       * The fraction of total entry width to move the progress
       * bouncing block for each pulse.
       *
       * See [method`Gtk`.Entry.progress_pulse].
       */
      progress_pulse_step?: number | null
      /**
       * Whether the secondary icon is activatable.
       *
       * GTK emits the [signal`Gtk`.Entry::icon-press] and
       * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
       * activatable icons.
       *
       * Sensitive, but non-activatable icons can be used for purely
       * informational purposes.
       */
      secondary_icon_activatable?: boolean | null
      /**
       * The `GIcon` to use for the secondary icon for the entry.
       */
      secondary_icon_gicon?: Gio.Icon | null
      /**
       * The icon name to use for the secondary icon for the entry.
       */
      secondary_icon_name?: string | null
      /**
       * A `GdkPaintable` to use as the secondary icon for the entry.
       */
      secondary_icon_paintable?: Gdk.Paintable | null
      /**
       * Whether the secondary icon is sensitive.
       *
       * An insensitive icon appears grayed out. GTK does not emit the
       * [signal`Gtk`.Entry::icon-press[ and [signal`Gtk`.Entry::icon-release]
       * signals and does not allow DND from insensitive icons.
       *
       * An icon should be set insensitive if the action that would trigger
       * when clicked is currently not available.
       */
      secondary_icon_sensitive?: boolean | null
      /**
       * The contents of the tooltip on the secondary icon, with markup.
       *
       * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
       */
      secondary_icon_tooltip_markup?: string | null
      /**
       * The contents of the tooltip on the secondary icon.
       *
       * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
       */
      secondary_icon_tooltip_text?: string | null
      show_emoji_icon?: boolean | null
      tabs?: Pango.TabArray | null
      /**
       * When %TRUE, pasted multi-line text is truncated to the first line.
       */
      truncate_multiline?: boolean | null
      /**
       * Whether the entry should show the “invisible char” instead of the
       * actual text (“password mode”).
       */
      visibility?: boolean | null
    }
  }

  interface Entry
    extends Accessible,
      Buildable,
      CellEditable,
      ConstraintTarget,
      Editable {
    // Own properties of Gtk-4.0.Gtk.Entry

    /**
     * Whether to activate the default widget when Enter is pressed.
     */
    activatesDefault: boolean
    /**
     * A list of Pango attributes to apply to the text of the entry.
     *
     * This is mainly useful to change the size or weight of the text.
     *
     * The `PangoAttribute`'s `start_index` and `end_index` must refer to the
     * [class`Gtk`.EntryBuffer] text, i.e. without the preedit string.
     */
    attributes: Pango.AttrList
    /**
     * The buffer object which actually stores the text.
     */
    buffer: EntryBuffer
    /**
     * The auxiliary completion object to use with the entry.
     */
    completion: EntryCompletion
    /**
     * Whether to suggest Emoji replacements for :-delimited names
     * like `:heart:`.
     */
    enableEmojiCompletion: boolean
    /**
     * A menu model whose contents will be appended to the context menu.
     */
    extraMenu: Gio.MenuModel
    /**
     * Whether the entry should draw a frame.
     */
    hasFrame: boolean
    /**
     * Which IM (input method) module should be used for this entry.
     *
     * See [class`Gtk`.IMContext].
     *
     * Setting this to a non-%NULL value overrides the system-wide IM
     * module setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module]
     * property.
     */
    imModule: string | null
    /**
     * Additional hints that allow input methods to fine-tune their behavior.
     *
     * Also see [property`Gtk`.Entry:input-purpose]
     */
    inputHints: InputHints
    /**
     * The purpose of this text field.
     *
     * This property can be used by on-screen keyboards and other input
     * methods to adjust their behaviour.
     *
     * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
     * %GTK_INPUT_PURPOSE_PIN is independent from setting
     * [property`Gtk`.Entry:visibility].
     */
    inputPurpose: InputPurpose
    /**
     * The character to use when masking entry contents (“password mode”).
     */
    invisibleChar: number
    /**
     * Whether the invisible char has been set for the `GtkEntry`.
     */
    invisibleCharSet: boolean
    /**
     * Maximum number of characters for this entry.
     */
    maxLength: number
    /**
     * If text is overwritten when typing in the `GtkEntry`.
     */
    overwriteMode: boolean
    /**
     * The text that will be displayed in the `GtkEntry` when it is empty
     * and unfocused.
     */
    placeholderText: string | null
    /**
     * Whether the primary icon is activatable.
     *
     * GTK emits the [signal`Gtk`.Entry::icon-press] and
     * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
     * activatable icons.
     *
     * Sensitive, but non-activatable icons can be used for purely
     * informational purposes.
     */
    primaryIconActivatable: boolean
    /**
     * The `GIcon` to use for the primary icon for the entry.
     */
    primaryIconGicon: Gio.Icon
    /**
     * The icon name to use for the primary icon for the entry.
     */
    primaryIconName: string | null
    /**
     * A `GdkPaintable` to use as the primary icon for the entry.
     */
    primaryIconPaintable: Gdk.Paintable
    /**
     * Whether the primary icon is sensitive.
     *
     * An insensitive icon appears grayed out. GTK does not emit the
     * [signal`Gtk`.Entry::icon-press] and [signal`Gtk`.Entry::icon-release]
     * signals and does not allow DND from insensitive icons.
     *
     * An icon should be set insensitive if the action that would trigger
     * when clicked is currently not available.
     */
    primaryIconSensitive: boolean
    /**
     * The representation which is used for the primary icon of the entry.
     */
    readonly primaryIconStorageType: ImageType
    /**
     * The contents of the tooltip on the primary icon, with markup.
     *
     * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
     */
    primaryIconTooltipMarkup: string | null
    /**
     * The contents of the tooltip on the primary icon.
     *
     * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
     */
    primaryIconTooltipText: string | null
    /**
     * The current fraction of the task that's been completed.
     */
    progressFraction: number
    /**
     * The fraction of total entry width to move the progress
     * bouncing block for each pulse.
     *
     * See [method`Gtk`.Entry.progress_pulse].
     */
    progressPulseStep: number
    /**
     * Number of pixels of the entry scrolled off the screen to the left.
     */
    readonly scrollOffset: number
    /**
     * Whether the secondary icon is activatable.
     *
     * GTK emits the [signal`Gtk`.Entry::icon-press] and
     * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
     * activatable icons.
     *
     * Sensitive, but non-activatable icons can be used for purely
     * informational purposes.
     */
    secondaryIconActivatable: boolean
    /**
     * The `GIcon` to use for the secondary icon for the entry.
     */
    secondaryIconGicon: Gio.Icon
    /**
     * The icon name to use for the secondary icon for the entry.
     */
    secondaryIconName: string | null
    /**
     * A `GdkPaintable` to use as the secondary icon for the entry.
     */
    secondaryIconPaintable: Gdk.Paintable
    /**
     * Whether the secondary icon is sensitive.
     *
     * An insensitive icon appears grayed out. GTK does not emit the
     * [signal`Gtk`.Entry::icon-press[ and [signal`Gtk`.Entry::icon-release]
     * signals and does not allow DND from insensitive icons.
     *
     * An icon should be set insensitive if the action that would trigger
     * when clicked is currently not available.
     */
    secondaryIconSensitive: boolean
    /**
     * The representation which is used for the secondary icon of the entry.
     */
    readonly secondaryIconStorageType: ImageType
    /**
     * The contents of the tooltip on the secondary icon, with markup.
     *
     * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
     */
    secondaryIconTooltipMarkup: string | null
    /**
     * The contents of the tooltip on the secondary icon.
     *
     * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
     */
    secondaryIconTooltipText: string | null
    showEmojiIcon: boolean
    tabs: Pango.TabArray
    /**
     * The length of the text in the `GtkEntry`.
     */
    readonly textLength: number
    /**
     * When %TRUE, pasted multi-line text is truncated to the first line.
     */
    truncateMultiline: boolean
    /**
     * Whether the entry should show the “invisible char” instead of the
     * actual text (“password mode”).
     */
    visibility: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Entry

    /**
     * Retrieves the value set by gtk_entry_set_activates_default().
     * @returns %TRUE if the entry will activate the default widget
     */
    getActivatesDefault(): boolean
    /**
     * Gets the value set by gtk_entry_set_alignment().
     *
     * See also: [property`Gtk`.Editable:xalign]
     * @returns the alignment
     */
    getAlignment(): number
    /**
     * Gets the attribute list of the `GtkEntry`.
     *
     * See [method`Gtk`.Entry.set_attributes].
     * @returns the attribute list
     */
    getAttributes(): Pango.AttrList | null
    /**
     * Get the `GtkEntryBuffer` object which holds the text for
     * this widget.
     * @returns A `GtkEntryBuffer` object.
     */
    getBuffer(): EntryBuffer
    /**
     * Returns the auxiliary completion object currently
     * in use by `entry`.
     * @returns The auxiliary   completion object currently in use by @entry
     */
    getCompletion(): EntryCompletion | null
    /**
     * Returns the index of the icon which is the source of the
     * current  DND operation, or -1.
     * @returns index of the icon which is the source of the   current DND operation, or -1.
     */
    getCurrentIconDragSource(): number
    /**
     * Gets the menu model set with gtk_entry_set_extra_menu().
     * @returns the menu model
     */
    getExtraMenu(): Gio.MenuModel | null
    /**
     * Gets the value set by gtk_entry_set_has_frame().
     * @returns whether the entry has a beveled frame
     */
    getHasFrame(): boolean
    /**
     * Returns whether the icon is activatable.
     * @param iconPos Icon position
     * @returns %TRUE if the icon is activatable.
     */
    getIconActivatable(iconPos: EntryIconPosition): boolean
    /**
     * Gets the area where entry’s icon at `icon_pos` is drawn.
     *
     * This function is useful when drawing something to the
     * entry in a draw callback.
     *
     * If the entry is not realized or has no icon at the given
     * position, `icon_area` is filled with zeros. Otherwise,
     * `icon_area` will be filled with the icon's allocation,
     * relative to `entry'`s allocation.
     * @param iconPos Icon position
     */
    getIconArea(iconPos: EntryIconPosition): /* iconArea */ Gdk.Rectangle
    /**
     * Finds the icon at the given position and return its index.
     *
     * The position’s coordinates are relative to the `entry’`s
     * top left corner. If `x,` `y` doesn’t lie inside an icon,
     * -1 is returned. This function is intended for use in a
     *  [signal`Gtk`.Widget::query-tooltip] signal handler.
     * @param x the x coordinate of the position to find, relative to `entry`
     * @param y the y coordinate of the position to find, relative to `entry`
     * @returns the index of the icon at the given position, or -1
     */
    getIconAtPos(x: number, y: number): number
    /**
     * Retrieves the `GIcon` used for the icon.
     *
     * %NULL will be returned if there is no icon or if the icon was
     * set by some other method (e.g., by `GdkPaintable` or icon name).
     * @param iconPos Icon position
     * @returns A `GIcon`
     */
    getIconGicon(iconPos: EntryIconPosition): Gio.Icon | null
    /**
     * Retrieves the icon name used for the icon.
     *
     * %NULL is returned if there is no icon or if the icon was set
     * by some other method (e.g., by `GdkPaintable` or gicon).
     * @param iconPos Icon position
     * @returns An icon name
     */
    getIconName(iconPos: EntryIconPosition): string | null
    /**
     * Retrieves the `GdkPaintable` used for the icon.
     *
     * If no `GdkPaintable` was used for the icon, %NULL is returned.
     * @param iconPos Icon position
     * @returns A `GdkPaintable`   if no icon is set for this position or the icon set is not   a `GdkPaintable`.
     */
    getIconPaintable(iconPos: EntryIconPosition): Gdk.Paintable | null
    /**
     * Returns whether the icon appears sensitive or insensitive.
     * @param iconPos Icon position
     * @returns %TRUE if the icon is sensitive.
     */
    getIconSensitive(iconPos: EntryIconPosition): boolean
    /**
     * Gets the type of representation being used by the icon
     * to store image data.
     *
     * If the icon has no image data, the return value will
     * be %GTK_IMAGE_EMPTY.
     * @param iconPos Icon position
     * @returns image representation being used
     */
    getIconStorageType(iconPos: EntryIconPosition): ImageType
    /**
     * Gets the contents of the tooltip on the icon at the specified
     * position in `entry`.
     * @param iconPos the icon position
     * @returns the tooltip text
     */
    getIconTooltipMarkup(iconPos: EntryIconPosition): string | null
    /**
     * Gets the contents of the tooltip on the icon at the specified
     * position in `entry`.
     * @param iconPos the icon position
     * @returns the tooltip text
     */
    getIconTooltipText(iconPos: EntryIconPosition): string | null
    /**
     * Gets the input hints of this `GtkEntry`.
     * @returns the input hints
     */
    getInputHints(): InputHints
    /**
     * Gets the input purpose of the `GtkEntry`.
     * @returns the input purpose
     */
    getInputPurpose(): InputPurpose
    /**
     * Retrieves the character displayed in place of the actual text
     * in “password mode”.
     * @returns the current invisible char, or 0, if the entry does not   show invisible text at all.
     */
    getInvisibleChar(): string
    /**
     * Retrieves the maximum allowed length of the text in `entry`.
     *
     * See [method`Gtk`.Entry.set_max_length].
     * @returns the maximum allowed number of characters   in `GtkEntry`, or 0 if there is no maximum.
     */
    getMaxLength(): number
    /**
     * Gets whether the `GtkEntry` is in overwrite mode.
     * @returns whether the text is overwritten when typing.
     */
    getOverwriteMode(): boolean
    /**
     * Retrieves the text that will be displayed when `entry`
     * is empty and unfocused
     * @returns a pointer to the   placeholder text as a string. This string points to   internally allocated storage in the widget and must   not be freed, modified or stored. If no placeholder   text has been set, %NULL will be returned.
     */
    getPlaceholderText(): string | null
    /**
     * Returns the current fraction of the task that’s been completed.
     *
     * See [method`Gtk`.Entry.set_progress_fraction].
     * @returns a fraction from 0.0 to 1.0
     */
    getProgressFraction(): number
    /**
     * Retrieves the pulse step set with
     * gtk_entry_set_progress_pulse_step().
     * @returns a fraction from 0.0 to 1.0
     */
    getProgressPulseStep(): number
    /**
     * Gets the tabstops of the `GtkEntry`.
     *
     * See [method`Gtk`.Entry.set_tabs].
     * @returns the tabstops
     */
    getTabs(): Pango.TabArray | null
    /**
     * Retrieves the current length of the text in `entry`.
     *
     * This is equivalent to getting `entry'`s `GtkEntryBuffer`
     * and calling [method`Gtk`.EntryBuffer.get_length] on it.
     * @returns the current number of characters   in `GtkEntry`, or 0 if there are none.
     */
    getTextLength(): number
    /**
     * Retrieves whether the text in `entry` is visible.
     *
     * See [method`Gtk`.Entry.set_visibility].
     * @returns %TRUE if the text is currently visible
     */
    getVisibility(): boolean
    /**
     * Causes `entry` to have keyboard focus.
     *
     * It behaves like [method`Gtk`.Widget.grab_focus], except that it doesn't
     * select the contents of the entry. You only want to call this on some
     * special entries which the user usually doesn't want to replace all text
     * in, such as search-as-you-type entries.
     * @returns %TRUE if focus is now inside @self
     */
    grabFocusWithoutSelecting(): boolean
    /**
     * Indicates that some progress is made, but you don’t
     * know how much.
     *
     * Causes the entry’s progress indicator to enter “activity
     * mode”, where a block bounces back and forth. Each call to
     * gtk_entry_progress_pulse() causes the block to move by a
     * little bit (the amount of movement per pulse is determined
     * by [method`Gtk`.Entry.set_progress_pulse_step]).
     */
    progressPulse(): void
    /**
     * Reset the input method context of the entry if needed.
     *
     * This can be necessary in the case where modifying the buffer
     * would confuse on-going input method behavior.
     */
    resetImContext(): void
    /**
     * Sets whether pressing Enter in the `entry` will activate the default
     * widget for the window containing the entry.
     *
     * This usually means that the dialog containing the entry will be closed,
     * since the default widget is usually one of the dialog buttons.
     * @param setting %TRUE to activate window’s default widget on Enter keypress
     */
    setActivatesDefault(setting: boolean): void
    /**
     * Sets the alignment for the contents of the entry.
     *
     * This controls the horizontal positioning of the contents when
     * the displayed text is shorter than the width of the entry.
     *
     * See also: [property`Gtk`.Editable:xalign]
     * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
     */
    setAlignment(xalign: number): void
    /**
     * Sets a `PangoAttrList`.
     *
     * The attributes in the list are applied to the entry text.
     *
     * Since the attributes will be applied to text that changes
     * as the user types, it makes most sense to use attributes
     * with unlimited extent.
     * @param attrs a `PangoAttrList`
     */
    setAttributes(attrs: Pango.AttrList): void
    /**
     * Set the `GtkEntryBuffer` object which holds the text for
     * this widget.
     * @param buffer a `GtkEntryBuffer`
     */
    setBuffer(buffer: EntryBuffer): void
    /**
     * Sets `completion` to be the auxiliary completion object
     * to use with `entry`.
     *
     * All further configuration of the completion mechanism is
     * done on `completion` using the `GtkEntryCompletion` API.
     * Completion is disabled if `completion` is set to %NULL.
     * @param completion The `GtkEntryCompletion`
     */
    setCompletion(completion: EntryCompletion | null): void
    /**
     * Sets a menu model to add when constructing
     * the context menu for `entry`.
     * @param model a `GMenuModel`
     */
    setExtraMenu(model: Gio.MenuModel | null): void
    /**
     * Sets whether the entry has a beveled frame around it.
     * @param setting new value
     */
    setHasFrame(setting: boolean): void
    /**
     * Sets whether the icon is activatable.
     * @param iconPos Icon position
     * @param activatable %TRUE if the icon should be activatable
     */
    setIconActivatable(iconPos: EntryIconPosition, activatable: boolean): void
    /**
     * Sets up the icon at the given position as drag source.
     *
     * This makes it so that GTK will start a drag
     * operation when the user clicks and drags the icon.
     * @param iconPos icon position
     * @param provider a `GdkContentProvider`
     * @param actions a bitmask of the allowed drag actions
     */
    setIconDragSource(
      iconPos: EntryIconPosition,
      provider: Gdk.ContentProvider,
      actions: Gdk.DragAction
    ): void
    /**
     * Sets the icon shown in the entry at the specified position
     * from the current icon theme.
     *
     * If the icon isn’t known, a “broken image” icon will be
     * displayed instead.
     *
     * If `icon` is %NULL, no icon will be shown in the
     * specified position.
     * @param iconPos The position at which to set the icon
     * @param icon The icon to set
     */
    setIconFromGicon(iconPos: EntryIconPosition, icon: Gio.Icon | null): void
    /**
     * Sets the icon shown in the entry at the specified position
     * from the current icon theme.
     *
     * If the icon name isn’t known, a “broken image” icon will be
     * displayed instead.
     *
     * If `icon_name` is %NULL, no icon will be shown in the
     * specified position.
     * @param iconPos The position at which to set the icon
     * @param iconName An icon name
     */
    setIconFromIconName(
      iconPos: EntryIconPosition,
      iconName: string | null
    ): void
    /**
     * Sets the icon shown in the specified position using a `GdkPaintable`.
     *
     * If `paintable` is %NULL, no icon will be shown in the specified position.
     * @param iconPos Icon position
     * @param paintable A `GdkPaintable`
     */
    setIconFromPaintable(
      iconPos: EntryIconPosition,
      paintable: Gdk.Paintable | null
    ): void
    /**
     * Sets the sensitivity for the specified icon.
     * @param iconPos Icon position
     * @param sensitive Specifies whether the icon should appear   sensitive or insensitive
     */
    setIconSensitive(iconPos: EntryIconPosition, sensitive: boolean): void
    /**
     * Sets `tooltip` as the contents of the tooltip for the icon at
     * the specified position.
     *
     * `tooltip` is assumed to be marked up with Pango Markup.
     *
     * Use %NULL for `tooltip` to remove an existing tooltip.
     *
     * See also [method`Gtk`.Widget.set_tooltip_markup] and
     * [method`Gtk`.Entry.set_icon_tooltip_text].
     * @param iconPos the icon position
     * @param tooltip the contents of the tooltip for the icon
     */
    setIconTooltipMarkup(
      iconPos: EntryIconPosition,
      tooltip: string | null
    ): void
    /**
     * Sets `tooltip` as the contents of the tooltip for the icon
     * at the specified position.
     *
     * Use %NULL for `tooltip` to remove an existing tooltip.
     *
     * See also [method`Gtk`.Widget.set_tooltip_text] and
     * [method`Gtk`.Entry.set_icon_tooltip_markup].
     *
     * If you unset the widget tooltip via
     * [method`Gtk`.Widget.set_tooltip_text] or
     * [method`Gtk`.Widget.set_tooltip_markup], this sets
     * [property`Gtk`.Widget:has-tooltip] to %FALSE, which suppresses
     * icon tooltips too. You can resolve this by then calling
     * [method`Gtk`.Widget.set_has_tooltip] to set
     * [property`Gtk`.Widget:has-tooltip] back to %TRUE, or
     * setting at least one non-empty tooltip on any icon
     * achieves the same result.
     * @param iconPos the icon position
     * @param tooltip the contents of the tooltip for the icon
     */
    setIconTooltipText(iconPos: EntryIconPosition, tooltip: string | null): void
    /**
     * Set additional hints which allow input methods to
     * fine-tune their behavior.
     * @param hints the hints
     */
    setInputHints(hints: InputHints): void
    /**
     * Sets the input purpose which can be used by input methods
     * to adjust their behavior.
     * @param purpose the purpose
     */
    setInputPurpose(purpose: InputPurpose): void
    /**
     * Sets the character to use in place of the actual text
     * in “password mode”.
     *
     * See [method`Gtk`.Entry.set_visibility] for how to enable
     * “password mode”.
     *
     * By default, GTK picks the best invisible char available in
     * the current font. If you set the invisible char to 0, then
     * the user will get no feedback at all; there will be no text
     * on the screen as they type.
     * @param ch a Unicode character
     */
    setInvisibleChar(ch: string): void
    /**
     * Sets the maximum allowed length of the contents of the widget.
     *
     * If the current contents are longer than the given length, then
     * they will be truncated to fit. The length is in characters.
     *
     * This is equivalent to getting `entry'`s `GtkEntryBuffer` and
     * calling [method`Gtk`.EntryBuffer.set_max_length] on it.
     * @param max the maximum length of the entry, or 0 for no maximum.   (other than the maximum length of entries.) The value passed in will   be clamped to the range 0-65536.
     */
    setMaxLength(max: number): void
    /**
     * Sets whether the text is overwritten when typing in the `GtkEntry`.
     * @param overwrite new value
     */
    setOverwriteMode(overwrite: boolean): void
    /**
     * Sets text to be displayed in `entry` when it is empty.
     *
     * This can be used to give a visual hint of the expected
     * contents of the `GtkEntry`.
     * @param text a string to be displayed when `entry` is empty and unfocused
     */
    setPlaceholderText(text: string | null): void
    /**
     * Causes the entry’s progress indicator to “fill in” the given
     * fraction of the bar.
     *
     * The fraction should be between 0.0 and 1.0, inclusive.
     * @param fraction fraction of the task that’s been completed
     */
    setProgressFraction(fraction: number): void
    /**
     * Sets the fraction of total entry width to move the progress
     * bouncing block for each pulse.
     *
     * Use [method`Gtk`.Entry.progress_pulse] to pulse
     * the progress.
     * @param fraction fraction between 0.0 and 1.0
     */
    setProgressPulseStep(fraction: number): void
    /**
     * Sets a `PangoTabArray`.
     *
     * The tabstops in the array are applied to the entry text.
     * @param tabs a `PangoTabArray`
     */
    setTabs(tabs: Pango.TabArray | null): void
    /**
     * Sets whether the contents of the entry are visible or not.
     *
     * When visibility is set to %FALSE, characters are displayed
     * as the invisible char, and will also appear that way when
     * the text in the entry widget is copied elsewhere.
     *
     * By default, GTK picks the best invisible character available
     * in the current font, but it can be changed with
     * [method`Gtk`.Entry.set_invisible_char].
     *
     * Note that you probably want to set [property`Gtk`.Entry:input-purpose]
     * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
     * inform input methods about the purpose of this entry,
     * in addition to setting visibility to %FALSE.
     * @param visible %TRUE if the contents of the entry are displayed as plaintext
     */
    setVisibility(visible: boolean): void
    /**
     * Unsets the invisible char, so that the default invisible char
     * is used again. See [method`Gtk`.Entry.set_invisible_char].
     */
    unsetInvisibleChar(): void

    // Own virtual methods of Gtk-4.0.Gtk.Entry

    /**
     * Class handler for the `GtkEntry::activate` signal. The default
     *   implementation activates the gtk.activate-default action.
     * @virtual
     */
    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean

    // Own signals of Gtk-4.0.Gtk.Entry

    connect(sigName: "activate", callback: Entry.ActivateSignalCallback): number
    on(
      sigName: "activate",
      callback: Entry.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: Entry.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: Entry.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "icon-press",
      callback: Entry.IconPressSignalCallback
    ): number
    on(
      sigName: "icon-press",
      callback: Entry.IconPressSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "icon-press",
      callback: Entry.IconPressSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "icon-press",
      callback: Entry.IconPressSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "icon-press", ...args: any[]): void
    connect(
      sigName: "icon-release",
      callback: Entry.IconReleaseSignalCallback
    ): number
    on(
      sigName: "icon-release",
      callback: Entry.IconReleaseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "icon-release",
      callback: Entry.IconReleaseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "icon-release",
      callback: Entry.IconReleaseSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "icon-release", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Entry

    connect(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activates-default", ...args: any[]): void
    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::buffer", ...args: any[]): void
    connect(
      sigName: "notify::completion",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::completion",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::completion", ...args: any[]): void
    connect(
      sigName: "notify::enable-emoji-completion",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-emoji-completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-emoji-completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-emoji-completion",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-emoji-completion", ...args: any[]): void
    connect(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::extra-menu", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::im-module", ...args: any[]): void
    connect(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-hints", ...args: any[]): void
    connect(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-purpose", ...args: any[]): void
    connect(
      sigName: "notify::invisible-char",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::invisible-char",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::invisible-char",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::invisible-char",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::invisible-char", ...args: any[]): void
    connect(
      sigName: "notify::invisible-char-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::invisible-char-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::invisible-char-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::invisible-char-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::invisible-char-set", ...args: any[]): void
    connect(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-length", ...args: any[]): void
    connect(
      sigName: "notify::overwrite-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overwrite-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overwrite-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overwrite-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overwrite-mode", ...args: any[]): void
    connect(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::placeholder-text", ...args: any[]): void
    connect(
      sigName: "notify::primary-icon-activatable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-icon-activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-icon-activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-icon-activatable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-icon-activatable", ...args: any[]): void
    connect(
      sigName: "notify::primary-icon-gicon",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-icon-gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-icon-gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-icon-gicon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-icon-gicon", ...args: any[]): void
    connect(
      sigName: "notify::primary-icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-icon-name", ...args: any[]): void
    connect(
      sigName: "notify::primary-icon-paintable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-icon-paintable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-icon-paintable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-icon-paintable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-icon-paintable", ...args: any[]): void
    connect(
      sigName: "notify::primary-icon-sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-icon-sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-icon-sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-icon-sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-icon-sensitive", ...args: any[]): void
    connect(
      sigName: "notify::primary-icon-storage-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-icon-storage-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-icon-storage-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-icon-storage-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-icon-storage-type", ...args: any[]): void
    connect(
      sigName: "notify::primary-icon-tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-icon-tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-icon-tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-icon-tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-icon-tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::primary-icon-tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary-icon-tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary-icon-tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary-icon-tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary-icon-tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::progress-fraction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::progress-fraction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::progress-fraction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::progress-fraction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::progress-fraction", ...args: any[]): void
    connect(
      sigName: "notify::progress-pulse-step",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::progress-pulse-step",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::progress-pulse-step",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::progress-pulse-step",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::progress-pulse-step", ...args: any[]): void
    connect(
      sigName: "notify::scroll-offset",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scroll-offset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scroll-offset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scroll-offset",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scroll-offset", ...args: any[]): void
    connect(
      sigName: "notify::secondary-icon-activatable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-icon-activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-icon-activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-icon-activatable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-icon-activatable", ...args: any[]): void
    connect(
      sigName: "notify::secondary-icon-gicon",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-icon-gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-icon-gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-icon-gicon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-icon-gicon", ...args: any[]): void
    connect(
      sigName: "notify::secondary-icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-icon-name", ...args: any[]): void
    connect(
      sigName: "notify::secondary-icon-paintable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-icon-paintable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-icon-paintable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-icon-paintable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-icon-paintable", ...args: any[]): void
    connect(
      sigName: "notify::secondary-icon-sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-icon-sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-icon-sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-icon-sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-icon-sensitive", ...args: any[]): void
    connect(
      sigName: "notify::secondary-icon-storage-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-icon-storage-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-icon-storage-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-icon-storage-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-icon-storage-type", ...args: any[]): void
    connect(
      sigName: "notify::secondary-icon-tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-icon-tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-icon-tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-icon-tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-icon-tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::secondary-icon-tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-icon-tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-icon-tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-icon-tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-icon-tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::show-emoji-icon",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-emoji-icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-emoji-icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-emoji-icon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-emoji-icon", ...args: any[]): void
    connect(sigName: "notify::tabs", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tabs", ...args: any[]): void
    connect(
      sigName: "notify::text-length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-length", ...args: any[]): void
    connect(
      sigName: "notify::truncate-multiline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::truncate-multiline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::truncate-multiline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::truncate-multiline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::truncate-multiline", ...args: any[]): void
    connect(
      sigName: "notify::visibility",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visibility",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visibility",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visibility",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visibility", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing-canceled", ...args: any[]): void
    connect(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-position", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-undo", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-bound", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEntry` is a single line text entry widget.
   *
   * ![An example GtkEntry](entry.png)
   *
   * A fairly large set of key bindings are supported by default. If the
   * entered text is longer than the allocation of the widget, the widget
   * will scroll so that the cursor position is visible.
   *
   * When using an entry for passwords and other sensitive information, it
   * can be put into “password mode” using [method`Gtk`.Entry.set_visibility].
   * In this mode, entered text is displayed using a “invisible” character.
   * By default, GTK picks the best invisible character that is available
   * in the current font, but it can be changed with
   * [method`Gtk`.Entry.set_invisible_char].
   *
   * `GtkEntry` has the ability to display progress or activity
   * information behind the text. To make an entry display such information,
   * use [method`Gtk`.Entry.set_progress_fraction] or
   * [method`Gtk`.Entry.set_progress_pulse_step].
   *
   * Additionally, `GtkEntry` can show icons at either side of the entry.
   * These icons can be activatable by clicking, can be set up as drag source
   * and can have tooltips. To add an icon, use
   * [method`Gtk`.Entry.set_icon_from_gicon] or one of the various other functions
   * that set an icon from an icon name or a paintable. To trigger an action when
   * the user clicks an icon, connect to the [signal`Gtk`.Entry::icon-press] signal.
   * To allow DND operations from an icon, use
   * [method`Gtk`.Entry.set_icon_drag_source]. To set a tooltip on an icon, use
   * [method`Gtk`.Entry.set_icon_tooltip_text] or the corresponding function
   * for markup.
   *
   * Note that functionality or information that is only available by clicking
   * on an icon in an entry may not be accessible at all to users which are not
   * able to use a mouse or other pointing device. It is therefore recommended
   * that any such functionality should also be available by other means, e.g.
   * via the context menu of the entry.
   *
   * # CSS nodes
   *
   * ```
   * entry[.flat][.warning][.error]
   * ├── text[.readonly]
   * ├── image.left
   * ├── image.right
   * ╰── [progress[.pulse]]
   * ```
   *
   * `GtkEntry` has a main node with the name entry. Depending on the properties
   * of the entry, the style classes .read-only and .flat may appear. The style
   * classes .warning and .error may also be used with entries.
   *
   * When the entry shows icons, it adds subnodes with the name image and the
   * style class .left or .right, depending on where the icon appears.
   *
   * When the entry shows progress, it adds a subnode with the name progress.
   * The node has the style class .pulse when the shown progress is pulsing.
   *
   * For all the subnodes added to the text node in various situations,
   * see [class`Gtk`.Text].
   *
   * # GtkEntry as GtkBuildable
   *
   * The `GtkEntry` implementation of the `GtkBuildable` interface supports a
   * custom `<attributes>` element, which supports any number of `<attribute>`
   * elements. The `<attribute>` element has attributes named “name“, “value“,
   * “start“ and “end“ and allows you to specify `PangoAttribute` values for
   * this label.
   *
   * An example of a UI definition fragment specifying Pango attributes:
   * ```xml
   * <object class="GtkEntry">
   *   <attributes>
   *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
   *     <attribute name="background" value="red" start="5" end="10"/>
   *   </attributes>
   * </object>
   * ```
   *
   * The start and end attributes specify the range of characters to which the
   * Pango attribute applies. If start and end are not specified, the attribute
   * is applied to the whole text. Note that specifying ranges does not make much
   * sense with translatable attributes. Use markup embedded in the translatable
   * content instead.
   *
   * # Accessibility
   *
   * `GtkEntry` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
   * @class
   */
  class Entry extends Widget {
    // Own properties of Gtk-4.0.Gtk.Entry

    static name: string

    // Constructors of Gtk-4.0.Gtk.Entry

    constructor(config?: Entry.ConstructorProperties)
    /**
     * Creates a new entry.
     * @constructor
     * @returns a new `GtkEntry`.
     */
    constructor()
    /**
     * Creates a new entry.
     * @constructor
     * @returns a new `GtkEntry`.
     */
    static new(): Entry
    /**
     * Creates a new entry with the specified text buffer.
     * @constructor
     * @param buffer The buffer to use for the new `GtkEntry`.
     * @returns a new `GtkEntry`
     */
    static newWithBuffer(buffer: EntryBuffer): Entry
    _init(config?: Entry.ConstructorProperties): void
  }

  module EntryBuffer {
    // Signal callback interfaces

    /**
     * Signal callback interface for `deleted-text`
     */
    interface DeletedTextSignalCallback {
      (position: number, nChars: number): void
    }

    /**
     * Signal callback interface for `inserted-text`
     */
    interface InsertedTextSignalCallback {
      (position: number, chars: string | null, nChars: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.EntryBuffer

      /**
       * The maximum length (in characters) of the text in the buffer.
       */
      max_length?: number | null
      /**
       * The contents of the buffer.
       */
      text?: string | null
    }
  }

  interface EntryBuffer {
    // Own properties of Gtk-4.0.Gtk.EntryBuffer

    /**
     * The length (in characters) of the text in buffer.
     */
    readonly length: number
    /**
     * The maximum length (in characters) of the text in the buffer.
     */
    maxLength: number
    /**
     * The contents of the buffer.
     */
    text: string | null
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.EntryBuffer

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.EntryBuffer

    // Has conflict: deleteText(position: number, nChars: number): number
    /**
     * Used when subclassing `GtkEntryBuffer`.
     * @param position position at which text was deleted
     * @param nChars number of characters deleted
     */
    emitDeletedText(position: number, nChars: number): void
    /**
     * Used when subclassing `GtkEntryBuffer`.
     * @param position position at which text was inserted
     * @param chars text that was inserted
     * @param nChars number of characters inserted
     */
    emitInsertedText(position: number, chars: string, nChars: number): void
    /**
     * Retrieves the length in bytes of the buffer.
     *
     * See [method`Gtk`.EntryBuffer.get_length].
     * @returns The byte length of the buffer.
     */
    getBytes(): number
    // Has conflict: getLength(): number
    /**
     * Retrieves the maximum allowed length of the text in `buffer`.
     * @returns the maximum allowed number of characters   in `GtkEntryBuffer`, or 0 if there is no maximum.
     */
    getMaxLength(): number
    // Has conflict: getText(): string
    // Has conflict: insertText(position: number, chars: string, nChars: number): number
    /**
     * Sets the maximum allowed length of the contents of the buffer.
     *
     * If the current contents are longer than the given length, then
     * they will be truncated to fit.
     * @param maxLength the maximum length of the entry buffer, or 0 for no maximum.   (other than the maximum length of entries.) The value passed in will   be clamped to the range 0-65536.
     */
    setMaxLength(maxLength: number): void
    /**
     * Sets the text in the buffer.
     *
     * This is roughly equivalent to calling
     * [method`Gtk`.EntryBuffer.delete_text] and
     * [method`Gtk`.EntryBuffer.insert_text].
     *
     * Note that `n_chars` is in characters, not in bytes.
     * @param chars the new text
     * @param nChars the number of characters in `text,` or -1
     */
    setText(chars: string, nChars: number): void

    // Own virtual methods of Gtk-4.0.Gtk.EntryBuffer

    /**
     * Deletes a sequence of characters from the buffer.
     *
     * `n_chars` characters are deleted starting at `position`.
     * If `n_chars` is negative, then all characters until the
     * end of the text are deleted.
     *
     * If `position` or `n_chars` are out of bounds, then they
     * are coerced to sane values.
     *
     * Note that the positions are specified in characters,
     * not bytes.
     * @virtual
     * @param position position at which to delete text
     * @param nChars number of characters to delete
     * @returns The number of characters deleted.
     */
    deleteText(position: number, nChars: number): number
    deletedText(position: number, nChars: number): void
    /**
     * Retrieves the length in characters of the buffer.
     * @virtual
     * @returns The number of characters in the buffer.
     */
    getLength(): number
    getText(nBytes: number): string
    /**
     * Inserts `n_chars` characters of `chars` into the contents of the
     * buffer, at position `position`.
     *
     * If `n_chars` is negative, then characters from chars will be inserted
     * until a null-terminator is found. If `position` or `n_chars` are out of
     * bounds, or the maximum buffer text length is exceeded, then they are
     * coerced to sane values.
     *
     * Note that the position and length are in characters, not in bytes.
     * @virtual
     * @param position the position at which to insert text.
     * @param chars the text to insert into the buffer.
     * @param nChars the length of the text in characters, or -1
     * @returns The number of characters actually inserted.
     */
    insertText(position: number, chars: string, nChars: number): number
    insertedText(position: number, chars: string, nChars: number): void

    // Own signals of Gtk-4.0.Gtk.EntryBuffer

    connect(
      sigName: "deleted-text",
      callback: EntryBuffer.DeletedTextSignalCallback
    ): number
    on(
      sigName: "deleted-text",
      callback: EntryBuffer.DeletedTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "deleted-text",
      callback: EntryBuffer.DeletedTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "deleted-text",
      callback: EntryBuffer.DeletedTextSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "deleted-text", nChars: number, ...args: any[]): void
    connect(
      sigName: "inserted-text",
      callback: EntryBuffer.InsertedTextSignalCallback
    ): number
    on(
      sigName: "inserted-text",
      callback: EntryBuffer.InsertedTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "inserted-text",
      callback: EntryBuffer.InsertedTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "inserted-text",
      callback: EntryBuffer.InsertedTextSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "inserted-text",
      chars: string | null,
      nChars: number,
      ...args: any[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.EntryBuffer

    connect(
      sigName: "notify::length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::length", ...args: any[]): void
    connect(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-length", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkEntryBuffer` hold the text displayed in a `GtkText` widget.
   *
   * A single `GtkEntryBuffer` object can be shared by multiple widgets
   * which will then share the same text content, but not the cursor
   * position, visibility attributes, icon etc.
   *
   * `GtkEntryBuffer` may be derived from. Such a derived class might allow
   * text to be stored in an alternate location, such as non-pageable memory,
   * useful in the case of important passwords. Or a derived class could
   * integrate with an application’s concept of undo/redo.
   * @class
   */
  class EntryBuffer extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.EntryBuffer

    static name: string

    // Constructors of Gtk-4.0.Gtk.EntryBuffer

    constructor(config?: EntryBuffer.ConstructorProperties)
    /**
     * Create a new `GtkEntryBuffer` object.
     *
     * Optionally, specify initial text to set in the buffer.
     * @constructor
     * @param initialChars initial buffer text
     * @param nInitialChars number of characters in `initial_chars,` or -1
     * @returns A new `GtkEntryBuffer` object.
     */
    constructor(initialChars: string | null, nInitialChars: number)
    /**
     * Create a new `GtkEntryBuffer` object.
     *
     * Optionally, specify initial text to set in the buffer.
     * @constructor
     * @param initialChars initial buffer text
     * @param nInitialChars number of characters in `initial_chars,` or -1
     * @returns A new `GtkEntryBuffer` object.
     */
    static new(initialChars: string | null, nInitialChars: number): EntryBuffer
    _init(config?: EntryBuffer.ConstructorProperties): void
  }

  module EntryCompletion {
    // Signal callback interfaces

    /**
     * Signal callback interface for `cursor-on-match`
     */
    interface CursorOnMatchSignalCallback {
      (model: TreeModel, iter: TreeIter): boolean
    }

    /**
     * Signal callback interface for `insert-prefix`
     */
    interface InsertPrefixSignalCallback {
      (prefix: string | null): boolean
    }

    /**
     * Signal callback interface for `match-selected`
     */
    interface MatchSelectedSignalCallback {
      (model: TreeModel, iter: TreeIter): boolean
    }

    /**
     * Signal callback interface for `no-matches`
     */
    interface NoMatchesSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        CellLayout.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.EntryCompletion

      /**
       * The `GtkCellArea` used to layout cell renderers in the treeview column.
       *
       * If no area is specified when creating the entry completion with
       * [ctor`Gtk`.EntryCompletion.new_with_area], a horizontally oriented
       * [class`Gtk`.CellAreaBox] will be used.
       */
      cell_area?: CellArea | null
      /**
       * Determines whether the common prefix of the possible completions
       * should be inserted automatically in the entry.
       *
       * Note that this requires text-column to be set, even if you are
       * using a custom match function.
       */
      inline_completion?: boolean | null
      /**
       * Determines whether the possible completions on the popup
       * will appear in the entry as you navigate through them.
       */
      inline_selection?: boolean | null
      minimum_key_length?: number | null
      model?: TreeModel | null
      /**
       * Determines whether the possible completions should be
       * shown in a popup window.
       */
      popup_completion?: boolean | null
      /**
       * Determines whether the completions popup window will be
       * resized to the width of the entry.
       */
      popup_set_width?: boolean | null
      /**
       * Determines whether the completions popup window will shown
       * for a single possible completion.
       *
       * You probably want to set this to %FALSE if you are using
       * [property`Gtk`.EntryCompletion:inline-completion].
       */
      popup_single_match?: boolean | null
      /**
       * The column of the model containing the strings.
       *
       * Note that the strings must be UTF-8.
       */
      text_column?: number | null
    }
  }

  interface EntryCompletion extends Buildable, CellLayout {
    // Own properties of Gtk-4.0.Gtk.EntryCompletion

    /**
     * The `GtkCellArea` used to layout cell renderers in the treeview column.
     *
     * If no area is specified when creating the entry completion with
     * [ctor`Gtk`.EntryCompletion.new_with_area], a horizontally oriented
     * [class`Gtk`.CellAreaBox] will be used.
     */
    readonly cellArea: CellArea
    /**
     * Determines whether the common prefix of the possible completions
     * should be inserted automatically in the entry.
     *
     * Note that this requires text-column to be set, even if you are
     * using a custom match function.
     */
    inlineCompletion: boolean
    /**
     * Determines whether the possible completions on the popup
     * will appear in the entry as you navigate through them.
     */
    inlineSelection: boolean
    minimumKeyLength: number
    model: TreeModel
    /**
     * Determines whether the possible completions should be
     * shown in a popup window.
     */
    popupCompletion: boolean
    /**
     * Determines whether the completions popup window will be
     * resized to the width of the entry.
     */
    popupSetWidth: boolean
    /**
     * Determines whether the completions popup window will shown
     * for a single possible completion.
     *
     * You probably want to set this to %FALSE if you are using
     * [property`Gtk`.EntryCompletion:inline-completion].
     */
    popupSingleMatch: boolean
    /**
     * The column of the model containing the strings.
     *
     * Note that the strings must be UTF-8.
     */
    textColumn: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.EntryCompletion

    /**
     * Requests a completion operation, or in other words a refiltering of the
     * current list with completions, using the current key.
     *
     * The completion list view will be updated accordingly.
     */
    complete(): void
    /**
     * Computes the common prefix that is shared by all rows in `completion`
     * that start with `key`.
     *
     * If no row matches `key,` %NULL will be returned.
     * Note that a text column must have been set for this function to work,
     * see [method`Gtk`.EntryCompletion.set_text_column] for details.
     * @param key The text to complete for
     * @returns The common prefix all rows   starting with @key
     */
    computePrefix(key: string): string | null
    /**
     * Get the original text entered by the user that triggered
     * the completion or %NULL if there’s no completion ongoing.
     * @returns the prefix for the current completion
     */
    getCompletionPrefix(): string | null
    /**
     * Gets the entry `completion` has been attached to.
     * @returns The entry @completion has been attached to
     */
    getEntry(): Widget
    /**
     * Returns whether the common prefix of the possible completions should
     * be automatically inserted in the entry.
     * @returns %TRUE if inline completion is turned on
     */
    getInlineCompletion(): boolean
    /**
     * Returns %TRUE if inline-selection mode is turned on.
     * @returns %TRUE if inline-selection mode is on
     */
    getInlineSelection(): boolean
    /**
     * Returns the minimum key length as set for `completion`.
     * @returns The currently used minimum key length
     */
    getMinimumKeyLength(): number
    /**
     * Returns the model the `GtkEntryCompletion` is using as data source.
     *
     * Returns %NULL if the model is unset.
     * @returns A `GtkTreeModel`
     */
    getModel(): TreeModel | null
    /**
     * Returns whether the completions should be presented in a popup window.
     * @returns %TRUE if popup completion is turned on
     */
    getPopupCompletion(): boolean
    /**
     * Returns whether the completion popup window will be resized to the
     * width of the entry.
     * @returns %TRUE if the popup window will be resized to the width of   the entry
     */
    getPopupSetWidth(): boolean
    /**
     * Returns whether the completion popup window will appear even if there is
     * only a single match.
     * @returns %TRUE if the popup window will appear regardless of the    number of matches
     */
    getPopupSingleMatch(): boolean
    /**
     * Returns the column in the model of `completion` to get strings from.
     * @returns the column containing the strings
     */
    getTextColumn(): number
    /**
     * Requests a prefix insertion.
     */
    insertPrefix(): void
    /**
     * Sets whether the common prefix of the possible completions should
     * be automatically inserted in the entry.
     * @param inlineCompletion %TRUE to do inline completion
     */
    setInlineCompletion(inlineCompletion: boolean): void
    /**
     * Sets whether it is possible to cycle through the possible completions
     * inside the entry.
     * @param inlineSelection %TRUE to do inline selection
     */
    setInlineSelection(inlineSelection: boolean): void
    /**
     * Sets the match function for `completion` to be `func`.
     *
     * The match function is used to determine if a row should or
     * should not be in the completion list.
     * @param func the `GtkEntryCompletion`MatchFunc to use
     */
    setMatchFunc(func: EntryCompletionMatchFunc): void
    /**
     * Requires the length of the search key for `completion` to be at least
     * `length`.
     *
     * This is useful for long lists, where completing using a small
     * key takes a lot of time and will come up with meaningless results anyway
     * (ie, a too large dataset).
     * @param length the minimum length of the key in order to start completing
     */
    setMinimumKeyLength(length: number): void
    /**
     * Sets the model for a `GtkEntryCompletion`.
     *
     * If `completion` already has a model set, it will remove it
     * before setting the new model. If model is %NULL, then it
     * will unset the model.
     * @param model the `GtkTreeModel`
     */
    setModel(model: TreeModel | null): void
    /**
     * Sets whether the completions should be presented in a popup window.
     * @param popupCompletion %TRUE to do popup completion
     */
    setPopupCompletion(popupCompletion: boolean): void
    /**
     * Sets whether the completion popup window will be resized to be the same
     * width as the entry.
     * @param popupSetWidth %TRUE to make the width of the popup the same as the entry
     */
    setPopupSetWidth(popupSetWidth: boolean): void
    /**
     * Sets whether the completion popup window will appear even if there is
     * only a single match.
     *
     * You may want to set this to %FALSE if you
     * are using [property`Gtk`.EntryCompletion:inline-completion].
     * @param popupSingleMatch %TRUE if the popup should appear even for a single match
     */
    setPopupSingleMatch(popupSingleMatch: boolean): void
    /**
     * Convenience function for setting up the most used case of this code: a
     * completion list with just strings.
     *
     * This function will set up `completion`
     * to have a list displaying all (and just) strings in the completion list,
     * and to get those strings from `column` in the model of `completion`.
     *
     * This functions creates and adds a `GtkCellRendererText` for the selected
     * column. If you need to set the text column, but don't want the cell
     * renderer, use g_object_set() to set the
     * [property`Gtk`.EntryCompletion:text-column] property directly.
     * @param column the column in the model of `completion` to get strings from
     */
    setTextColumn(column: number): void

    // Own signals of Gtk-4.0.Gtk.EntryCompletion

    connect(
      sigName: "cursor-on-match",
      callback: EntryCompletion.CursorOnMatchSignalCallback
    ): number
    on(
      sigName: "cursor-on-match",
      callback: EntryCompletion.CursorOnMatchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cursor-on-match",
      callback: EntryCompletion.CursorOnMatchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cursor-on-match",
      callback: EntryCompletion.CursorOnMatchSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cursor-on-match", iter: TreeIter, ...args: any[]): void
    connect(
      sigName: "insert-prefix",
      callback: EntryCompletion.InsertPrefixSignalCallback
    ): number
    on(
      sigName: "insert-prefix",
      callback: EntryCompletion.InsertPrefixSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-prefix",
      callback: EntryCompletion.InsertPrefixSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-prefix",
      callback: EntryCompletion.InsertPrefixSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "insert-prefix", ...args: any[]): void
    connect(
      sigName: "match-selected",
      callback: EntryCompletion.MatchSelectedSignalCallback
    ): number
    on(
      sigName: "match-selected",
      callback: EntryCompletion.MatchSelectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "match-selected",
      callback: EntryCompletion.MatchSelectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "match-selected",
      callback: EntryCompletion.MatchSelectedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "match-selected", iter: TreeIter, ...args: any[]): void
    connect(
      sigName: "no-matches",
      callback: EntryCompletion.NoMatchesSignalCallback
    ): number
    on(
      sigName: "no-matches",
      callback: EntryCompletion.NoMatchesSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "no-matches",
      callback: EntryCompletion.NoMatchesSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "no-matches",
      callback: EntryCompletion.NoMatchesSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "no-matches", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.EntryCompletion

    connect(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-area", ...args: any[]): void
    connect(
      sigName: "notify::inline-completion",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inline-completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inline-completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inline-completion",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inline-completion", ...args: any[]): void
    connect(
      sigName: "notify::inline-selection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inline-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inline-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inline-selection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inline-selection", ...args: any[]): void
    connect(
      sigName: "notify::minimum-key-length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::minimum-key-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::minimum-key-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::minimum-key-length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::minimum-key-length", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::popup-completion",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::popup-completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::popup-completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::popup-completion",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::popup-completion", ...args: any[]): void
    connect(
      sigName: "notify::popup-set-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::popup-set-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::popup-set-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::popup-set-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::popup-set-width", ...args: any[]): void
    connect(
      sigName: "notify::popup-single-match",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::popup-single-match",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::popup-single-match",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::popup-single-match",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::popup-single-match", ...args: any[]): void
    connect(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-column", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEntryCompletion` is an auxiliary object to provide completion functionality
   * for `GtkEntry`.
   *
   * It implements the [iface`Gtk`.CellLayout] interface, to allow the user
   * to add extra cells to the `GtkTreeView` with completion matches.
   *
   * “Completion functionality” means that when the user modifies the text
   * in the entry, `GtkEntryCompletion` checks which rows in the model match
   * the current content of the entry, and displays a list of matches.
   * By default, the matching is done by comparing the entry text
   * case-insensitively against the text column of the model (see
   * [method`Gtk`.EntryCompletion.set_text_column]), but this can be overridden
   * with a custom match function (see [method`Gtk`.EntryCompletion.set_match_func]).
   *
   * When the user selects a completion, the content of the entry is
   * updated. By default, the content of the entry is replaced by the
   * text column of the model, but this can be overridden by connecting
   * to the [signal`Gtk`.EntryCompletion::match-selected] signal and updating the
   * entry in the signal handler. Note that you should return %TRUE from
   * the signal handler to suppress the default behaviour.
   *
   * To add completion functionality to an entry, use
   * [method`Gtk`.Entry.set_completion].
   *
   * `GtkEntryCompletion` uses a [class`Gtk`.TreeModelFilter] model to
   * represent the subset of the entire model that is currently matching.
   * While the `GtkEntryCompletion` signals
   * [signal`Gtk`.EntryCompletion::match-selected] and
   * [signal`Gtk`.EntryCompletion::cursor-on-match] take the original model
   * and an iter pointing to that model as arguments, other callbacks and
   * signals (such as `GtkCellLayoutDataFunc` or
   * [signal`Gtk`.CellArea::apply-attributes)]
   * will generally take the filter model as argument. As long as you are
   * only calling [method`Gtk`.TreeModel.get], this will make no difference to
   * you. If for some reason, you need the original model, use
   * [method`Gtk`.TreeModelFilter.get_model]. Don’t forget to use
   * [method`Gtk`.TreeModelFilter.convert_iter_to_child_iter] to obtain a
   * matching iter.
   * @class
   */
  class EntryCompletion extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.EntryCompletion

    static name: string

    // Constructors of Gtk-4.0.Gtk.EntryCompletion

    constructor(config?: EntryCompletion.ConstructorProperties)
    /**
     * Creates a new `GtkEntryCompletion` object.
     * @constructor
     * @returns A newly created `GtkEntryCompletion` object
     */
    constructor()
    /**
     * Creates a new `GtkEntryCompletion` object.
     * @constructor
     * @returns A newly created `GtkEntryCompletion` object
     */
    static new(): EntryCompletion
    /**
     * Creates a new `GtkEntryCompletion` object using the
     * specified `area`.
     *
     * The `GtkCellArea` is used to layout cells in the underlying
     * `GtkTreeViewColumn` for the drop-down menu.
     * @constructor
     * @param area the `GtkCellArea` used to layout cells
     * @returns A newly created `GtkEntryCompletion` object
     */
    static newWithArea(area: CellArea): EntryCompletion
    _init(config?: EntryCompletion.ConstructorProperties): void
  }

  module EventController {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.EventController

      /**
       * The name for this controller, typically used for debugging purposes.
       */
      name?: string | null
      /**
       * The limit for which events this controller will handle.
       */
      propagation_limit?: PropagationLimit | null
      /**
       * The propagation phase at which this controller will handle events.
       */
      propagation_phase?: PropagationPhase | null
    }
  }

  interface EventController {
    // Own properties of Gtk-4.0.Gtk.EventController

    /**
     * The name for this controller, typically used for debugging purposes.
     */
    name: string | null
    /**
     * The limit for which events this controller will handle.
     */
    propagationLimit: PropagationLimit
    /**
     * The propagation phase at which this controller will handle events.
     */
    propagationPhase: PropagationPhase
    /**
     * The widget receiving the `GdkEvents` that the controller will handle.
     */
    readonly widget: Widget
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.EventController

    /**
     * Returns the event that is currently being handled by the controller.
     *
     * At other times, %NULL is returned.
     * @returns the event that is currently   handled by @controller
     */
    getCurrentEvent(): Gdk.Event | null
    /**
     * Returns the device of the event that is currently being
     * handled by the controller.
     *
     * At other times, %NULL is returned.
     * @returns device of the event is   currently handled by @controller
     */
    getCurrentEventDevice(): Gdk.Device | null
    /**
     * Returns the modifier state of the event that is currently being
     * handled by the controller.
     *
     * At other times, 0 is returned.
     * @returns modifier state of the event is currently handled by @controller
     */
    getCurrentEventState(): Gdk.ModifierType
    /**
     * Returns the timestamp of the event that is currently being
     * handled by the controller.
     *
     * At other times, 0 is returned.
     * @returns timestamp of the event is currently handled by @controller
     */
    getCurrentEventTime(): number
    /**
     * Gets the name of `controller`.
     * @returns The controller name
     */
    getName(): string | null
    /**
     * Gets the propagation limit of the event controller.
     * @returns the propagation limit
     */
    getPropagationLimit(): PropagationLimit
    /**
     * Gets the propagation phase at which `controller` handles events.
     * @returns the propagation phase
     */
    getPropagationPhase(): PropagationPhase
    /**
     * Returns the `GtkWidget` this controller relates to.
     * @returns a `GtkWidget`
     */
    getWidget(): Widget
    /**
     * Resets the `controller` to a clean state.
     */
    reset(): void
    /**
     * Sets a name on the controller that can be used for debugging.
     * @param name a name for `controller`
     */
    setName(name: string | null): void
    /**
     * Sets the event propagation limit on the event controller.
     *
     * If the limit is set to %GTK_LIMIT_SAME_NATIVE, the controller
     * won't handle events that are targeted at widgets on a different
     * surface, such as popovers.
     * @param limit the propagation limit
     */
    setPropagationLimit(limit: PropagationLimit): void
    /**
     * Sets the propagation phase at which a controller handles events.
     *
     * If `phase` is %GTK_PHASE_NONE, no automatic event handling will be
     * performed, but other additional gesture maintenance will.
     * @param phase a propagation phase
     */
    setPropagationPhase(phase: PropagationPhase): void
    /**
     * Sets a name on the controller that can be used for debugging.
     * @param name a name for `controller,` must be a static string
     */
    setStaticName(name: string | null): void

    // Class property signals of Gtk-4.0.Gtk.EventController

    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEventController` is the base class for event controllers.
   *
   * These are ancillary objects associated to widgets, which react
   * to `GdkEvents`, and possibly trigger actions as a consequence.
   *
   * Event controllers are added to a widget with
   * [method`Gtk`.Widget.add_controller]. It is rarely necessary to
   * explicitly remove a controller with [method`Gtk`.Widget.remove_controller].
   *
   * See the chapter on [input handling](input-handling.html) for
   * an overview of the basic concepts, such as the capture and bubble
   * phases of event propagation.
   * @class
   */
  class EventController extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.EventController

    static name: string

    // Constructors of Gtk-4.0.Gtk.EventController

    constructor(config?: EventController.ConstructorProperties)
    _init(config?: EventController.ConstructorProperties): void
  }

  module EventControllerFocus {
    // Signal callback interfaces

    /**
     * Signal callback interface for `enter`
     */
    interface EnterSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `leave`
     */
    interface LeaveSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {}
  }

  interface EventControllerFocus {
    // Own properties of Gtk-4.0.Gtk.EventControllerFocus

    /**
     * %TRUE if focus is contained in the controllers widget.
     *
     * See [property`Gtk`.EventControllerFocus:is-focus] for whether
     * the focus is in the widget itself or inside a descendent.
     *
     * When handling focus events, this property is updated
     * before [signal`Gtk`.EventControllerFocus::enter] or
     * [signal`Gtk`.EventControllerFocus::leave] are emitted.
     */
    readonly containsFocus: boolean
    /**
     * %TRUE if focus is in the controllers widget itself,
     * as opposed to in a descendent widget.
     *
     * See also [property`Gtk`.EventControllerFocus:contains-focus].
     *
     * When handling focus events, this property is updated
     * before [signal`Gtk`.EventControllerFocus::enter] or
     * [signal`Gtk`.EventControllerFocus::leave] are emitted.
     */
    readonly isFocus: boolean
    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.EventControllerFocus

    connect(
      sigName: "enter",
      callback: EventControllerFocus.EnterSignalCallback
    ): number
    on(
      sigName: "enter",
      callback: EventControllerFocus.EnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "enter",
      callback: EventControllerFocus.EnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "enter",
      callback: EventControllerFocus.EnterSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "enter", ...args: any[]): void
    connect(
      sigName: "leave",
      callback: EventControllerFocus.LeaveSignalCallback
    ): number
    on(
      sigName: "leave",
      callback: EventControllerFocus.LeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "leave",
      callback: EventControllerFocus.LeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "leave",
      callback: EventControllerFocus.LeaveSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "leave", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.EventControllerFocus

    connect(
      sigName: "notify::contains-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::contains-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::contains-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::contains-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::contains-focus", ...args: any[]): void
    connect(
      sigName: "notify::is-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-focus", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEventControllerFocus` is an event controller to keep track of
   * keyboard focus.
   *
   * The event controller offers [signal`Gtk`.EventControllerFocus::enter]
   * and [signal`Gtk`.EventControllerFocus::leave] signals, as well as
   * [property`Gtk`.EventControllerFocus:is-focus] and
   * [property`Gtk`.EventControllerFocus:contains-focus] properties
   * which are updated to reflect focus changes inside the widget hierarchy
   * that is rooted at the controllers widget.
   * @class
   */
  class EventControllerFocus extends EventController {
    // Own properties of Gtk-4.0.Gtk.EventControllerFocus

    static name: string

    // Constructors of Gtk-4.0.Gtk.EventControllerFocus

    constructor(config?: EventControllerFocus.ConstructorProperties)
    /**
     * Creates a new event controller that will handle focus events.
     * @constructor
     * @returns a new `GtkEventControllerFocus`
     */
    constructor()
    /**
     * Creates a new event controller that will handle focus events.
     * @constructor
     * @returns a new `GtkEventControllerFocus`
     */
    static new(): EventControllerFocus
    _init(config?: EventControllerFocus.ConstructorProperties): void
  }

  module EventControllerKey {
    // Signal callback interfaces

    /**
     * Signal callback interface for `im-update`
     */
    interface ImUpdateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `key-pressed`
     */
    interface KeyPressedSignalCallback {
      (keyval: number, keycode: number, state: Gdk.ModifierType): boolean
    }

    /**
     * Signal callback interface for `key-released`
     */
    interface KeyReleasedSignalCallback {
      (keyval: number, keycode: number, state: Gdk.ModifierType): void
    }

    /**
     * Signal callback interface for `modifiers`
     */
    interface ModifiersSignalCallback {
      (state: Gdk.ModifierType): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {}
  }

  interface EventControllerKey {
    // Own properties of Gtk-4.0.Gtk.EventControllerKey

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.EventControllerKey

    /**
     * Forwards the current event of this `controller` to a `widget`.
     *
     * This function can only be used in handlers for the
     * [signal`Gtk`.EventControllerKey::key-pressed],
     * [signal`Gtk`.EventControllerKey::key-released]
     * or [signal`Gtk`.EventControllerKey::modifiers] signals.
     * @param widget a `GtkWidget`
     * @returns whether the @widget handled the event
     */
    forward(widget: Widget): boolean
    /**
     * Gets the key group of the current event of this `controller`.
     *
     * See [method`Gdk`.KeyEvent.get_layout].
     * @returns the key group
     */
    getGroup(): number
    /**
     * Gets the input method context of the key `controller`.
     * @returns the `GtkIMContext`
     */
    getImContext(): IMContext | null
    /**
     * Sets the input method context of the key `controller`.
     * @param imContext a `GtkIMContext`
     */
    setImContext(imContext: IMContext | null): void

    // Own signals of Gtk-4.0.Gtk.EventControllerKey

    connect(
      sigName: "im-update",
      callback: EventControllerKey.ImUpdateSignalCallback
    ): number
    on(
      sigName: "im-update",
      callback: EventControllerKey.ImUpdateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "im-update",
      callback: EventControllerKey.ImUpdateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "im-update",
      callback: EventControllerKey.ImUpdateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "im-update", ...args: any[]): void
    connect(
      sigName: "key-pressed",
      callback: EventControllerKey.KeyPressedSignalCallback
    ): number
    on(
      sigName: "key-pressed",
      callback: EventControllerKey.KeyPressedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "key-pressed",
      callback: EventControllerKey.KeyPressedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "key-pressed",
      callback: EventControllerKey.KeyPressedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "key-pressed",
      keycode: number,
      state: Gdk.ModifierType,
      ...args: any[]
    ): void
    connect(
      sigName: "key-released",
      callback: EventControllerKey.KeyReleasedSignalCallback
    ): number
    on(
      sigName: "key-released",
      callback: EventControllerKey.KeyReleasedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "key-released",
      callback: EventControllerKey.KeyReleasedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "key-released",
      callback: EventControllerKey.KeyReleasedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "key-released",
      keycode: number,
      state: Gdk.ModifierType,
      ...args: any[]
    ): void
    connect(
      sigName: "modifiers",
      callback: EventControllerKey.ModifiersSignalCallback
    ): number
    on(
      sigName: "modifiers",
      callback: EventControllerKey.ModifiersSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "modifiers",
      callback: EventControllerKey.ModifiersSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "modifiers",
      callback: EventControllerKey.ModifiersSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "modifiers", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.EventControllerKey

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEventControllerKey` is an event controller that provides access
   * to key events.
   * @class
   */
  class EventControllerKey extends EventController {
    // Own properties of Gtk-4.0.Gtk.EventControllerKey

    static name: string

    // Constructors of Gtk-4.0.Gtk.EventControllerKey

    constructor(config?: EventControllerKey.ConstructorProperties)
    /**
     * Creates a new event controller that will handle key events.
     * @constructor
     * @returns a new `GtkEventControllerKey`
     */
    constructor()
    /**
     * Creates a new event controller that will handle key events.
     * @constructor
     * @returns a new `GtkEventControllerKey`
     */
    static new(): EventControllerKey
    _init(config?: EventControllerKey.ConstructorProperties): void
  }

  module EventControllerLegacy {
    // Signal callback interfaces

    /**
     * Signal callback interface for `event`
     */
    interface EventSignalCallback {
      (event: Gdk.Event): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {}
  }

  interface EventControllerLegacy {
    // Own properties of Gtk-4.0.Gtk.EventControllerLegacy

    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.EventControllerLegacy

    connect(
      sigName: "event",
      callback: EventControllerLegacy.EventSignalCallback
    ): number
    on(
      sigName: "event",
      callback: EventControllerLegacy.EventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "event",
      callback: EventControllerLegacy.EventSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "event",
      callback: EventControllerLegacy.EventSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "event", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.EventControllerLegacy

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEventControllerLegacy` is an event controller that provides raw
   * access to the event stream.
   *
   * It should only be used as a last resort if none of the other event
   * controllers or gestures do the job.
   * @class
   */
  class EventControllerLegacy extends EventController {
    // Own properties of Gtk-4.0.Gtk.EventControllerLegacy

    static name: string

    // Constructors of Gtk-4.0.Gtk.EventControllerLegacy

    constructor(config?: EventControllerLegacy.ConstructorProperties)
    /**
     * Creates a new legacy event controller.
     * @constructor
     * @returns the newly created event controller.
     */
    constructor()
    /**
     * Creates a new legacy event controller.
     * @constructor
     * @returns the newly created event controller.
     */
    static new(): EventControllerLegacy
    _init(config?: EventControllerLegacy.ConstructorProperties): void
  }

  module EventControllerMotion {
    // Signal callback interfaces

    /**
     * Signal callback interface for `enter`
     */
    interface EnterSignalCallback {
      (x: number, y: number): void
    }

    /**
     * Signal callback interface for `leave`
     */
    interface LeaveSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `motion`
     */
    interface MotionSignalCallback {
      (x: number, y: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {}
  }

  interface EventControllerMotion {
    // Own properties of Gtk-4.0.Gtk.EventControllerMotion

    /**
     * Whether the pointer is in the controllers widget or a descendant.
     *
     * See also [property`Gtk`.EventControllerMotion:is-pointer].
     *
     * When handling crossing events, this property is updated
     * before [signal`Gtk`.EventControllerMotion::enter], but after
     * [signal`Gtk`.EventControllerMotion::leave] is emitted.
     */
    readonly containsPointer: boolean
    /**
     * Whether the pointer is in the controllers widget itself,
     * as opposed to in a descendent widget.
     *
     * See also [property`Gtk`.EventControllerMotion:contains-pointer].
     *
     * When handling crossing events, this property is updated
     * before [signal`Gtk`.EventControllerMotion::enter], but after
     * [signal`Gtk`.EventControllerMotion::leave] is emitted.
     */
    readonly isPointer: boolean
    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.EventControllerMotion

    connect(
      sigName: "enter",
      callback: EventControllerMotion.EnterSignalCallback
    ): number
    on(
      sigName: "enter",
      callback: EventControllerMotion.EnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "enter",
      callback: EventControllerMotion.EnterSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "enter",
      callback: EventControllerMotion.EnterSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "enter", y: number, ...args: any[]): void
    connect(
      sigName: "leave",
      callback: EventControllerMotion.LeaveSignalCallback
    ): number
    on(
      sigName: "leave",
      callback: EventControllerMotion.LeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "leave",
      callback: EventControllerMotion.LeaveSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "leave",
      callback: EventControllerMotion.LeaveSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "leave", ...args: any[]): void
    connect(
      sigName: "motion",
      callback: EventControllerMotion.MotionSignalCallback
    ): number
    on(
      sigName: "motion",
      callback: EventControllerMotion.MotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "motion",
      callback: EventControllerMotion.MotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "motion",
      callback: EventControllerMotion.MotionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "motion", y: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.EventControllerMotion

    connect(
      sigName: "notify::contains-pointer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::contains-pointer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::contains-pointer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::contains-pointer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::contains-pointer", ...args: any[]): void
    connect(
      sigName: "notify::is-pointer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-pointer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-pointer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-pointer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-pointer", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEventControllerMotion` is an event controller tracking the pointer
   * position.
   *
   * The event controller offers [signal`Gtk`.EventControllerMotion::enter]
   * and [signal`Gtk`.EventControllerMotion::leave] signals, as well as
   * [property`Gtk`.EventControllerMotion:is-pointer] and
   * [property`Gtk`.EventControllerMotion:contains-pointer] properties
   * which are updated to reflect changes in the pointer position as it
   * moves over the widget.
   * @class
   */
  class EventControllerMotion extends EventController {
    // Own properties of Gtk-4.0.Gtk.EventControllerMotion

    static name: string

    // Constructors of Gtk-4.0.Gtk.EventControllerMotion

    constructor(config?: EventControllerMotion.ConstructorProperties)
    /**
     * Creates a new event controller that will handle motion events.
     * @constructor
     * @returns a new `GtkEventControllerMotion`
     */
    constructor()
    /**
     * Creates a new event controller that will handle motion events.
     * @constructor
     * @returns a new `GtkEventControllerMotion`
     */
    static new(): EventControllerMotion
    _init(config?: EventControllerMotion.ConstructorProperties): void
  }

  module EventControllerScroll {
    // Signal callback interfaces

    /**
     * Signal callback interface for `decelerate`
     */
    interface DecelerateSignalCallback {
      (velX: number, velY: number): void
    }

    /**
     * Signal callback interface for `scroll`
     */
    interface ScrollSignalCallback {
      (dx: number, dy: number): boolean
    }

    /**
     * Signal callback interface for `scroll-begin`
     */
    interface ScrollBeginSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `scroll-end`
     */
    interface ScrollEndSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.EventControllerScroll

      /**
       * The flags affecting event controller behavior.
       */
      flags?: EventControllerScrollFlags | null
    }
  }

  interface EventControllerScroll {
    // Own properties of Gtk-4.0.Gtk.EventControllerScroll

    /**
     * The flags affecting event controller behavior.
     */
    flags: EventControllerScrollFlags
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.EventControllerScroll

    /**
     * Gets the flags conditioning the scroll controller behavior.
     * @returns the controller flags.
     */
    getFlags(): EventControllerScrollFlags
    /**
     * Gets the scroll unit of the last
     * [signal`Gtk`.EventControllerScroll::scroll] signal received.
     *
     * Always returns %GDK_SCROLL_UNIT_WHEEL if the
     * %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag is set.
     * @returns the scroll unit.
     */
    getUnit(): Gdk.ScrollUnit
    /**
     * Sets the flags conditioning scroll controller behavior.
     * @param flags flags affecting the controller behavior
     */
    setFlags(flags: EventControllerScrollFlags): void

    // Own signals of Gtk-4.0.Gtk.EventControllerScroll

    connect(
      sigName: "decelerate",
      callback: EventControllerScroll.DecelerateSignalCallback
    ): number
    on(
      sigName: "decelerate",
      callback: EventControllerScroll.DecelerateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "decelerate",
      callback: EventControllerScroll.DecelerateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "decelerate",
      callback: EventControllerScroll.DecelerateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "decelerate", velY: number, ...args: any[]): void
    connect(
      sigName: "scroll",
      callback: EventControllerScroll.ScrollSignalCallback
    ): number
    on(
      sigName: "scroll",
      callback: EventControllerScroll.ScrollSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "scroll",
      callback: EventControllerScroll.ScrollSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "scroll",
      callback: EventControllerScroll.ScrollSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "scroll", dy: number, ...args: any[]): void
    connect(
      sigName: "scroll-begin",
      callback: EventControllerScroll.ScrollBeginSignalCallback
    ): number
    on(
      sigName: "scroll-begin",
      callback: EventControllerScroll.ScrollBeginSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "scroll-begin",
      callback: EventControllerScroll.ScrollBeginSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "scroll-begin",
      callback: EventControllerScroll.ScrollBeginSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "scroll-begin", ...args: any[]): void
    connect(
      sigName: "scroll-end",
      callback: EventControllerScroll.ScrollEndSignalCallback
    ): number
    on(
      sigName: "scroll-end",
      callback: EventControllerScroll.ScrollEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "scroll-end",
      callback: EventControllerScroll.ScrollEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "scroll-end",
      callback: EventControllerScroll.ScrollEndSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "scroll-end", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.EventControllerScroll

    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEventControllerScroll` is an event controller that handles scroll
   * events.
   *
   * It is capable of handling both discrete and continuous scroll
   * events from mice or touchpads, abstracting them both with the
   * [signal`Gtk`.EventControllerScroll::scroll] signal. Deltas in
   * the discrete case are multiples of 1.
   *
   * In the case of continuous scroll events, `GtkEventControllerScroll`
   * encloses all [signal`Gtk`.EventControllerScroll::scroll] emissions
   * between two [signal`Gtk`.EventControllerScroll::scroll-begin] and
   * [signal`Gtk`.EventControllerScroll::scroll-end] signals.
   *
   * The behavior of the event controller can be modified by the flags
   * given at creation time, or modified at a later point through
   * [method`Gtk`.EventControllerScroll.set_flags] (e.g. because the scrolling
   * conditions of the widget changed).
   *
   * The controller can be set up to emit motion for either/both vertical
   * and horizontal scroll events through %GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
   * %GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and %GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES.
   * If any axis is disabled, the respective [signal`Gtk`.EventControllerScroll::scroll]
   * delta will be 0. Vertical scroll events will be translated to horizontal
   * motion for the devices incapable of horizontal scrolling.
   *
   * The event controller can also be forced to emit discrete events on all
   * devices through %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used
   * to implement discrete actions triggered through scroll events (e.g.
   * switching across combobox options).
   *
   * The %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the
   * [signal`Gtk`.EventControllerScroll::decelerate] signal, emitted at the end
   * of scrolling with two X/Y velocity arguments that are consistent with the
   * motion that was received.
   * @class
   */
  class EventControllerScroll extends EventController {
    // Own properties of Gtk-4.0.Gtk.EventControllerScroll

    static name: string

    // Constructors of Gtk-4.0.Gtk.EventControllerScroll

    constructor(config?: EventControllerScroll.ConstructorProperties)
    /**
     * Creates a new event controller that will handle scroll events.
     * @constructor
     * @param flags flags affecting the controller behavior
     * @returns a new `GtkEventControllerScroll`
     */
    constructor(flags: EventControllerScrollFlags)
    /**
     * Creates a new event controller that will handle scroll events.
     * @constructor
     * @param flags flags affecting the controller behavior
     * @returns a new `GtkEventControllerScroll`
     */
    static new(flags: EventControllerScrollFlags): EventControllerScroll
    _init(config?: EventControllerScroll.ConstructorProperties): void
  }

  module EveryFilter {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        Buildable.ConstructorProperties,
        MultiFilter.ConstructorProperties {}
  }

  interface EveryFilter extends Gio.ListModel, Buildable {
    // Own properties of Gtk-4.0.Gtk.EveryFilter

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.EveryFilter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkEveryFilter` matches an item when each of its filters matches.
   *
   * To add filters to a `GtkEveryFilter`, use [method`Gtk`.MultiFilter.append].
   * @class
   */
  class EveryFilter extends MultiFilter {
    // Own properties of Gtk-4.0.Gtk.EveryFilter

    static name: string

    // Constructors of Gtk-4.0.Gtk.EveryFilter

    constructor(config?: EveryFilter.ConstructorProperties)
    /**
     * Creates a new empty "every" filter.
     *
     * Use [method`Gtk`.MultiFilter.append] to add filters to it.
     *
     * This filter matches an item if each of the filters added to it
     * matches the item. In particular, this means that if no filter
     * has been added to it, the filter matches every item.
     * @constructor
     * @returns a new `GtkEveryFilter`
     */
    constructor()
    /**
     * Creates a new empty "every" filter.
     *
     * Use [method`Gtk`.MultiFilter.append] to add filters to it.
     *
     * This filter matches an item if each of the filters added to it
     * matches the item. In particular, this means that if no filter
     * has been added to it, the filter matches every item.
     * @constructor
     * @returns a new `GtkEveryFilter`
     */
    static new(): EveryFilter
    _init(config?: EveryFilter.ConstructorProperties): void
  }

  module Expander {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Expander

      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Whether the expander has been opened to reveal the child.
       */
      expanded?: boolean | null
      /**
       * The text of the expanders label.
       */
      label?: string | null
      /**
       * A widget to display instead of the usual expander label.
       */
      label_widget?: Widget | null
      /**
       * When this property is %TRUE, the expander will resize the toplevel
       * widget containing the expander upon expanding and collapsing.
       */
      resize_toplevel?: boolean | null
      /**
       * Whether the text in the label is Pango markup.
       */
      use_markup?: boolean | null
      /**
       * Whether an underline in the text indicates a mnemonic.
       */
      use_underline?: boolean | null
    }
  }

  interface Expander extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Expander

    /**
     * The child widget.
     */
    child: Widget
    /**
     * Whether the expander has been opened to reveal the child.
     */
    expanded: boolean
    /**
     * The text of the expanders label.
     */
    label: string | null
    /**
     * A widget to display instead of the usual expander label.
     */
    labelWidget: Widget
    /**
     * When this property is %TRUE, the expander will resize the toplevel
     * widget containing the expander upon expanding and collapsing.
     */
    resizeToplevel: boolean
    /**
     * Whether the text in the label is Pango markup.
     */
    useMarkup: boolean
    /**
     * Whether an underline in the text indicates a mnemonic.
     */
    useUnderline: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Expander

    /**
     * Gets the child widget of `expander`.
     * @returns the child widget of @expander
     */
    getChild(): Widget | null
    /**
     * Queries a `GtkExpander` and returns its current state.
     *
     * Returns %TRUE if the child widget is revealed.
     * @returns the current state of the expander
     */
    getExpanded(): boolean
    /**
     * Fetches the text from a label widget.
     *
     * This is including any embedded underlines indicating mnemonics and
     * Pango markup, as set by [method`Gtk`.Expander.set_label]. If the label
     * text has not been set the return value will be %NULL. This will be the
     * case if you create an empty button with gtk_button_new() to use as a
     * container.
     * @returns The text of the label widget. This string is owned   by the widget and must not be modified or freed.
     */
    getLabel(): string | null
    /**
     * Retrieves the label widget for the frame.
     * @returns the label widget
     */
    getLabelWidget(): Widget | null
    /**
     * Returns whether the expander will resize the toplevel widget
     * containing the expander upon resizing and collapsing.
     * @returns the “resize toplevel” setting.
     */
    getResizeToplevel(): boolean
    /**
     * Returns whether the label’s text is interpreted as Pango markup.
     * @returns %TRUE if the label’s text will be parsed for markup
     */
    getUseMarkup(): boolean
    /**
     * Returns whether an underline in the text indicates a mnemonic.
     * @returns %TRUE if an embedded underline in the expander   label indicates the mnemonic accelerator keys
     */
    getUseUnderline(): boolean
    /**
     * Sets the child widget of `expander`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets the state of the expander.
     *
     * Set to %TRUE, if you want the child widget to be revealed,
     * and %FALSE if you want the child widget to be hidden.
     * @param expanded whether the child widget is revealed
     */
    setExpanded(expanded: boolean): void
    /**
     * Sets the text of the label of the expander to `label`.
     *
     * This will also clear any previously set labels.
     * @param label a string
     */
    setLabel(label: string | null): void
    /**
     * Set the label widget for the expander.
     *
     * This is the widget that will appear embedded alongside
     * the expander arrow.
     * @param labelWidget the new label widget
     */
    setLabelWidget(labelWidget: Widget | null): void
    /**
     * Sets whether the expander will resize the toplevel widget
     * containing the expander upon resizing and collapsing.
     * @param resizeToplevel whether to resize the toplevel
     */
    setResizeToplevel(resizeToplevel: boolean): void
    /**
     * Sets whether the text of the label contains Pango markup.
     * @param useMarkup %TRUE if the label’s text should be parsed for markup
     */
    setUseMarkup(useMarkup: boolean): void
    /**
     * If true, an underline in the text indicates a mnemonic.
     * @param useUnderline %TRUE if underlines in the text indicate mnemonics
     */
    setUseUnderline(useUnderline: boolean): void

    // Own signals of Gtk-4.0.Gtk.Expander

    connect(
      sigName: "activate",
      callback: Expander.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: Expander.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: Expander.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: Expander.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Expander

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expanded", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::label-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label-widget", ...args: any[]): void
    connect(
      sigName: "notify::resize-toplevel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resize-toplevel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resize-toplevel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resize-toplevel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resize-toplevel", ...args: any[]): void
    connect(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-markup", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkExpander` allows the user to reveal its child by clicking
   * on an expander triangle.
   *
   * ![An example GtkExpander](expander.png)
   *
   * This is similar to the triangles used in a `GtkTreeView`.
   *
   * Normally you use an expander as you would use a frame; you create
   * the child widget and use [method`Gtk`.Expander.set_child] to add it
   * to the expander. When the expander is toggled, it will take care of
   * showing and hiding the child automatically.
   *
   * # Special Usage
   *
   * There are situations in which you may prefer to show and hide the
   * expanded widget yourself, such as when you want to actually create
   * the widget at expansion time. In this case, create a `GtkExpander`
   * but do not add a child to it. The expander widget has an
   * [property`Gtk`.Expander:expanded] property which can be used to
   * monitor its expansion state. You should watch this property with
   * a signal connection as follows:
   *
   * ```c
   * static void
   * expander_callback (GObject    *object,
   *                    GParamSpec *param_spec,
   *                    gpointer    user_data)
   * {
   *   GtkExpander *expander;
   *
   *   expander = GTK_EXPANDER (object);
   *
   *   if (gtk_expander_get_expanded (expander))
   *     {
   *       // Show or create widgets
   *     }
   *   else
   *     {
   *       // Hide or destroy widgets
   *     }
   * }
   *
   * static void
   * create_expander (void)
   * {
   *   GtkWidget *expander = gtk_expander_new_with_mnemonic ("_More Options");
   *   g_signal_connect (expander, "notify::expanded",
   *                     G_CALLBACK (expander_callback), NULL);
   *
   *   // ...
   * }
   * ```
   *
   * # GtkExpander as GtkBuildable
   *
   * The `GtkExpander` implementation of the `GtkBuildable` interface supports
   * placing a child in the label position by specifying “label” as the
   * “type” attribute of a `<child>` element. A normal content child can be
   * specified without specifying a `<child>` type attribute.
   *
   * An example of a UI definition fragment with GtkExpander:
   *
   * ```xml
   * <object class="GtkExpander">
   *   <child type="label">
   *     <object class="GtkLabel" id="expander-label"/>
   *   </child>
   *   <child>
   *     <object class="GtkEntry" id="expander-content"/>
   *   </child>
   * </object>
   * ```
   *
   * # CSS nodes
   *
   * ```
   * expander-widget
   * ╰── box
   *     ├── title
   *     │   ├── expander
   *     │   ╰── <label widget>
   *     ╰── <child>
   * ```
   *
   * `GtkExpander` has a main node `expander-widget`, and subnode `box` containing
   * the title and child widget. The box subnode `title` contains node `expander`,
   * i.e. the expand/collapse arrow; then the label widget if any. The arrow of an
   * expander that is showing its child gets the `:checked` pseudoclass set on it.
   *
   * # Accessibility
   *
   * `GtkExpander` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
   * @class
   */
  class Expander extends Widget {
    // Own properties of Gtk-4.0.Gtk.Expander

    static name: string

    // Constructors of Gtk-4.0.Gtk.Expander

    constructor(config?: Expander.ConstructorProperties)
    /**
     * Creates a new expander using `label` as the text of the label.
     * @constructor
     * @param label the text of the label
     * @returns a new `GtkExpander` widget.
     */
    constructor(label: string | null)
    /**
     * Creates a new expander using `label` as the text of the label.
     * @constructor
     * @param label the text of the label
     * @returns a new `GtkExpander` widget.
     */
    static new(label: string | null): Expander
    /**
     * Creates a new expander using `label` as the text of the label.
     *
     * If characters in `label` are preceded by an underscore, they are
     * underlined. If you need a literal underscore character in a label,
     * use “__” (two underscores). The first underlined character represents
     * a keyboard accelerator called a mnemonic.
     *
     * Pressing Alt and that key activates the button.
     * @constructor
     * @param label the text of the label with an underscore   in front of the mnemonic character
     * @returns a new `GtkExpander` widget.
     */
    static newWithMnemonic(label: string | null): Expander
    _init(config?: Expander.ConstructorProperties): void
  }

  interface Expression {
    // Owm methods of Gtk-4.0.Gtk.Expression

    /**
     * Bind `target`'s property named `property` to `self`.
     *
     * The value that `self` evaluates to is set via `g_object_set()` on
     * `target`. This is repeated whenever `self` changes to ensure that
     * the object's property stays synchronized with `self`.
     *
     * If `self`'s evaluation fails, `target`'s `property` is not updated.
     * You can ensure that this doesn't happen by using a fallback
     * expression.
     *
     * Note that this function takes ownership of `self`. If you want
     * to keep it around, you should [method`Gtk`.Expression.ref] it beforehand.
     * @param target the target object to bind to
     * @param property name of the property on `target` to bind to
     * @param this_ the this argument for   the evaluation of `self`
     * @returns a `GtkExpressionWatch`
     */
    bind(
      target: GObject.Object,
      property: string,
      this_: GObject.Object | null
    ): ExpressionWatch
    /**
     * Evaluates the given expression and on success stores the result
     * in `value`.
     *
     * The `GType` of `value` will be the type given by
     * [method`Gtk`.Expression.get_value_type].
     *
     * It is possible that expressions cannot be evaluated - for example
     * when the expression references objects that have been destroyed or
     * set to `NULL`. In that case `value` will remain empty and `FALSE`
     * will be returned.
     * @param this_ the this argument for the evaluation
     * @param value an empty `GValue`
     * @returns `TRUE` if the expression could be evaluated
     */
    evaluate(this_: GObject.Object | null, value: any): boolean
    /**
     * Gets the `GType` that this expression evaluates to.
     *
     * This type is constant and will not change over the lifetime
     * of this expression.
     * @returns The type returned from [method@Gtk.Expression.evaluate]
     */
    getValueType(): GObject.GType
    /**
     * Checks if the expression is static.
     *
     * A static expression will never change its result when
     * [method`Gtk`.Expression.evaluate] is called on it with the same arguments.
     *
     * That means a call to [method`Gtk`.Expression.watch] is not necessary because
     * it will never trigger a notify.
     * @returns `TRUE` if the expression is static
     */
    isStatic(): boolean
    /**
     * Acquires a reference on the given `GtkExpression`.
     * @returns the `GtkExpression` with an additional reference
     */
    ref(): Expression
    /**
     * Releases a reference on the given `GtkExpression`.
     *
     * If the reference was the last, the resources associated to the `self` are
     * freed.
     */
    unref(): void
    /**
     * Watch the given `expression` for changes.
     *
     * The `notify` function will be called whenever the evaluation of `self`
     * may have changed.
     *
     * GTK cannot guarantee that the evaluation did indeed change when the `notify`
     * gets invoked, but it guarantees the opposite: When it did in fact change,
     * the `notify` will be invoked.
     * @param this_ the `this` argument to   watch
     * @param notify callback to invoke when the expression changes
     * @returns The newly installed watch. Note that the only   reference held to the watch will be released when the watch is unwatched   which can happen automatically, and not just via   [method@Gtk.ExpressionWatch.unwatch]. You should call [method@Gtk.ExpressionWatch.ref]   if you want to keep the watch around.
     */
    watch(
      this_: GObject.Object | null,
      notify: ExpressionNotify
    ): ExpressionWatch
  }

  /**
   * `GtkExpression` provides a way to describe references to values.
   *
   * An important aspect of expressions is that the value can be obtained
   * from a source that is several steps away. For example, an expression
   * may describe ‘the value of property A of `object1`, which is itself the
   * value of a property of `object2`’. And `object1` may not even exist yet
   * at the time that the expression is created. This is contrast to `GObject`
   * property bindings, which can only create direct connections between
   * the properties of two objects that must both exist for the duration
   * of the binding.
   *
   * An expression needs to be "evaluated" to obtain the value that it currently
   * refers to. An evaluation always happens in the context of a current object
   * called `this` (it mirrors the behavior of object-oriented languages),
   * which may or may not influence the result of the evaluation. Use
   * [method`Gtk`.Expression.evaluate] for evaluating an expression.
   *
   * Various methods for defining expressions exist, from simple constants via
   * [ctor`Gtk`.ConstantExpression.new] to looking up properties in a `GObject`
   * (even recursively) via [ctor`Gtk`.PropertyExpression.new] or providing
   * custom functions to transform and combine expressions via
   * [ctor`Gtk`.ClosureExpression.new].
   *
   * Here is an example of a complex expression:
   *
   * ```c
   *   color_expr = gtk_property_expression_new (GTK_TYPE_LIST_ITEM,
   *                                             NULL, "item");
   *   expression = gtk_property_expression_new (GTK_TYPE_COLOR,
   *                                             color_expr, "name");
   * ```
   *
   * when evaluated with `this` being a `GtkListItem`, it will obtain the
   * "item" property from the `GtkListItem`, and then obtain the "name" property
   * from the resulting object (which is assumed to be of type `GTK_TYPE_COLOR`).
   *
   * A more concise way to describe this would be
   *
   * ```
   *   this->item->name
   * ```
   *
   * The most likely place where you will encounter expressions is in the context
   * of list models and list widgets using them. For example, `GtkDropDown` is
   * evaluating a `GtkExpression` to obtain strings from the items in its model
   * that it can then use to match against the contents of its search entry.
   * `GtkStringFilter` is using a `GtkExpression` for similar reasons.
   *
   * By default, expressions are not paying attention to changes and evaluation is
   * just a snapshot of the current state at a given time. To get informed about
   * changes, an expression needs to be "watched" via a [struct`Gtk`.ExpressionWatch],
   * which will cause a callback to be called whenever the value of the expression may
   * have changed; [method`Gtk`.Expression.watch] starts watching an expression, and
   * [method`Gtk`.ExpressionWatch.unwatch] stops.
   *
   * Watches can be created for automatically updating the property of an object,
   * similar to GObject's `GBinding` mechanism, by using [method`Gtk`.Expression.bind].
   *
   * ## GtkExpression in GObject properties
   *
   * In order to use a `GtkExpression` as a `GObject` property, you must use the
   * [func`Gtk`.param_spec_expression] when creating a `GParamSpec` to install in the
   * `GObject` class being defined; for instance:
   *
   * ```c
   * obj_props[PROP_EXPRESSION] =
   *   gtk_param_spec_expression ("expression",
   *                              "Expression",
   *                              "The expression used by the widget",
   *                              G_PARAM_READWRITE |
   *                              G_PARAM_STATIC_STRINGS |
   *                              G_PARAM_EXPLICIT_NOTIFY);
   * ```
   *
   * When implementing the `GObjectClass.set_property` and `GObjectClass.get_property`
   * virtual functions, you must use [func`Gtk`.value_get_expression], to retrieve the
   * stored `GtkExpression` from the `GValue` container, and [func`Gtk`.value_set_expression],
   * to store the `GtkExpression` into the `GValue`; for instance:
   *
   * ```c
   *   // in set_property()...
   *   case PROP_EXPRESSION:
   *     foo_widget_set_expression (foo, gtk_value_get_expression (value));
   *     break;
   *
   *   // in get_property()...
   *   case PROP_EXPRESSION:
   *     gtk_value_set_expression (value, foo->expression);
   *     break;
   * ```
   *
   * ## GtkExpression in .ui files
   *
   * `GtkBuilder` has support for creating expressions. The syntax here can be used where
   * a `GtkExpression` object is needed like in a `<property>` tag for an expression
   * property, or in a `<binding name="property">` tag to bind a property to an expression.
   *
   * To create a property expression, use the `<lookup>` element. It can have a `type`
   * attribute to specify the object type, and a `name` attribute to specify the property
   * to look up. The content of `<lookup>` can either be an element specifying the expression
   * to use the object, or a string that specifies the name of the object to use.
   *
   * Example:
   *
   * ```xml
   *   <lookup name='search'>string_filter</lookup>
   * ```
   *
   * Since the `<lookup>` element creates an expression and its element content can
   * itself be an expression, this means that `<lookup>` tags can also be nested.
   * This is a common idiom when dealing with `GtkListItem`s. See
   * [class`Gtk`.BuilderListItemFactory] for an example of this technique.
   *
   * To create a constant expression, use the `<constant>` element. If the type attribute
   * is specified, the element content is interpreted as a value of that type. Otherwise,
   * it is assumed to be an object. For instance:
   *
   * ```xml
   *   <constant>string_filter</constant>
   *   <constant type='gchararray'>Hello, world</constant>
   * ```
   *
   * To create a closure expression, use the `<closure>` element. The `function`
   * attribute specifies what function to use for the closure, and the `type`
   * attribute specifies its return type. The content of the element contains the
   * expressions for the parameters. For instance:
   *
   * ```xml
   *   <closure type='gchararray' function='combine_args_somehow'>
   *     <constant type='gchararray'>File size:</constant>
   *     <lookup type='GFile' name='size'>myfile</lookup>
   *   </closure>
   * ```
   *
   * To create a property binding, use the `<binding>` element in place of where a
   * `<property>` tag would ordinarily be used. The `name` and `object` attributes are
   * supported. The `name` attribute is required, and pertains to the applicable property
   * name. The `object` attribute is optional. If provided, it will use the specified object
   * as the `this` object when the expression is evaluated. Here is an example in which the
   * `label` property of a `GtkLabel` is bound to the `string` property of another arbitrary
   * object:
   *
   * ```xml
   *   <object class='GtkLabel'>
   *     <binding name='label'>
   *       <lookup name='string'>some_other_object</lookup>
   *     </binding>
   *   </object>
   * ```
   * @class
   */
  class Expression {
    // Own properties of Gtk-4.0.Gtk.Expression

    static name: string
  }

  module FileChooserDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        FileChooser.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Dialog.ConstructorProperties {}
  }

  interface FileChooserDialog
    extends Accessible,
      Buildable,
      ConstraintTarget,
      FileChooser,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.FileChooserDialog

    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void
    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @virtual
     */
    close(): void

    // Overloads of close

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void

    // Class property signals of Gtk-4.0.Gtk.FileChooserDialog

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action", ...args: any[]): void
    connect(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::create-folders", ...args: any[]): void
    connect(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filter", ...args: any[]): void
    connect(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filters", ...args: any[]): void
    connect(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::select-multiple", ...args: any[]): void
    connect(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shortcut-folders", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFileChooserDialog` is a dialog suitable for use with
   * “File Open” or “File Save” commands.
   *
   * ![An example GtkFileChooserDialog](filechooser.png)
   *
   * This widget works by putting a [class`Gtk`.FileChooserWidget]
   * inside a [class`Gtk`.Dialog]. It exposes the [iface`Gtk`.FileChooser]
   * interface, so you can use all of the [iface`Gtk`.FileChooser] functions
   * on the file chooser dialog as well as those for [class`Gtk`.Dialog].
   *
   * Note that `GtkFileChooserDialog` does not have any methods of its
   * own. Instead, you should use the functions that work on a
   * [iface`Gtk`.FileChooser].
   *
   * If you want to integrate well with the platform you should use the
   * [class`Gtk`.FileChooserNative] API, which will use a platform-specific
   * dialog if available and fall back to `GtkFileChooserDialog`
   * otherwise.
   *
   * ## Typical usage
   *
   * In the simplest of cases, you can the following code to use
   * `GtkFileChooserDialog` to select a file for opening:
   *
   * ```c
   * static void
   * on_open_response (GtkDialog *dialog,
   *                   int        response)
   * {
   *   if (response == GTK_RESPONSE_ACCEPT)
   *     {
   *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
   *
   *       g_autoptr(GFile) file = gtk_file_chooser_get_file (chooser);
   *
   *       open_file (file);
   *     }
   *
   *   gtk_window_destroy (GTK_WINDOW (dialog));
   * }
   *
   *   // ...
   *   GtkWidget *dialog;
   *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
   *
   *   dialog = gtk_file_chooser_dialog_new ("Open File",
   *                                         parent_window,
   *                                         action,
   *                                         _("_Cancel"),
   *                                         GTK_RESPONSE_CANCEL,
   *                                         _("_Open"),
   *                                         GTK_RESPONSE_ACCEPT,
   *                                         NULL);
   *
   *   gtk_window_present (GTK_WINDOW (dialog));
   *
   *   g_signal_connect (dialog, "response",
   *                     G_CALLBACK (on_open_response),
   *                     NULL);
   * ```
   *
   * To use a dialog for saving, you can use this:
   *
   * ```c
   * static void
   * on_save_response (GtkDialog *dialog,
   *                   int        response)
   * {
   *   if (response == GTK_RESPONSE_ACCEPT)
   *     {
   *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
   *
   *       g_autoptr(GFile) file = gtk_file_chooser_get_file (chooser);
   *
   *       save_to_file (file);
   *     }
   *
   *   gtk_window_destroy (GTK_WINDOW (dialog));
   * }
   *
   *   // ...
   *   GtkWidget *dialog;
   *   GtkFileChooser *chooser;
   *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
   *
   *   dialog = gtk_file_chooser_dialog_new ("Save File",
   *                                         parent_window,
   *                                         action,
   *                                         _("_Cancel"),
   *                                         GTK_RESPONSE_CANCEL,
   *                                         _("_Save"),
   *                                         GTK_RESPONSE_ACCEPT,
   *                                         NULL);
   *   chooser = GTK_FILE_CHOOSER (dialog);
   *
   *   if (user_edited_a_new_document)
   *     gtk_file_chooser_set_current_name (chooser, _("Untitled document"));
   *   else
   *     gtk_file_chooser_set_file (chooser, existing_filename);
   *
   *   gtk_window_present (GTK_WINDOW (dialog));
   *
   *   g_signal_connect (dialog, "response",
   *                     G_CALLBACK (on_save_response),
   *                     NULL);
   * ```
   *
   * ## Setting up a file chooser dialog
   *
   * There are various cases in which you may need to use a `GtkFileChooserDialog`:
   *
   * - To select a file for opening, use %GTK_FILE_CHOOSER_ACTION_OPEN.
   *
   * - To save a file for the first time, use %GTK_FILE_CHOOSER_ACTION_SAVE,
   *   and suggest a name such as “Untitled” with
   *   [method`Gtk`.FileChooser.set_current_name].
   *
   * - To save a file under a different name, use %GTK_FILE_CHOOSER_ACTION_SAVE,
   *   and set the existing file with [method`Gtk`.FileChooser.set_file].
   *
   * - To choose a folder instead of a filem use %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
   *
   * In general, you should only cause the file chooser to show a specific
   * folder when it is appropriate to use [method`Gtk`.FileChooser.set_file],
   * i.e. when you are doing a “Save As” command and you already have a file
   * saved somewhere.
   *
   * ## Response Codes
   *
   * `GtkFileChooserDialog` inherits from [class`Gtk`.Dialog], so buttons that
   * go in its action area have response codes such as %GTK_RESPONSE_ACCEPT and
   * %GTK_RESPONSE_CANCEL. For example, you could call
   * [ctor`Gtk`.FileChooserDialog.new] as follows:
   *
   * ```c
   * GtkWidget *dialog;
   * GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
   *
   * dialog = gtk_file_chooser_dialog_new ("Open File",
   *                                       parent_window,
   *                                       action,
   *                                       _("_Cancel"),
   *                                       GTK_RESPONSE_CANCEL,
   *                                       _("_Open"),
   *                                       GTK_RESPONSE_ACCEPT,
   *                                       NULL);
   * ```
   *
   * This will create buttons for “Cancel” and “Open” that use predefined
   * response identifiers from [enum`Gtk`.ResponseType].  For most dialog
   * boxes you can use your own custom response codes rather than the
   * ones in [enum`Gtk`.ResponseType], but `GtkFileChooserDialog` assumes that
   * its “accept”-type action, e.g. an “Open” or “Save” button,
   * will have one of the following response codes:
   *
   * - %GTK_RESPONSE_ACCEPT
   * - %GTK_RESPONSE_OK
   * - %GTK_RESPONSE_YES
   * - %GTK_RESPONSE_APPLY
   *
   * This is because `GtkFileChooserDialog` must intercept responses and switch
   * to folders if appropriate, rather than letting the dialog terminate — the
   * implementation uses these known response codes to know which responses can
   * be blocked if appropriate.
   *
   * To summarize, make sure you use a predefined response code
   * when you use `GtkFileChooserDialog` to ensure proper operation.
   *
   * ## CSS nodes
   *
   * `GtkFileChooserDialog` has a single CSS node with the name `window` and style
   * class `.filechooser`.
   * @class
   */
  class FileChooserDialog extends Dialog {
    // Own properties of Gtk-4.0.Gtk.FileChooserDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.FileChooserDialog

    constructor(config?: FileChooserDialog.ConstructorProperties)
    _init(config?: FileChooserDialog.ConstructorProperties): void
  }

  module FileChooserNative {
    // Constructor properties interface

    interface ConstructorProperties
      extends FileChooser.ConstructorProperties,
        NativeDialog.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FileChooserNative

      /**
       * The text used for the label on the accept button in the dialog, or
       * %NULL to use the default text.
       */
      accept_label?: string | null
      /**
       * The text used for the label on the cancel button in the dialog, or
       * %NULL to use the default text.
       */
      cancel_label?: string | null
    }
  }

  interface FileChooserNative extends FileChooser {
    // Own properties of Gtk-4.0.Gtk.FileChooserNative

    /**
     * The text used for the label on the accept button in the dialog, or
     * %NULL to use the default text.
     */
    acceptLabel: string | null
    /**
     * The text used for the label on the cancel button in the dialog, or
     * %NULL to use the default text.
     */
    cancelLabel: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FileChooserNative

    /**
     * Retrieves the custom label text for the accept button.
     * @returns The custom label
     */
    getAcceptLabel(): string | null
    /**
     * Retrieves the custom label text for the cancel button.
     * @returns The custom label
     */
    getCancelLabel(): string | null
    /**
     * Sets the custom label text for the accept button.
     *
     * If characters in `label` are preceded by an underscore, they are
     * underlined. If you need a literal underscore character in a label,
     * use “__” (two underscores). The first underlined character represents
     * a keyboard accelerator called a mnemonic.
     *
     * Pressing Alt and that key should activate the button.
     * @param acceptLabel custom label
     */
    setAcceptLabel(acceptLabel: string | null): void
    /**
     * Sets the custom label text for the cancel button.
     *
     * If characters in `label` are preceded by an underscore, they are
     * underlined. If you need a literal underscore character in a label,
     * use “__” (two underscores). The first underlined character represents
     * a keyboard accelerator called a mnemonic.
     *
     * Pressing Alt and that key should activate the button.
     * @param cancelLabel custom label
     */
    setCancelLabel(cancelLabel: string | null): void

    // Class property signals of Gtk-4.0.Gtk.FileChooserNative

    connect(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accept-label", ...args: any[]): void
    connect(
      sigName: "notify::cancel-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cancel-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cancel-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cancel-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cancel-label", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action", ...args: any[]): void
    connect(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::create-folders", ...args: any[]): void
    connect(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filter", ...args: any[]): void
    connect(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filters", ...args: any[]): void
    connect(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::select-multiple", ...args: any[]): void
    connect(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shortcut-folders", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFileChooserNative` is an abstraction of a dialog suitable
   * for use with “File Open” or “File Save as” commands.
   *
   * By default, this just uses a `GtkFileChooserDialog` to implement
   * the actual dialog. However, on some platforms, such as Windows and
   * macOS, the native platform file chooser is used instead. When the
   * application is running in a sandboxed environment without direct
   * filesystem access (such as Flatpak), `GtkFileChooserNative` may call
   * the proper APIs (portals) to let the user choose a file and make it
   * available to the application.
   *
   * While the API of `GtkFileChooserNative` closely mirrors `GtkFileChooserDialog`,
   * the main difference is that there is no access to any `GtkWindow` or `GtkWidget`
   * for the dialog. This is required, as there may not be one in the case of a
   * platform native dialog.
   *
   * Showing, hiding and running the dialog is handled by the
   * [class`Gtk`.NativeDialog] functions.
   *
   * Note that unlike `GtkFileChooserDialog`, `GtkFileChooserNative` objects
   * are not toplevel widgets, and GTK does not keep them alive. It is your
   * responsibility to keep a reference until you are done with the
   * object.
   *
   * ## Typical usage
   *
   * In the simplest of cases, you can the following code to use
   * `GtkFileChooserNative` to select a file for opening:
   *
   * ```c
   * static void
   * on_response (GtkNativeDialog *native,
   *              int              response)
   * {
   *   if (response == GTK_RESPONSE_ACCEPT)
   *     {
   *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
   *       GFile *file = gtk_file_chooser_get_file (chooser);
   *
   *       open_file (file);
   *
   *       g_object_unref (file);
   *     }
   *
   *   g_object_unref (native);
   * }
   *
   *   // ...
   *   GtkFileChooserNative *native;
   *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
   *
   *   native = gtk_file_chooser_native_new ("Open File",
   *                                         parent_window,
   *                                         action,
   *                                         "_Open",
   *                                         "_Cancel");
   *
   *   g_signal_connect (native, "response", G_CALLBACK (on_response), NULL);
   *   gtk_native_dialog_show (GTK_NATIVE_DIALOG (native));
   * ```
   *
   * To use a `GtkFileChooserNative` for saving, you can use this:
   *
   * ```c
   * static void
   * on_response (GtkNativeDialog *native,
   *              int              response)
   * {
   *   if (response == GTK_RESPONSE_ACCEPT)
   *     {
   *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
   *       GFile *file = gtk_file_chooser_get_file (chooser);
   *
   *       save_to_file (file);
   *
   *       g_object_unref (file);
   *     }
   *
   *   g_object_unref (native);
   * }
   *
   *   // ...
   *   GtkFileChooserNative *native;
   *   GtkFileChooser *chooser;
   *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
   *
   *   native = gtk_file_chooser_native_new ("Save File",
   *                                         parent_window,
   *                                         action,
   *                                         "_Save",
   *                                         "_Cancel");
   *   chooser = GTK_FILE_CHOOSER (native);
   *
   *   if (user_edited_a_new_document)
   *     gtk_file_chooser_set_current_name (chooser, _("Untitled document"));
   *   else
   *     gtk_file_chooser_set_file (chooser, existing_file, NULL);
   *
   *   g_signal_connect (native, "response", G_CALLBACK (on_response), NULL);
   *   gtk_native_dialog_show (GTK_NATIVE_DIALOG (native));
   * ```
   *
   * For more information on how to best set up a file dialog,
   * see the [class`Gtk`.FileChooserDialog] documentation.
   *
   * ## Response Codes
   *
   * `GtkFileChooserNative` inherits from [class`Gtk`.NativeDialog],
   * which means it will return %GTK_RESPONSE_ACCEPT if the user accepted,
   * and %GTK_RESPONSE_CANCEL if he pressed cancel. It can also return
   * %GTK_RESPONSE_DELETE_EVENT if the window was unexpectedly closed.
   *
   * ## Differences from `GtkFileChooserDialog`
   *
   * There are a few things in the [iface`Gtk`.FileChooser] interface that
   * are not possible to use with `GtkFileChooserNative`, as such use would
   * prohibit the use of a native dialog.
   *
   * No operations that change the dialog work while the dialog is visible.
   * Set all the properties that are required before showing the dialog.
   *
   * ## Win32 details
   *
   * On windows the `IFileDialog` implementation (added in Windows Vista) is
   * used. It supports many of the features that `GtkFileChooser` has, but
   * there are some things it does not handle:
   *
   * * Any [class`Gtk`.FileFilter] added using a mimetype
   *
   * If any of these features are used the regular `GtkFileChooserDialog`
   * will be used in place of the native one.
   *
   * ## Portal details
   *
   * When the `org.freedesktop.portal.FileChooser` portal is available on
   * the session bus, it is used to bring up an out-of-process file chooser.
   * Depending on the kind of session the application is running in, this may
   * or may not be a GTK file chooser.
   *
   * ## macOS details
   *
   * On macOS the `NSSavePanel` and `NSOpenPanel` classes are used to provide
   * native file chooser dialogs. Some features provided by `GtkFileChooser`
   * are not supported:
   *
   * * Shortcut folders.
   * @class
   */
  class FileChooserNative extends NativeDialog {
    // Own properties of Gtk-4.0.Gtk.FileChooserNative

    static name: string

    // Constructors of Gtk-4.0.Gtk.FileChooserNative

    constructor(config?: FileChooserNative.ConstructorProperties)
    /**
     * Creates a new `GtkFileChooserNative`.
     * @constructor
     * @param title Title of the native
     * @param parent Transient parent of the native
     * @param action Open or save mode for the dialog
     * @param acceptLabel text to go in the accept button, or %NULL for the default
     * @param cancelLabel text to go in the cancel button, or %NULL for the default
     * @returns a new `GtkFileChooserNative`
     */
    constructor(
      title: string | null,
      parent: Window | null,
      action: FileChooserAction,
      acceptLabel: string | null,
      cancelLabel: string | null
    )
    /**
     * Creates a new `GtkFileChooserNative`.
     * @constructor
     * @param title Title of the native
     * @param parent Transient parent of the native
     * @param action Open or save mode for the dialog
     * @param acceptLabel text to go in the accept button, or %NULL for the default
     * @param cancelLabel text to go in the cancel button, or %NULL for the default
     * @returns a new `GtkFileChooserNative`
     */
    static new(
      title: string | null,
      parent: Window | null,
      action: FileChooserAction,
      acceptLabel: string | null,
      cancelLabel: string | null
    ): FileChooserNative
    _init(config?: FileChooserNative.ConstructorProperties): void
  }

  module FileChooserWidget {
    // Signal callback interfaces

    /**
     * Signal callback interface for `desktop-folder`
     */
    interface DesktopFolderSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `down-folder`
     */
    interface DownFolderSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `home-folder`
     */
    interface HomeFolderSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `location-popup`
     */
    interface LocationPopupSignalCallback {
      (path: string | null): void
    }

    /**
     * Signal callback interface for `location-popup-on-paste`
     */
    interface LocationPopupOnPasteSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `location-toggle-popup`
     */
    interface LocationTogglePopupSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `places-shortcut`
     */
    interface PlacesShortcutSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `quick-bookmark`
     */
    interface QuickBookmarkSignalCallback {
      (bookmarkIndex: number): void
    }

    /**
     * Signal callback interface for `recent-shortcut`
     */
    interface RecentShortcutSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `search-shortcut`
     */
    interface SearchShortcutSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `show-hidden`
     */
    interface ShowHiddenSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `up-folder`
     */
    interface UpFolderSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        FileChooser.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FileChooserWidget

      search_mode?: boolean | null
    }
  }

  interface FileChooserWidget
    extends Accessible,
      Buildable,
      ConstraintTarget,
      FileChooser {
    // Own properties of Gtk-4.0.Gtk.FileChooserWidget

    searchMode: boolean
    /**
     * Whether to show the time.
     */
    readonly showTime: boolean
    readonly subtitle: string | null
    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.FileChooserWidget

    connect(
      sigName: "desktop-folder",
      callback: FileChooserWidget.DesktopFolderSignalCallback
    ): number
    on(
      sigName: "desktop-folder",
      callback: FileChooserWidget.DesktopFolderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "desktop-folder",
      callback: FileChooserWidget.DesktopFolderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "desktop-folder",
      callback: FileChooserWidget.DesktopFolderSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "desktop-folder", ...args: any[]): void
    connect(
      sigName: "down-folder",
      callback: FileChooserWidget.DownFolderSignalCallback
    ): number
    on(
      sigName: "down-folder",
      callback: FileChooserWidget.DownFolderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "down-folder",
      callback: FileChooserWidget.DownFolderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "down-folder",
      callback: FileChooserWidget.DownFolderSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "down-folder", ...args: any[]): void
    connect(
      sigName: "home-folder",
      callback: FileChooserWidget.HomeFolderSignalCallback
    ): number
    on(
      sigName: "home-folder",
      callback: FileChooserWidget.HomeFolderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "home-folder",
      callback: FileChooserWidget.HomeFolderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "home-folder",
      callback: FileChooserWidget.HomeFolderSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "home-folder", ...args: any[]): void
    connect(
      sigName: "location-popup",
      callback: FileChooserWidget.LocationPopupSignalCallback
    ): number
    on(
      sigName: "location-popup",
      callback: FileChooserWidget.LocationPopupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "location-popup",
      callback: FileChooserWidget.LocationPopupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "location-popup",
      callback: FileChooserWidget.LocationPopupSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "location-popup", ...args: any[]): void
    connect(
      sigName: "location-popup-on-paste",
      callback: FileChooserWidget.LocationPopupOnPasteSignalCallback
    ): number
    on(
      sigName: "location-popup-on-paste",
      callback: FileChooserWidget.LocationPopupOnPasteSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "location-popup-on-paste",
      callback: FileChooserWidget.LocationPopupOnPasteSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "location-popup-on-paste",
      callback: FileChooserWidget.LocationPopupOnPasteSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "location-popup-on-paste", ...args: any[]): void
    connect(
      sigName: "location-toggle-popup",
      callback: FileChooserWidget.LocationTogglePopupSignalCallback
    ): number
    on(
      sigName: "location-toggle-popup",
      callback: FileChooserWidget.LocationTogglePopupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "location-toggle-popup",
      callback: FileChooserWidget.LocationTogglePopupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "location-toggle-popup",
      callback: FileChooserWidget.LocationTogglePopupSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "location-toggle-popup", ...args: any[]): void
    connect(
      sigName: "places-shortcut",
      callback: FileChooserWidget.PlacesShortcutSignalCallback
    ): number
    on(
      sigName: "places-shortcut",
      callback: FileChooserWidget.PlacesShortcutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "places-shortcut",
      callback: FileChooserWidget.PlacesShortcutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "places-shortcut",
      callback: FileChooserWidget.PlacesShortcutSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "places-shortcut", ...args: any[]): void
    connect(
      sigName: "quick-bookmark",
      callback: FileChooserWidget.QuickBookmarkSignalCallback
    ): number
    on(
      sigName: "quick-bookmark",
      callback: FileChooserWidget.QuickBookmarkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "quick-bookmark",
      callback: FileChooserWidget.QuickBookmarkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "quick-bookmark",
      callback: FileChooserWidget.QuickBookmarkSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "quick-bookmark", ...args: any[]): void
    connect(
      sigName: "recent-shortcut",
      callback: FileChooserWidget.RecentShortcutSignalCallback
    ): number
    on(
      sigName: "recent-shortcut",
      callback: FileChooserWidget.RecentShortcutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "recent-shortcut",
      callback: FileChooserWidget.RecentShortcutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "recent-shortcut",
      callback: FileChooserWidget.RecentShortcutSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "recent-shortcut", ...args: any[]): void
    connect(
      sigName: "search-shortcut",
      callback: FileChooserWidget.SearchShortcutSignalCallback
    ): number
    on(
      sigName: "search-shortcut",
      callback: FileChooserWidget.SearchShortcutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "search-shortcut",
      callback: FileChooserWidget.SearchShortcutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "search-shortcut",
      callback: FileChooserWidget.SearchShortcutSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "search-shortcut", ...args: any[]): void
    connect(
      sigName: "show-hidden",
      callback: FileChooserWidget.ShowHiddenSignalCallback
    ): number
    on(
      sigName: "show-hidden",
      callback: FileChooserWidget.ShowHiddenSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "show-hidden",
      callback: FileChooserWidget.ShowHiddenSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "show-hidden",
      callback: FileChooserWidget.ShowHiddenSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "show-hidden", ...args: any[]): void
    connect(
      sigName: "up-folder",
      callback: FileChooserWidget.UpFolderSignalCallback
    ): number
    on(
      sigName: "up-folder",
      callback: FileChooserWidget.UpFolderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "up-folder",
      callback: FileChooserWidget.UpFolderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "up-folder",
      callback: FileChooserWidget.UpFolderSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "up-folder", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.FileChooserWidget

    connect(
      sigName: "notify::search-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::search-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::search-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::search-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::search-mode", ...args: any[]): void
    connect(
      sigName: "notify::show-time",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-time",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-time",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-time",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-time", ...args: any[]): void
    connect(
      sigName: "notify::subtitle",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::subtitle",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::subtitle",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::subtitle",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::subtitle", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action", ...args: any[]): void
    connect(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::create-folders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::create-folders", ...args: any[]): void
    connect(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filter", ...args: any[]): void
    connect(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filters", ...args: any[]): void
    connect(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::select-multiple",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::select-multiple", ...args: any[]): void
    connect(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shortcut-folders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shortcut-folders", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFileChooserWidget` is a widget for choosing files.
   *
   * It exposes the [iface`Gtk`.FileChooser] interface, and you should
   * use the methods of this interface to interact with the
   * widget.
   *
   * # CSS nodes
   *
   * `GtkFileChooserWidget` has a single CSS node with name filechooser.
   * @class
   */
  class FileChooserWidget extends Widget {
    // Own properties of Gtk-4.0.Gtk.FileChooserWidget

    static name: string

    // Constructors of Gtk-4.0.Gtk.FileChooserWidget

    constructor(config?: FileChooserWidget.ConstructorProperties)
    /**
     * Creates a new `GtkFileChooserWidget`.
     *
     * This is a file chooser widget that can be embedded in custom
     * windows, and it is the same widget that is used by
     * `GtkFileChooserDialog`.
     * @constructor
     * @param action Open or save mode for the widget
     * @returns a new `GtkFileChooserWidget`
     */
    constructor(action: FileChooserAction)
    /**
     * Creates a new `GtkFileChooserWidget`.
     *
     * This is a file chooser widget that can be embedded in custom
     * windows, and it is the same widget that is used by
     * `GtkFileChooserDialog`.
     * @constructor
     * @param action Open or save mode for the widget
     * @returns a new `GtkFileChooserWidget`
     */
    static new(action: FileChooserAction): FileChooserWidget
    _init(config?: FileChooserWidget.ConstructorProperties): void
  }

  module FileDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FileDialog

      /**
       * Label for the file chooser's accept button.
       */
      accept_label?: string | null
      /**
       * The default filter, that is, the filter that is initially
       * active in the file chooser dialog.
       *
       * If the default filter is %NULL, the first filter of [property`Gtk`.FileDialog:filters]
       * is used as the default filter. If that property contains no filter, the dialog will
       * be unfiltered.
       *
       * If [property`Gtk`.FileDialog:filters] is not %NULL, the default filter should be part
       * of the list. If it is not, the dialog may choose to not make it available.
       */
      default_filter?: FileFilter | null
      /**
       * The list of filters.
       *
       * See [property`Gtk`.FileDialog:default-filter] about how those two properties interact.
       */
      filters?: Gio.ListModel | null
      /**
       * The initial file, that is, the file that is initially selected
       * in the file chooser dialog
       *
       * This is a utility property that sets both [property`Gtk`.FileDialog:initial-folder] and
       * [property`Gtk`.FileDialog:initial-name].
       */
      initial_file?: Gio.File | null
      /**
       * The initial folder, that is, the directory that is initially
       * opened in the file chooser dialog
       */
      initial_folder?: Gio.File | null
      /**
       * The initial name, that is, the filename that is initially
       * selected in the file chooser dialog.
       */
      initial_name?: string | null
      /**
       * Whether the file chooser dialog is modal.
       */
      modal?: boolean | null
      /**
       * A title that may be shown on the file chooser dialog.
       */
      title?: string | null
    }
  }

  interface FileDialog {
    // Own properties of Gtk-4.0.Gtk.FileDialog

    /**
     * Label for the file chooser's accept button.
     */
    acceptLabel: string | null
    /**
     * The default filter, that is, the filter that is initially
     * active in the file chooser dialog.
     *
     * If the default filter is %NULL, the first filter of [property`Gtk`.FileDialog:filters]
     * is used as the default filter. If that property contains no filter, the dialog will
     * be unfiltered.
     *
     * If [property`Gtk`.FileDialog:filters] is not %NULL, the default filter should be part
     * of the list. If it is not, the dialog may choose to not make it available.
     */
    defaultFilter: FileFilter
    /**
     * The list of filters.
     *
     * See [property`Gtk`.FileDialog:default-filter] about how those two properties interact.
     */
    filters: Gio.ListModel
    /**
     * The initial file, that is, the file that is initially selected
     * in the file chooser dialog
     *
     * This is a utility property that sets both [property`Gtk`.FileDialog:initial-folder] and
     * [property`Gtk`.FileDialog:initial-name].
     */
    initialFile: Gio.File
    /**
     * The initial folder, that is, the directory that is initially
     * opened in the file chooser dialog
     */
    initialFolder: Gio.File
    /**
     * The initial name, that is, the filename that is initially
     * selected in the file chooser dialog.
     */
    initialName: string | null
    /**
     * Whether the file chooser dialog is modal.
     */
    modal: boolean
    /**
     * A title that may be shown on the file chooser dialog.
     */
    title: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FileDialog

    getAcceptLabel(): string | null
    /**
     * Gets the filter that will be selected by default
     * in the file chooser dialog.
     * @returns the current filter
     */
    getDefaultFilter(): FileFilter | null
    /**
     * Gets the filters that will be offered to the user
     * in the file chooser dialog.
     * @returns the filters, as   a `GListModel` of `GtkFileFilters`
     */
    getFilters(): Gio.ListModel | null
    /**
     * Gets the file that will be initially selected in
     * the file chooser dialog.
     * @returns the file
     */
    getInitialFile(): Gio.File | null
    /**
     * Gets the folder that will be set as the
     * initial folder in the file chooser dialog.
     * @returns the folder
     */
    getInitialFolder(): Gio.File | null
    /**
     * Gets the name for the file that should be initially set.
     * @returns the name
     */
    getInitialName(): string | null
    /**
     * Returns whether the file chooser dialog
     * blocks interaction with the parent window
     * while it is presented.
     * @returns `TRUE` if the file chooser dialog is modal
     */
    getModal(): boolean
    /**
     * Returns the title that will be shown on the
     * file chooser dialog.
     * @returns the title
     */
    getTitle(): string
    /**
     * This function initiates a file selection operation by
     * presenting a file chooser dialog to the user.
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FileDialog.open_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    open(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FileDialog.open] call and
     * returns the resulting file.
     * @param result a `GAsyncResult`
     * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
     */
    openFinish(result: Gio.AsyncResult): Gio.File | null
    /**
     * This function initiates a multi-file selection operation by
     * presenting a file chooser dialog to the user.
     *
     * The file chooser will initially be opened in the directory
     * [property`Gtk`.FileDialog:initial-folder].
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FileDialog.open_multiple_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    openMultiple(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FileDialog.open] call and
     * returns the resulting files in a `GListModel`.
     * @param result a `GAsyncResult`
     * @returns the file that was selected,   as a `GListModel` of `GFiles`. Otherwise, `NULL` is returned   and @error is set
     */
    openMultipleFinish(result: Gio.AsyncResult): Gio.ListModel | null
    /**
     * This function initiates a file save operation by
     * presenting a file chooser dialog to the user.
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FileDialog.save_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    save(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FileDialog.save] call and
     * returns the resulting file.
     * @param result a `GAsyncResult`
     * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
     */
    saveFinish(result: Gio.AsyncResult): Gio.File | null
    /**
     * This function initiates a directory selection operation by
     * presenting a file chooser dialog to the user.
     *
     * If you pass `initial_folder,` the file chooser will initially be
     * opened in the parent directory of that folder, otherwise, it
     * will be in the directory [property`Gtk`.FileDialog:initial-folder].
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FileDialog.select_folder_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    selectFolder(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FileDialog.select_folder] call and
     * returns the resulting file.
     * @param result a `GAsyncResult`
     * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
     */
    selectFolderFinish(result: Gio.AsyncResult): Gio.File | null
    /**
     * This function initiates a multi-directory selection operation by
     * presenting a file chooser dialog to the user.
     *
     * The file chooser will initially be opened in the directory
     * [property`Gtk`.FileDialog:initial-folder].
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FileDialog.select_multiple_folders_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    selectMultipleFolders(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FileDialog.select_multiple_folders]
     * call and returns the resulting files in a `GListModel`.
     * @param result a `GAsyncResult`
     * @returns the file that was selected,   as a `GListModel` of `GFiles`. Otherwise, `NULL` is returned   and @error is set
     */
    selectMultipleFoldersFinish(result: Gio.AsyncResult): Gio.ListModel | null
    /**
     * Sets the label shown on the file chooser's accept button.
     *
     * Leaving the accept label unset or setting it as `NULL` will fall back to
     * a default label, depending on what API is used to launch the file dialog.
     * @param acceptLabel the new accept label
     */
    setAcceptLabel(acceptLabel: string | null): void
    /**
     * Sets the filter that will be selected by default
     * in the file chooser dialog.
     *
     * If set to %NULL, the first item in [property`Gtk`.FileDialog:filters]
     * will be used as the default filter. If that list is empty, the dialog
     * will be unfiltered.
     * @param filter a `GtkFileFilter`
     */
    setDefaultFilter(filter: FileFilter | null): void
    /**
     * Sets the filters that will be offered to the user
     * in the file chooser dialog.
     * @param filters a `GListModel` of `GtkFileFilters`
     */
    setFilters(filters: Gio.ListModel | null): void
    /**
     * Sets the file that will be initially selected in
     * the file chooser dialog.
     *
     * This function is a shortcut for calling both
     * gtk_file_dialog_set_initial_folder() and
     * gtk_file_dialog_set_initial_name() with the directory and
     * name of `file` respectively.
     * @param file a `GFile`
     */
    setInitialFile(file: Gio.File | null): void
    /**
     * Sets the folder that will be set as the
     * initial folder in the file chooser dialog.
     * @param folder a `GFile`
     */
    setInitialFolder(folder: Gio.File | null): void
    /**
     * Sets the name for the file that should be initially set.
     * For saving dialogs, this will usually be pre-entered into the name field.
     *
     * If a file with this name already exists in the directory set via
     * [property`Gtk`.FileDialog:initial-folder], the dialog should preselect it.
     * @param name a UTF8 string
     */
    setInitialName(name: string | null): void
    /**
     * Sets whether the file chooser dialog
     * blocks interaction with the parent window
     * while it is presented.
     * @param modal the new value
     */
    setModal(modal: boolean): void
    /**
     * Sets the title that will be shown on the
     * file chooser dialog.
     * @param title the new title
     */
    setTitle(title: string): void

    // Class property signals of Gtk-4.0.Gtk.FileDialog

    connect(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accept-label", ...args: any[]): void
    connect(
      sigName: "notify::default-filter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-filter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-filter", ...args: any[]): void
    connect(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filters",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filters",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filters", ...args: any[]): void
    connect(
      sigName: "notify::initial-file",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::initial-file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::initial-file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::initial-file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::initial-file", ...args: any[]): void
    connect(
      sigName: "notify::initial-folder",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::initial-folder",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::initial-folder",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::initial-folder",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::initial-folder", ...args: any[]): void
    connect(
      sigName: "notify::initial-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::initial-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::initial-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::initial-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::initial-name", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkFileDialog` object collects the arguments that
   * are needed to present a file chooser dialog to the
   * user, such as a title for the dialog and whether it
   * should be modal.
   *
   * The dialog is shown with [method`Gtk`.FileDialog.open],
   * [method`Gtk`.FileDialog.save], etc. These APIs follow the
   * GIO async pattern, and the result can be obtained by calling
   * the corresponding finish function, for example
   * [method`Gtk`.FileDialog.open_finish].
   * @class
   */
  class FileDialog extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.FileDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.FileDialog

    constructor(config?: FileDialog.ConstructorProperties)
    /**
     * Creates a new `GtkFileDialog` object.
     * @constructor
     * @returns the new `GtkFileDialog`
     */
    constructor()
    /**
     * Creates a new `GtkFileDialog` object.
     * @constructor
     * @returns the new `GtkFileDialog`
     */
    static new(): FileDialog
    _init(config?: FileDialog.ConstructorProperties): void
  }

  module FileFilter {
    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        Filter.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FileFilter

      /**
       * The MIME types that this filter matches.
       */
      mime_types?: string[] | null
      /**
       * The human-readable name of the filter.
       *
       * This is the string that will be displayed in the file chooser
       * user interface if there is a selectable list of filters.
       */
      name?: string | null
      /**
       * The patterns that this filter matches.
       */
      patterns?: string[] | null
      /**
       * The suffixes that this filter matches.
       */
      suffixes?: string[] | null
    }
  }

  interface FileFilter extends Buildable {
    // Own properties of Gtk-4.0.Gtk.FileFilter

    /**
     * The MIME types that this filter matches.
     */
    readonly mimeTypes: string[]
    /**
     * The human-readable name of the filter.
     *
     * This is the string that will be displayed in the file chooser
     * user interface if there is a selectable list of filters.
     */
    name: string | null
    /**
     * The patterns that this filter matches.
     */
    readonly patterns: string[]
    /**
     * The suffixes that this filter matches.
     */
    readonly suffixes: string[]
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FileFilter

    /**
     * Adds a rule allowing a given mime type to `filter`.
     * @param mimeType name of a MIME type
     */
    addMimeType(mimeType: string): void
    /**
     * Adds a rule allowing a shell style glob to a filter.
     *
     * Note that it depends on the platform whether pattern
     * matching ignores case or not. On Windows, it does, on
     * other platforms, it doesn't.
     * @param pattern a shell style glob
     */
    addPattern(pattern: string): void
    /**
     * Adds a rule allowing image files in the formats supported
     * by GdkPixbuf.
     *
     * This is equivalent to calling [method`Gtk`.FileFilter.add_mime_type]
     * for all the supported mime types.
     */
    addPixbufFormats(): void
    /**
     * Adds a suffix match rule to a filter.
     *
     * This is similar to adding a match for the pattern
     * "*.`suffix"`.
     *
     * In contrast to pattern matches, suffix matches
     * are *always* case-insensitive.
     * @param suffix filename suffix to match
     */
    addSuffix(suffix: string): void
    /**
     * Gets the attributes that need to be filled in for the `GFileInfo`
     * passed to this filter.
     *
     * This function will not typically be used by applications;
     * it is intended principally for use in the implementation
     * of `GtkFileChooser`.
     * @returns the attributes
     */
    getAttributes(): string[]
    /**
     * Gets the human-readable name for the filter.
     *
     * See [method`Gtk`.FileFilter.set_name].
     * @returns The human-readable name of the filter
     */
    getName(): string | null
    /**
     * Sets a human-readable name of the filter.
     *
     * This is the string that will be displayed in the file chooser
     * if there is a selectable list of filters.
     * @param name the human-readable-name for the filter, or %NULL   to remove any existing name.
     */
    setName(name: string | null): void
    /**
     * Serialize a file filter to an `a{sv}` variant.
     * @returns a new, floating, `GVariant`
     */
    toGvariant(): GLib.Variant

    // Class property signals of Gtk-4.0.Gtk.FileFilter

    connect(
      sigName: "notify::mime-types",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mime-types",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mime-types",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mime-types",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mime-types", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::patterns",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::patterns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::patterns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::patterns",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::patterns", ...args: any[]): void
    connect(
      sigName: "notify::suffixes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suffixes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suffixes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suffixes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suffixes", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFileFilter` filters files by name or mime type.
   *
   * `GtkFileFilter` can be used to restrict the files being shown in a
   * `GtkFileChooser`. Files can be filtered based on their name (with
   * [method`Gtk`.FileFilter.add_pattern] or [method`Gtk`.FileFilter.add_suffix])
   * or on their mime type (with [method`Gtk`.FileFilter.add_mime_type]).
   *
   * Filtering by mime types handles aliasing and subclassing of mime
   * types; e.g. a filter for text/plain also matches a file with mime
   * type application/rtf, since application/rtf is a subclass of
   * text/plain. Note that `GtkFileFilter` allows wildcards for the
   * subtype of a mime type, so you can e.g. filter for image/\*.
   *
   * Normally, file filters are used by adding them to a `GtkFileChooser`
   * (see [method`Gtk`.FileChooser.add_filter]), but it is also possible to
   * manually use a file filter on any [class`Gtk`.FilterListModel] containing
   * `GFileInfo` objects.
   *
   * # GtkFileFilter as GtkBuildable
   *
   * The `GtkFileFilter` implementation of the `GtkBuildable` interface
   * supports adding rules using the `<mime-types>` and `<patterns>` and
   * `<suffixes>` elements and listing the rules within. Specifying a
   * `<mime-type>` or `<pattern>` or `<suffix>` has the same effect as
   * as calling
   * [method`Gtk`.FileFilter.add_mime_type] or
   * [method`Gtk`.FileFilter.add_pattern] or
   * [method`Gtk`.FileFilter.add_suffix].
   *
   * An example of a UI definition fragment specifying `GtkFileFilter`
   * rules:
   * ```xml
   * <object class="GtkFileFilter">
   *   <property name="name" translatable="yes">Text and Images</property>
   *   <mime-types>
   *     <mime-type>text/plain</mime-type>
   *     <mime-type>image/ *</mime-type>
   *   </mime-types>
   *   <patterns>
   *     <pattern>*.txt</pattern>
   *   </patterns>
   *   <suffixes>
   *     <suffix>png</suffix>
   *   </suffixes>
   * </object>
   * ```
   * @class
   */
  class FileFilter extends Filter {
    // Own properties of Gtk-4.0.Gtk.FileFilter

    static name: string

    // Constructors of Gtk-4.0.Gtk.FileFilter

    constructor(config?: FileFilter.ConstructorProperties)
    /**
     * Creates a new `GtkFileFilter` with no rules added to it.
     *
     * Such a filter doesn’t accept any files, so is not
     * particularly useful until you add rules with
     * [method`Gtk`.FileFilter.add_mime_type],
     * [method`Gtk`.FileFilter.add_pattern],
     * [method`Gtk`.FileFilter.add_suffix] or
     * [method`Gtk`.FileFilter.add_pixbuf_formats].
     *
     * To create a filter that accepts any file, use:
     * ```c
     * GtkFileFilter *filter = gtk_file_filter_new ();
     * gtk_file_filter_add_pattern (filter, "*");
     * ```
     * @constructor
     * @returns a new `GtkFileFilter`
     */
    constructor()
    /**
     * Creates a new `GtkFileFilter` with no rules added to it.
     *
     * Such a filter doesn’t accept any files, so is not
     * particularly useful until you add rules with
     * [method`Gtk`.FileFilter.add_mime_type],
     * [method`Gtk`.FileFilter.add_pattern],
     * [method`Gtk`.FileFilter.add_suffix] or
     * [method`Gtk`.FileFilter.add_pixbuf_formats].
     *
     * To create a filter that accepts any file, use:
     * ```c
     * GtkFileFilter *filter = gtk_file_filter_new ();
     * gtk_file_filter_add_pattern (filter, "*");
     * ```
     * @constructor
     * @returns a new `GtkFileFilter`
     */
    static new(): FileFilter
    /**
     * Deserialize a file filter from a `GVariant`.
     *
     * The variant must be in the format produced by
     * [method`Gtk`.FileFilter.to_gvariant].
     * @constructor
     * @param variant an `a{sv}` `GVariant`
     * @returns a new `GtkFileFilter` object
     */
    static newFromGvariant(variant: GLib.Variant): FileFilter
    _init(config?: FileFilter.ConstructorProperties): void
  }

  module FileLauncher {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FileLauncher

      /**
       * Whether to ask the user to choose an app for opening the file. If `FALSE`,
       * the file might be opened with a default app or the previous choice.
       */
      always_ask?: boolean | null
      /**
       * The file to launch.
       */
      file?: Gio.File | null
      /**
       * Whether to make the file writable for the handler.
       */
      writable?: boolean | null
    }
  }

  interface FileLauncher {
    // Own properties of Gtk-4.0.Gtk.FileLauncher

    /**
     * Whether to ask the user to choose an app for opening the file. If `FALSE`,
     * the file might be opened with a default app or the previous choice.
     */
    alwaysAsk: boolean
    /**
     * The file to launch.
     */
    file: Gio.File
    /**
     * Whether to make the file writable for the handler.
     */
    writable: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FileLauncher

    /**
     * Returns whether to ask the user to choose an app for opening the file.
     * @returns `TRUE` if always asking for app
     */
    getAlwaysAsk(): boolean
    /**
     * Gets the file that will be opened.
     * @returns the file
     */
    getFile(): Gio.File | null
    /**
     * Returns whether to make the file writable for the handler.
     * @returns `TRUE` if the file will be made writable
     */
    getWritable(): boolean
    /**
     * Launch an application to open the file.
     *
     * This may present an app chooser dialog to the user.
     *
     * The `callback` will be called when the operation is completed.
     * It should call [method`Gtk`.FileLauncher.launch_finish] to obtain
     * the result.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    launch(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FileLauncher.launch] call and
     * returns the result.
     * @param result a `GAsyncResult`
     * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
     */
    launchFinish(result: Gio.AsyncResult): boolean
    /**
     * Launch a file manager to show the file in its parent directory.
     *
     * This is only supported native files. It will fail if `file`
     * is e.g. a http:// uri.
     *
     * The `callback` will be called when the operation is completed.
     * It should call [method`Gtk`.FileLauncher.open_containing_folder_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    openContainingFolder(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FileLauncher.open_containing_folder]
     * call and returns the result.
     * @param result a `GAsyncResult`
     * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
     */
    openContainingFolderFinish(result: Gio.AsyncResult): boolean
    /**
     * Sets whether to awlays ask the user to choose an app for opening the file.
     * If `FALSE`, the file might be opened with a default app or the previous choice.
     * @param alwaysAsk a `gboolean`
     */
    setAlwaysAsk(alwaysAsk: boolean): void
    /**
     * Sets the file that will be opened.
     * @param file a `GFile`
     */
    setFile(file: Gio.File | null): void
    /**
     * Sets whether to make the file writable for the handler.
     * @param writable a `gboolean`
     */
    setWritable(writable: boolean): void

    // Class property signals of Gtk-4.0.Gtk.FileLauncher

    connect(
      sigName: "notify::always-ask",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::always-ask",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::always-ask",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::always-ask",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::always-ask", ...args: any[]): void
    connect(sigName: "notify::file", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file", ...args: any[]): void
    connect(
      sigName: "notify::writable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::writable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::writable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::writable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::writable", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkFileLauncher` object collects the arguments that are needed to open a
   * file with an application.
   *
   * Depending on system configuration, user preferences and available APIs, this
   * may or may not show an app chooser dialog or launch the default application
   * right away.
   *
   * The operation is started with the [method`Gtk`.FileLauncher.launch] function.
   * This API follows the GIO async pattern, and the result can be obtained by
   * calling [method`Gtk`.FileLauncher.launch_finish].
   *
   * To launch uris that don't represent files, use [class`Gtk`.UriLauncher].
   * @class
   */
  class FileLauncher extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.FileLauncher

    static name: string

    // Constructors of Gtk-4.0.Gtk.FileLauncher

    constructor(config?: FileLauncher.ConstructorProperties)
    /**
     * Creates a new `GtkFileLauncher` object.
     * @constructor
     * @param file the file to open
     * @returns the new `GtkFileLauncher`
     */
    constructor(file: Gio.File | null)
    /**
     * Creates a new `GtkFileLauncher` object.
     * @constructor
     * @param file the file to open
     * @returns the new `GtkFileLauncher`
     */
    static new(file: Gio.File | null): FileLauncher
    _init(config?: FileLauncher.ConstructorProperties): void
  }

  module Filter {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (change: FilterChange): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Filter {
    // Own properties of Gtk-4.0.Gtk.Filter

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Filter

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.Filter

    /**
     * Notifies all users of the filter that it has changed.
     *
     * This emits the [signal`Gtk`.Filter::changed] signal. Users
     * of the filter should then check items again via
     * [method`Gtk`.Filter.match].
     *
     * Depending on the `change` parameter, not all items need to
     * be changed, but only some. Refer to the [enum`Gtk`.FilterChange]
     * documentation for details.
     *
     * This function is intended for implementers of `GtkFilter`
     * subclasses and should not be called from other functions.
     * @param change How the filter changed
     */
    changed(change: FilterChange): void
    // Has conflict: getStrictness(): FilterMatch
    // Has conflict: match(item: GObject.Object): boolean

    // Own virtual methods of Gtk-4.0.Gtk.Filter

    /**
     * Gets the known strictness of `filters`.
     *
     * If the strictness is not known, %GTK_FILTER_MATCH_SOME is returned.
     *
     * This value may change after emission of the [signal`Gtk`.Filter::changed]
     * signal.
     *
     * This function is meant purely for optimization purposes, filters can
     * choose to omit implementing it, but `GtkFilterListModel` uses it.
     * @virtual
     * @returns the strictness of @self
     */
    getStrictness(): FilterMatch
    /**
     * Checks if the given `item` is matched by the filter or not.
     * @virtual
     * @param item The item to check
     * @returns %TRUE if the filter matches the item and a filter model should   keep it, %FALSE if not.
     */
    match(item: GObject.Object | null): boolean

    // Own signals of Gtk-4.0.Gtk.Filter

    connect(sigName: "changed", callback: Filter.ChangedSignalCallback): number
    on(
      sigName: "changed",
      callback: Filter.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Filter.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Filter.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Filter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkFilter` object describes the filtering to be performed by a
   * [class`Gtk`.FilterListModel].
   *
   * The model will use the filter to determine if it should include items
   * or not by calling [method`Gtk`.Filter.match] for each item and only
   * keeping the ones that the function returns %TRUE for.
   *
   * Filters may change what items they match through their lifetime. In that
   * case, they will emit the [signal`Gtk`.Filter::changed] signal to notify
   * that previous filter results are no longer valid and that items should
   * be checked again via [method`Gtk`.Filter.match].
   *
   * GTK provides various pre-made filter implementations for common filtering
   * operations. These filters often include properties that can be linked to
   * various widgets to easily allow searches.
   *
   * However, in particular for large lists or complex search methods, it is
   * also possible to subclass `GtkFilter` and provide one's own filter.
   * @class
   */
  class Filter extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Filter

    static name: string

    // Constructors of Gtk-4.0.Gtk.Filter

    constructor(config?: Filter.ConstructorProperties)
    _init(config?: Filter.ConstructorProperties): void
  }

  module FilterListModel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        SectionModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FilterListModel

      /**
       * The filter for this model.
       */
      filter?: Filter | null
      /**
       * If the model should filter items incrementally.
       */
      incremental?: boolean | null
      /**
       * The model being filtered.
       */
      model?: Gio.ListModel | null
    }
  }

  interface FilterListModel extends Gio.ListModel, SectionModel {
    // Own properties of Gtk-4.0.Gtk.FilterListModel

    /**
     * The filter for this model.
     */
    filter: Filter
    /**
     * If the model should filter items incrementally.
     */
    incremental: boolean
    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The model being filtered.
     */
    model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    /**
     * Number of items not yet filtered.
     */
    readonly pending: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FilterListModel

    /**
     * Gets the `GtkFilter` currently set on `self`.
     * @returns The filter currently in use
     */
    getFilter(): Filter | null
    /**
     * Returns whether incremental filtering is enabled.
     *
     * See [method`Gtk`.FilterListModel.set_incremental].
     * @returns %TRUE if incremental filtering is enabled
     */
    getIncremental(): boolean
    /**
     * Gets the model currently filtered or %NULL if none.
     * @returns The model that gets filtered
     */
    getModel(): Gio.ListModel | null
    /**
     * Returns the number of items that have not been filtered yet.
     *
     * You can use this value to check if `self` is busy filtering by
     * comparing the return value to 0 or you can compute the percentage
     * of the filter remaining by dividing the return value by the total
     * number of items in the underlying model:
     *
     * ```c
     * pending = gtk_filter_list_model_get_pending (self);
     * model = gtk_filter_list_model_get_model (self);
     * percentage = pending / (double) g_list_model_get_n_items (model);
     * ```
     *
     * If no filter operation is ongoing - in particular when
     * [property`Gtk`.FilterListModel:incremental] is %FALSE - this
     * function returns 0.
     * @returns The number of items not yet filtered
     */
    getPending(): number
    /**
     * Sets the filter used to filter items.
     * @param filter filter to use
     */
    setFilter(filter: Filter | null): void
    /**
     * Sets the filter model to do an incremental sort.
     *
     * When incremental filtering is enabled, the `GtkFilterListModel` will not
     * run filters immediately, but will instead queue an idle handler that
     * incrementally filters the items and adds them to the list. This of course
     * means that items are not instantly added to the list, but only appear
     * incrementally.
     *
     * When your filter blocks the UI while filtering, you might consider
     * turning this on. Depending on your model and filters, this may become
     * interesting around 10,000 to 100,000 items.
     *
     * By default, incremental filtering is disabled.
     *
     * See [method`Gtk`.FilterListModel.get_pending] for progress information
     * about an ongoing incremental filtering operation.
     * @param incremental %TRUE to enable incremental filtering
     */
    setIncremental(incremental: boolean): void
    /**
     * Sets the model to be filtered.
     *
     * Note that GTK makes no effort to ensure that `model` conforms to
     * the item type of `self`. It assumes that the caller knows what they
     * are doing and have set up an appropriate filter to ensure that item
     * types match.
     * @param model The model to be filtered
     */
    setModel(model: Gio.ListModel | null): void

    // Class property signals of Gtk-4.0.Gtk.FilterListModel

    connect(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filter", ...args: any[]): void
    connect(
      sigName: "notify::incremental",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::incremental",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::incremental",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::incremental",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::incremental", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::pending",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pending",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pending",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pending",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pending", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFilterListModel` is a list model that filters the elements of
   * the underlying model according to a `GtkFilter`.
   *
   * It hides some elements from the other model according to
   * criteria given by a `GtkFilter`.
   *
   * The model can be set up to do incremental filtering, so that
   * filtering long lists doesn't block the UI. See
   * [method`Gtk`.FilterListModel.set_incremental] for details.
   *
   * `GtkFilterListModel` passes through sections from the underlying model.
   * @class
   */
  class FilterListModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.FilterListModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.FilterListModel

    constructor(config?: FilterListModel.ConstructorProperties)
    /**
     * Creates a new `GtkFilterListModel` that will filter `model` using the given
     * `filter`.
     * @constructor
     * @param model the model to sort
     * @param filter filter
     * @returns a new `GtkFilterListModel`
     */
    constructor(model: Gio.ListModel | null, filter: Filter | null)
    /**
     * Creates a new `GtkFilterListModel` that will filter `model` using the given
     * `filter`.
     * @constructor
     * @param model the model to sort
     * @param filter filter
     * @returns a new `GtkFilterListModel`
     */
    static new(
      model: Gio.ListModel | null,
      filter: Filter | null
    ): FilterListModel
    _init(config?: FilterListModel.ConstructorProperties): void
  }

  module Fixed {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {}
  }

  interface Fixed extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Fixed

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Fixed

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.Fixed

    /**
     * Retrieves the translation transformation of the
     * given child `GtkWidget` in the `GtkFixed`.
     *
     * See also: [method`Gtk`.Fixed.get_child_transform].
     * @param widget a child of `fixed`
     */
    getChildPosition(widget: Widget): [/* x */ number, /* y */ number]
    /**
     * Retrieves the transformation for `widget` set using
     * gtk_fixed_set_child_transform().
     * @param widget a `GtkWidget`, child of `fixed`
     * @returns a `GskTransform`
     */
    getChildTransform(widget: Widget): Gsk.Transform | null
    /**
     * Sets a translation transformation to the given `x` and `y`
     * coordinates to the child `widget` of the `GtkFixed`.
     * @param widget the child widget
     * @param x the horizontal position to move the widget to
     * @param y the vertical position to move the widget to
     */
    move(widget: Widget, x: number, y: number): void
    /**
     * Adds a widget to a `GtkFixed` at the given position.
     * @param widget the widget to add
     * @param x the horizontal position to place the widget at
     * @param y the vertical position to place the widget at
     */
    put(widget: Widget, x: number, y: number): void
    /**
     * Removes a child from `fixed`.
     * @param widget the child widget to remove
     */
    remove(widget: Widget): void
    /**
     * Sets the transformation for `widget`.
     *
     * This is a convenience function that retrieves the
     * [class`Gtk`.FixedLayoutChild] instance associated to
     * `widget` and calls [method`Gtk`.FixedLayoutChild.set_transform].
     * @param widget a `GtkWidget`, child of `fixed`
     * @param transform the transformation assigned to `widget`   to reset `widget'`s transform
     */
    setChildTransform(widget: Widget, transform: Gsk.Transform | null): void

    // Class property signals of Gtk-4.0.Gtk.Fixed

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFixed` places its child widgets at fixed positions and with fixed sizes.
   *
   * `GtkFixed` performs no automatic layout management.
   *
   * For most applications, you should not use this container! It keeps
   * you from having to learn about the other GTK containers, but it
   * results in broken applications.  With `GtkFixed`, the following
   * things will result in truncated text, overlapping widgets, and
   * other display bugs:
   *
   * - Themes, which may change widget sizes.
   *
   * - Fonts other than the one you used to write the app will of course
   *   change the size of widgets containing text; keep in mind that
   *   users may use a larger font because of difficulty reading the
   *   default, or they may be using a different OS that provides different fonts.
   *
   * - Translation of text into other languages changes its size. Also,
   *   display of non-English text will use a different font in many
   *   cases.
   *
   * In addition, `GtkFixed` does not pay attention to text direction and
   * thus may produce unwanted results if your app is run under right-to-left
   * languages such as Hebrew or Arabic. That is: normally GTK will order
   * containers appropriately for the text direction, e.g. to put labels to
   * the right of the thing they label when using an RTL language, but it can’t
   * do that with `GtkFixed`. So if you need to reorder widgets depending on
   * the text direction, you would need to manually detect it and adjust child
   * positions accordingly.
   *
   * Finally, fixed positioning makes it kind of annoying to add/remove
   * UI elements, since you have to reposition all the other elements. This
   * is a long-term maintenance problem for your application.
   *
   * If you know none of these things are an issue for your application,
   * and prefer the simplicity of `GtkFixed`, by all means use the
   * widget. But you should be aware of the tradeoffs.
   * @class
   */
  class Fixed extends Widget {
    // Own properties of Gtk-4.0.Gtk.Fixed

    static name: string

    // Constructors of Gtk-4.0.Gtk.Fixed

    constructor(config?: Fixed.ConstructorProperties)
    /**
     * Creates a new `GtkFixed`.
     * @constructor
     * @returns a new `GtkFixed`.
     */
    constructor()
    /**
     * Creates a new `GtkFixed`.
     * @constructor
     * @returns a new `GtkFixed`.
     */
    static new(): Fixed
    _init(config?: Fixed.ConstructorProperties): void
  }

  module FixedLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends LayoutManager.ConstructorProperties {}
  }

  interface FixedLayout {
    // Own properties of Gtk-4.0.Gtk.FixedLayout

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.FixedLayout

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFixedLayout` is a layout manager which can place child widgets
   * at fixed positions.
   *
   * Most applications should never use this layout manager; fixed positioning
   * and sizing requires constant recalculations on where children need to be
   * positioned and sized. Other layout managers perform this kind of work
   * internally so that application developers don't need to do it. Specifically,
   * widgets positioned in a fixed layout manager will need to take into account:
   *
   * - Themes, which may change widget sizes.
   *
   * - Fonts other than the one you used to write the app will of course
   *   change the size of widgets containing text; keep in mind that
   *   users may use a larger font because of difficulty reading the
   *   default, or they may be using a different OS that provides different
   *   fonts.
   *
   * - Translation of text into other languages changes its size. Also,
   *   display of non-English text will use a different font in many
   *   cases.
   *
   * In addition, `GtkFixedLayout` does not pay attention to text direction and
   * thus may produce unwanted results if your app is run under right-to-left
   * languages such as Hebrew or Arabic. That is: normally GTK will order
   * containers appropriately depending on the text direction, e.g. to put labels
   * to the right of the thing they label when using an RTL language;
   * `GtkFixedLayout` won't be able to do that for you.
   *
   * Finally, fixed positioning makes it kind of annoying to add/remove UI
   * elements, since you have to reposition all the other  elements. This is a
   * long-term maintenance problem for your application.
   * @class
   */
  class FixedLayout extends LayoutManager {
    // Own properties of Gtk-4.0.Gtk.FixedLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.FixedLayout

    constructor(config?: FixedLayout.ConstructorProperties)
    /**
     * Creates a new `GtkFixedLayout`.
     * @constructor
     * @returns the newly created `GtkFixedLayout`
     */
    constructor()
    /**
     * Creates a new `GtkFixedLayout`.
     * @constructor
     * @returns the newly created `GtkFixedLayout`
     */
    static new(): FixedLayout
    _init(config?: FixedLayout.ConstructorProperties): void
  }

  module FixedLayoutChild {
    // Constructor properties interface

    interface ConstructorProperties extends LayoutChild.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FixedLayoutChild

      /**
       * The transform of the child.
       */
      transform?: Gsk.Transform | null
    }
  }

  interface FixedLayoutChild {
    // Own properties of Gtk-4.0.Gtk.FixedLayoutChild

    /**
     * The transform of the child.
     */
    transform: Gsk.Transform
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FixedLayoutChild

    /**
     * Retrieves the transformation of the child.
     * @returns a `GskTransform`
     */
    getTransform(): Gsk.Transform | null
    /**
     * Sets the transformation of the child of a `GtkFixedLayout`.
     * @param transform a `GskTransform`
     */
    setTransform(transform: Gsk.Transform): void

    // Class property signals of Gtk-4.0.Gtk.FixedLayoutChild

    connect(
      sigName: "notify::transform",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transform",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transform",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transform",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transform", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child-widget", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkLayoutChild` subclass for children in a `GtkFixedLayout`.
   * @class
   */
  class FixedLayoutChild extends LayoutChild {
    // Own properties of Gtk-4.0.Gtk.FixedLayoutChild

    static name: string

    // Constructors of Gtk-4.0.Gtk.FixedLayoutChild

    constructor(config?: FixedLayoutChild.ConstructorProperties)
    _init(config?: FixedLayoutChild.ConstructorProperties): void
  }

  module FlattenListModel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        SectionModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FlattenListModel

      /**
       * The model being flattened.
       */
      model?: Gio.ListModel | null
    }
  }

  interface FlattenListModel extends Gio.ListModel, SectionModel {
    // Own properties of Gtk-4.0.Gtk.FlattenListModel

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The model being flattened.
     */
    model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FlattenListModel

    /**
     * Gets the model set via gtk_flatten_list_model_set_model().
     * @returns The model flattened by @self
     */
    getModel(): Gio.ListModel | null
    /**
     * Returns the model containing the item at the given position.
     * @param position a position
     * @returns the model containing the item at @position
     */
    getModelForItem(position: number): Gio.ListModel | null
    /**
     * Sets a new model to be flattened.
     * @param model the new model
     */
    setModel(model: Gio.ListModel | null): void

    // Class property signals of Gtk-4.0.Gtk.FlattenListModel

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFlattenListModel` is a list model that concatenates other list models.
   *
   * `GtkFlattenListModel` takes a list model containing list models, and flattens
   * it into a single model. Each list model becomes a section in the single model.
   * @class
   */
  class FlattenListModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.FlattenListModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.FlattenListModel

    constructor(config?: FlattenListModel.ConstructorProperties)
    /**
     * Creates a new `GtkFlattenListModel` that flattens `list`.
     * @constructor
     * @param model the model to be flattened
     * @returns a new `GtkFlattenListModel`
     */
    constructor(model: Gio.ListModel | null)
    /**
     * Creates a new `GtkFlattenListModel` that flattens `list`.
     * @constructor
     * @param model the model to be flattened
     * @returns a new `GtkFlattenListModel`
     */
    static new(model: Gio.ListModel | null): FlattenListModel
    _init(config?: FlattenListModel.ConstructorProperties): void
  }

  module FlowBox {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate-cursor-child`
     */
    interface ActivateCursorChildSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `child-activated`
     */
    interface ChildActivatedSignalCallback {
      (child: FlowBoxChild): void
    }

    /**
     * Signal callback interface for `move-cursor`
     */
    interface MoveCursorSignalCallback {
      (
        step: MovementStep,
        count: number,
        extend: boolean,
        modify: boolean
      ): boolean
    }

    /**
     * Signal callback interface for `select-all`
     */
    interface SelectAllSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `selected-children-changed`
     */
    interface SelectedChildrenChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `toggle-cursor-child`
     */
    interface ToggleCursorChildSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `unselect-all`
     */
    interface UnselectAllSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FlowBox

      accept_unpaired_release?: boolean | null
      /**
       * Determines whether children can be activated with a single
       * click, or require a double-click.
       */
      activate_on_single_click?: boolean | null
      /**
       * The amount of horizontal space between two children.
       */
      column_spacing?: number | null
      /**
       * Determines whether all children should be allocated the
       * same size.
       */
      homogeneous?: boolean | null
      /**
       * The maximum amount of children to request space for consecutively
       * in the given orientation.
       */
      max_children_per_line?: number | null
      /**
       * The minimum number of children to allocate consecutively
       * in the given orientation.
       *
       * Setting the minimum children per line ensures
       * that a reasonably small height will be requested
       * for the overall minimum width of the box.
       */
      min_children_per_line?: number | null
      /**
       * The amount of vertical space between two children.
       */
      row_spacing?: number | null
      /**
       * The selection mode used by the flow box.
       */
      selection_mode?: SelectionMode | null
    }
  }

  interface FlowBox
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.FlowBox

    acceptUnpairedRelease: boolean
    /**
     * Determines whether children can be activated with a single
     * click, or require a double-click.
     */
    activateOnSingleClick: boolean
    /**
     * The amount of horizontal space between two children.
     */
    columnSpacing: number
    /**
     * Determines whether all children should be allocated the
     * same size.
     */
    homogeneous: boolean
    /**
     * The maximum amount of children to request space for consecutively
     * in the given orientation.
     */
    maxChildrenPerLine: number
    /**
     * The minimum number of children to allocate consecutively
     * in the given orientation.
     *
     * Setting the minimum children per line ensures
     * that a reasonably small height will be requested
     * for the overall minimum width of the box.
     */
    minChildrenPerLine: number
    /**
     * The amount of vertical space between two children.
     */
    rowSpacing: number
    /**
     * The selection mode used by the flow box.
     */
    selectionMode: SelectionMode
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FlowBox

    /**
     * Adds `child` to the end of `self`.
     *
     * If a sort function is set, the widget will
     * actually be inserted at the calculated position.
     *
     * See also: [method`Gtk`.FlowBox.insert].
     * @param child the `GtkWidget` to add
     */
    append(child: Widget): void
    /**
     * Binds `model` to `box`.
     *
     * If `box` was already bound to a model, that previous binding is
     * destroyed.
     *
     * The contents of `box` are cleared and then filled with widgets that
     * represent items from `model`. `box` is updated whenever `model` changes.
     * If `model` is %NULL, `box` is left empty.
     *
     * It is undefined to add or remove widgets directly (for example, with
     * [method`Gtk`.FlowBox.insert]) while `box` is bound to a model.
     *
     * Note that using a model is incompatible with the filtering and sorting
     * functionality in `GtkFlowBox`. When using a model, filtering and sorting
     * should be implemented by the model.
     * @param model the `GListModel` to be bound to `box`
     * @param createWidgetFunc a function that creates widgets for items
     */
    bindModel(
      model: Gio.ListModel | null,
      createWidgetFunc: FlowBoxCreateWidgetFunc
    ): void
    /**
     * Returns whether children activate on single clicks.
     * @returns %TRUE if children are activated on single click,   %FALSE otherwise
     */
    getActivateOnSingleClick(): boolean
    /**
     * Gets the nth child in the `box`.
     * @param idx the position of the child
     * @returns the child widget, which will   always be a `GtkFlowBoxChild` or %NULL in case no child widget   with the given index exists.
     */
    getChildAtIndex(idx: number): FlowBoxChild | null
    /**
     * Gets the child in the (`x,` `y)` position.
     *
     * Both `x` and `y` are assumed to be relative to the origin of `box`.
     * @param x the x coordinate of the child
     * @param y the y coordinate of the child
     * @returns the child widget, which will   always be a `GtkFlowBoxChild` or %NULL in case no child widget   exists for the given x and y coordinates.
     */
    getChildAtPos(x: number, y: number): FlowBoxChild | null
    /**
     * Gets the horizontal spacing.
     * @returns the horizontal spacing
     */
    getColumnSpacing(): number
    /**
     * Returns whether the box is homogeneous.
     * @returns %TRUE if the box is homogeneous.
     */
    getHomogeneous(): boolean
    /**
     * Gets the maximum number of children per line.
     * @returns the maximum number of children per line
     */
    getMaxChildrenPerLine(): number
    /**
     * Gets the minimum number of children per line.
     * @returns the minimum number of children per line
     */
    getMinChildrenPerLine(): number
    /**
     * Gets the vertical spacing.
     * @returns the vertical spacing
     */
    getRowSpacing(): number
    /**
     * Creates a list of all selected children.
     * @returns A `GList` containing the `GtkWidget` for each selected child.   Free with g_list_free() when done.
     */
    getSelectedChildren(): FlowBoxChild[]
    /**
     * Gets the selection mode of `box`.
     * @returns the `GtkSelectionMode`
     */
    getSelectionMode(): SelectionMode
    /**
     * Inserts the `widget` into `box` at `position`.
     *
     * If a sort function is set, the widget will actually be inserted
     * at the calculated position.
     *
     * If `position` is -1, or larger than the total number of children
     * in the `box,` then the `widget` will be appended to the end.
     * @param widget the `GtkWidget` to add
     * @param position the position to insert `child` in
     */
    insert(widget: Widget, position: number): void
    /**
     * Updates the filtering for all children.
     *
     * Call this function when the result of the filter
     * function on the `box` is changed due to an external
     * factor. For instance, this would be used if the
     * filter function just looked for a specific search
     * term, and the entry with the string has changed.
     */
    invalidateFilter(): void
    /**
     * Updates the sorting for all children.
     *
     * Call this when the result of the sort function on
     * `box` is changed due to an external factor.
     */
    invalidateSort(): void
    /**
     * Adds `child` to the start of `self`.
     *
     * If a sort function is set, the widget will
     * actually be inserted at the calculated position.
     *
     * See also: [method`Gtk`.FlowBox.insert].
     * @param child the `GtkWidget` to add
     */
    prepend(child: Widget): void
    /**
     * Removes a child from `box`.
     * @param widget the child widget to remove
     */
    remove(widget: Widget): void
    /**
     * Removes all children from `box`.
     *
     * This function does nothing if `box` is backed by a model.
     */
    removeAll(): void
    /**
     * Select all children of `box,` if the selection
     * mode allows it.
     */
    selectAll(): void
    /**
     * Selects a single child of `box,` if the selection
     * mode allows it.
     * @param child a child of `box`
     */
    selectChild(child: FlowBoxChild): void
    /**
     * Calls a function for each selected child.
     *
     * Note that the selection cannot be modified from within
     * this function.
     * @param func the function to call for each selected child
     */
    selectedForeach(func: FlowBoxForeachFunc): void
    /**
     * If `single` is %TRUE, children will be activated when you click
     * on them, otherwise you need to double-click.
     * @param single %TRUE to emit child-activated on a single click
     */
    setActivateOnSingleClick(single: boolean): void
    /**
     * Sets the horizontal space to add between children.
     * @param spacing the spacing to use
     */
    setColumnSpacing(spacing: number): void
    /**
     * By setting a filter function on the `box` one can decide dynamically
     * which of the children to show.
     *
     * For instance, to implement a search function that only shows the
     * children matching the search terms.
     *
     * The `filter_func` will be called for each child after the call, and
     * it will continue to be called each time a child changes (via
     * [method`Gtk`.FlowBoxChild.changed]) or when
     * [method`Gtk`.FlowBox.invalidate_filter] is called.
     *
     * Note that using a filter function is incompatible with using a model
     * (see [method`Gtk`.FlowBox.bind_model]).
     * @param filterFunc callback that   lets you filter which children to show
     */
    setFilterFunc(filterFunc: FlowBoxFilterFunc | null): void
    /**
     * Hooks up an adjustment to focus handling in `box`.
     *
     * The adjustment is also used for autoscrolling during
     * rubberband selection. See [method`Gtk`.ScrolledWindow.get_hadjustment]
     * for a typical way of obtaining the adjustment, and
     * [method`Gtk`.FlowBox.set_vadjustment] for setting the vertical
     * adjustment.
     *
     * The adjustments have to be in pixel units and in the same
     * coordinate system as the allocation for immediate children
     * of the box.
     * @param adjustment an adjustment which should be adjusted    when the focus is moved among the descendents of `container`
     */
    setHadjustment(adjustment: Adjustment): void
    /**
     * Sets whether or not all children of `box` are given
     * equal space in the box.
     * @param homogeneous %TRUE to create equal allotments,   %FALSE for variable allotments
     */
    setHomogeneous(homogeneous: boolean): void
    /**
     * Sets the maximum number of children to request and
     * allocate space for in `box’`s orientation.
     *
     * Setting the maximum number of children per line
     * limits the overall natural size request to be no more
     * than `n_children` children long in the given orientation.
     * @param nChildren the maximum number of children per line
     */
    setMaxChildrenPerLine(nChildren: number): void
    /**
     * Sets the minimum number of children to line up
     * in `box’`s orientation before flowing.
     * @param nChildren the minimum number of children per line
     */
    setMinChildrenPerLine(nChildren: number): void
    /**
     * Sets the vertical space to add between children.
     * @param spacing the spacing to use
     */
    setRowSpacing(spacing: number): void
    /**
     * Sets how selection works in `box`.
     * @param mode the new selection mode
     */
    setSelectionMode(mode: SelectionMode): void
    /**
     * By setting a sort function on the `box,` one can dynamically
     * reorder the children of the box, based on the contents of
     * the children.
     *
     * The `sort_func` will be called for each child after the call,
     * and will continue to be called each time a child changes (via
     * [method`Gtk`.FlowBoxChild.changed]) and when
     * [method`Gtk`.FlowBox.invalidate_sort] is called.
     *
     * Note that using a sort function is incompatible with using a model
     * (see [method`Gtk`.FlowBox.bind_model]).
     * @param sortFunc the sort function
     */
    setSortFunc(sortFunc: FlowBoxSortFunc | null): void
    /**
     * Hooks up an adjustment to focus handling in `box`.
     *
     * The adjustment is also used for autoscrolling during
     * rubberband selection. See [method`Gtk`.ScrolledWindow.get_vadjustment]
     * for a typical way of obtaining the adjustment, and
     * [method`Gtk`.FlowBox.set_hadjustment] for setting the horizontal
     * adjustment.
     *
     * The adjustments have to be in pixel units and in the same
     * coordinate system as the allocation for immediate children
     * of the box.
     * @param adjustment an adjustment which should be adjusted    when the focus is moved among the descendents of `container`
     */
    setVadjustment(adjustment: Adjustment): void
    /**
     * Unselect all children of `box,` if the selection
     * mode allows it.
     */
    unselectAll(): void
    /**
     * Unselects a single child of `box,` if the selection
     * mode allows it.
     * @param child a child of `box`
     */
    unselectChild(child: FlowBoxChild): void

    // Own signals of Gtk-4.0.Gtk.FlowBox

    connect(
      sigName: "activate-cursor-child",
      callback: FlowBox.ActivateCursorChildSignalCallback
    ): number
    on(
      sigName: "activate-cursor-child",
      callback: FlowBox.ActivateCursorChildSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-cursor-child",
      callback: FlowBox.ActivateCursorChildSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-cursor-child",
      callback: FlowBox.ActivateCursorChildSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-cursor-child", ...args: any[]): void
    connect(
      sigName: "child-activated",
      callback: FlowBox.ChildActivatedSignalCallback
    ): number
    on(
      sigName: "child-activated",
      callback: FlowBox.ChildActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "child-activated",
      callback: FlowBox.ChildActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "child-activated",
      callback: FlowBox.ChildActivatedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "child-activated", ...args: any[]): void
    connect(
      sigName: "move-cursor",
      callback: FlowBox.MoveCursorSignalCallback
    ): number
    on(
      sigName: "move-cursor",
      callback: FlowBox.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-cursor",
      callback: FlowBox.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-cursor",
      callback: FlowBox.MoveCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "move-cursor",
      count: number,
      extend: boolean,
      modify: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "select-all",
      callback: FlowBox.SelectAllSignalCallback
    ): number
    on(
      sigName: "select-all",
      callback: FlowBox.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-all",
      callback: FlowBox.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-all",
      callback: FlowBox.SelectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-all", ...args: any[]): void
    connect(
      sigName: "selected-children-changed",
      callback: FlowBox.SelectedChildrenChangedSignalCallback
    ): number
    on(
      sigName: "selected-children-changed",
      callback: FlowBox.SelectedChildrenChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "selected-children-changed",
      callback: FlowBox.SelectedChildrenChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "selected-children-changed",
      callback: FlowBox.SelectedChildrenChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "selected-children-changed", ...args: any[]): void
    connect(
      sigName: "toggle-cursor-child",
      callback: FlowBox.ToggleCursorChildSignalCallback
    ): number
    on(
      sigName: "toggle-cursor-child",
      callback: FlowBox.ToggleCursorChildSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggle-cursor-child",
      callback: FlowBox.ToggleCursorChildSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggle-cursor-child",
      callback: FlowBox.ToggleCursorChildSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggle-cursor-child", ...args: any[]): void
    connect(
      sigName: "unselect-all",
      callback: FlowBox.UnselectAllSignalCallback
    ): number
    on(
      sigName: "unselect-all",
      callback: FlowBox.UnselectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unselect-all",
      callback: FlowBox.UnselectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unselect-all",
      callback: FlowBox.UnselectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unselect-all", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.FlowBox

    connect(
      sigName: "notify::accept-unpaired-release",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accept-unpaired-release",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accept-unpaired-release",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accept-unpaired-release",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accept-unpaired-release", ...args: any[]): void
    connect(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activate-on-single-click", ...args: any[]): void
    connect(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column-spacing", ...args: any[]): void
    connect(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::max-children-per-line",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-children-per-line",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-children-per-line",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-children-per-line",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-children-per-line", ...args: any[]): void
    connect(
      sigName: "notify::min-children-per-line",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-children-per-line",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-children-per-line",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-children-per-line",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-children-per-line", ...args: any[]): void
    connect(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row-spacing", ...args: any[]): void
    connect(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-mode", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkFlowBox` puts child widgets in reflowing grid.
   *
   * For instance, with the horizontal orientation, the widgets will be
   * arranged from left to right, starting a new row under the previous
   * row when necessary. Reducing the width in this case will require more
   * rows, so a larger height will be requested.
   *
   * Likewise, with the vertical orientation, the widgets will be arranged
   * from top to bottom, starting a new column to the right when necessary.
   * Reducing the height will require more columns, so a larger width will
   * be requested.
   *
   * The size request of a `GtkFlowBox` alone may not be what you expect;
   * if you need to be able to shrink it along both axes and dynamically
   * reflow its children, you may have to wrap it in a `GtkScrolledWindow`
   * to enable that.
   *
   * The children of a `GtkFlowBox` can be dynamically sorted and filtered.
   *
   * Although a `GtkFlowBox` must have only `GtkFlowBoxChild` children, you
   * can add any kind of widget to it via [method`Gtk`.FlowBox.insert], and a
   * `GtkFlowBoxChild` widget will automatically be inserted between the box
   * and the widget.
   *
   * Also see [class`Gtk`.ListBox].
   *
   * # CSS nodes
   *
   * ```
   * flowbox
   * ├── flowboxchild
   * │   ╰── <child>
   * ├── flowboxchild
   * │   ╰── <child>
   * ┊
   * ╰── [rubberband]
   * ```
   *
   * `GtkFlowBox` uses a single CSS node with name flowbox. `GtkFlowBoxChild`
   * uses a single CSS node with name flowboxchild. For rubberband selection,
   * a subnode with name rubberband is used.
   *
   * # Accessibility
   *
   * `GtkFlowBox` uses the %GTK_ACCESSIBLE_ROLE_GRID role, and `GtkFlowBoxChild`
   * uses the %GTK_ACCESSIBLE_ROLE_GRID_CELL role.
   * @class
   */
  class FlowBox extends Widget {
    // Own properties of Gtk-4.0.Gtk.FlowBox

    static name: string

    // Constructors of Gtk-4.0.Gtk.FlowBox

    constructor(config?: FlowBox.ConstructorProperties)
    /**
     * Creates a `GtkFlowBox`.
     * @constructor
     * @returns a new `GtkFlowBox`
     */
    constructor()
    /**
     * Creates a `GtkFlowBox`.
     * @constructor
     * @returns a new `GtkFlowBox`
     */
    static new(): FlowBox
    _init(config?: FlowBox.ConstructorProperties): void
  }

  module FlowBoxChild {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FlowBoxChild

      /**
       * The child widget.
       */
      child?: Widget | null
    }
  }

  interface FlowBoxChild extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.FlowBoxChild

    /**
     * The child widget.
     */
    child: Widget
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FlowBoxChild

    /**
     * Marks `child` as changed, causing any state that depends on this
     * to be updated.
     *
     * This affects sorting and filtering.
     *
     * Note that calls to this method must be in sync with the data
     * used for the sorting and filtering functions. For instance, if
     * the list is mirroring some external data set, and *two* children
     * changed in the external data set when you call
     * gtk_flow_box_child_changed() on the first child, the sort function
     * must only read the new data for the first of the two changed
     * children, otherwise the resorting of the children will be wrong.
     *
     * This generally means that if you don’t fully control the data
     * model, you have to duplicate the data that affects the sorting
     * and filtering functions into the widgets themselves.
     *
     * Another alternative is to call [method`Gtk`.FlowBox.invalidate_sort]
     * on any model change, but that is more expensive.
     */
    changed(): void
    /**
     * Gets the child widget of `self`.
     * @returns the child widget of @self
     */
    getChild(): Widget | null
    /**
     * Gets the current index of the `child` in its `GtkFlowBox` container.
     * @returns the index of the @child, or -1 if the @child is not   in a flow box
     */
    getIndex(): number
    /**
     * Returns whether the `child` is currently selected in its
     * `GtkFlowBox` container.
     * @returns %TRUE if @child is selected
     */
    isSelected(): boolean
    /**
     * Sets the child widget of `self`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void

    // Own virtual methods of Gtk-4.0.Gtk.FlowBoxChild

    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean

    // Own signals of Gtk-4.0.Gtk.FlowBoxChild

    connect(
      sigName: "activate",
      callback: FlowBoxChild.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: FlowBoxChild.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: FlowBoxChild.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: FlowBoxChild.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.FlowBoxChild

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFlowBoxChild` is the kind of widget that can be added to a `GtkFlowBox`.
   * @class
   */
  class FlowBoxChild extends Widget {
    // Own properties of Gtk-4.0.Gtk.FlowBoxChild

    static name: string

    // Constructors of Gtk-4.0.Gtk.FlowBoxChild

    constructor(config?: FlowBoxChild.ConstructorProperties)
    /**
     * Creates a new `GtkFlowBoxChild`.
     *
     * This should only be used as a child of a `GtkFlowBox`.
     * @constructor
     * @returns a new `GtkFlowBoxChild`
     */
    constructor()
    /**
     * Creates a new `GtkFlowBoxChild`.
     *
     * This should only be used as a child of a `GtkFlowBox`.
     * @constructor
     * @returns a new `GtkFlowBoxChild`
     */
    static new(): FlowBoxChild
    _init(config?: FlowBoxChild.ConstructorProperties): void
  }

  module FontButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `font-set`
     */
    interface FontSetSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        FontChooser.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FontButton

      /**
       * Whether the font chooser dialog should be modal.
       */
      modal?: boolean | null
      /**
       * The title of the font chooser dialog.
       */
      title?: string | null
      /**
       * Whether the buttons label will be drawn in the selected font.
       */
      use_font?: boolean | null
      /**
       * Whether the buttons label will use the selected font size.
       */
      use_size?: boolean | null
    }
  }

  interface FontButton
    extends Accessible,
      Buildable,
      ConstraintTarget,
      FontChooser {
    // Own properties of Gtk-4.0.Gtk.FontButton

    /**
     * Whether the font chooser dialog should be modal.
     */
    modal: boolean
    /**
     * The title of the font chooser dialog.
     */
    title: string | null
    /**
     * Whether the buttons label will be drawn in the selected font.
     */
    useFont: boolean
    /**
     * Whether the buttons label will use the selected font size.
     */
    useSize: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FontButton

    /**
     * Gets whether the dialog is modal.
     * @returns %TRUE if the dialog is modal
     */
    getModal(): boolean
    /**
     * Retrieves the title of the font chooser dialog.
     * @returns an internal copy of the title string   which must not be freed.
     */
    getTitle(): string
    /**
     * Returns whether the selected font is used in the label.
     * @returns whether the selected font is used in the label.
     */
    getUseFont(): boolean
    /**
     * Returns whether the selected size is used in the label.
     * @returns whether the selected size is used in the label.
     */
    getUseSize(): boolean
    /**
     * Sets whether the dialog should be modal.
     * @param modal %TRUE to make the dialog modal
     */
    setModal(modal: boolean): void
    /**
     * Sets the title for the font chooser dialog.
     * @param title a string containing the font chooser dialog title
     */
    setTitle(title: string): void
    /**
     * If `use_font` is %TRUE, the font name will be written
     * using the selected font.
     * @param useFont If %TRUE, font name will be written using font chosen.
     */
    setUseFont(useFont: boolean): void
    /**
     * If `use_size` is %TRUE, the font name will be written using
     * the selected size.
     * @param useSize If %TRUE, font name will be written using the   selected size.
     */
    setUseSize(useSize: boolean): void

    // Conflicting methods

    /**
     * Gets the font map of `widget`.
     *
     * See [method`Gtk`.Widget.set_font_map].
     * @returns A `PangoFontMap`
     */
    getFontMap(): Pango.FontMap | null
    /**
     * Gets the custom font map of this font chooser widget,
     * or %NULL if it does not have one.
     * @virtual
     * @returns a `PangoFontMap`
     */
    getFontMap(): Pango.FontMap | null
    /**
     * Sets the font map to use for Pango rendering.
     *
     * The font map is the object that is used to look up fonts.
     * Setting a custom font map can be useful in special situations,
     * e.g. when you need to add application-specific fonts to the set
     * of available fonts.
     *
     * When not set, the widget will inherit the font map from its parent.
     * @param fontMap a `PangoFontMap`, or %NULL to unset any   previously set font map
     */
    setFontMap(fontMap: Pango.FontMap | null): void
    /**
     * Sets a custom font map to use for this font chooser widget.
     *
     * A custom font map can be used to present application-specific
     * fonts instead of or in addition to the normal system fonts.
     *
     * ```c
     * FcConfig *config;
     * PangoFontMap *fontmap;
     *
     * config = FcInitLoadConfigAndFonts ();
     * FcConfigAppFontAddFile (config, my_app_font_file);
     *
     * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
     * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
     *
     * gtk_font_chooser_set_font_map (font_chooser, fontmap);
     * ```
     *
     * Note that other GTK widgets will only be able to use the
     * application-specific font if it is present in the font map they use:
     *
     * ```c
     * context = gtk_widget_get_pango_context (label);
     * pango_context_set_font_map (context, fontmap);
     * ```
     * @virtual
     * @param fontmap a `PangoFontMap`
     */
    setFontMap(fontmap: Pango.FontMap | null): void

    // Own signals of Gtk-4.0.Gtk.FontButton

    connect(
      sigName: "activate",
      callback: FontButton.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: FontButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: FontButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: FontButton.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "font-set",
      callback: FontButton.FontSetSignalCallback
    ): number
    on(
      sigName: "font-set",
      callback: FontButton.FontSetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "font-set",
      callback: FontButton.FontSetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "font-set",
      callback: FontButton.FontSetSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "font-set", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.FontButton

    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::use-font",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-font", ...args: any[]): void
    connect(
      sigName: "notify::use-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-size", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-features", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::level", ...args: any[]): void
    connect(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::preview-text", ...args: any[]): void
    connect(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-preview-entry", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkFontButton` allows to open a font chooser dialog to change
   * the font.
   *
   * ![An example GtkFontButton](font-button.png)
   *
   * It is suitable widget for selecting a font in a preference dialog.
   *
   * # CSS nodes
   *
   * ```
   * fontbutton
   * ╰── button.font
   *     ╰── [content]
   * ```
   *
   * `GtkFontButton` has a single CSS node with name fontbutton which
   * contains a button node with the .font style class.
   * @class
   */
  class FontButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.FontButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.FontButton

    constructor(config?: FontButton.ConstructorProperties)
    /**
     * Creates a new font picker widget.
     * @constructor
     * @returns a new font picker widget.
     */
    constructor()
    /**
     * Creates a new font picker widget.
     * @constructor
     * @returns a new font picker widget.
     */
    static new(): FontButton
    /**
     * Creates a new font picker widget showing the given font.
     * @constructor
     * @param fontname Name of font to display in font chooser dialog
     * @returns a new font picker widget.
     */
    static newWithFont(fontname: string): FontButton
    _init(config?: FontButton.ConstructorProperties): void
  }

  module FontChooserDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        FontChooser.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Dialog.ConstructorProperties {}
  }

  interface FontChooserDialog
    extends Accessible,
      Buildable,
      ConstraintTarget,
      FontChooser,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.FontChooserDialog

    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Conflicting methods

    /**
     * Gets the custom font map of this font chooser widget,
     * or %NULL if it does not have one.
     * @virtual
     * @returns a `PangoFontMap`
     */
    getFontMap(): Pango.FontMap | null
    /**
     * Gets the font map of `widget`.
     *
     * See [method`Gtk`.Widget.set_font_map].
     * @returns A `PangoFontMap`
     */
    getFontMap(): Pango.FontMap | null
    /**
     * Sets a custom font map to use for this font chooser widget.
     *
     * A custom font map can be used to present application-specific
     * fonts instead of or in addition to the normal system fonts.
     *
     * ```c
     * FcConfig *config;
     * PangoFontMap *fontmap;
     *
     * config = FcInitLoadConfigAndFonts ();
     * FcConfigAppFontAddFile (config, my_app_font_file);
     *
     * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
     * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
     *
     * gtk_font_chooser_set_font_map (font_chooser, fontmap);
     * ```
     *
     * Note that other GTK widgets will only be able to use the
     * application-specific font if it is present in the font map they use:
     *
     * ```c
     * context = gtk_widget_get_pango_context (label);
     * pango_context_set_font_map (context, fontmap);
     * ```
     * @virtual
     * @param fontmap a `PangoFontMap`
     */
    setFontMap(fontmap: Pango.FontMap | null): void
    /**
     * Sets the font map to use for Pango rendering.
     *
     * The font map is the object that is used to look up fonts.
     * Setting a custom font map can be useful in special situations,
     * e.g. when you need to add application-specific fonts to the set
     * of available fonts.
     *
     * When not set, the widget will inherit the font map from its parent.
     * @param fontMap a `PangoFontMap`, or %NULL to unset any   previously set font map
     */
    setFontMap(fontMap: Pango.FontMap | null): void
    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void
    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @virtual
     */
    close(): void

    // Overloads of close

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void

    // Class property signals of Gtk-4.0.Gtk.FontChooserDialog

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-features", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::level", ...args: any[]): void
    connect(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::preview-text", ...args: any[]): void
    connect(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-preview-entry", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkFontChooserDialog` widget is a dialog for selecting a font.
   *
   * ![An example GtkFontChooserDialog](fontchooser.png)
   *
   * `GtkFontChooserDialog` implements the [iface`Gtk`.FontChooser] interface
   * and does not provide much API of its own.
   *
   * To create a `GtkFontChooserDialog`, use [ctor`Gtk`.FontChooserDialog.new].
   *
   * # GtkFontChooserDialog as GtkBuildable
   *
   * The `GtkFontChooserDialog` implementation of the `GtkBuildable`
   * interface exposes the buttons with the names “select_button”
   * and “cancel_button”.
   *
   * ## CSS nodes
   *
   * `GtkFontChooserDialog` has a single CSS node with the name `window` and style
   * class `.fontchooser`.
   * @class
   */
  class FontChooserDialog extends Dialog {
    // Own properties of Gtk-4.0.Gtk.FontChooserDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.FontChooserDialog

    constructor(config?: FontChooserDialog.ConstructorProperties)
    /**
     * Creates a new `GtkFontChooserDialog`.
     * @constructor
     * @param title Title of the dialog
     * @param parent Transient parent of the dialog
     * @returns a new `GtkFontChooserDialog`
     */
    constructor(title: string | null, parent: Window | null)
    /**
     * Creates a new `GtkFontChooserDialog`.
     * @constructor
     * @param title Title of the dialog
     * @param parent Transient parent of the dialog
     * @returns a new `GtkFontChooserDialog`
     */
    static new(title: string | null, parent: Window | null): FontChooserDialog

    // Overloads of new

    /**
     * Creates a new dialog box.
     *
     * Widgets should not be packed into the `GtkWindow`
     * directly, but into the `content_area` and `action_area,`
     * as described above.
     * @constructor
     * @returns the new dialog as a `GtkWidget`
     */
    static new(): Dialog
    _init(config?: FontChooserDialog.ConstructorProperties): void
  }

  module FontChooserWidget {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        FontChooser.ConstructorProperties,
        Widget.ConstructorProperties {}
  }

  interface FontChooserWidget
    extends Accessible,
      Buildable,
      ConstraintTarget,
      FontChooser {
    // Own properties of Gtk-4.0.Gtk.FontChooserWidget

    /**
     * A toggle action that can be used to switch to the tweak page
     * of the font chooser widget, which lets the user tweak the
     * OpenType features and variation axes of the selected font.
     *
     * The action will be enabled or disabled depending on whether
     * the selected font has any features or axes.
     */
    readonly tweakAction: Gio.Action
    __gtype__: number

    // Conflicting methods

    /**
     * Gets the font map of `widget`.
     *
     * See [method`Gtk`.Widget.set_font_map].
     * @returns A `PangoFontMap`
     */
    getFontMap(): Pango.FontMap | null
    /**
     * Gets the custom font map of this font chooser widget,
     * or %NULL if it does not have one.
     * @virtual
     * @returns a `PangoFontMap`
     */
    getFontMap(): Pango.FontMap | null
    /**
     * Sets the font map to use for Pango rendering.
     *
     * The font map is the object that is used to look up fonts.
     * Setting a custom font map can be useful in special situations,
     * e.g. when you need to add application-specific fonts to the set
     * of available fonts.
     *
     * When not set, the widget will inherit the font map from its parent.
     * @param fontMap a `PangoFontMap`, or %NULL to unset any   previously set font map
     */
    setFontMap(fontMap: Pango.FontMap | null): void
    /**
     * Sets a custom font map to use for this font chooser widget.
     *
     * A custom font map can be used to present application-specific
     * fonts instead of or in addition to the normal system fonts.
     *
     * ```c
     * FcConfig *config;
     * PangoFontMap *fontmap;
     *
     * config = FcInitLoadConfigAndFonts ();
     * FcConfigAppFontAddFile (config, my_app_font_file);
     *
     * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
     * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
     *
     * gtk_font_chooser_set_font_map (font_chooser, fontmap);
     * ```
     *
     * Note that other GTK widgets will only be able to use the
     * application-specific font if it is present in the font map they use:
     *
     * ```c
     * context = gtk_widget_get_pango_context (label);
     * pango_context_set_font_map (context, fontmap);
     * ```
     * @virtual
     * @param fontmap a `PangoFontMap`
     */
    setFontMap(fontmap: Pango.FontMap | null): void

    // Class property signals of Gtk-4.0.Gtk.FontChooserWidget

    connect(
      sigName: "notify::tweak-action",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tweak-action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tweak-action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tweak-action",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tweak-action", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-features", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::level", ...args: any[]): void
    connect(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::preview-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::preview-text", ...args: any[]): void
    connect(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-preview-entry",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-preview-entry", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkFontChooserWidget` widget lets the user select a font.
   *
   * It is used in the `GtkFontChooserDialog` widget to provide a
   * dialog for selecting fonts.
   *
   * To set the font which is initially selected, use
   * [method`Gtk`.FontChooser.set_font] or [method`Gtk`.FontChooser.set_font_desc].
   *
   * To get the selected font use [method`Gtk`.FontChooser.get_font] or
   * [method`Gtk`.FontChooser.get_font_desc].
   *
   * To change the text which is shown in the preview area, use
   * [method`Gtk`.FontChooser.set_preview_text].
   *
   * # CSS nodes
   *
   * `GtkFontChooserWidget` has a single CSS node with name fontchooser.
   * @class
   */
  class FontChooserWidget extends Widget {
    // Own properties of Gtk-4.0.Gtk.FontChooserWidget

    static name: string

    // Constructors of Gtk-4.0.Gtk.FontChooserWidget

    constructor(config?: FontChooserWidget.ConstructorProperties)
    /**
     * Creates a new `GtkFontChooserWidget`.
     * @constructor
     * @returns a new `GtkFontChooserWidget`
     */
    constructor()
    /**
     * Creates a new `GtkFontChooserWidget`.
     * @constructor
     * @returns a new `GtkFontChooserWidget`
     */
    static new(): FontChooserWidget
    _init(config?: FontChooserWidget.ConstructorProperties): void
  }

  module FontDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FontDialog

      /**
       * Sets a filter to restrict what fonts are shown
       * in the font chooser dialog.
       */
      filter?: Filter | null
      /**
       * Sets a custom font map to select fonts from.
       *
       * A custom font map can be used to present application-specific
       * fonts instead of or in addition to the normal system fonts.
       */
      font_map?: Pango.FontMap | null
      /**
       * The language for which the font features are selected.
       */
      language?: Pango.Language | null
      /**
       * Whether the font chooser dialog is modal.
       */
      modal?: boolean | null
      /**
       * A title that may be shown on the font chooser
       * dialog that is presented by [method`Gtk`.FontDialog.choose_font].
       */
      title?: string | null
    }
  }

  interface FontDialog {
    // Own properties of Gtk-4.0.Gtk.FontDialog

    /**
     * Sets a filter to restrict what fonts are shown
     * in the font chooser dialog.
     */
    filter: Filter
    /**
     * Sets a custom font map to select fonts from.
     *
     * A custom font map can be used to present application-specific
     * fonts instead of or in addition to the normal system fonts.
     */
    fontMap: Pango.FontMap
    /**
     * The language for which the font features are selected.
     */
    language: Pango.Language
    /**
     * Whether the font chooser dialog is modal.
     */
    modal: boolean
    /**
     * A title that may be shown on the font chooser
     * dialog that is presented by [method`Gtk`.FontDialog.choose_font].
     */
    title: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FontDialog

    /**
     * This function initiates a font selection operation by
     * presenting a dialog to the user for selecting a font face
     * (i.e. a font family and style, but not a specific font size).
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FontDialog.choose_face_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param initialValue the initial value
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    chooseFace(
      parent: Window | null,
      initialValue: Pango.FontFace | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FontDialog.choose_face] call
     * and returns the resulting font face.
     * @param result a `GAsyncResult`
     * @returns the selected font face
     */
    chooseFaceFinish(result: Gio.AsyncResult): Pango.FontFace | null
    /**
     * This function initiates a font selection operation by
     * presenting a dialog to the user for selecting a font family.
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FontDialog.choose_family_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param initialValue the initial value
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    chooseFamily(
      parent: Window | null,
      initialValue: Pango.FontFamily | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FontDialog.choose_family] call
     * and returns the resulting family.
     *
     * This function never returns an error. If the operation is
     * not finished successfully, the value passed as `initial_value`
     * to [method`Gtk`.FontDialog.choose_family] is returned.
     * @param result a `GAsyncResult`
     * @returns the selected family
     */
    chooseFamilyFinish(result: Gio.AsyncResult): Pango.FontFamily | null
    /**
     * This function initiates a font selection operation by
     * presenting a dialog to the user for selecting a font.
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FontDialog.choose_font_finish]
     * to obtain the result.
     *
     * If you want to let the user select font features as well,
     * use [method`Gtk`.FontDialog.choose_font_and_features] instead.
     * @param parent the parent `GtkWindow`
     * @param initialValue the font to select initially
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    chooseFont(
      parent: Window | null,
      initialValue: Pango.FontDescription | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * This function initiates a font selection operation by
     * presenting a dialog to the user for selecting a font and
     * font features.
     *
     * Font features affect how the font is rendered, for example
     * enabling glyph variants or ligatures.
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.FontDialog.choose_font_and_features_finish]
     * to obtain the result.
     * @param parent the parent `GtkWindow`
     * @param initialValue the font to select initially
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    chooseFontAndFeatures(
      parent: Window | null,
      initialValue: Pango.FontDescription | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.FontDialog.choose_font_and_features]
     * call and returns the resulting font description and font features.
     * @param result a `GAsyncResult`
     * @returns `TRUE` if a font was selected. Otherwise `FALSE` is returned   and @error is set
     */
    chooseFontAndFeaturesFinish(
      result: Gio.AsyncResult
    ): [
      /* returnType */ boolean,
      /* fontDesc */ Pango.FontDescription,
      /* fontFeatures */ string | null,
      /* language */ Pango.Language,
    ]
    /**
     * Finishes the [method`Gtk`.FontDialog.choose_font] call
     * and returns the resulting font description.
     * @param result a `GAsyncResult`
     * @returns the selected font
     */
    chooseFontFinish(result: Gio.AsyncResult): Pango.FontDescription | null
    /**
     * Returns the filter that decides which fonts to display
     * in the font chooser dialog.
     * @returns the filter
     */
    getFilter(): Filter | null
    /**
     * Returns the fontmap from which fonts are selected,
     * or `NULL` for the default fontmap.
     * @returns the fontmap
     */
    getFontMap(): Pango.FontMap | null
    /**
     * Returns the language for which font features are applied.
     * @returns the language for font features
     */
    getLanguage(): Pango.Language | null
    /**
     * Returns whether the font chooser dialog
     * blocks interaction with the parent window
     * while it is presented.
     * @returns `TRUE` if the font chooser dialog is modal
     */
    getModal(): boolean
    /**
     * Returns the title that will be shown on the
     * font chooser dialog.
     * @returns the title
     */
    getTitle(): string
    /**
     * Adds a filter that decides which fonts to display
     * in the font chooser dialog.
     *
     * The `GtkFilter` must be able to handle both `PangoFontFamily`
     * and `PangoFontFace` objects.
     * @param filter a `GtkFilter`
     */
    setFilter(filter: Filter | null): void
    /**
     * Sets the fontmap from which fonts are selected.
     *
     * If `fontmap` is `NULL`, the default fontmap is used.
     * @param fontmap the fontmap
     */
    setFontMap(fontmap: Pango.FontMap | null): void
    /**
     * Sets the language for which font features are applied.
     * @param language the language for font features
     */
    setLanguage(language: Pango.Language): void
    /**
     * Sets whether the font chooser dialog
     * blocks interaction with the parent window
     * while it is presented.
     * @param modal the new value
     */
    setModal(modal: boolean): void
    /**
     * Sets the title that will be shown on the
     * font chooser dialog.
     * @param title the new title
     */
    setTitle(title: string): void

    // Class property signals of Gtk-4.0.Gtk.FontDialog

    connect(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filter", ...args: any[]): void
    connect(
      sigName: "notify::font-map",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-map",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-map",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-map",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-map", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkFontDialog` object collects the arguments that
   * are needed to present a font chooser dialog to the
   * user, such as a title for the dialog and whether it
   * should be modal.
   *
   * The dialog is shown with the [method`Gtk`.FontDialog.choose_font]
   * function or its variants. This API follows the GIO async pattern,
   * and the result can be obtained by calling the corresponding
   * finish function, such as [method`Gtk`.FontDialog.choose_font_finish].
   *
   * See [class`Gtk`.FontDialogButton] for a convenient control
   * that uses `GtkFontDialog` and presents the results.
   * @class
   */
  class FontDialog extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.FontDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.FontDialog

    constructor(config?: FontDialog.ConstructorProperties)
    /**
     * Creates a new `GtkFontDialog` object.
     * @constructor
     * @returns the new `GtkFontDialog`
     */
    constructor()
    /**
     * Creates a new `GtkFontDialog` object.
     * @constructor
     * @returns the new `GtkFontDialog`
     */
    static new(): FontDialog
    _init(config?: FontDialog.ConstructorProperties): void
  }

  module FontDialogButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.FontDialogButton

      /**
       * The `GtkFontDialog` that contains parameters for
       * the font chooser dialog.
       */
      dialog?: FontDialog | null
      /**
       * The selected font.
       *
       * This property can be set to give the button its initial
       * font, and it will be updated to reflect the users choice
       * in the font chooser dialog.
       *
       * Listen to `notify::font-desc` to get informed about changes
       * to the buttons font.
       */
      font_desc?: Pango.FontDescription | null
      /**
       * The selected font features.
       *
       * This property will be updated to reflect the users choice
       * in the font chooser dialog.
       *
       * Listen to `notify::font-features` to get informed about changes
       * to the buttons font features.
       */
      font_features?: string | null
      /**
       * The selected language for font features.
       *
       * This property will be updated to reflect the users choice
       * in the font chooser dialog.
       *
       * Listen to `notify::language` to get informed about changes
       * to the buttons language.
       */
      language?: Pango.Language | null
      /**
       * The level of detail for the font chooser dialog.
       */
      level?: FontLevel | null
      /**
       * Whether the buttons label will be drawn in the selected font.
       */
      use_font?: boolean | null
      /**
       * Whether the buttons label will use the selected font size.
       */
      use_size?: boolean | null
    }
  }

  interface FontDialogButton extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.FontDialogButton

    /**
     * The `GtkFontDialog` that contains parameters for
     * the font chooser dialog.
     */
    dialog: FontDialog
    /**
     * The selected font.
     *
     * This property can be set to give the button its initial
     * font, and it will be updated to reflect the users choice
     * in the font chooser dialog.
     *
     * Listen to `notify::font-desc` to get informed about changes
     * to the buttons font.
     */
    fontDesc: Pango.FontDescription
    /**
     * The selected font features.
     *
     * This property will be updated to reflect the users choice
     * in the font chooser dialog.
     *
     * Listen to `notify::font-features` to get informed about changes
     * to the buttons font features.
     */
    fontFeatures: string | null
    /**
     * The selected language for font features.
     *
     * This property will be updated to reflect the users choice
     * in the font chooser dialog.
     *
     * Listen to `notify::language` to get informed about changes
     * to the buttons language.
     */
    language: Pango.Language
    /**
     * The level of detail for the font chooser dialog.
     */
    level: FontLevel
    /**
     * Whether the buttons label will be drawn in the selected font.
     */
    useFont: boolean
    /**
     * Whether the buttons label will use the selected font size.
     */
    useSize: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.FontDialogButton

    /**
     * Returns the `GtkFontDialog` of `self`.
     * @returns the `GtkFontDialog`
     */
    getDialog(): FontDialog | null
    /**
     * Returns the font of the button.
     *
     * This function is what should be used to obtain
     * the font that was chosen by the user. To get
     * informed about changes, listen to "notify::font-desc".
     * @returns the font
     */
    getFontDesc(): Pango.FontDescription | null
    /**
     * Returns the font features of the button.
     *
     * This function is what should be used to obtain the font features
     * that were chosen by the user. To get informed about changes, listen
     * to "notify::font-features".
     *
     * Note that the button will only let users choose font features
     * if [property`Gtk`.FontDialogButton:level] is set to
     * `GTK_FONT_LEVEL_FEATURES`.
     * @returns the font features
     */
    getFontFeatures(): string | null
    /**
     * Returns the language that is used for font features.
     * @returns the language
     */
    getLanguage(): Pango.Language | null
    /**
     * Returns the level of detail at which this dialog
     * lets the user select fonts.
     * @returns the level of detail
     */
    getLevel(): FontLevel
    /**
     * Returns whether the selected font is used in the label.
     * @returns whether the selected font is used in the label
     */
    getUseFont(): boolean
    /**
     * Returns whether the selected font size is used in the label.
     * @returns whether the selected font size is used in the label
     */
    getUseSize(): boolean
    /**
     * Sets a `GtkFontDialog` object to use for
     * creating the font chooser dialog that is
     * presented when the user clicks the button.
     * @param dialog the new `GtkFontDialog`
     */
    setDialog(dialog: FontDialog): void
    /**
     * Sets the font of the button.
     * @param fontDesc the new font
     */
    setFontDesc(fontDesc: Pango.FontDescription): void
    /**
     * Sets the font features of the button.
     * @param fontFeatures the font features
     */
    setFontFeatures(fontFeatures: string | null): void
    /**
     * Sets the language to use for font features.
     * @param language the new language
     */
    setLanguage(language: Pango.Language | null): void
    /**
     * Sets the level of detail at which this dialog
     * lets the user select fonts.
     * @param level the level of detail
     */
    setLevel(level: FontLevel): void
    /**
     * If `use_font` is `TRUE`, the font name will be written
     * using the selected font.
     * @param useFont If `TRUE`, font name will be written using   the chosen font
     */
    setUseFont(useFont: boolean): void
    /**
     * If `use_size` is `TRUE`, the font name will be written
     * using the selected font size.
     * @param useSize If `TRUE`, font name will be written using   the chosen font size
     */
    setUseSize(useSize: boolean): void

    // Own signals of Gtk-4.0.Gtk.FontDialogButton

    connect(
      sigName: "activate",
      callback: FontDialogButton.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: FontDialogButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: FontDialogButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: FontDialogButton.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.FontDialogButton

    connect(
      sigName: "notify::dialog",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::dialog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::dialog",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::dialog",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::dialog", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-features", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::level", ...args: any[]): void
    connect(
      sigName: "notify::use-font",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-font", ...args: any[]): void
    connect(
      sigName: "notify::use-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-size", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkFontDialogButton` is wrapped around a [class`Gtk`.FontDialog]
   * and allows to open a font chooser dialog to change the font.
   *
   * ![An example GtkFontDialogButton](font-button.png)
   *
   * It is suitable widget for selecting a font in a preference dialog.
   *
   * # CSS nodes
   *
   * ```
   * fontbutton
   * ╰── button.font
   *     ╰── [content]
   * ```
   *
   * `GtkFontDialogButton` has a single CSS node with name fontbutton which
   * contains a button node with the .font style class.
   * @class
   */
  class FontDialogButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.FontDialogButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.FontDialogButton

    constructor(config?: FontDialogButton.ConstructorProperties)
    /**
     * Creates a new `GtkFontDialogButton` with the
     * given `GtkFontDialog`.
     *
     * You can pass `NULL` to this function and set a `GtkFontDialog`
     * later. The button will be insensitive until that happens.
     * @constructor
     * @param dialog the `GtkFontDialog` to use
     * @returns the new `GtkFontDialogButton`
     */
    constructor(dialog: FontDialog | null)
    /**
     * Creates a new `GtkFontDialogButton` with the
     * given `GtkFontDialog`.
     *
     * You can pass `NULL` to this function and set a `GtkFontDialog`
     * later. The button will be insensitive until that happens.
     * @constructor
     * @param dialog the `GtkFontDialog` to use
     * @returns the new `GtkFontDialogButton`
     */
    static new(dialog: FontDialog | null): FontDialogButton
    _init(config?: FontDialogButton.ConstructorProperties): void
  }

  module Frame {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Frame

      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Text of the frame's label.
       */
      label?: string | null
      /**
       * Widget to display in place of the usual frame label.
       */
      label_widget?: Widget | null
      /**
       * The horizontal alignment of the label.
       */
      label_xalign?: number | null
    }
  }

  interface Frame extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Frame

    /**
     * The child widget.
     */
    child: Widget
    /**
     * Text of the frame's label.
     */
    label: string | null
    /**
     * Widget to display in place of the usual frame label.
     */
    labelWidget: Widget
    /**
     * The horizontal alignment of the label.
     */
    labelXalign: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Frame

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.Frame

    /**
     * Gets the child widget of `frame`.
     * @returns the child widget of @frame
     */
    getChild(): Widget | null
    /**
     * Returns the frame labels text.
     *
     * If the frame's label widget is not a `GtkLabel`, %NULL
     * is returned.
     * @returns the text in the label, or %NULL if there    was no label widget or the label widget was not a `GtkLabel`.    This string is owned by GTK and must not be modified or freed.
     */
    getLabel(): string | null
    /**
     * Retrieves the X alignment of the frame’s label.
     * @returns the frames X alignment
     */
    getLabelAlign(): number
    /**
     * Retrieves the label widget for the frame.
     * @returns the label widget
     */
    getLabelWidget(): Widget | null
    /**
     * Sets the child widget of `frame`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Creates a new `GtkLabel` with the `label` and sets it as the frame's
     * label widget.
     * @param label the text to use as the label of the frame
     */
    setLabel(label: string | null): void
    /**
     * Sets the X alignment of the frame widget’s label.
     *
     * The default value for a newly created frame is 0.0.
     * @param xalign The position of the label along the top edge   of the widget. A value of 0.0 represents left alignment;   1.0 represents right alignment.
     */
    setLabelAlign(xalign: number): void
    /**
     * Sets the label widget for the frame.
     *
     * This is the widget that will appear embedded in the top edge
     * of the frame as a title.
     * @param labelWidget the new label widget
     */
    setLabelWidget(labelWidget: Widget | null): void

    // Own virtual methods of Gtk-4.0.Gtk.Frame

    computeChildAllocation(allocation: Allocation): void

    // Class property signals of Gtk-4.0.Gtk.Frame

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::label-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label-widget", ...args: any[]): void
    connect(
      sigName: "notify::label-xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label-xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label-xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label-xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label-xalign", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkFrame` is a widget that surrounds its child with a decorative
   * frame and an optional label.
   *
   * ![An example GtkFrame](frame.png)
   *
   * If present, the label is drawn inside the top edge of the frame.
   * The horizontal position of the label can be controlled with
   * [method`Gtk`.Frame.set_label_align].
   *
   * `GtkFrame` clips its child. You can use this to add rounded corners
   * to widgets, but be aware that it also cuts off shadows.
   *
   * # GtkFrame as GtkBuildable
   *
   * The `GtkFrame` implementation of the `GtkBuildable` interface supports
   * placing a child in the label position by specifying “label” as the
   * “type” attribute of a `<child>` element. A normal content child can
   * be specified without specifying a `<child>` type attribute.
   *
   * An example of a UI definition fragment with GtkFrame:
   * ```xml
   * <object class="GtkFrame">
   *   <child type="label">
   *     <object class="GtkLabel" id="frame_label"/>
   *   </child>
   *   <child>
   *     <object class="GtkEntry" id="frame_content"/>
   *   </child>
   * </object>
   * ```
   *
   * # CSS nodes
   *
   * ```
   * frame
   * ├── <label widget>
   * ╰── <child>
   * ```
   *
   * `GtkFrame` has a main CSS node with name “frame”, which is used to draw the
   * visible border. You can set the appearance of the border using CSS properties
   * like “border-style” on this node.
   *
   * # Accessibility
   *
   * `GtkFrame` uses the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   * @class
   */
  class Frame extends Widget {
    // Own properties of Gtk-4.0.Gtk.Frame

    static name: string

    // Constructors of Gtk-4.0.Gtk.Frame

    constructor(config?: Frame.ConstructorProperties)
    /**
     * Creates a new `GtkFrame`, with optional label `label`.
     *
     * If `label` is %NULL, the label is omitted.
     * @constructor
     * @param label the text to use as the label of the frame
     * @returns a new `GtkFrame` widget
     */
    constructor(label: string | null)
    /**
     * Creates a new `GtkFrame`, with optional label `label`.
     *
     * If `label` is %NULL, the label is omitted.
     * @constructor
     * @param label the text to use as the label of the frame
     * @returns a new `GtkFrame` widget
     */
    static new(label: string | null): Frame
    _init(config?: Frame.ConstructorProperties): void
  }

  module GLArea {
    // Signal callback interfaces

    /**
     * Signal callback interface for `create-context`
     */
    interface CreateContextSignalCallback {
      (): Gdk.GLContext
    }

    /**
     * Signal callback interface for `render`
     */
    interface RenderSignalCallback {
      (context: Gdk.GLContext): boolean
    }

    /**
     * Signal callback interface for `resize`
     */
    interface ResizeSignalCallback {
      (width: number, height: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GLArea

      /**
       * The allowed APIs.
       */
      allowed_apis?: Gdk.GLAPI | null
      /**
       * If set to %TRUE the ::render signal will be emitted every time
       * the widget draws.
       *
       * This is the default and is useful if drawing the widget is faster.
       *
       * If set to %FALSE the data from previous rendering is kept around and will
       * be used for drawing the widget the next time, unless the window is resized.
       * In order to force a rendering [method`Gtk`.GLArea.queue_render] must be called.
       * This mode is useful when the scene changes seldom, but takes a long time
       * to redraw.
       */
      auto_render?: boolean | null
      /**
       * If set to %TRUE the widget will allocate and enable a depth buffer for the
       * target framebuffer.
       *
       * Setting this property will enable GL's depth testing as a side effect. If
       * you don't need depth testing, you should call `glDisable(GL_DEPTH_TEST)`
       * in your `GtkGLArea::render` handler.
       */
      has_depth_buffer?: boolean | null
      /**
       * If set to %TRUE the widget will allocate and enable a stencil buffer for the
       * target framebuffer.
       */
      has_stencil_buffer?: boolean | null
      /**
       * If set to %TRUE the widget will try to create a `GdkGLContext` using
       * OpenGL ES instead of OpenGL.
       */
      use_es?: boolean | null
    }
  }

  interface GLArea extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.GLArea

    /**
     * The allowed APIs.
     */
    allowedApis: Gdk.GLAPI
    /**
     * The API currently in use.
     */
    readonly api: Gdk.GLAPI
    /**
     * If set to %TRUE the ::render signal will be emitted every time
     * the widget draws.
     *
     * This is the default and is useful if drawing the widget is faster.
     *
     * If set to %FALSE the data from previous rendering is kept around and will
     * be used for drawing the widget the next time, unless the window is resized.
     * In order to force a rendering [method`Gtk`.GLArea.queue_render] must be called.
     * This mode is useful when the scene changes seldom, but takes a long time
     * to redraw.
     */
    autoRender: boolean
    /**
     * The `GdkGLContext` used by the `GtkGLArea` widget.
     *
     * The `GtkGLArea` widget is responsible for creating the `GdkGLContext`
     * instance. If you need to render with other kinds of buffers (stencil,
     * depth, etc), use render buffers.
     */
    readonly context: Gdk.GLContext
    /**
     * If set to %TRUE the widget will allocate and enable a depth buffer for the
     * target framebuffer.
     *
     * Setting this property will enable GL's depth testing as a side effect. If
     * you don't need depth testing, you should call `glDisable(GL_DEPTH_TEST)`
     * in your `GtkGLArea::render` handler.
     */
    hasDepthBuffer: boolean
    /**
     * If set to %TRUE the widget will allocate and enable a stencil buffer for the
     * target framebuffer.
     */
    hasStencilBuffer: boolean
    /**
     * If set to %TRUE the widget will try to create a `GdkGLContext` using
     * OpenGL ES instead of OpenGL.
     */
    useEs: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GLArea

    /**
     * Binds buffers to the framebuffer.
     *
     * Ensures that the `area` framebuffer object is made the current draw
     * and read target, and that all the required buffers for the `area`
     * are created and bound to the framebuffer.
     *
     * This function is automatically called before emitting the
     * [signal`Gtk`.GLArea::render] signal, and doesn't normally need to be
     * called by application code.
     */
    attachBuffers(): void
    /**
     * Gets the allowed APIs.
     *
     * See [method`Gtk`.GLArea.set_allowed_apis].
     * @returns the allowed APIs
     */
    getAllowedApis(): Gdk.GLAPI
    /**
     * Gets the API that is currently in use.
     *
     * If the GL area has not been realized yet, 0 is returned.
     * @returns the currently used API
     */
    getApi(): Gdk.GLAPI
    /**
     * Returns whether the area is in auto render mode or not.
     * @returns %TRUE if the @area is auto rendering, %FALSE otherwise
     */
    getAutoRender(): boolean
    /**
     * Retrieves the `GdkGLContext` used by `area`.
     * @returns the `GdkGLContext`
     */
    getContext(): Gdk.GLContext | null
    /**
     * Gets the current error set on the `area`.
     * @returns the `GError`
     */
    getError(): GLib.Error | null
    /**
     * Returns whether the area has a depth buffer.
     * @returns %TRUE if the @area has a depth buffer, %FALSE otherwise
     */
    getHasDepthBuffer(): boolean
    /**
     * Returns whether the area has a stencil buffer.
     * @returns %TRUE if the @area has a stencil buffer, %FALSE otherwise
     */
    getHasStencilBuffer(): boolean
    /**
     * Retrieves the required version of OpenGL.
     *
     * See [method`Gtk`.GLArea.set_required_version].
     */
    getRequiredVersion(): [/* major */ number, /* minor */ number]
    /**
     * Returns whether the `GtkGLArea` should use OpenGL ES.
     *
     * See [method`Gtk`.GLArea.set_use_es].
     * @returns %TRUE if the `GtkGLArea` should create an OpenGL ES context   and %FALSE otherwise
     */
    getUseEs(): boolean
    /**
     * Ensures that the `GdkGLContext` used by `area` is associated with
     * the `GtkGLArea`.
     *
     * This function is automatically called before emitting the
     * [signal`Gtk`.GLArea::render] signal, and doesn't normally need
     * to be called by application code.
     */
    makeCurrent(): void
    /**
     * Marks the currently rendered data (if any) as invalid, and queues
     * a redraw of the widget.
     *
     * This ensures that the [signal`Gtk`.GLArea::render] signal
     * is emitted during the draw.
     *
     * This is only needed when [method`Gtk`.GLArea.set_auto_render] has
     * been called with a %FALSE value. The default behaviour is to
     * emit [signal`Gtk`.GLArea::render] on each draw.
     */
    queueRender(): void
    /**
     * Sets the allowed APIs to create a context with.
     *
     * You should check [property`Gtk`.GLArea:api] before drawing
     * with either API.
     *
     * By default, all APIs are allowed.
     * @param apis the allowed APIs
     */
    setAllowedApis(apis: Gdk.GLAPI): void
    /**
     * Sets whether the `GtkGLArea` is in auto render mode.
     *
     * If `auto_render` is %TRUE the [signal`Gtk`.GLArea::render] signal will
     * be emitted every time the widget draws. This is the default and is
     * useful if drawing the widget is faster.
     *
     * If `auto_render` is %FALSE the data from previous rendering is kept
     * around and will be used for drawing the widget the next time,
     * unless the window is resized. In order to force a rendering
     * [method`Gtk`.GLArea.queue_render] must be called. This mode is
     * useful when the scene changes seldom, but takes a long time to redraw.
     * @param autoRender a boolean
     */
    setAutoRender(autoRender: boolean): void
    /**
     * Sets an error on the area which will be shown instead of the
     * GL rendering.
     *
     * This is useful in the [signal`Gtk`.GLArea::create-context]
     * signal if GL context creation fails.
     * @param error a new `GError`, or %NULL to unset the error
     */
    setError(error: GLib.Error | null): void
    /**
     * Sets whether the `GtkGLArea` should use a depth buffer.
     *
     * If `has_depth_buffer` is %TRUE the widget will allocate and
     * enable a depth buffer for the target framebuffer. Otherwise
     * there will be none.
     * @param hasDepthBuffer %TRUE to add a depth buffer
     */
    setHasDepthBuffer(hasDepthBuffer: boolean): void
    /**
     * Sets whether the `GtkGLArea` should use a stencil buffer.
     *
     * If `has_stencil_buffer` is %TRUE the widget will allocate and
     * enable a stencil buffer for the target framebuffer. Otherwise
     * there will be none.
     * @param hasStencilBuffer %TRUE to add a stencil buffer
     */
    setHasStencilBuffer(hasStencilBuffer: boolean): void
    /**
     * Sets the required version of OpenGL to be used when creating
     * the context for the widget.
     *
     * This function must be called before the area has been realized.
     * @param major the major version
     * @param minor the minor version
     */
    setRequiredVersion(major: number, minor: number): void
    /**
     * Sets whether the `area` should create an OpenGL or an OpenGL ES context.
     *
     * You should check the capabilities of the `GdkGLContext` before drawing
     * with either API.
     * @param useEs whether to use OpenGL or OpenGL ES
     */
    setUseEs(useEs: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.GLArea

    /**
     * class closure for the `GtkGLArea::render` signal
     * @virtual
     * @param context
     */
    render(context: Gdk.GLContext): boolean
    /**
     * class closeure for the `GtkGLArea::resize` signal
     * @virtual
     * @param width
     * @param height
     */
    resize(width: number, height: number): void

    // Own signals of Gtk-4.0.Gtk.GLArea

    connect(
      sigName: "create-context",
      callback: GLArea.CreateContextSignalCallback
    ): number
    on(
      sigName: "create-context",
      callback: GLArea.CreateContextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "create-context",
      callback: GLArea.CreateContextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "create-context",
      callback: GLArea.CreateContextSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "create-context", ...args: any[]): void
    connect(sigName: "render", callback: GLArea.RenderSignalCallback): number
    on(
      sigName: "render",
      callback: GLArea.RenderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "render",
      callback: GLArea.RenderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "render",
      callback: GLArea.RenderSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "render", ...args: any[]): void
    connect(sigName: "resize", callback: GLArea.ResizeSignalCallback): number
    on(
      sigName: "resize",
      callback: GLArea.ResizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "resize",
      callback: GLArea.ResizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "resize",
      callback: GLArea.ResizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "resize", height: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GLArea

    connect(
      sigName: "notify::allowed-apis",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::allowed-apis",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::allowed-apis",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::allowed-apis",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::allowed-apis", ...args: any[]): void
    connect(sigName: "notify::api", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::api",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::api",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::api",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::api", ...args: any[]): void
    connect(
      sigName: "notify::auto-render",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::auto-render",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::auto-render",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::auto-render",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::auto-render", ...args: any[]): void
    connect(
      sigName: "notify::context",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::context",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::context",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::context",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::context", ...args: any[]): void
    connect(
      sigName: "notify::has-depth-buffer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-depth-buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-depth-buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-depth-buffer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-depth-buffer", ...args: any[]): void
    connect(
      sigName: "notify::has-stencil-buffer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-stencil-buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-stencil-buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-stencil-buffer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-stencil-buffer", ...args: any[]): void
    connect(
      sigName: "notify::use-es",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-es",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-es",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-es",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-es", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGLArea` is a widget that allows drawing with OpenGL.
   *
   * ![An example GtkGLArea](glarea.png)
   *
   * `GtkGLArea` sets up its own [class`Gdk`.GLContext], and creates a custom
   * GL framebuffer that the widget will do GL rendering onto. It also ensures
   * that this framebuffer is the default GL rendering target when rendering.
   * The completed rendering is integrated into the larger GTK scene graph as
   * a texture.
   *
   * In order to draw, you have to connect to the [signal`Gtk`.GLArea::render]
   * signal, or subclass `GtkGLArea` and override the GtkGLAreaClass.render
   * virtual function.
   *
   * The `GtkGLArea` widget ensures that the `GdkGLContext` is associated with
   * the widget's drawing area, and it is kept updated when the size and
   * position of the drawing area changes.
   *
   * ## Drawing with GtkGLArea
   *
   * The simplest way to draw using OpenGL commands in a `GtkGLArea` is to
   * create a widget instance and connect to the [signal`Gtk`.GLArea::render] signal:
   *
   * The `render()` function will be called when the `GtkGLArea` is ready
   * for you to draw its content:
   *
   * The initial contents of the framebuffer are transparent.
   *
   * ```c
   * static gboolean
   * render (GtkGLArea *area, GdkGLContext *context)
   * {
   *   // inside this function it's safe to use GL; the given
   *   // GdkGLContext has been made current to the drawable
   *   // surface used by the `GtkGLArea` and the viewport has
   *   // already been set to be the size of the allocation
   *
   *   // we can start by clearing the buffer
   *   glClearColor (0, 0, 0, 0);
   *   glClear (GL_COLOR_BUFFER_BIT);
   *
   *   // draw your object
   *   // draw_an_object ();
   *
   *   // we completed our drawing; the draw commands will be
   *   // flushed at the end of the signal emission chain, and
   *   // the buffers will be drawn on the window
   *   return TRUE;
   * }
   *
   * void setup_glarea (void)
   * {
   *   // create a GtkGLArea instance
   *   GtkWidget *gl_area = gtk_gl_area_new ();
   *
   *   // connect to the "render" signal
   *   g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
   * }
   * ```
   *
   * If you need to initialize OpenGL state, e.g. buffer objects or
   * shaders, you should use the [signal`Gtk`.Widget::realize] signal;
   * you can use the [signal`Gtk`.Widget::unrealize] signal to clean up.
   * Since the `GdkGLContext` creation and initialization may fail, you
   * will need to check for errors, using [method`Gtk`.GLArea.get_error].
   *
   * An example of how to safely initialize the GL state is:
   *
   * ```c
   * static void
   * on_realize (GtkGLarea *area)
   * {
   *   // We need to make the context current if we want to
   *   // call GL API
   *   gtk_gl_area_make_current (area);
   *
   *   // If there were errors during the initialization or
   *   // when trying to make the context current, this
   *   // function will return a GError for you to catch
   *   if (gtk_gl_area_get_error (area) != NULL)
   *     return;
   *
   *   // You can also use gtk_gl_area_set_error() in order
   *   // to show eventual initialization errors on the
   *   // GtkGLArea widget itself
   *   GError *internal_error = NULL;
   *   init_buffer_objects (&error);
   *   if (error != NULL)
   *     {
   *       gtk_gl_area_set_error (area, error);
   *       g_error_free (error);
   *       return;
   *     }
   *
   *   init_shaders (&error);
   *   if (error != NULL)
   *     {
   *       gtk_gl_area_set_error (area, error);
   *       g_error_free (error);
   *       return;
   *     }
   * }
   * ```
   *
   * If you need to change the options for creating the `GdkGLContext`
   * you should use the [signal`Gtk`.GLArea::create-context] signal.
   * @class
   */
  class GLArea extends Widget {
    // Own properties of Gtk-4.0.Gtk.GLArea

    static name: string

    // Constructors of Gtk-4.0.Gtk.GLArea

    constructor(config?: GLArea.ConstructorProperties)
    /**
     * Creates a new `GtkGLArea` widget.
     * @constructor
     * @returns a new `GtkGLArea`
     */
    constructor()
    /**
     * Creates a new `GtkGLArea` widget.
     * @constructor
     * @returns a new `GtkGLArea`
     */
    static new(): GLArea
    _init(config?: GLArea.ConstructorProperties): void
  }

  module Gesture {
    // Signal callback interfaces

    /**
     * Signal callback interface for `begin`
     */
    interface BeginSignalCallback {
      (sequence: Gdk.EventSequence | null): void
    }

    /**
     * Signal callback interface for `cancel`
     */
    interface CancelSignalCallback {
      (sequence: Gdk.EventSequence | null): void
    }

    /**
     * Signal callback interface for `end`
     */
    interface EndSignalCallback {
      (sequence: Gdk.EventSequence | null): void
    }

    /**
     * Signal callback interface for `sequence-state-changed`
     */
    interface SequenceStateChangedSignalCallback {
      (sequence: Gdk.EventSequence | null, state: EventSequenceState): void
    }

    /**
     * Signal callback interface for `update`
     */
    interface UpdateSignalCallback {
      (sequence: Gdk.EventSequence | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Gesture

      /**
       * The number of touch points that trigger
       * recognition on this gesture.
       */
      n_points?: number | null
    }
  }

  interface Gesture {
    // Own properties of Gtk-4.0.Gtk.Gesture

    /**
     * The number of touch points that trigger
     * recognition on this gesture.
     */
    readonly nPoints: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Gesture

    /**
     * If there are touch sequences being currently handled by `gesture,`
     * returns %TRUE and fills in `rect` with the bounding box containing
     * all active touches.
     *
     * Otherwise, %FALSE will be returned.
     *
     * Note: This function will yield unexpected results on touchpad
     * gestures. Since there is no correlation between physical and
     * pixel distances, these will look as if constrained in an
     * infinitely small area, `rect` width and height will thus be 0
     * regardless of the number of touchpoints.
     * @returns %TRUE if there are active touches, %FALSE otherwise
     */
    getBoundingBox(): [/* returnType */ boolean, /* rect */ Gdk.Rectangle]
    /**
     * If there are touch sequences being currently handled by `gesture,`
     * returns %TRUE and fills in `x` and `y` with the center of the bounding
     * box containing all active touches.
     *
     * Otherwise, %FALSE will be returned.
     * @returns %FALSE if no active touches are present, %TRUE otherwise
     */
    getBoundingBoxCenter(): [
      /* returnType */ boolean,
      /* x */ number,
      /* y */ number,
    ]
    /**
     * Returns the logical `GdkDevice` that is currently operating
     * on `gesture`.
     *
     * This returns %NULL if the gesture is not being interacted.
     * @returns a `GdkDevice`
     */
    getDevice(): Gdk.Device | null
    /**
     * Returns all gestures in the group of `gesture`
     * @returns The list   of `GtkGesture`s, free with g_list_free()
     */
    getGroup(): Gesture[]
    /**
     * Returns the last event that was processed for `sequence`.
     *
     * Note that the returned pointer is only valid as long as the
     * `sequence` is still interpreted by the `gesture`. If in doubt,
     * you should make a copy of the event.
     * @param sequence a `GdkEventSequence`
     * @returns The last event from @sequence
     */
    getLastEvent(sequence: Gdk.EventSequence | null): Gdk.Event | null
    /**
     * Returns the `GdkEventSequence` that was last updated on `gesture`.
     * @returns The last updated sequence
     */
    getLastUpdatedSequence(): Gdk.EventSequence | null
    /**
     * If `sequence` is currently being interpreted by `gesture,`
     * returns %TRUE and fills in `x` and `y` with the last coordinates
     * stored for that event sequence.
     *
     * The coordinates are always relative to the widget allocation.
     * @param sequence a `GdkEventSequence`, or %NULL for pointer events
     * @returns %TRUE if @sequence is currently interpreted
     */
    getPoint(
      sequence: Gdk.EventSequence | null
    ): [/* returnType */ boolean, /* x */ number, /* y */ number]
    /**
     * Returns the `sequence` state, as seen by `gesture`.
     * @param sequence a `GdkEventSequence`
     * @returns The sequence state in @gesture
     */
    getSequenceState(sequence: Gdk.EventSequence): EventSequenceState
    /**
     * Returns the list of `GdkEventSequences` currently being interpreted
     * by `gesture`.
     * @returns A list   of `GdkEventSequence`, the list elements are owned by GTK and must   not be freed or modified, the list itself must be deleted   through g_list_free()
     */
    getSequences(): Gdk.EventSequence[]
    /**
     * Adds `gesture` to the same group than `group_gesture`.
     *
     * Gestures are by default isolated in their own groups.
     *
     * Both gestures must have been added to the same widget before
     * they can be grouped.
     *
     * When gestures are grouped, the state of `GdkEventSequences`
     * is kept in sync for all of those, so calling
     * [method`Gtk`.Gesture.set_sequence_state], on one will transfer
     * the same value to the others.
     *
     * Groups also perform an "implicit grabbing" of sequences, if a
     * `GdkEventSequence` state is set to %GTK_EVENT_SEQUENCE_CLAIMED
     * on one group, every other gesture group attached to the same
     * `GtkWidget` will switch the state for that sequence to
     * %GTK_EVENT_SEQUENCE_DENIED.
     * @param gesture a `GtkGesture`
     */
    group(gesture: Gesture): void
    /**
     * Returns %TRUE if `gesture` is currently handling events
     * corresponding to `sequence`.
     * @param sequence a `GdkEventSequence`
     * @returns %TRUE if @gesture is handling @sequence, %FALSE otherwise
     */
    handlesSequence(sequence: Gdk.EventSequence | null): boolean
    /**
     * Returns %TRUE if the gesture is currently active.
     *
     * A gesture is active while there are touch sequences
     * interacting with it.
     * @returns %TRUE if gesture is active
     */
    isActive(): boolean
    /**
     * Returns %TRUE if both gestures pertain to the same group.
     * @param other another `GtkGesture`
     * @returns whether the gestures are grouped
     */
    isGroupedWith(other: Gesture): boolean
    /**
     * Returns %TRUE if the gesture is currently recognized.
     *
     * A gesture is recognized if there are as many interacting
     * touch sequences as required by `gesture`.
     * @returns %TRUE if gesture is recognized
     */
    isRecognized(): boolean
    /**
     * Sets the state of `sequence` in `gesture`.
     *
     * Sequences start in state %GTK_EVENT_SEQUENCE_NONE, and whenever
     * they change state, they can never go back to that state. Likewise,
     * sequences in state %GTK_EVENT_SEQUENCE_DENIED cannot turn back to
     * a not denied state. With these rules, the lifetime of an event
     * sequence is constrained to the next four:
     *
     * * None
     * * None → Denied
     * * None → Claimed
     * * None → Claimed → Denied
     *
     * Note: Due to event handling ordering, it may be unsafe to set the
     * state on another gesture within a [signal`Gtk`.Gesture::begin] signal
     * handler, as the callback might be executed before the other gesture
     * knows about the sequence. A safe way to perform this could be:
     *
     * ```c
     * static void
     * first_gesture_begin_cb (GtkGesture       *first_gesture,
     *                         GdkEventSequence *sequence,
     *                         gpointer          user_data)
     * {
     *   gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
     *   gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
     * }
     *
     * static void
     * second_gesture_begin_cb (GtkGesture       *second_gesture,
     *                          GdkEventSequence *sequence,
     *                          gpointer          user_data)
     * {
     *   if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
     *     gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
     * }
     * ```
     *
     * If both gestures are in the same group, just set the state on
     * the gesture emitting the event, the sequence will be already
     * be initialized to the group's global state when the second
     * gesture processes the event.
     * @param sequence a `GdkEventSequence`
     * @param state the sequence state
     * @returns %TRUE if @sequence is handled by @gesture,   and the state is changed successfully
     */
    setSequenceState(
      sequence: Gdk.EventSequence,
      state: EventSequenceState
    ): boolean
    /**
     * Sets the state of all sequences that `gesture` is currently
     * interacting with.
     *
     * Sequences start in state %GTK_EVENT_SEQUENCE_NONE, and whenever
     * they change state, they can never go back to that state. Likewise,
     * sequences in state %GTK_EVENT_SEQUENCE_DENIED cannot turn back to
     * a not denied state. With these rules, the lifetime of an event
     * sequence is constrained to the next four:
     *
     * * None
     * * None → Denied
     * * None → Claimed
     * * None → Claimed → Denied
     *
     * Note: Due to event handling ordering, it may be unsafe to set the
     * state on another gesture within a [signal`Gtk`.Gesture::begin] signal
     * handler, as the callback might be executed before the other gesture
     * knows about the sequence. A safe way to perform this could be:
     *
     * ```c
     * static void
     * first_gesture_begin_cb (GtkGesture       *first_gesture,
     *                         GdkEventSequence *sequence,
     *                         gpointer          user_data)
     * {
     *   gtk_gesture_set_state (first_gesture, GTK_EVENT_SEQUENCE_CLAIMED);
     *   gtk_gesture_set_state (second_gesture, GTK_EVENT_SEQUENCE_DENIED);
     * }
     *
     * static void
     * second_gesture_begin_cb (GtkGesture       *second_gesture,
     *                          GdkEventSequence *sequence,
     *                          gpointer          user_data)
     * {
     *   if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
     *     gtk_gesture_set_state (second_gesture, GTK_EVENT_SEQUENCE_DENIED);
     * }
     * ```
     *
     * If both gestures are in the same group, just set the state on
     * the gesture emitting the event, the sequence will be already
     * be initialized to the group's global state when the second
     * gesture processes the event.
     * @param state the sequence state
     * @returns %TRUE if the state of at least one sequence   was changed successfully
     */
    setState(state: EventSequenceState): boolean
    /**
     * Separates `gesture` into an isolated group.
     */
    ungroup(): void

    // Own signals of Gtk-4.0.Gtk.Gesture

    connect(sigName: "begin", callback: Gesture.BeginSignalCallback): number
    on(
      sigName: "begin",
      callback: Gesture.BeginSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "begin",
      callback: Gesture.BeginSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "begin",
      callback: Gesture.BeginSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "begin", ...args: any[]): void
    connect(sigName: "cancel", callback: Gesture.CancelSignalCallback): number
    on(
      sigName: "cancel",
      callback: Gesture.CancelSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cancel",
      callback: Gesture.CancelSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cancel",
      callback: Gesture.CancelSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cancel", ...args: any[]): void
    connect(sigName: "end", callback: Gesture.EndSignalCallback): number
    on(
      sigName: "end",
      callback: Gesture.EndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "end",
      callback: Gesture.EndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "end",
      callback: Gesture.EndSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "end", ...args: any[]): void
    connect(
      sigName: "sequence-state-changed",
      callback: Gesture.SequenceStateChangedSignalCallback
    ): number
    on(
      sigName: "sequence-state-changed",
      callback: Gesture.SequenceStateChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "sequence-state-changed",
      callback: Gesture.SequenceStateChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "sequence-state-changed",
      callback: Gesture.SequenceStateChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "sequence-state-changed",
      state: EventSequenceState,
      ...args: any[]
    ): void
    connect(sigName: "update", callback: Gesture.UpdateSignalCallback): number
    on(
      sigName: "update",
      callback: Gesture.UpdateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "update",
      callback: Gesture.UpdateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "update",
      callback: Gesture.UpdateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "update", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Gesture

    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGesture` is the base class for gesture recognition.
   *
   * Although `GtkGesture` is quite generalized to serve as a base for
   * multi-touch gestures, it is suitable to implement single-touch and
   * pointer-based gestures (using the special %NULL `GdkEventSequence`
   * value for these).
   *
   * The number of touches that a `GtkGesture` need to be recognized is
   * controlled by the [property`Gtk`.Gesture:n-points] property, if a
   * gesture is keeping track of less or more than that number of sequences,
   * it won't check whether the gesture is recognized.
   *
   * As soon as the gesture has the expected number of touches, it will check
   * regularly if it is recognized, the criteria to consider a gesture as
   * "recognized" is left to `GtkGesture` subclasses.
   *
   * A recognized gesture will then emit the following signals:
   *
   * - [signal`Gtk`.Gesture::begin] when the gesture is recognized.
   * - [signal`Gtk`.Gesture::update], whenever an input event is processed.
   * - [signal`Gtk`.Gesture::end] when the gesture is no longer recognized.
   *
   * ## Event propagation
   *
   * In order to receive events, a gesture needs to set a propagation phase
   * through [method`Gtk`.EventController.set_propagation_phase].
   *
   * In the capture phase, events are propagated from the toplevel down
   * to the target widget, and gestures that are attached to containers
   * above the widget get a chance to interact with the event before it
   * reaches the target.
   *
   * In the bubble phase, events are propagated up from the target widget
   * to the toplevel, and gestures that are attached to containers above
   * the widget get a chance to interact with events that have not been
   * handled yet.
   *
   * ## States of a sequence
   *
   * Whenever input interaction happens, a single event may trigger a cascade
   * of `GtkGesture`s, both across the parents of the widget receiving the
   * event and in parallel within an individual widget. It is a responsibility
   * of the widgets using those gestures to set the state of touch sequences
   * accordingly in order to enable cooperation of gestures around the
   * `GdkEventSequence`s triggering those.
   *
   * Within a widget, gestures can be grouped through [method`Gtk`.Gesture.group].
   * Grouped gestures synchronize the state of sequences, so calling
   * [method`Gtk`.Gesture.set_state] on one will effectively propagate
   * the state throughout the group.
   *
   * By default, all sequences start out in the %GTK_EVENT_SEQUENCE_NONE state,
   * sequences in this state trigger the gesture event handler, but event
   * propagation will continue unstopped by gestures.
   *
   * If a sequence enters into the %GTK_EVENT_SEQUENCE_DENIED state, the gesture
   * group will effectively ignore the sequence, letting events go unstopped
   * through the gesture, but the "slot" will still remain occupied while
   * the touch is active.
   *
   * If a sequence enters in the %GTK_EVENT_SEQUENCE_CLAIMED state, the gesture
   * group will grab all interaction on the sequence, by:
   *
   * - Setting the same sequence to %GTK_EVENT_SEQUENCE_DENIED on every other
   *   gesture group within the widget, and every gesture on parent widgets
   *   in the propagation chain.
   * - Emitting [signal`Gtk`.Gesture::cancel] on every gesture in widgets
   *   underneath in the propagation chain.
   * - Stopping event propagation after the gesture group handles the event.
   *
   * Note: if a sequence is set early to %GTK_EVENT_SEQUENCE_CLAIMED on
   * %GDK_TOUCH_BEGIN/%GDK_BUTTON_PRESS (so those events are captured before
   * reaching the event widget, this implies %GTK_PHASE_CAPTURE), one similar
   * event will be emulated if the sequence changes to %GTK_EVENT_SEQUENCE_DENIED.
   * This way event coherence is preserved before event propagation is unstopped
   * again.
   *
   * Sequence states can't be changed freely.
   * See [method`Gtk`.Gesture.set_state] to know about the possible
   * lifetimes of a `GdkEventSequence`.
   *
   * ## Touchpad gestures
   *
   * On the platforms that support it, `GtkGesture` will handle transparently
   * touchpad gesture events. The only precautions users of `GtkGesture` should
   * do to enable this support are:
   *
   * - If the gesture has %GTK_PHASE_NONE, ensuring events of type
   *   %GDK_TOUCHPAD_SWIPE and %GDK_TOUCHPAD_PINCH are handled by the `GtkGesture`
   * @class
   */
  class Gesture extends EventController {
    // Own properties of Gtk-4.0.Gtk.Gesture

    static name: string

    // Constructors of Gtk-4.0.Gtk.Gesture

    constructor(config?: Gesture.ConstructorProperties)
    _init(config?: Gesture.ConstructorProperties): void
  }

  module GestureClick {
    // Signal callback interfaces

    /**
     * Signal callback interface for `pressed`
     */
    interface PressedSignalCallback {
      (nPress: number, x: number, y: number): void
    }

    /**
     * Signal callback interface for `released`
     */
    interface ReleasedSignalCallback {
      (nPress: number, x: number, y: number): void
    }

    /**
     * Signal callback interface for `stopped`
     */
    interface StoppedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `unpaired-release`
     */
    interface UnpairedReleaseSignalCallback {
      (
        x: number,
        y: number,
        button: number,
        sequence: Gdk.EventSequence | null
      ): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GestureSingle.ConstructorProperties {}
  }

  interface GestureClick {
    // Own properties of Gtk-4.0.Gtk.GestureClick

    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.GestureClick

    connect(
      sigName: "pressed",
      callback: GestureClick.PressedSignalCallback
    ): number
    on(
      sigName: "pressed",
      callback: GestureClick.PressedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "pressed",
      callback: GestureClick.PressedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "pressed",
      callback: GestureClick.PressedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "pressed", x: number, y: number, ...args: any[]): void
    connect(
      sigName: "released",
      callback: GestureClick.ReleasedSignalCallback
    ): number
    on(
      sigName: "released",
      callback: GestureClick.ReleasedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "released",
      callback: GestureClick.ReleasedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "released",
      callback: GestureClick.ReleasedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "released", x: number, y: number, ...args: any[]): void
    connect(
      sigName: "stopped",
      callback: GestureClick.StoppedSignalCallback
    ): number
    on(
      sigName: "stopped",
      callback: GestureClick.StoppedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "stopped",
      callback: GestureClick.StoppedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "stopped",
      callback: GestureClick.StoppedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "stopped", ...args: any[]): void
    connect(
      sigName: "unpaired-release",
      callback: GestureClick.UnpairedReleaseSignalCallback
    ): number
    on(
      sigName: "unpaired-release",
      callback: GestureClick.UnpairedReleaseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unpaired-release",
      callback: GestureClick.UnpairedReleaseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unpaired-release",
      callback: GestureClick.UnpairedReleaseSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "unpaired-release",
      y: number,
      button: number,
      sequence: Gdk.EventSequence | null,
      ...args: any[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.GestureClick

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button", ...args: any[]): void
    connect(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exclusive", ...args: any[]): void
    connect(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::touch-only", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGestureClick` is a `GtkGesture` implementation for clicks.
   *
   * It is able to recognize multiple clicks on a nearby zone, which
   * can be listened for through the [signal`Gtk`.GestureClick::pressed]
   * signal. Whenever time or distance between clicks exceed the GTK
   * defaults, [signal`Gtk`.GestureClick::stopped] is emitted, and the
   * click counter is reset.
   * @class
   */
  class GestureClick extends GestureSingle {
    // Own properties of Gtk-4.0.Gtk.GestureClick

    static name: string

    // Constructors of Gtk-4.0.Gtk.GestureClick

    constructor(config?: GestureClick.ConstructorProperties)
    /**
     * Returns a newly created `GtkGesture` that recognizes
     * single and multiple presses.
     * @constructor
     * @returns a newly created `GtkGestureClick`
     */
    constructor()
    /**
     * Returns a newly created `GtkGesture` that recognizes
     * single and multiple presses.
     * @constructor
     * @returns a newly created `GtkGestureClick`
     */
    static new(): GestureClick
    _init(config?: GestureClick.ConstructorProperties): void
  }

  module GestureDrag {
    // Signal callback interfaces

    /**
     * Signal callback interface for `drag-begin`
     */
    interface DragBeginSignalCallback {
      (startX: number, startY: number): void
    }

    /**
     * Signal callback interface for `drag-end`
     */
    interface DragEndSignalCallback {
      (offsetX: number, offsetY: number): void
    }

    /**
     * Signal callback interface for `drag-update`
     */
    interface DragUpdateSignalCallback {
      (offsetX: number, offsetY: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GestureSingle.ConstructorProperties {}
  }

  interface GestureDrag {
    // Own properties of Gtk-4.0.Gtk.GestureDrag

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GestureDrag

    /**
     * Gets the offset from the start point.
     *
     * If the `gesture` is active, this function returns %TRUE and
     * fills in `x` and `y` with the coordinates of the current point,
     * as an offset to the starting drag point.
     * @returns %TRUE if the gesture is active
     */
    getOffset(): [/* returnType */ boolean, /* x */ number, /* y */ number]
    /**
     * Gets the point where the drag started.
     *
     * If the `gesture` is active, this function returns %TRUE
     * and fills in `x` and `y` with the drag start coordinates,
     * in widget-relative coordinates.
     * @returns %TRUE if the gesture is active
     */
    getStartPoint(): [/* returnType */ boolean, /* x */ number, /* y */ number]

    // Own signals of Gtk-4.0.Gtk.GestureDrag

    connect(
      sigName: "drag-begin",
      callback: GestureDrag.DragBeginSignalCallback
    ): number
    on(
      sigName: "drag-begin",
      callback: GestureDrag.DragBeginSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-begin",
      callback: GestureDrag.DragBeginSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-begin",
      callback: GestureDrag.DragBeginSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drag-begin", startY: number, ...args: any[]): void
    connect(
      sigName: "drag-end",
      callback: GestureDrag.DragEndSignalCallback
    ): number
    on(
      sigName: "drag-end",
      callback: GestureDrag.DragEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-end",
      callback: GestureDrag.DragEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-end",
      callback: GestureDrag.DragEndSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drag-end", offsetY: number, ...args: any[]): void
    connect(
      sigName: "drag-update",
      callback: GestureDrag.DragUpdateSignalCallback
    ): number
    on(
      sigName: "drag-update",
      callback: GestureDrag.DragUpdateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "drag-update",
      callback: GestureDrag.DragUpdateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "drag-update",
      callback: GestureDrag.DragUpdateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "drag-update", offsetY: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GestureDrag

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button", ...args: any[]): void
    connect(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exclusive", ...args: any[]): void
    connect(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::touch-only", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGestureDrag` is a `GtkGesture` implementation for drags.
   *
   * The drag operation itself can be tracked throughout the
   * [signal`Gtk`.GestureDrag::drag-begin],
   * [signal`Gtk`.GestureDrag::drag-update] and
   * [signal`Gtk`.GestureDrag::drag-end] signals, and the relevant
   * coordinates can be extracted through
   * [method`Gtk`.GestureDrag.get_offset] and
   * [method`Gtk`.GestureDrag.get_start_point].
   * @class
   */
  class GestureDrag extends GestureSingle {
    // Own properties of Gtk-4.0.Gtk.GestureDrag

    static name: string

    // Constructors of Gtk-4.0.Gtk.GestureDrag

    constructor(config?: GestureDrag.ConstructorProperties)
    /**
     * Returns a newly created `GtkGesture` that recognizes drags.
     * @constructor
     * @returns a newly created `GtkGestureDrag`
     */
    constructor()
    /**
     * Returns a newly created `GtkGesture` that recognizes drags.
     * @constructor
     * @returns a newly created `GtkGestureDrag`
     */
    static new(): GestureDrag
    _init(config?: GestureDrag.ConstructorProperties): void
  }

  module GestureLongPress {
    // Signal callback interfaces

    /**
     * Signal callback interface for `cancelled`
     */
    interface CancelledSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `pressed`
     */
    interface PressedSignalCallback {
      (x: number, y: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GestureSingle.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GestureLongPress

      /**
       * Factor by which to modify the default timeout.
       */
      delay_factor?: number | null
    }
  }

  interface GestureLongPress {
    // Own properties of Gtk-4.0.Gtk.GestureLongPress

    /**
     * Factor by which to modify the default timeout.
     */
    delayFactor: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GestureLongPress

    /**
     * Returns the delay factor.
     * @returns the delay factor
     */
    getDelayFactor(): number
    /**
     * Applies the given delay factor.
     *
     * The default long press time will be multiplied by this value.
     * Valid values are in the range [0.5..2.0].
     * @param delayFactor The delay factor to apply
     */
    setDelayFactor(delayFactor: number): void

    // Own signals of Gtk-4.0.Gtk.GestureLongPress

    connect(
      sigName: "cancelled",
      callback: GestureLongPress.CancelledSignalCallback
    ): number
    on(
      sigName: "cancelled",
      callback: GestureLongPress.CancelledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cancelled",
      callback: GestureLongPress.CancelledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cancelled",
      callback: GestureLongPress.CancelledSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cancelled", ...args: any[]): void
    connect(
      sigName: "pressed",
      callback: GestureLongPress.PressedSignalCallback
    ): number
    on(
      sigName: "pressed",
      callback: GestureLongPress.PressedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "pressed",
      callback: GestureLongPress.PressedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "pressed",
      callback: GestureLongPress.PressedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "pressed", y: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GestureLongPress

    connect(
      sigName: "notify::delay-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::delay-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::delay-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::delay-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::delay-factor", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button", ...args: any[]): void
    connect(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exclusive", ...args: any[]): void
    connect(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::touch-only", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGestureLongPress` is a `GtkGesture` for long presses.
   *
   * This gesture is also known as “Press and Hold”.
   *
   * When the timeout is exceeded, the gesture is triggering the
   * [signal`Gtk`.GestureLongPress::pressed] signal.
   *
   * If the touchpoint is lifted before the timeout passes, or if
   * it drifts too far of the initial press point, the
   * [signal`Gtk`.GestureLongPress::cancelled] signal will be emitted.
   *
   * How long the timeout is before the ::pressed signal gets emitted is
   * determined by the [property`Gtk`.Settings:gtk-long-press-time] setting.
   * It can be modified by the [property`Gtk`.GestureLongPress:delay-factor]
   * property.
   * @class
   */
  class GestureLongPress extends GestureSingle {
    // Own properties of Gtk-4.0.Gtk.GestureLongPress

    static name: string

    // Constructors of Gtk-4.0.Gtk.GestureLongPress

    constructor(config?: GestureLongPress.ConstructorProperties)
    /**
     * Returns a newly created `GtkGesture` that recognizes long presses.
     * @constructor
     * @returns a newly created `GtkGestureLongPress`.
     */
    constructor()
    /**
     * Returns a newly created `GtkGesture` that recognizes long presses.
     * @constructor
     * @returns a newly created `GtkGestureLongPress`.
     */
    static new(): GestureLongPress
    _init(config?: GestureLongPress.ConstructorProperties): void
  }

  module GesturePan {
    // Signal callback interfaces

    /**
     * Signal callback interface for `pan`
     */
    interface PanSignalCallback {
      (direction: PanDirection, offset: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties extends GestureDrag.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GesturePan

      /**
       * The expected orientation of pan gestures.
       */
      orientation?: Orientation | null
    }
  }

  interface GesturePan {
    // Own properties of Gtk-4.0.Gtk.GesturePan

    /**
     * The expected orientation of pan gestures.
     */
    orientation: Orientation
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GesturePan

    /**
     * Returns the orientation of the pan gestures that this `gesture` expects.
     * @returns the expected orientation for pan gestures
     */
    getOrientation(): Orientation
    /**
     * Sets the orientation to be expected on pan gestures.
     * @param orientation expected orientation
     */
    setOrientation(orientation: Orientation): void

    // Own signals of Gtk-4.0.Gtk.GesturePan

    connect(sigName: "pan", callback: GesturePan.PanSignalCallback): number
    on(
      sigName: "pan",
      callback: GesturePan.PanSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "pan",
      callback: GesturePan.PanSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "pan",
      callback: GesturePan.PanSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "pan", offset: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GesturePan

    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button", ...args: any[]): void
    connect(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exclusive", ...args: any[]): void
    connect(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::touch-only", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGesturePan` is a `GtkGesture` for pan gestures.
   *
   * These are drags that are locked to happen along one axis. The axis
   * that a `GtkGesturePan` handles is defined at construct time, and
   * can be changed through [method`Gtk`.GesturePan.set_orientation].
   *
   * When the gesture starts to be recognized, `GtkGesturePan` will
   * attempt to determine as early as possible whether the sequence
   * is moving in the expected direction, and denying the sequence if
   * this does not happen.
   *
   * Once a panning gesture along the expected axis is recognized,
   * the [signal`Gtk`.GesturePan::pan] signal will be emitted as input
   * events are received, containing the offset in the given axis.
   * @class
   */
  class GesturePan extends GestureDrag {
    // Own properties of Gtk-4.0.Gtk.GesturePan

    static name: string

    // Constructors of Gtk-4.0.Gtk.GesturePan

    constructor(config?: GesturePan.ConstructorProperties)
    /**
     * Returns a newly created `GtkGesture` that recognizes pan gestures.
     * @constructor
     * @param orientation expected orientation
     * @returns a newly created `GtkGesturePan`
     */
    constructor(orientation: Orientation)
    /**
     * Returns a newly created `GtkGesture` that recognizes pan gestures.
     * @constructor
     * @param orientation expected orientation
     * @returns a newly created `GtkGesturePan`
     */
    static new(orientation: Orientation): GesturePan

    // Overloads of new

    /**
     * Returns a newly created `GtkGesture` that recognizes drags.
     * @constructor
     * @returns a newly created `GtkGestureDrag`
     */
    static new(): GestureDrag
    _init(config?: GesturePan.ConstructorProperties): void
  }

  module GestureRotate {
    // Signal callback interfaces

    /**
     * Signal callback interface for `angle-changed`
     */
    interface AngleChangedSignalCallback {
      (angle: number, angleDelta: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties extends Gesture.ConstructorProperties {}
  }

  interface GestureRotate {
    // Own properties of Gtk-4.0.Gtk.GestureRotate

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GestureRotate

    /**
     * Gets the angle delta in radians.
     *
     * If `gesture` is active, this function returns the angle difference
     * in radians since the gesture was first recognized. If `gesture` is
     * not active, 0 is returned.
     * @returns the angle delta in radians
     */
    getAngleDelta(): number

    // Own signals of Gtk-4.0.Gtk.GestureRotate

    connect(
      sigName: "angle-changed",
      callback: GestureRotate.AngleChangedSignalCallback
    ): number
    on(
      sigName: "angle-changed",
      callback: GestureRotate.AngleChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "angle-changed",
      callback: GestureRotate.AngleChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "angle-changed",
      callback: GestureRotate.AngleChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "angle-changed", angleDelta: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GestureRotate

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGestureRotate` is a `GtkGesture` for 2-finger rotations.
   *
   * Whenever the angle between both handled sequences changes, the
   * [signal`Gtk`.GestureRotate::angle-changed] signal is emitted.
   * @class
   */
  class GestureRotate extends Gesture {
    // Own properties of Gtk-4.0.Gtk.GestureRotate

    static name: string

    // Constructors of Gtk-4.0.Gtk.GestureRotate

    constructor(config?: GestureRotate.ConstructorProperties)
    /**
     * Returns a newly created `GtkGesture` that recognizes 2-touch
     * rotation gestures.
     * @constructor
     * @returns a newly created `GtkGestureRotate`
     */
    constructor()
    /**
     * Returns a newly created `GtkGesture` that recognizes 2-touch
     * rotation gestures.
     * @constructor
     * @returns a newly created `GtkGestureRotate`
     */
    static new(): GestureRotate
    _init(config?: GestureRotate.ConstructorProperties): void
  }

  module GestureSingle {
    // Constructor properties interface

    interface ConstructorProperties extends Gesture.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GestureSingle

      /**
       * Mouse button number to listen to, or 0 to listen for any button.
       */
      button?: number | null
      /**
       * Whether the gesture is exclusive.
       *
       * Exclusive gestures only listen to pointer and pointer emulated events.
       */
      exclusive?: boolean | null
      /**
       * Whether the gesture handles only touch events.
       */
      touch_only?: boolean | null
    }
  }

  interface GestureSingle {
    // Own properties of Gtk-4.0.Gtk.GestureSingle

    /**
     * Mouse button number to listen to, or 0 to listen for any button.
     */
    button: number
    /**
     * Whether the gesture is exclusive.
     *
     * Exclusive gestures only listen to pointer and pointer emulated events.
     */
    exclusive: boolean
    /**
     * Whether the gesture handles only touch events.
     */
    touchOnly: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GestureSingle

    /**
     * Returns the button number `gesture` listens for.
     *
     * If this is 0, the gesture reacts to any button press.
     * @returns The button number, or 0 for any button
     */
    getButton(): number
    /**
     * Returns the button number currently interacting
     * with `gesture,` or 0 if there is none.
     * @returns The current button number
     */
    getCurrentButton(): number
    /**
     * Returns the event sequence currently interacting with `gesture`.
     *
     * This is only meaningful if [method`Gtk`.Gesture.is_active]
     * returns %TRUE.
     * @returns the current sequence
     */
    getCurrentSequence(): Gdk.EventSequence | null
    /**
     * Gets whether a gesture is exclusive.
     *
     * For more information, see [method`Gtk`.GestureSingle.set_exclusive].
     * @returns Whether the gesture is exclusive
     */
    getExclusive(): boolean
    /**
     * Returns %TRUE if the gesture is only triggered by touch events.
     * @returns %TRUE if the gesture only handles touch events
     */
    getTouchOnly(): boolean
    /**
     * Sets the button number `gesture` listens to.
     *
     * If non-0, every button press from a different button
     * number will be ignored. Touch events implicitly match
     * with button 1.
     * @param button button number to listen to, or 0 for any button
     */
    setButton(button: number): void
    /**
     * Sets whether `gesture` is exclusive.
     *
     * An exclusive gesture will only handle pointer and "pointer emulated"
     * touch events, so at any given time, there is only one sequence able
     * to interact with those.
     * @param exclusive %TRUE to make `gesture` exclusive
     */
    setExclusive(exclusive: boolean): void
    /**
     * Sets whether to handle only touch events.
     *
     * If `touch_only` is %TRUE, `gesture` will only handle events of type
     * %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE or %GDK_TOUCH_END. If %FALSE,
     * mouse events will be handled too.
     * @param touchOnly whether `gesture` handles only touch events
     */
    setTouchOnly(touchOnly: boolean): void

    // Class property signals of Gtk-4.0.Gtk.GestureSingle

    connect(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button", ...args: any[]): void
    connect(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exclusive", ...args: any[]): void
    connect(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::touch-only", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGestureSingle` is a `GtkGestures` subclass optimized for singe-touch
   * and mouse gestures.
   *
   * Under interaction, these gestures stick to the first interacting sequence,
   * which is accessible through [method`Gtk`.GestureSingle.get_current_sequence]
   * while the gesture is being interacted with.
   *
   * By default gestures react to both %GDK_BUTTON_PRIMARY and touch events.
   * [method`Gtk`.GestureSingle.set_touch_only] can be used to change the
   * touch behavior. Callers may also specify a different mouse button number
   * to interact with through [method`Gtk`.GestureSingle.set_button], or react
   * to any mouse button by setting it to 0. While the gesture is active, the
   * button being currently pressed can be known through
   * [method`Gtk`.GestureSingle.get_current_button].
   * @class
   */
  class GestureSingle extends Gesture {
    // Own properties of Gtk-4.0.Gtk.GestureSingle

    static name: string

    // Constructors of Gtk-4.0.Gtk.GestureSingle

    constructor(config?: GestureSingle.ConstructorProperties)
    _init(config?: GestureSingle.ConstructorProperties): void
  }

  module GestureStylus {
    // Signal callback interfaces

    /**
     * Signal callback interface for `down`
     */
    interface DownSignalCallback {
      (x: number, y: number): void
    }

    /**
     * Signal callback interface for `motion`
     */
    interface MotionSignalCallback {
      (x: number, y: number): void
    }

    /**
     * Signal callback interface for `proximity`
     */
    interface ProximitySignalCallback {
      (x: number, y: number): void
    }

    /**
     * Signal callback interface for `up`
     */
    interface UpSignalCallback {
      (x: number, y: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GestureSingle.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GestureStylus

      /**
       * If this gesture should exclusively react to stylus input devices.
       */
      stylus_only?: boolean | null
    }
  }

  interface GestureStylus {
    // Own properties of Gtk-4.0.Gtk.GestureStylus

    /**
     * If this gesture should exclusively react to stylus input devices.
     */
    stylusOnly: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GestureStylus

    /**
     * Returns the current values for the requested `axes`.
     *
     * This function must be called from the handler of one of the
     * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
     * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
     * signals.
     * @param axes array of requested axes, terminated with %GDK_AXIS_IGNORE
     * @returns %TRUE if there is a current value for the axes
     */
    getAxes(
      axes: Gdk.AxisUse[]
    ): [/* returnType */ boolean, /* values */ number[]]
    /**
     * Returns the current value for the requested `axis`.
     *
     * This function must be called from the handler of one of the
     * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
     * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
     * signals.
     * @param axis requested device axis
     * @returns %TRUE if there is a current value for the axis
     */
    getAxis(axis: Gdk.AxisUse): [/* returnType */ boolean, /* value */ number]
    /**
     * Returns the accumulated backlog of tracking information.
     *
     * By default, GTK will limit rate of input events. On stylus input
     * where accuracy of strokes is paramount, this function returns the
     * accumulated coordinate/timing state before the emission of the
     * current [Gtk.GestureStylus::motion] signal.
     *
     * This function may only be called within a [signal`Gtk`.GestureStylus::motion]
     * signal handler, the state given in this signal and obtainable through
     * [method`Gtk`.GestureStylus.get_axis] express the latest (most up-to-date)
     * state in motion history.
     *
     * The `backlog` is provided in chronological order.
     * @returns %TRUE if there is a backlog to unfold in the current state.
     */
    getBacklog(): [/* returnType */ boolean, /* backlog */ Gdk.TimeCoord[]]
    /**
     * Returns the `GdkDeviceTool` currently driving input through this gesture.
     *
     * This function must be called from the handler of one of the
     * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
     * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
     * signals.
     * @returns The current stylus tool
     */
    getDeviceTool(): Gdk.DeviceTool | null
    /**
     * Checks whether the gesture is for styluses only.
     *
     * Stylus-only gestures will signal events exclusively from stylus
     * input devices.
     * @returns %TRUE if the gesture is only for stylus events
     */
    getStylusOnly(): boolean
    /**
     * Sets the state of stylus-only
     *
     * If true, the gesture will exclusively handle events from stylus input devices,
     * otherwise it'll handle events from any pointing device.
     * @param stylusOnly whether the gesture is used exclusively for stylus events
     */
    setStylusOnly(stylusOnly: boolean): void

    // Own signals of Gtk-4.0.Gtk.GestureStylus

    connect(sigName: "down", callback: GestureStylus.DownSignalCallback): number
    on(
      sigName: "down",
      callback: GestureStylus.DownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "down",
      callback: GestureStylus.DownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "down",
      callback: GestureStylus.DownSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "down", y: number, ...args: any[]): void
    connect(
      sigName: "motion",
      callback: GestureStylus.MotionSignalCallback
    ): number
    on(
      sigName: "motion",
      callback: GestureStylus.MotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "motion",
      callback: GestureStylus.MotionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "motion",
      callback: GestureStylus.MotionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "motion", y: number, ...args: any[]): void
    connect(
      sigName: "proximity",
      callback: GestureStylus.ProximitySignalCallback
    ): number
    on(
      sigName: "proximity",
      callback: GestureStylus.ProximitySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "proximity",
      callback: GestureStylus.ProximitySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "proximity",
      callback: GestureStylus.ProximitySignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "proximity", y: number, ...args: any[]): void
    connect(sigName: "up", callback: GestureStylus.UpSignalCallback): number
    on(
      sigName: "up",
      callback: GestureStylus.UpSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "up",
      callback: GestureStylus.UpSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "up",
      callback: GestureStylus.UpSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "up", y: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GestureStylus

    connect(
      sigName: "notify::stylus-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stylus-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stylus-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stylus-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stylus-only", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button", ...args: any[]): void
    connect(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exclusive", ...args: any[]): void
    connect(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::touch-only", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGestureStylus` is a `GtkGesture` specific to stylus input.
   *
   * The provided signals just relay the basic information of the
   * stylus events.
   * @class
   */
  class GestureStylus extends GestureSingle {
    // Own properties of Gtk-4.0.Gtk.GestureStylus

    static name: string

    // Constructors of Gtk-4.0.Gtk.GestureStylus

    constructor(config?: GestureStylus.ConstructorProperties)
    /**
     * Creates a new `GtkGestureStylus`.
     * @constructor
     * @returns a newly created stylus gesture
     */
    constructor()
    /**
     * Creates a new `GtkGestureStylus`.
     * @constructor
     * @returns a newly created stylus gesture
     */
    static new(): GestureStylus
    _init(config?: GestureStylus.ConstructorProperties): void
  }

  module GestureSwipe {
    // Signal callback interfaces

    /**
     * Signal callback interface for `swipe`
     */
    interface SwipeSignalCallback {
      (velocityX: number, velocityY: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GestureSingle.ConstructorProperties {}
  }

  interface GestureSwipe {
    // Own properties of Gtk-4.0.Gtk.GestureSwipe

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GestureSwipe

    /**
     * Gets the current velocity.
     *
     * If the gesture is recognized, this function returns %TRUE and fills
     * in `velocity_x` and `velocity_y` with the recorded velocity, as per the
     * last events processed.
     * @returns whether velocity could be calculated
     */
    getVelocity(): [
      /* returnType */ boolean,
      /* velocityX */ number,
      /* velocityY */ number,
    ]

    // Own signals of Gtk-4.0.Gtk.GestureSwipe

    connect(
      sigName: "swipe",
      callback: GestureSwipe.SwipeSignalCallback
    ): number
    on(
      sigName: "swipe",
      callback: GestureSwipe.SwipeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "swipe",
      callback: GestureSwipe.SwipeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "swipe",
      callback: GestureSwipe.SwipeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "swipe", velocityY: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GestureSwipe

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::button", ...args: any[]): void
    connect(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::exclusive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::exclusive", ...args: any[]): void
    connect(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::touch-only",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::touch-only", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGestureSwipe` is a `GtkGesture` for swipe gestures.
   *
   * After a press/move/.../move/release sequence happens, the
   * [signal`Gtk`.GestureSwipe::swipe] signal will be emitted,
   * providing the velocity and directionality of the sequence
   * at the time it was lifted.
   *
   * If the velocity is desired in intermediate points,
   * [method`Gtk`.GestureSwipe.get_velocity] can be called in a
   * [signal`Gtk`.Gesture::update] handler.
   *
   * All velocities are reported in pixels/sec units.
   * @class
   */
  class GestureSwipe extends GestureSingle {
    // Own properties of Gtk-4.0.Gtk.GestureSwipe

    static name: string

    // Constructors of Gtk-4.0.Gtk.GestureSwipe

    constructor(config?: GestureSwipe.ConstructorProperties)
    /**
     * Returns a newly created `GtkGesture` that recognizes swipes.
     * @constructor
     * @returns a newly created `GtkGestureSwipe`
     */
    constructor()
    /**
     * Returns a newly created `GtkGesture` that recognizes swipes.
     * @constructor
     * @returns a newly created `GtkGestureSwipe`
     */
    static new(): GestureSwipe
    _init(config?: GestureSwipe.ConstructorProperties): void
  }

  module GestureZoom {
    // Signal callback interfaces

    /**
     * Signal callback interface for `scale-changed`
     */
    interface ScaleChangedSignalCallback {
      (scale: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties extends Gesture.ConstructorProperties {}
  }

  interface GestureZoom {
    // Own properties of Gtk-4.0.Gtk.GestureZoom

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GestureZoom

    /**
     * Gets the scale delta.
     *
     * If `gesture` is active, this function returns the zooming
     * difference since the gesture was recognized (hence the
     * starting point is considered 1:1). If `gesture` is not
     * active, 1 is returned.
     * @returns the scale delta
     */
    getScaleDelta(): number

    // Own signals of Gtk-4.0.Gtk.GestureZoom

    connect(
      sigName: "scale-changed",
      callback: GestureZoom.ScaleChangedSignalCallback
    ): number
    on(
      sigName: "scale-changed",
      callback: GestureZoom.ScaleChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "scale-changed",
      callback: GestureZoom.ScaleChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "scale-changed",
      callback: GestureZoom.ScaleChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "scale-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GestureZoom

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-points", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGestureZoom` is a `GtkGesture` for 2-finger pinch/zoom gestures.
   *
   * Whenever the distance between both tracked sequences changes, the
   * [signal`Gtk`.GestureZoom::scale-changed] signal is emitted to report
   * the scale factor.
   * @class
   */
  class GestureZoom extends Gesture {
    // Own properties of Gtk-4.0.Gtk.GestureZoom

    static name: string

    // Constructors of Gtk-4.0.Gtk.GestureZoom

    constructor(config?: GestureZoom.ConstructorProperties)
    /**
     * Returns a newly created `GtkGesture` that recognizes
     * pinch/zoom gestures.
     * @constructor
     * @returns a newly created `GtkGestureZoom`
     */
    constructor()
    /**
     * Returns a newly created `GtkGesture` that recognizes
     * pinch/zoom gestures.
     * @constructor
     * @returns a newly created `GtkGestureZoom`
     */
    static new(): GestureZoom
    _init(config?: GestureZoom.ConstructorProperties): void
  }

  module GraphicsOffload {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GraphicsOffload

      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Whether graphics offload is enabled.
       */
      enabled?: GraphicsOffloadEnabled | null
    }
  }

  interface GraphicsOffload extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.GraphicsOffload

    /**
     * The child widget.
     */
    child: Widget
    /**
     * Whether graphics offload is enabled.
     */
    enabled: GraphicsOffloadEnabled
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GraphicsOffload

    /**
     * Gets the child of `self`.
     * @returns the child widget
     */
    getChild(): Widget | null
    /**
     * Returns whether offload is enabled for `self`.
     * @returns whether offload is enabled
     */
    getEnabled(): GraphicsOffloadEnabled
    /**
     * Sets the child of `self`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets whether this GtkGraphicsOffload widget will attempt
     * to offload the content of its child widget.
     * @param enabled whether to enable offload
     */
    setEnabled(enabled: GraphicsOffloadEnabled): void

    // Class property signals of Gtk-4.0.Gtk.GraphicsOffload

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enabled", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A widget that allows to bypass gsk rendering for its child by passing the content
   * directly to the compositor.
   *
   * Graphics offload is an optimization to reduce overhead and battery use that is
   * most useful for video content. It only works on some platforms and in certain
   * situations. GTK will automatically fall back to normal rendering if it doesn't.
   *
   * Graphics offload is most efficient if there are no controls drawn on top of the
   * video content.
   *
   * You should consider using graphics offload for your main widget if it shows
   * frequently changing content (such as a video, or a VM display) and you provide
   * the content in the form of dmabuf textures (see [class`Gdk`.DmabufTextureBuilder]),
   * in particular if it may be fullscreen.
   *
   * Numerous factors can prohibit graphics offload:
   *
   * - Unsupported platforms. Currently, graphics offload only works on Linux with Wayland.
   *
   * - Clipping, such as rounded corners that cause the video content to not be rectangular
   *
   * - Unsupported dmabuf formats (see [method`Gdk`.Display.get_dmabuf_formats])
   *
   * - Translucent video content (content with an alpha channel, even if it isn't used)
   *
   * - Transforms that are more complex than translations and scales
   *
   * - Filters such as opacity, grayscale or similar
   *
   * To investigate problems related graphics offload, GTK offers debug flags to print
   * out information about graphics offload and dmabuf use:
   *
   *     GDK_DEBUG=offload
   *     GDK_DEBUG=dmabuf
   *
   * The GTK inspector provides a visual debugging tool for graphics offload.
   * @class
   */
  class GraphicsOffload extends Widget {
    // Own properties of Gtk-4.0.Gtk.GraphicsOffload

    static name: string

    // Constructors of Gtk-4.0.Gtk.GraphicsOffload

    constructor(config?: GraphicsOffload.ConstructorProperties)
    /**
     * Creates a new GtkGraphicsOffload widget.
     * @constructor
     * @param child the child widget
     * @returns the new widget
     */
    constructor(child: Widget | null)
    /**
     * Creates a new GtkGraphicsOffload widget.
     * @constructor
     * @param child the child widget
     * @returns the new widget
     */
    static new(child: Widget | null): GraphicsOffload
    _init(config?: GraphicsOffload.ConstructorProperties): void
  }

  module Grid {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Grid

      /**
       * The row to align to the baseline when valign is using baseline alignment.
       */
      baseline_row?: number | null
      /**
       * If %TRUE, the columns are all the same width.
       */
      column_homogeneous?: boolean | null
      /**
       * The amount of space between two consecutive columns.
       */
      column_spacing?: number | null
      /**
       * If %TRUE, the rows are all the same height.
       */
      row_homogeneous?: boolean | null
      /**
       * The amount of space between two consecutive rows.
       */
      row_spacing?: number | null
    }
  }

  interface Grid extends Accessible, Buildable, ConstraintTarget, Orientable {
    // Own properties of Gtk-4.0.Gtk.Grid

    /**
     * The row to align to the baseline when valign is using baseline alignment.
     */
    baselineRow: number
    /**
     * If %TRUE, the columns are all the same width.
     */
    columnHomogeneous: boolean
    /**
     * The amount of space between two consecutive columns.
     */
    columnSpacing: number
    /**
     * If %TRUE, the rows are all the same height.
     */
    rowHomogeneous: boolean
    /**
     * The amount of space between two consecutive rows.
     */
    rowSpacing: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Grid

    /**
     * Adds a widget to the grid.
     *
     * The position of `child` is determined by `column` and `row`.
     * The number of “cells” that `child` will occupy is determined
     * by `width` and `height`.
     * @param child the widget to add
     * @param column the column number to attach the left side of `child` to
     * @param row the row number to attach the top side of `child` to
     * @param width the number of columns that `child` will span
     * @param height the number of rows that `child` will span
     */
    attach(
      child: Widget,
      column: number,
      row: number,
      width: number,
      height: number
    ): void
    /**
     * Adds a widget to the grid.
     *
     * The widget is placed next to `sibling,` on the side determined by
     * `side`. When `sibling` is %NULL, the widget is placed in row (for
     * left or right placement) or column 0 (for top or bottom placement),
     * at the end indicated by `side`.
     *
     * Attaching widgets labeled `[1]`, `[2]`, `[3]` with ``sibling` == %NULL` and
     * ``side` == %GTK_POS_LEFT` yields a layout of `[3][2][1]`.
     * @param child the widget to add
     * @param sibling the child of `grid` that `child` will be placed   next to, or %NULL to place `child` at the beginning or end
     * @param side the side of `sibling` that `child` is positioned next to
     * @param width the number of columns that `child` will span
     * @param height the number of rows that `child` will span
     */
    attachNextTo(
      child: Widget,
      sibling: Widget | null,
      side: PositionType,
      width: number,
      height: number
    ): void
    /**
     * Returns which row defines the global baseline of `grid`.
     * @returns the row index defining the global baseline
     */
    getBaselineRow(): number
    /**
     * Gets the child of `grid` whose area covers the grid
     * cell at `column,` `row`.
     * @param column the left edge of the cell
     * @param row the top edge of the cell
     * @returns the child at the given position
     */
    getChildAt(column: number, row: number): Widget | null
    /**
     * Returns whether all columns of `grid` have the same width.
     * @returns whether all columns of @grid have the same width.
     */
    getColumnHomogeneous(): boolean
    /**
     * Returns the amount of space between the columns of `grid`.
     * @returns the column spacing of @grid
     */
    getColumnSpacing(): number
    /**
     * Returns the baseline position of `row`.
     *
     * See [method`Gtk`.Grid.set_row_baseline_position].
     * @param row a row index
     * @returns the baseline position of @row
     */
    getRowBaselinePosition(row: number): BaselinePosition
    /**
     * Returns whether all rows of `grid` have the same height.
     * @returns whether all rows of @grid have the same height.
     */
    getRowHomogeneous(): boolean
    /**
     * Returns the amount of space between the rows of `grid`.
     * @returns the row spacing of @grid
     */
    getRowSpacing(): number
    /**
     * Inserts a column at the specified position.
     *
     * Children which are attached at or to the right of this position
     * are moved one column to the right. Children which span across this
     * position are grown to span the new column.
     * @param position the position to insert the column at
     */
    insertColumn(position: number): void
    /**
     * Inserts a row or column at the specified position.
     *
     * The new row or column is placed next to `sibling,` on the side
     * determined by `side`. If `side` is %GTK_POS_TOP or %GTK_POS_BOTTOM,
     * a row is inserted. If `side` is %GTK_POS_LEFT of %GTK_POS_RIGHT,
     * a column is inserted.
     * @param sibling the child of `grid` that the new row or column will be   placed next to
     * @param side the side of `sibling` that `child` is positioned next to
     */
    insertNextTo(sibling: Widget, side: PositionType): void
    /**
     * Inserts a row at the specified position.
     *
     * Children which are attached at or below this position
     * are moved one row down. Children which span across this
     * position are grown to span the new row.
     * @param position the position to insert the row at
     */
    insertRow(position: number): void
    /**
     * Queries the attach points and spans of `child` inside the given `GtkGrid`.
     * @param child a `GtkWidget` child of `grid`
     */
    queryChild(
      child: Widget
    ): [
      /* column */ number,
      /* row */ number,
      /* width */ number,
      /* height */ number,
    ]
    /**
     * Removes a child from `grid`.
     *
     * The child must have been added with
     * [method`Gtk`.Grid.attach] or [method`Gtk`.Grid.attach_next_to].
     * @param child the child widget to remove
     */
    remove(child: Widget): void
    /**
     * Removes a column from the grid.
     *
     * Children that are placed in this column are removed,
     * spanning children that overlap this column have their
     * width reduced by one, and children after the column
     * are moved to the left.
     * @param position the position of the column to remove
     */
    removeColumn(position: number): void
    /**
     * Removes a row from the grid.
     *
     * Children that are placed in this row are removed,
     * spanning children that overlap this row have their
     * height reduced by one, and children below the row
     * are moved up.
     * @param position the position of the row to remove
     */
    removeRow(position: number): void
    /**
     * Sets which row defines the global baseline for the entire grid.
     *
     * Each row in the grid can have its own local baseline, but only
     * one of those is global, meaning it will be the baseline in the
     * parent of the `grid`.
     * @param row the row index
     */
    setBaselineRow(row: number): void
    /**
     * Sets whether all columns of `grid` will have the same width.
     * @param homogeneous %TRUE to make columns homogeneous
     */
    setColumnHomogeneous(homogeneous: boolean): void
    /**
     * Sets the amount of space between columns of `grid`.
     * @param spacing the amount of space to insert between columns
     */
    setColumnSpacing(spacing: number): void
    /**
     * Sets how the baseline should be positioned on `row` of the
     * grid, in case that row is assigned more space than is requested.
     *
     * The default baseline position is %GTK_BASELINE_POSITION_CENTER.
     * @param row a row index
     * @param pos a `GtkBaselinePosition`
     */
    setRowBaselinePosition(row: number, pos: BaselinePosition): void
    /**
     * Sets whether all rows of `grid` will have the same height.
     * @param homogeneous %TRUE to make rows homogeneous
     */
    setRowHomogeneous(homogeneous: boolean): void
    /**
     * Sets the amount of space between rows of `grid`.
     * @param spacing the amount of space to insert between rows
     */
    setRowSpacing(spacing: number): void

    // Class property signals of Gtk-4.0.Gtk.Grid

    connect(
      sigName: "notify::baseline-row",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-row",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-row",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-row",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-row", ...args: any[]): void
    connect(
      sigName: "notify::column-homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column-homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column-homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column-homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column-homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column-spacing", ...args: any[]): void
    connect(
      sigName: "notify::row-homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::row-homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row-homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row-homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row-homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row-spacing", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGrid` is a container which arranges its child widgets in
   * rows and columns.
   *
   * ![An example GtkGrid](grid.png)
   *
   * It supports arbitrary positions and horizontal/vertical spans.
   *
   * Children are added using [method`Gtk`.Grid.attach]. They can span multiple
   * rows or columns. It is also possible to add a child next to an existing
   * child, using [method`Gtk`.Grid.attach_next_to]. To remove a child from the
   * grid, use [method`Gtk`.Grid.remove].
   *
   * The behaviour of `GtkGrid` when several children occupy the same grid
   * cell is undefined.
   *
   * # GtkGrid as GtkBuildable
   *
   * Every child in a `GtkGrid` has access to a custom [iface`Gtk`.Buildable]
   * element, called `<layout>`. It can by used to specify a position in the
   * grid and optionally spans. All properties that can be used in the `<layout>`
   * element are implemented by [class`Gtk`.GridLayoutChild].
   *
   * It is implemented by `GtkWidget` using [class`Gtk`.LayoutManager].
   *
   * To showcase it, here is a simple example:
   *
   * ```xml
   * <object class="GtkGrid" id="my_grid">
   *   <child>
   *     <object class="GtkButton" id="button1">
   *       <property name="label">Button 1</property>
   *       <layout>
   *         <property name="column">0</property>
   *         <property name="row">0</property>
   *       </layout>
   *     </object>
   *   </child>
   *   <child>
   *     <object class="GtkButton" id="button2">
   *       <property name="label">Button 2</property>
   *       <layout>
   *         <property name="column">1</property>
   *         <property name="row">0</property>
   *       </layout>
   *     </object>
   *   </child>
   *   <child>
   *     <object class="GtkButton" id="button3">
   *       <property name="label">Button 3</property>
   *       <layout>
   *         <property name="column">2</property>
   *         <property name="row">0</property>
   *         <property name="row-span">2</property>
   *       </layout>
   *     </object>
   *   </child>
   *   <child>
   *     <object class="GtkButton" id="button4">
   *       <property name="label">Button 4</property>
   *       <layout>
   *         <property name="column">0</property>
   *         <property name="row">1</property>
   *         <property name="column-span">2</property>
   *       </layout>
   *     </object>
   *   </child>
   * </object>
   * ```
   *
   * It organizes the first two buttons side-by-side in one cell each.
   * The third button is in the last column but spans across two rows.
   * This is defined by the `row-span` property. The last button is
   * located in the second row and spans across two columns, which is
   * defined by the `column-span` property.
   *
   * # CSS nodes
   *
   * `GtkGrid` uses a single CSS node with name `grid`.
   *
   * # Accessibility
   *
   * Until GTK 4.10, `GtkGrid` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   *
   * Starting from GTK 4.12, `GtkGrid` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
   * @class
   */
  class Grid extends Widget {
    // Own properties of Gtk-4.0.Gtk.Grid

    static name: string

    // Constructors of Gtk-4.0.Gtk.Grid

    constructor(config?: Grid.ConstructorProperties)
    /**
     * Creates a new grid widget.
     * @constructor
     * @returns the new `GtkGrid`
     */
    constructor()
    /**
     * Creates a new grid widget.
     * @constructor
     * @returns the new `GtkGrid`
     */
    static new(): Grid
    _init(config?: Grid.ConstructorProperties): void
  }

  module GridLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends LayoutManager.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GridLayout

      /**
       * The row to align to the baseline, when `GtkWidget:valign` is set
       * to %GTK_ALIGN_BASELINE.
       */
      baseline_row?: number | null
      /**
       * Whether all the columns in the grid have the same width.
       */
      column_homogeneous?: boolean | null
      /**
       * The amount of space between to consecutive columns.
       */
      column_spacing?: number | null
      /**
       * Whether all the rows in the grid have the same height.
       */
      row_homogeneous?: boolean | null
      /**
       * The amount of space between to consecutive rows.
       */
      row_spacing?: number | null
    }
  }

  interface GridLayout {
    // Own properties of Gtk-4.0.Gtk.GridLayout

    /**
     * The row to align to the baseline, when `GtkWidget:valign` is set
     * to %GTK_ALIGN_BASELINE.
     */
    baselineRow: number
    /**
     * Whether all the columns in the grid have the same width.
     */
    columnHomogeneous: boolean
    /**
     * The amount of space between to consecutive columns.
     */
    columnSpacing: number
    /**
     * Whether all the rows in the grid have the same height.
     */
    rowHomogeneous: boolean
    /**
     * The amount of space between to consecutive rows.
     */
    rowSpacing: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GridLayout

    /**
     * Retrieves the row set with gtk_grid_layout_set_baseline_row().
     * @returns the global baseline row
     */
    getBaselineRow(): number
    /**
     * Checks whether all columns of `grid` should have the same width.
     * @returns %TRUE if the columns are homogeneous, and %FALSE otherwise
     */
    getColumnHomogeneous(): boolean
    /**
     * Retrieves the spacing set with gtk_grid_layout_set_column_spacing().
     * @returns the spacing between consecutive columns
     */
    getColumnSpacing(): number
    /**
     * Returns the baseline position of `row`.
     *
     * If no value has been set with
     * [method`Gtk`.GridLayout.set_row_baseline_position],
     * the default value of %GTK_BASELINE_POSITION_CENTER
     * is returned.
     * @param row a row index
     * @returns the baseline position of @row
     */
    getRowBaselinePosition(row: number): BaselinePosition
    /**
     * Checks whether all rows of `grid` should have the same height.
     * @returns %TRUE if the rows are homogeneous, and %FALSE otherwise
     */
    getRowHomogeneous(): boolean
    /**
     * Retrieves the spacing set with gtk_grid_layout_set_row_spacing().
     * @returns the spacing between consecutive rows
     */
    getRowSpacing(): number
    /**
     * Sets which row defines the global baseline for the entire grid.
     *
     * Each row in the grid can have its own local baseline, but only
     * one of those is global, meaning it will be the baseline in the
     * parent of the `grid`.
     * @param row the row index
     */
    setBaselineRow(row: number): void
    /**
     * Sets whether all columns of `grid` should have the same width.
     * @param homogeneous %TRUE to make columns homogeneous
     */
    setColumnHomogeneous(homogeneous: boolean): void
    /**
     * Sets the amount of space to insert between consecutive columns.
     * @param spacing the amount of space between columns, in pixels
     */
    setColumnSpacing(spacing: number): void
    /**
     * Sets how the baseline should be positioned on `row` of the
     * grid, in case that row is assigned more space than is requested.
     * @param row a row index
     * @param pos a `GtkBaselinePosition`
     */
    setRowBaselinePosition(row: number, pos: BaselinePosition): void
    /**
     * Sets whether all rows of `grid` should have the same height.
     * @param homogeneous %TRUE to make rows homogeneous
     */
    setRowHomogeneous(homogeneous: boolean): void
    /**
     * Sets the amount of space to insert between consecutive rows.
     * @param spacing the amount of space between rows, in pixels
     */
    setRowSpacing(spacing: number): void

    // Class property signals of Gtk-4.0.Gtk.GridLayout

    connect(
      sigName: "notify::baseline-row",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-row",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-row",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-row",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-row", ...args: any[]): void
    connect(
      sigName: "notify::column-homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column-homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column-homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column-homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column-homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column-spacing", ...args: any[]): void
    connect(
      sigName: "notify::row-homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::row-homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row-homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row-homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row-homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row-spacing", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGridLayout` is a layout manager which arranges child widgets in
   * rows and columns.
   *
   * Children have an "attach point" defined by the horizontal and vertical
   * index of the cell they occupy; children can span multiple rows or columns.
   * The layout properties for setting the attach points and spans are set
   * using the [class`Gtk`.GridLayoutChild] associated to each child widget.
   *
   * The behaviour of `GtkGridLayout` when several children occupy the same
   * grid cell is undefined.
   *
   * `GtkGridLayout` can be used like a `GtkBoxLayout` if all children are
   * attached to the same row or column; however, if you only ever need a
   * single row or column, you should consider using `GtkBoxLayout`.
   * @class
   */
  class GridLayout extends LayoutManager {
    // Own properties of Gtk-4.0.Gtk.GridLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.GridLayout

    constructor(config?: GridLayout.ConstructorProperties)
    /**
     * Creates a new `GtkGridLayout`.
     * @constructor
     * @returns the newly created `GtkGridLayout`
     */
    constructor()
    /**
     * Creates a new `GtkGridLayout`.
     * @constructor
     * @returns the newly created `GtkGridLayout`
     */
    static new(): GridLayout
    _init(config?: GridLayout.ConstructorProperties): void
  }

  module GridLayoutChild {
    // Constructor properties interface

    interface ConstructorProperties extends LayoutChild.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GridLayoutChild

      /**
       * The column to place the child in.
       */
      column?: number | null
      /**
       * The number of columns the child spans to.
       */
      column_span?: number | null
      /**
       * The row to place the child in.
       */
      row?: number | null
      /**
       * The number of rows the child spans to.
       */
      row_span?: number | null
    }
  }

  interface GridLayoutChild {
    // Own properties of Gtk-4.0.Gtk.GridLayoutChild

    /**
     * The column to place the child in.
     */
    column: number
    /**
     * The number of columns the child spans to.
     */
    columnSpan: number
    /**
     * The row to place the child in.
     */
    row: number
    /**
     * The number of rows the child spans to.
     */
    rowSpan: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GridLayoutChild

    /**
     * Retrieves the column number to which `child` attaches its left side.
     * @returns the column number
     */
    getColumn(): number
    /**
     * Retrieves the number of columns that `child` spans to.
     * @returns the number of columns
     */
    getColumnSpan(): number
    /**
     * Retrieves the row number to which `child` attaches its top side.
     * @returns the row number
     */
    getRow(): number
    /**
     * Retrieves the number of rows that `child` spans to.
     * @returns the number of row
     */
    getRowSpan(): number
    /**
     * Sets the column number to attach the left side of `child`.
     * @param column the attach point for `child`
     */
    setColumn(column: number): void
    /**
     * Sets the number of columns `child` spans to.
     * @param span the span of `child`
     */
    setColumnSpan(span: number): void
    /**
     * Sets the row to place `child` in.
     * @param row the row for `child`
     */
    setRow(row: number): void
    /**
     * Sets the number of rows `child` spans to.
     * @param span the span of `child`
     */
    setRowSpan(span: number): void

    // Class property signals of Gtk-4.0.Gtk.GridLayoutChild

    connect(
      sigName: "notify::column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column", ...args: any[]): void
    connect(
      sigName: "notify::column-span",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column-span",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column-span",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column-span",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column-span", ...args: any[]): void
    connect(sigName: "notify::row", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::row",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row", ...args: any[]): void
    connect(
      sigName: "notify::row-span",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::row-span",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row-span",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row-span",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row-span", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child-widget", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkLayoutChild` subclass for children in a `GtkGridLayout`.
   * @class
   */
  class GridLayoutChild extends LayoutChild {
    // Own properties of Gtk-4.0.Gtk.GridLayoutChild

    static name: string

    // Constructors of Gtk-4.0.Gtk.GridLayoutChild

    constructor(config?: GridLayoutChild.ConstructorProperties)
    _init(config?: GridLayoutChild.ConstructorProperties): void
  }

  module GridView {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (position: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Scrollable.ConstructorProperties,
        ListBase.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.GridView

      /**
       * Allow rubberband selection.
       */
      enable_rubberband?: boolean | null
      /**
       * Factory for populating list items.
       */
      factory?: ListItemFactory | null
      /**
       * Maximum number of columns per row.
       *
       * If this number is smaller than [property`Gtk`.GridView:min-columns],
       * that value is used instead.
       */
      max_columns?: number | null
      /**
       * Minimum number of columns per row.
       */
      min_columns?: number | null
      /**
       * Model for the items displayed.
       */
      model?: SelectionModel | null
      /**
       * Activate rows on single click and select them on hover.
       */
      single_click_activate?: boolean | null
      /**
       * Behavior of the <kbd>Tab</kbd> key
       */
      tab_behavior?: ListTabBehavior | null
    }
  }

  interface GridView
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable,
      Scrollable {
    // Own properties of Gtk-4.0.Gtk.GridView

    /**
     * Allow rubberband selection.
     */
    enableRubberband: boolean
    /**
     * Factory for populating list items.
     */
    factory: ListItemFactory
    /**
     * Maximum number of columns per row.
     *
     * If this number is smaller than [property`Gtk`.GridView:min-columns],
     * that value is used instead.
     */
    maxColumns: number
    /**
     * Minimum number of columns per row.
     */
    minColumns: number
    /**
     * Model for the items displayed.
     */
    model: SelectionModel
    /**
     * Activate rows on single click and select them on hover.
     */
    singleClickActivate: boolean
    /**
     * Behavior of the <kbd>Tab</kbd> key
     */
    tabBehavior: ListTabBehavior
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.GridView

    /**
     * Returns whether rows can be selected by dragging with the mouse.
     * @returns %TRUE if rubberband selection is enabled
     */
    getEnableRubberband(): boolean
    /**
     * Gets the factory that's currently used to populate list items.
     * @returns The factory in use
     */
    getFactory(): ListItemFactory | null
    /**
     * Gets the maximum number of columns that the grid will use.
     * @returns The maximum number of columns
     */
    getMaxColumns(): number
    /**
     * Gets the minimum number of columns that the grid will use.
     * @returns The minimum number of columns
     */
    getMinColumns(): number
    /**
     * Gets the model that's currently used to read the items displayed.
     * @returns The model in use
     */
    getModel(): SelectionModel | null
    /**
     * Returns whether items will be activated on single click and
     * selected on hover.
     * @returns %TRUE if items are activated on single click
     */
    getSingleClickActivate(): boolean
    /**
     * Gets the behavior set for the <kbd>Tab</kbd> key.
     * @returns The behavior of the <kbd>Tab</kbd> key
     */
    getTabBehavior(): ListTabBehavior
    /**
     * Scrolls to the item at the given position and performs the actions
     * specified in `flags`.
     *
     * This function works no matter if the gridview is shown or focused.
     * If it isn't, then the changes will take effect once that happens.
     * @param pos position of the item
     * @param flags actions to perform
     * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
     */
    scrollTo(
      pos: number,
      flags: ListScrollFlags,
      scroll: ScrollInfo | null
    ): void
    /**
     * Sets whether selections can be changed by dragging with the mouse.
     * @param enableRubberband %TRUE to enable rubberband selection
     */
    setEnableRubberband(enableRubberband: boolean): void
    /**
     * Sets the `GtkListItemFactory` to use for populating list items.
     * @param factory the factory to use
     */
    setFactory(factory: ListItemFactory | null): void
    /**
     * Sets the maximum number of columns to use.
     *
     * This number must be at least 1.
     *
     * If `max_columns` is smaller than the minimum set via
     * [method`Gtk`.GridView.set_min_columns], that value is used instead.
     * @param maxColumns The maximum number of columns
     */
    setMaxColumns(maxColumns: number): void
    /**
     * Sets the minimum number of columns to use.
     *
     * This number must be at least 1.
     *
     * If `min_columns` is smaller than the minimum set via
     * [method`Gtk`.GridView.set_max_columns], that value is ignored.
     * @param minColumns The minimum number of columns
     */
    setMinColumns(minColumns: number): void
    /**
     * Sets the model to use.
     *
     * This must be a [iface`Gtk`.SelectionModel].
     * @param model the model to use
     */
    setModel(model: SelectionModel | null): void
    /**
     * Sets whether items should be activated on single click and
     * selected on hover.
     * @param singleClickActivate %TRUE to activate items on single click
     */
    setSingleClickActivate(singleClickActivate: boolean): void
    /**
     * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
     * @param tabBehavior The desired tab behavior
     */
    setTabBehavior(tabBehavior: ListTabBehavior): void

    // Own signals of Gtk-4.0.Gtk.GridView

    connect(
      sigName: "activate",
      callback: GridView.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: GridView.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: GridView.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: GridView.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.GridView

    connect(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-rubberband", ...args: any[]): void
    connect(
      sigName: "notify::factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::factory", ...args: any[]): void
    connect(
      sigName: "notify::max-columns",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-columns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-columns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-columns",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-columns", ...args: any[]): void
    connect(
      sigName: "notify::min-columns",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-columns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-columns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-columns",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-columns", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::single-click-activate", ...args: any[]): void
    connect(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tab-behavior", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkGridView` presents a large dynamic grid of items.
   *
   * `GtkGridView` uses its factory to generate one child widget for each
   * visible item and shows them in a grid. The orientation of the grid view
   * determines if the grid reflows vertically or horizontally.
   *
   * `GtkGridView` allows the user to select items according to the selection
   * characteristics of the model. For models that allow multiple selected items,
   * it is possible to turn on _rubberband selection_, using
   * [property`Gtk`.GridView:enable-rubberband].
   *
   * To learn more about the list widget framework, see the
   * [overview](section-list-widget.html).
   *
   * # CSS nodes
   *
   * ```
   * gridview
   * ├── child[.activatable]
   * │
   * ├── child[.activatable]
   * │
   * ┊
   * ╰── [rubberband]
   * ```
   *
   * `GtkGridView` uses a single CSS node with name `gridview`. Each child uses
   * a single CSS node with name `child`. If the [property`Gtk`.ListItem:activatable]
   * property is set, the corresponding row will have the `.activatable` style
   * class. For rubberband selection, a subnode with name `rubberband` is used.
   *
   * # Accessibility
   *
   * `GtkGridView` uses the %GTK_ACCESSIBLE_ROLE_GRID role, and the items
   * use the %GTK_ACCESSIBLE_ROLE_GRID_CELL role.
   * @class
   */
  class GridView extends ListBase {
    // Own properties of Gtk-4.0.Gtk.GridView

    static name: string

    // Constructors of Gtk-4.0.Gtk.GridView

    constructor(config?: GridView.ConstructorProperties)
    /**
     * Creates a new `GtkGridView` that uses the given `factory` for
     * mapping items to widgets.
     *
     * The function takes ownership of the
     * arguments, so you can write code like
     * ```c
     * grid_view = gtk_grid_view_new (create_model (),
     *   gtk_builder_list_item_factory_new_from_resource ("/resource.ui"));
     * ```
     * @constructor
     * @param model the model to use
     * @param factory The factory to populate items with
     * @returns a new `GtkGridView` using the given @model and @factory
     */
    constructor(model: SelectionModel | null, factory: ListItemFactory | null)
    /**
     * Creates a new `GtkGridView` that uses the given `factory` for
     * mapping items to widgets.
     *
     * The function takes ownership of the
     * arguments, so you can write code like
     * ```c
     * grid_view = gtk_grid_view_new (create_model (),
     *   gtk_builder_list_item_factory_new_from_resource ("/resource.ui"));
     * ```
     * @constructor
     * @param model the model to use
     * @param factory The factory to populate items with
     * @returns a new `GtkGridView` using the given @model and @factory
     */
    static new(
      model: SelectionModel | null,
      factory: ListItemFactory | null
    ): GridView
    _init(config?: GridView.ConstructorProperties): void
  }

  module HeaderBar {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.HeaderBar

      /**
       * The decoration layout for buttons.
       *
       * If this property is not set, the
       * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
       */
      decoration_layout?: string | null
      /**
       * Whether to show title buttons like close, minimize, maximize.
       *
       * Which buttons are actually shown and where is determined
       * by the [property`Gtk`.HeaderBar:decoration-layout] property,
       * and by the state of the window (e.g. a close button will not
       * be shown if the window can't be closed).
       */
      show_title_buttons?: boolean | null
      title_widget?: Widget | null
    }
  }

  interface HeaderBar extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.HeaderBar

    /**
     * The decoration layout for buttons.
     *
     * If this property is not set, the
     * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
     */
    decorationLayout: string | null
    /**
     * Whether to show title buttons like close, minimize, maximize.
     *
     * Which buttons are actually shown and where is determined
     * by the [property`Gtk`.HeaderBar:decoration-layout] property,
     * and by the state of the window (e.g. a close button will not
     * be shown if the window can't be closed).
     */
    showTitleButtons: boolean
    titleWidget: Widget
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.HeaderBar

    /**
     * Gets the decoration layout of the `GtkHeaderBar`.
     * @returns the decoration layout
     */
    getDecorationLayout(): string | null
    /**
     * Returns whether this header bar shows the standard window
     * title buttons.
     * @returns %TRUE if title buttons are shown
     */
    getShowTitleButtons(): boolean
    /**
     * Retrieves the title widget of the header.
     *
     * See [method`Gtk`.HeaderBar.set_title_widget].
     * @returns the title widget of the header
     */
    getTitleWidget(): Widget | null
    /**
     * Adds `child` to `bar,` packed with reference to the
     * end of the `bar`.
     * @param child the `GtkWidget` to be added to `bar`
     */
    packEnd(child: Widget): void
    /**
     * Adds `child` to `bar,` packed with reference to the
     * start of the `bar`.
     * @param child the `GtkWidget` to be added to `bar`
     */
    packStart(child: Widget): void
    /**
     * Removes a child from the `GtkHeaderBar`.
     *
     * The child must have been added with
     * [method`Gtk`.HeaderBar.pack_start],
     * [method`Gtk`.HeaderBar.pack_end] or
     * [method`Gtk`.HeaderBar.set_title_widget].
     * @param child the child to remove
     */
    remove(child: Widget): void
    /**
     * Sets the decoration layout for this header bar.
     *
     * This property overrides the
     * [property`Gtk`.Settings:gtk-decoration-layout] setting.
     *
     * There can be valid reasons for overriding the setting, such
     * as a header bar design that does not allow for buttons to take
     * room on the right, or only offers room for a single close button.
     * Split header bars are another example for overriding the setting.
     *
     * The format of the string is button names, separated by commas.
     * A colon separates the buttons that should appear on the left
     * from those on the right. Recognized button names are minimize,
     * maximize, close and icon (the window icon).
     *
     * For example, “icon:minimize,maximize,close” specifies an icon
     * on the left, and minimize, maximize and close buttons on the right.
     * @param layout a decoration layout, or %NULL to unset the layout
     */
    setDecorationLayout(layout: string | null): void
    /**
     * Sets whether this header bar shows the standard window
     * title buttons.
     * @param setting %TRUE to show standard title buttons
     */
    setShowTitleButtons(setting: boolean): void
    /**
     * Sets the title for the `GtkHeaderBar`.
     *
     * When set to %NULL, the headerbar will display the title of
     * the window it is contained in.
     *
     * The title should help a user identify the current view.
     * To achieve the same style as the builtin title, use the
     * “title” style class.
     *
     * You should set the title widget to %NULL, for the window
     * title label to be visible again.
     * @param titleWidget a widget to use for a title
     */
    setTitleWidget(titleWidget: Widget | null): void

    // Class property signals of Gtk-4.0.Gtk.HeaderBar

    connect(
      sigName: "notify::decoration-layout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decoration-layout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decoration-layout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decoration-layout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decoration-layout", ...args: any[]): void
    connect(
      sigName: "notify::show-title-buttons",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-title-buttons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-title-buttons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-title-buttons",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-title-buttons", ...args: any[]): void
    connect(
      sigName: "notify::title-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title-widget", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkHeaderBar` is a widget for creating custom title bars for windows.
   *
   * ![An example GtkHeaderBar](headerbar.png)
   *
   * `GtkHeaderBar` is similar to a horizontal `GtkCenterBox`. It allows
   * children to be placed at the start or the end. In addition, it allows
   * the window title to be displayed. The title will be centered with respect
   * to the width of the box, even if the children at either side take up
   * different amounts of space.
   *
   * `GtkHeaderBar` can add typical window frame controls, such as minimize,
   * maximize and close buttons, or the window icon.
   *
   * For these reasons, `GtkHeaderBar` is the natural choice for use as the
   * custom titlebar widget of a `GtkWindow` (see [method`Gtk`.Window.set_titlebar]),
   * as it gives features typical of titlebars while allowing the addition of
   * child widgets.
   *
   * ## GtkHeaderBar as GtkBuildable
   *
   * The `GtkHeaderBar` implementation of the `GtkBuildable` interface supports
   * adding children at the start or end sides by specifying “start” or “end” as
   * the “type” attribute of a `<child>` element, or setting the title widget by
   * specifying “title” value.
   *
   * By default the `GtkHeaderBar` uses a `GtkLabel` displaying the title of the
   * window it is contained in as the title widget, equivalent to the following
   * UI definition:
   *
   * ```xml
   * <object class="GtkHeaderBar">
   *   <property name="title-widget">
   *     <object class="GtkLabel">
   *       <property name="label" translatable="yes">Label</property>
   *       <property name="single-line-mode">True</property>
   *       <property name="ellipsize">end</property>
   *       <property name="width-chars">5</property>
   *       <style>
   *         <class name="title"/>
   *       </style>
   *     </object>
   *   </property>
   * </object>
   * ```
   *
   * # CSS nodes
   *
   * ```
   * headerbar
   * ╰── windowhandle
   *     ╰── box
   *         ├── box.start
   *         │   ├── windowcontrols.start
   *         │   ╰── [other children]
   *         ├── [Title Widget]
   *         ╰── box.end
   *             ├── [other children]
   *             ╰── windowcontrols.end
   * ```
   *
   * A `GtkHeaderBar`'s CSS node is called `headerbar`. It contains a `windowhandle`
   * subnode, which contains a `box` subnode, which contains two `box` subnodes at
   * the start and end of the header bar, as well as a center node that represents
   * the title.
   *
   * Each of the boxes contains a `windowcontrols` subnode, see
   * [class`Gtk`.WindowControls] for details, as well as other children.
   *
   * # Accessibility
   *
   * `GtkHeaderBar` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
   * @class
   */
  class HeaderBar extends Widget {
    // Own properties of Gtk-4.0.Gtk.HeaderBar

    static name: string

    // Constructors of Gtk-4.0.Gtk.HeaderBar

    constructor(config?: HeaderBar.ConstructorProperties)
    /**
     * Creates a new `GtkHeaderBar` widget.
     * @constructor
     * @returns a new `GtkHeaderBar`
     */
    constructor()
    /**
     * Creates a new `GtkHeaderBar` widget.
     * @constructor
     * @returns a new `GtkHeaderBar`
     */
    static new(): HeaderBar
    _init(config?: HeaderBar.ConstructorProperties): void
  }

  module IMContext {
    // Signal callback interfaces

    /**
     * Signal callback interface for `commit`
     */
    interface CommitSignalCallback {
      (str: string | null): void
    }

    /**
     * Signal callback interface for `delete-surrounding`
     */
    interface DeleteSurroundingSignalCallback {
      (offset: number, nChars: number): boolean
    }

    /**
     * Signal callback interface for `preedit-changed`
     */
    interface PreeditChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `preedit-end`
     */
    interface PreeditEndSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `preedit-start`
     */
    interface PreeditStartSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `retrieve-surrounding`
     */
    interface RetrieveSurroundingSignalCallback {
      (): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.IMContext

      /**
       * Additional hints that allow input methods to fine-tune
       * their behaviour.
       */
      input_hints?: InputHints | null
      /**
       * The purpose of the text field that the `GtkIMContext is connected to.
       *
       * This property can be used by on-screen keyboards and other input
       * methods to adjust their behaviour.
       */
      input_purpose?: InputPurpose | null
    }
  }

  interface IMContext {
    // Own properties of Gtk-4.0.Gtk.IMContext

    /**
     * Additional hints that allow input methods to fine-tune
     * their behaviour.
     */
    inputHints: InputHints
    /**
     * The purpose of the text field that the `GtkIMContext is connected to.
     *
     * This property can be used by on-screen keyboards and other input
     * methods to adjust their behaviour.
     */
    inputPurpose: InputPurpose
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.IMContext

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.IMContext

    // Has conflict: activateOsk(event: Gdk.Event | null): boolean
    // Has conflict: deleteSurrounding(offset: number, nChars: number): boolean
    /**
     * Allow an input method to forward key press and release events
     * to another input method without necessarily having a `GdkEvent`
     * available.
     * @param press whether to forward a key press or release event
     * @param surface the surface the event is for
     * @param device the device that the event is for
     * @param time the timestamp for the event
     * @param keycode the keycode for the event
     * @param state modifier state for the event
     * @param group the active keyboard group for the event
     * @returns %TRUE if the input method handled the key event.
     */
    filterKey(
      press: boolean,
      surface: Gdk.Surface,
      device: Gdk.Device,
      time: number,
      keycode: number,
      state: Gdk.ModifierType,
      group: number
    ): boolean
    // Has conflict: filterKeypress(event: Gdk.Event): boolean
    // Has conflict: focusIn(): void
    // Has conflict: focusOut(): void
    // Has conflict: getPreeditString(): [ /* str */ string | null, /* attrs */ Pango.AttrList, /* cursorPos */ number ]
    // Has conflict: getSurrounding(): [ /* returnType */ boolean, /* text */ string | null, /* cursorIndex */ number ]
    // Has conflict: getSurroundingWithSelection(): [ /* returnType */ boolean, /* text */ string | null, /* cursorIndex */ number, /* anchorIndex */ number ]
    // Has conflict: reset(): void
    // Has conflict: setClientWidget(widget: Widget | null): void
    // Has conflict: setCursorLocation(area: Gdk.Rectangle): void
    // Has conflict: setSurrounding(text: string, len: number, cursorIndex: number): void
    // Has conflict: setSurroundingWithSelection(text: string, len: number, cursorIndex: number, anchorIndex: number): void
    // Has conflict: setUsePreedit(usePreedit: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.IMContext

    activateOsk(): void
    activateOskWithEvent(event: Gdk.Event): boolean
    /**
     * Default handler of the [signal`Gtk`.IMContext::commit] signal.
     * @virtual
     * @param str
     */
    commit(str: string): void
    /**
     * Asks the widget that the input context is attached to delete
     * characters around the cursor position by emitting the
     * `::delete_surrounding` signal.
     *
     * Note that `offset` and `n_chars` are in characters not in bytes
     * which differs from the usage other places in `GtkIMContext`.
     *
     * In order to use this function, you should first call
     * [method`Gtk`.IMContext.get_surrounding] to get the current context,
     * and call this function immediately afterwards to make sure that you
     * know what you are deleting. You should also account for the fact
     * that even if the signal was handled, the input context might not
     * have deleted all the characters that were requested to be deleted.
     *
     * This function is used by an input method that wants to make
     * substitutions in the existing text in response to new input.
     * It is not useful for applications.
     * @virtual
     * @param offset offset from cursor position in chars;    a negative value means start before the cursor.
     * @param nChars number of characters to delete.
     * @returns %TRUE if the signal was handled.
     */
    deleteSurrounding(offset: number, nChars: number): boolean
    /**
     * Allow an input method to internally handle key press and release
     * events.
     *
     * If this function returns %TRUE, then no further processing
     * should be done for this key event.
     * @virtual
     * @param event the key event
     * @returns %TRUE if the input method handled the key event.
     */
    filterKeypress(event: Gdk.Event): boolean
    /**
     * Notify the input method that the widget to which this
     * input context corresponds has gained focus.
     *
     * The input method may, for example, change the displayed
     * feedback to reflect this change.
     * @virtual
     */
    focusIn(): void
    /**
     * Notify the input method that the widget to which this
     * input context corresponds has lost focus.
     *
     * The input method may, for example, change the displayed
     * feedback or reset the contexts state to reflect this change.
     * @virtual
     */
    focusOut(): void
    /**
     * Retrieve the current preedit string for the input context,
     * and a list of attributes to apply to the string.
     *
     * This string should be displayed inserted at the insertion point.
     * @virtual
     */
    getPreeditString(): [
      /* str */ string | null,
      /* attrs */ Pango.AttrList,
      /* cursorPos */ number,
    ]
    /**
     * Retrieves context around the insertion point.
     *
     * Input methods typically want context in order to constrain input text
     * based on existing text; this is important for languages such as Thai
     * where only some sequences of characters are allowed.
     *
     * This function is implemented by emitting the
     * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
     * in response to this signal, a widget should provide as much context as
     * is available, up to an entire paragraph, by calling
     * [method`Gtk`.IMContext.set_surrounding].
     *
     * Note that there is no obligation for a widget to respond to the
     * `::retrieve-surrounding` signal, so input methods must be prepared to
     * function without context.
     * @virtual
     * @returns `TRUE` if surrounding text was provided; in this case    you must free the result stored in `text`.
     */
    getSurrounding(): [
      /* returnType */ boolean,
      /* text */ string | null,
      /* cursorIndex */ number,
    ]
    /**
     * Retrieves context around the insertion point.
     *
     * Input methods typically want context in order to constrain input
     * text based on existing text; this is important for languages such
     * as Thai where only some sequences of characters are allowed.
     *
     * This function is implemented by emitting the
     * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
     * in response to this signal, a widget should provide as much context as
     * is available, up to an entire paragraph, by calling
     * [method`Gtk`.IMContext.set_surrounding_with_selection].
     *
     * Note that there is no obligation for a widget to respond to the
     * `::retrieve-surrounding` signal, so input methods must be prepared to
     * function without context.
     * @virtual
     * @returns `TRUE` if surrounding text was provided; in this case   you must free the result stored in `text`.
     */
    getSurroundingWithSelection(): [
      /* returnType */ boolean,
      /* text */ string | null,
      /* cursorIndex */ number,
      /* anchorIndex */ number,
    ]
    /**
     * Default handler of the [signal`Gtk`.IMContext::preedit-changed]
     *   signal.
     * @virtual
     */
    preeditChanged(): void
    /**
     * Default handler of the [signal`Gtk`.IMContext::preedit-end] signal.
     * @virtual
     */
    preeditEnd(): void
    /**
     * Default handler of the [signal`Gtk`.IMContext::preedit-start] signal.
     * @virtual
     */
    preeditStart(): void
    /**
     * Notify the input method that a change such as a change in cursor
     * position has been made.
     *
     * This will typically cause the input method to clear the preedit state.
     * @virtual
     */
    reset(): void
    /**
     * Default handler of the
     *   [signal`Gtk`.IMContext::retrieve-surrounding] signal.
     * @virtual
     */
    retrieveSurrounding(): boolean
    /**
     * Set the client widget for the input context.
     *
     * This is the `GtkWidget` holding the input focus. This widget is
     * used in order to correctly position status windows, and may
     * also be used for purposes internal to the input method.
     * @virtual
     * @param widget the client widget. This may be %NULL to indicate   that the previous client widget no longer exists.
     */
    setClientWidget(widget: Widget | null): void
    /**
     * Notify the input method that a change in cursor
     * position has been made.
     *
     * The location is relative to the client widget.
     * @virtual
     * @param area new location
     */
    setCursorLocation(area: Gdk.Rectangle): void
    /**
     * Sets surrounding context around the insertion point and preedit
     * string.
     *
     * This function is expected to be called in response to the
     * [signal`Gtk`.IMContext::retrieve-surrounding] signal, and will
     * likely have no effect if called at other times.
     * @virtual
     * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within `text`
     * @param len the length of `text,` or -1 if `text` is nul-terminated
     * @param cursorIndex the byte index of the insertion cursor within `text`.
     */
    setSurrounding(text: string, len: number, cursorIndex: number): void
    /**
     * Sets surrounding context around the insertion point and preedit
     * string. This function is expected to be called in response to the
     * [signal`Gtk`.IMContext::retrieve_surrounding] signal, and will likely
     * have no effect if called at other times.
     * @virtual
     * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within `text`
     * @param len the length of `text,` or -1 if `text` is nul-terminated
     * @param cursorIndex the byte index of the insertion cursor within `text`
     * @param anchorIndex the byte index of the selection bound within `text`
     */
    setSurroundingWithSelection(
      text: string,
      len: number,
      cursorIndex: number,
      anchorIndex: number
    ): void
    /**
     * Sets whether the IM context should use the preedit string
     * to display feedback.
     *
     * If `use_preedit` is %FALSE (default is %TRUE), then the IM context
     * may use some other method to display feedback, such as displaying
     * it in a child of the root window.
     * @virtual
     * @param usePreedit whether the IM context should use the preedit string.
     */
    setUsePreedit(usePreedit: boolean): void

    // Own signals of Gtk-4.0.Gtk.IMContext

    connect(sigName: "commit", callback: IMContext.CommitSignalCallback): number
    on(
      sigName: "commit",
      callback: IMContext.CommitSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "commit",
      callback: IMContext.CommitSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "commit",
      callback: IMContext.CommitSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "commit", ...args: any[]): void
    connect(
      sigName: "delete-surrounding",
      callback: IMContext.DeleteSurroundingSignalCallback
    ): number
    on(
      sigName: "delete-surrounding",
      callback: IMContext.DeleteSurroundingSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "delete-surrounding",
      callback: IMContext.DeleteSurroundingSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "delete-surrounding",
      callback: IMContext.DeleteSurroundingSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "delete-surrounding", nChars: number, ...args: any[]): void
    connect(
      sigName: "preedit-changed",
      callback: IMContext.PreeditChangedSignalCallback
    ): number
    on(
      sigName: "preedit-changed",
      callback: IMContext.PreeditChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "preedit-changed",
      callback: IMContext.PreeditChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "preedit-changed",
      callback: IMContext.PreeditChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "preedit-changed", ...args: any[]): void
    connect(
      sigName: "preedit-end",
      callback: IMContext.PreeditEndSignalCallback
    ): number
    on(
      sigName: "preedit-end",
      callback: IMContext.PreeditEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "preedit-end",
      callback: IMContext.PreeditEndSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "preedit-end",
      callback: IMContext.PreeditEndSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "preedit-end", ...args: any[]): void
    connect(
      sigName: "preedit-start",
      callback: IMContext.PreeditStartSignalCallback
    ): number
    on(
      sigName: "preedit-start",
      callback: IMContext.PreeditStartSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "preedit-start",
      callback: IMContext.PreeditStartSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "preedit-start",
      callback: IMContext.PreeditStartSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "preedit-start", ...args: any[]): void
    connect(
      sigName: "retrieve-surrounding",
      callback: IMContext.RetrieveSurroundingSignalCallback
    ): number
    on(
      sigName: "retrieve-surrounding",
      callback: IMContext.RetrieveSurroundingSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "retrieve-surrounding",
      callback: IMContext.RetrieveSurroundingSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "retrieve-surrounding",
      callback: IMContext.RetrieveSurroundingSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "retrieve-surrounding", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.IMContext

    connect(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-hints", ...args: any[]): void
    connect(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-purpose", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkIMContext` defines the interface for GTK input methods.
   *
   * `GtkIMContext` is used by GTK text input widgets like `GtkText`
   * to map from key events to Unicode character strings.
   *
   * An input method may consume multiple key events in sequence before finally
   * outputting the composed result. This is called *preediting*, and an input
   * method may provide feedback about this process by displaying the intermediate
   * composition states as preedit text. To do so, the `GtkIMContext` will emit
   * [signal`Gtk`.IMContext::preedit-start], [signal`Gtk`.IMContext::preedit-changed]
   * and [signal`Gtk`.IMContext::preedit-end] signals.
   *
   * For instance, the built-in GTK input method [class`Gtk`.IMContextSimple]
   * implements the input of arbitrary Unicode code points by holding down the
   * <kbd>Control</kbd> and <kbd>Shift</kbd> keys and then typing <kbd>u</kbd>
   * followed by the hexadecimal digits of the code point. When releasing the
   * <kbd>Control</kbd> and <kbd>Shift</kbd> keys, preediting ends and the
   * character is inserted as text. For example,
   *
   *     Ctrl+Shift+u 2 0 A C
   *
   * results in the € sign.
   *
   * Additional input methods can be made available for use by GTK widgets as
   * loadable modules. An input method module is a small shared library which
   * provides a `GIOExtension` for the extension point named "gtk-im-module".
   *
   * To connect a widget to the users preferred input method, you should use
   * [class`Gtk`.IMMulticontext].
   * @class
   */
  class IMContext extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.IMContext

    static name: string

    // Constructors of Gtk-4.0.Gtk.IMContext

    constructor(config?: IMContext.ConstructorProperties)
    _init(config?: IMContext.ConstructorProperties): void
  }

  module IMContextSimple {
    // Constructor properties interface

    interface ConstructorProperties extends IMContext.ConstructorProperties {}
  }

  interface IMContextSimple {
    // Own properties of Gtk-4.0.Gtk.IMContextSimple

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.IMContextSimple

    object: IMContext

    // Owm methods of Gtk-4.0.Gtk.IMContextSimple

    /**
     * Adds an additional table from the X11 compose file.
     * @param composeFile The path of compose file
     */
    addComposeFile(composeFile: string): void

    // Class property signals of Gtk-4.0.Gtk.IMContextSimple

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-hints", ...args: any[]): void
    connect(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-purpose", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkIMContextSimple` is an input method supporting table-based input methods.
   *
   * ## Compose sequences
   *
   * `GtkIMContextSimple` reads compose sequences from the first of the
   * following files that is found: ~/.config/gtk-4.0/Compose, ~/.XCompose,
   * /usr/share/X11/locale/$locale/Compose (for locales that have a nontrivial
   * Compose file). A subset of the file syntax described in the Compose(5)
   * manual page is supported. Additionally, `include "%L"` loads GTK’s built-in
   * table of compose sequences rather than the locale-specific one from X11.
   *
   * If none of these files is found, `GtkIMContextSimple` uses a built-in table
   * of compose sequences that is derived from the X11 Compose files.
   *
   * Note that compose sequences typically start with the Compose_key, which is
   * often not available as a dedicated key on keyboards. Keyboard layouts may
   * map this keysym to other keys, such as the right Control key.
   *
   * ## Unicode characters
   *
   * `GtkIMContextSimple` also supports numeric entry of Unicode characters
   * by typing <kbd>Ctrl</kbd>-<kbd>Shift</kbd>-<kbd>u</kbd>, followed by a
   * hexadecimal Unicode codepoint.
   *
   * For example,
   *
   *     Ctrl-Shift-u 1 2 3 Enter
   *
   * yields U+0123 LATIN SMALL LETTER G WITH CEDILLA, i.e. ģ.
   *
   * ## Dead keys
   *
   * `GtkIMContextSimple` supports dead keys. For example, typing
   *
   *     dead_acute a
   *
   *  yields U+00E! LATIN SMALL LETTER_A WITH ACUTE, i.e. á. Note that this
   *  depends on the keyboard layout including dead keys.
   * @class
   */
  class IMContextSimple extends IMContext {
    // Own properties of Gtk-4.0.Gtk.IMContextSimple

    static name: string

    // Constructors of Gtk-4.0.Gtk.IMContextSimple

    constructor(config?: IMContextSimple.ConstructorProperties)
    /**
     * Creates a new `GtkIMContextSimple`.
     * @constructor
     * @returns a new `GtkIMContextSimple`
     */
    constructor()
    /**
     * Creates a new `GtkIMContextSimple`.
     * @constructor
     * @returns a new `GtkIMContextSimple`
     */
    static new(): IMContextSimple
    _init(config?: IMContextSimple.ConstructorProperties): void
  }

  module IMMulticontext {
    // Constructor properties interface

    interface ConstructorProperties extends IMContext.ConstructorProperties {}
  }

  interface IMMulticontext {
    // Own properties of Gtk-4.0.Gtk.IMMulticontext

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.IMMulticontext

    object: IMContext

    // Owm methods of Gtk-4.0.Gtk.IMMulticontext

    /**
     * Gets the id of the currently active delegate of the `context`.
     * @returns the id of the currently active delegate
     */
    getContextId(): string
    /**
     * Sets the context id for `context`.
     *
     * This causes the currently active delegate of `context` to be
     * replaced by the delegate corresponding to the new context id.
     *
     * Setting this to a non-%NULL value overrides the system-wide
     * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
     * property.
     * @param contextId the id to use
     */
    setContextId(contextId: string | null): void

    // Class property signals of Gtk-4.0.Gtk.IMMulticontext

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-hints", ...args: any[]): void
    connect(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-purpose", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkIMMulticontext` is an input method context supporting multiple,
   * switchable input methods.
   *
   * Text widgets such as `GtkText` or `GtkTextView` use a `GtkIMMultiContext`
   * to implement their `im-module` property for switching between different
   * input methods.
   * @class
   */
  class IMMulticontext extends IMContext {
    // Own properties of Gtk-4.0.Gtk.IMMulticontext

    static name: string

    // Constructors of Gtk-4.0.Gtk.IMMulticontext

    constructor(config?: IMMulticontext.ConstructorProperties)
    /**
     * Creates a new `GtkIMMulticontext`.
     * @constructor
     * @returns a new `GtkIMMulticontext`.
     */
    constructor()
    /**
     * Creates a new `GtkIMMulticontext`.
     * @constructor
     * @returns a new `GtkIMMulticontext`.
     */
    static new(): IMMulticontext
    _init(config?: IMMulticontext.ConstructorProperties): void
  }

  module IconPaintable {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gdk.Paintable.ConstructorProperties,
        SymbolicPaintable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.IconPaintable

      /**
       * The file representing the icon, if any.
       */
      file?: Gio.File | null
      /**
       * The icon name that was chosen during lookup.
       */
      icon_name?: string | null
      /**
       * Whether the icon is symbolic or not.
       */
      is_symbolic?: boolean | null
    }
  }

  interface IconPaintable extends Gdk.Paintable, SymbolicPaintable {
    // Own properties of Gtk-4.0.Gtk.IconPaintable

    /**
     * The file representing the icon, if any.
     */
    readonly file: Gio.File
    /**
     * The icon name that was chosen during lookup.
     */
    readonly iconName: string | null
    /**
     * Whether the icon is symbolic or not.
     */
    readonly isSymbolic: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.IconPaintable

    /**
     * Gets the `GFile` that was used to load the icon.
     *
     * Returns %NULL if the icon was not loaded from a file.
     * @returns the `GFile` for the icon
     */
    getFile(): Gio.File | null
    /**
     * Get the icon name being used for this icon.
     *
     * When an icon looked up in the icon theme was not available, the
     * icon theme may use fallback icons - either those specified to
     * gtk_icon_theme_lookup_icon() or the always-available
     * "image-missing". The icon chosen is returned by this function.
     *
     * If the icon was created without an icon theme, this function
     * returns %NULL.
     * @returns the themed icon-name for the   icon, or %NULL if its not a themed icon.
     */
    getIconName(): string | null

    // Class property signals of Gtk-4.0.Gtk.IconPaintable

    connect(sigName: "notify::file", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-symbolic",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-symbolic",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-symbolic",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-symbolic",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-symbolic", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Contains information found when looking up an icon in `GtkIconTheme`.
   *
   * `GtkIconPaintable` implements `GdkPaintable`.
   * @class
   */
  class IconPaintable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.IconPaintable

    static name: string

    // Constructors of Gtk-4.0.Gtk.IconPaintable

    constructor(config?: IconPaintable.ConstructorProperties)
    /**
     * Creates a `GtkIconPaintable` for a file with a given size and scale.
     *
     * The icon can then be rendered by using it as a `GdkPaintable`.
     * @constructor
     * @param file a `GFile`
     * @param size desired icon size
     * @param scale the desired scale
     * @returns a `GtkIconPaintable` containing   for the icon. Unref with g_object_unref()
     */
    static newForFile(
      file: Gio.File,
      size: number,
      scale: number
    ): IconPaintable
    _init(config?: IconPaintable.ConstructorProperties): void
  }

  module IconTheme {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.IconTheme

      /**
       * The display that this icon theme object is attached to.
       */
      display?: Gdk.Display | null
      /**
       * Resource paths that will be looked at when looking for icons,
       * similar to search paths.
       *
       * The resources are considered as part of the hicolor icon theme
       * and must be located in subdirectories that are defined in the
       * hicolor icon theme, such as ``path/`16x16/actions/run.png`.
       * Icons that are directly placed in the resource path instead
       * of a subdirectory are also considered as ultimate fallback.
       */
      resource_path?: string[] | null
      /**
       * The search path for this icon theme.
       *
       * When looking for icons, GTK will search for a subdirectory of
       * one or more of the directories in the search path with the same
       * name as the icon theme containing an index.theme file. (Themes
       * from multiple of the path elements are combined to allow themes
       * to be extended by adding icons in the user’s home directory.)
       */
      search_path?: string[] | null
      /**
       * The name of the icon theme that is being used.
       *
       * Unless set to a different value, this will be the value of
       * the `GtkSettings:gtk-icon-theme-name` property of the `GtkSettings`
       * object associated to the display of the icontheme object.
       */
      theme_name?: string | null
    }
  }

  interface IconTheme {
    // Own properties of Gtk-4.0.Gtk.IconTheme

    /**
     * The display that this icon theme object is attached to.
     */
    display: Gdk.Display
    /**
     * The icon names that are supported by the icon theme.
     */
    readonly iconNames: string[]
    /**
     * Resource paths that will be looked at when looking for icons,
     * similar to search paths.
     *
     * The resources are considered as part of the hicolor icon theme
     * and must be located in subdirectories that are defined in the
     * hicolor icon theme, such as ``path/`16x16/actions/run.png`.
     * Icons that are directly placed in the resource path instead
     * of a subdirectory are also considered as ultimate fallback.
     */
    resourcePath: string[]
    /**
     * The search path for this icon theme.
     *
     * When looking for icons, GTK will search for a subdirectory of
     * one or more of the directories in the search path with the same
     * name as the icon theme containing an index.theme file. (Themes
     * from multiple of the path elements are combined to allow themes
     * to be extended by adding icons in the user’s home directory.)
     */
    searchPath: string[]
    /**
     * The name of the icon theme that is being used.
     *
     * Unless set to a different value, this will be the value of
     * the `GtkSettings:gtk-icon-theme-name` property of the `GtkSettings`
     * object associated to the display of the icontheme object.
     */
    themeName: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.IconTheme

    /**
     * Adds a resource path that will be looked at when looking
     * for icons, similar to search paths.
     *
     * See [method`Gtk`.IconTheme.set_resource_path].
     *
     * This function should be used to make application-specific icons
     * available as part of the icon theme.
     * @param path a resource path
     */
    addResourcePath(path: string): void
    /**
     * Appends a directory to the search path.
     *
     * See [method`Gtk`.IconTheme.set_search_path].
     * @param path directory name to append to the icon path
     */
    addSearchPath(path: string): void
    /**
     * Returns the display that the `GtkIconTheme` object was
     * created for.
     * @returns the display of @icon_theme
     */
    getDisplay(): Gdk.Display | null
    /**
     * Lists the names of icons in the current icon theme.
     * @returns a string array   holding the names of all the icons in the theme. You must   free the array using g_strfreev().
     */
    getIconNames(): string[]
    /**
     * Returns an array of integers describing the sizes at which
     * the icon is available without scaling.
     *
     * A size of -1 means that the icon is available in a scalable
     * format. The array is zero-terminated.
     * @param iconName the name of an icon
     * @returns A newly   allocated array describing the sizes at which the icon is   available. The array should be freed with g_free() when it is no   longer needed.
     */
    getIconSizes(iconName: string): number[]
    /**
     * Gets the current resource path.
     *
     * See [method`Gtk`.IconTheme.set_resource_path].
     * @returns A list of resource paths
     */
    getResourcePath(): string[] | null
    /**
     * Gets the current search path.
     *
     * See [method`Gtk`.IconTheme.set_search_path].
     * @returns a list of icon theme path directories
     */
    getSearchPath(): string[] | null
    /**
     * Gets the current icon theme name.
     *
     * Returns (transfer full): the current icon theme name,
     */
    getThemeName(): string | null
    /**
     * Checks whether an icon theme includes an icon
     * for a particular `GIcon`.
     * @param gicon a `GIcon`
     * @returns %TRUE if @self includes an icon for @gicon
     */
    hasGicon(gicon: Gio.Icon): boolean
    /**
     * Checks whether an icon theme includes an icon
     * for a particular name.
     * @param iconName the name of an icon
     * @returns %TRUE if @self includes an  icon for @icon_name.
     */
    hasIcon(iconName: string): boolean
    /**
     * Looks up a icon for a desired size and window scale.
     *
     * The icon can then be rendered by using it as a `GdkPaintable`,
     * or you can get information such as the filename and size.
     * @param icon the `GIcon` to look up
     * @param size desired icon size
     * @param scale the desired scale
     * @param direction text direction the icon will be displayed in
     * @param flags flags modifying the behavior of the icon lookup
     * @returns a `GtkIconPaintable` containing   information about the icon. Unref with g_object_unref()
     */
    lookupByGicon(
      icon: Gio.Icon,
      size: number,
      scale: number,
      direction: TextDirection,
      flags: IconLookupFlags
    ): IconPaintable
    /**
     * Looks up a named icon for a desired size and window scale,
     * returning a `GtkIconPaintable`.
     *
     * The icon can then be rendered by using it as a `GdkPaintable`,
     * or you can get information such as the filename and size.
     *
     * If the available `icon_name` is not available and `fallbacks` are
     * provided, they will be tried in order.
     *
     * If no matching icon is found, then a paintable that renders the
     * "missing icon" icon is returned. If you need to do something else
     * for missing icons you need to use [method`Gtk`.IconTheme.has_icon].
     *
     * Note that you probably want to listen for icon theme changes and
     * update the icon. This is usually done by overriding the
     * GtkWidgetClass.css-changed() function.
     * @param iconName the name of the icon to lookup
     * @param fallbacks
     * @param size desired icon size.
     * @param scale the window scale this will be displayed on
     * @param direction text direction the icon will be displayed in
     * @param flags flags modifying the behavior of the icon lookup
     * @returns a `GtkIconPaintable` object   containing the icon.
     */
    lookupIcon(
      iconName: string,
      fallbacks: string[] | null,
      size: number,
      scale: number,
      direction: TextDirection,
      flags: IconLookupFlags
    ): IconPaintable
    /**
     * Sets the resource paths that will be looked at when
     * looking for icons, similar to search paths.
     *
     * The resources are considered as part of the hicolor icon theme
     * and must be located in subdirectories that are defined in the
     * hicolor icon theme, such as ``path/`16x16/actions/run.png`
     * or ``path/`scalable/actions/run.svg`.
     *
     * Icons that are directly placed in the resource path instead
     * of a subdirectory are also considered as ultimate fallback,
     * but they are treated like unthemed icons.
     * @param path NULL-terminated array of resource paths   that are searched for icons
     */
    setResourcePath(path: string[] | null): void
    /**
     * Sets the search path for the icon theme object.
     *
     * When looking for an icon theme, GTK will search for a subdirectory
     * of one or more of the directories in `path` with the same name
     * as the icon theme containing an index.theme file. (Themes from
     * multiple of the path elements are combined to allow themes to be
     * extended by adding icons in the user’s home directory.)
     *
     * In addition if an icon found isn’t found either in the current
     * icon theme or the default icon theme, and an image file with
     * the right name is found directly in one of the elements of
     * `path,` then that image will be used for the icon name.
     * (This is legacy feature, and new icons should be put
     * into the fallback icon theme, which is called hicolor,
     * rather than directly on the icon path.)
     * @param path NULL-terminated   array of directories that are searched for icon themes
     */
    setSearchPath(path: string[] | null): void
    /**
     * Sets the name of the icon theme that the `GtkIconTheme` object uses
     * overriding system configuration.
     *
     * This function cannot be called on the icon theme objects returned
     * from [func`Gtk`.IconTheme.get_for_display].
     * @param themeName name of icon theme to use instead of   configured theme, or %NULL to unset a previously set custom theme
     */
    setThemeName(themeName: string | null): void

    // Own signals of Gtk-4.0.Gtk.IconTheme

    connect(
      sigName: "changed",
      callback: IconTheme.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: IconTheme.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: IconTheme.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: IconTheme.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.IconTheme

    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::icon-names",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-names",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-names",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-names",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-names", ...args: any[]): void
    connect(
      sigName: "notify::resource-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resource-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resource-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resource-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resource-path", ...args: any[]): void
    connect(
      sigName: "notify::search-path",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::search-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::search-path",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::search-path",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::search-path", ...args: any[]): void
    connect(
      sigName: "notify::theme-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::theme-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::theme-name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkIconTheme` provides a facility for loading themed icons.
   *
   * The main reason for using a name rather than simply providing a filename
   * is to allow different icons to be used depending on what “icon theme” is
   * selected by the user. The operation of icon themes on Linux and Unix
   * follows the [Icon Theme Specification](http://www.freedesktop.org/Standards/icon-theme-spec)
   * There is a fallback icon theme, named `hicolor`, where applications
   * should install their icons, but additional icon themes can be installed
   * as operating system vendors and users choose.
   *
   * In many cases, named themes are used indirectly, via [class`Gtk`.Image]
   * rather than directly, but looking up icons directly is also simple. The
   * `GtkIconTheme` object acts as a database of all the icons in the current
   * theme. You can create new `GtkIconTheme` objects, but it’s much more
   * efficient to use the standard icon theme of the `GtkWidget` so that the
   * icon information is shared with other people looking up icons.
   *
   * ```c
   * GtkIconTheme *icon_theme;
   * GtkIconPaintable *icon;
   * GdkPaintable *paintable;
   *
   * icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (my_widget));
   * icon = gtk_icon_theme_lookup_icon (icon_theme,
   *                                    "my-icon-name", // icon name
   *                                    48, // icon size
   *                                    1,  // scale
   *                                    0,  // flags);
   * paintable = GDK_PAINTABLE (icon);
   * // Use the paintable
   * g_object_unref (icon);
   * ```
   * @class
   */
  class IconTheme extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.IconTheme

    static name: string

    // Constructors of Gtk-4.0.Gtk.IconTheme

    constructor(config?: IconTheme.ConstructorProperties)
    /**
     * Creates a new icon theme object.
     *
     * Icon theme objects are used to lookup up an icon by name
     * in a particular icon theme. Usually, you’ll want to use
     * [func`Gtk`.IconTheme.get_for_display] rather than creating
     * a new icon theme object for scratch.
     * @constructor
     * @returns the newly created `GtkIconTheme` object.
     */
    constructor()
    /**
     * Creates a new icon theme object.
     *
     * Icon theme objects are used to lookup up an icon by name
     * in a particular icon theme. Usually, you’ll want to use
     * [func`Gtk`.IconTheme.get_for_display] rather than creating
     * a new icon theme object for scratch.
     * @constructor
     * @returns the newly created `GtkIconTheme` object.
     */
    static new(): IconTheme
    _init(config?: IconTheme.ConstructorProperties): void
    /**
     * Gets the icon theme object associated with `display`.
     *
     * If this function has not previously been called for the given
     * display, a new icon theme object will be created and associated
     * with the display. Icon theme objects are fairly expensive to create,
     * so using this function is usually a better choice than calling
     * [ctor`Gtk`.IconTheme.new] and setting the display yourself; by using
     * this function a single icon theme object will be shared between users.
     * @param display a `GdkDisplay`
     * @returns A unique `GtkIconTheme` associated with   the given display. This icon theme is associated with the display   and can be used as long as the display is open. Do not ref or unref it.
     */
    static getForDisplay(display: Gdk.Display): IconTheme
  }

  module IconView {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate-cursor-item`
     */
    interface ActivateCursorItemSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `item-activated`
     */
    interface ItemActivatedSignalCallback {
      (path: TreePath): void
    }

    /**
     * Signal callback interface for `move-cursor`
     */
    interface MoveCursorSignalCallback {
      (
        step: MovementStep,
        count: number,
        extend: boolean,
        modify: boolean
      ): boolean
    }

    /**
     * Signal callback interface for `select-all`
     */
    interface SelectAllSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `select-cursor-item`
     */
    interface SelectCursorItemSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `selection-changed`
     */
    interface SelectionChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `toggle-cursor-item`
     */
    interface ToggleCursorItemSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `unselect-all`
     */
    interface UnselectAllSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        CellLayout.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Scrollable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.IconView

      /**
       * The activate-on-single-click property specifies whether the "item-activated" signal
       * will be emitted after a single click.
       */
      activate_on_single_click?: boolean | null
      /**
       * The `GtkCellArea` used to layout cell renderers for this view.
       *
       * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
       * a `GtkCellAreaBox` will be used.
       */
      cell_area?: CellArea | null
      /**
       * The column-spacing property specifies the space which is inserted between
       * the columns of the icon view.
       */
      column_spacing?: number | null
      /**
       * The columns property contains the number of the columns in which the
       * items should be displayed. If it is -1, the number of columns will
       * be chosen automatically to fill the available area.
       */
      columns?: number | null
      /**
       * The item-orientation property specifies how the cells (i.e. the icon and
       * the text) of the item are positioned relative to each other.
       */
      item_orientation?: Orientation | null
      /**
       * The item-padding property specifies the padding around each
       * of the icon view's item.
       */
      item_padding?: number | null
      /**
       * The item-width property specifies the width to use for each item.
       * If it is set to -1, the icon view will automatically determine a
       * suitable item size.
       */
      item_width?: number | null
      /**
       * The margin property specifies the space which is inserted
       * at the edges of the icon view.
       */
      margin?: number | null
      /**
       * The ::markup-column property contains the number of the model column
       * containing markup information to be displayed. The markup column must be
       * of type `G_TYPE_STRING`. If this property and the :text-column property
       * are both set to column numbers, it overrides the text column.
       * If both are set to -1, no texts are displayed.
       */
      markup_column?: number | null
      model?: TreeModel | null
      /**
       * The ::pixbuf-column property contains the number of the model column
       * containing the pixbufs which are displayed. The pixbuf column must be
       * of type `GDK_TYPE_PIXBUF`. Setting this property to -1 turns off the
       * display of pixbufs.
       */
      pixbuf_column?: number | null
      /**
       * The reorderable property specifies if the items can be reordered
       * by DND.
       */
      reorderable?: boolean | null
      /**
       * The row-spacing property specifies the space which is inserted between
       * the rows of the icon view.
       */
      row_spacing?: number | null
      /**
       * The ::selection-mode property specifies the selection mode of
       * icon view. If the mode is %GTK_SELECTION_MULTIPLE, rubberband selection
       * is enabled, for the other modes, only keyboard selection is possible.
       */
      selection_mode?: SelectionMode | null
      /**
       * The spacing property specifies the space which is inserted between
       * the cells (i.e. the icon and the text) of an item.
       */
      spacing?: number | null
      /**
       * The ::text-column property contains the number of the model column
       * containing the texts which are displayed. The text column must be
       * of type `G_TYPE_STRING`. If this property and the :markup-column
       * property are both set to -1, no texts are displayed.
       */
      text_column?: number | null
      tooltip_column?: number | null
    }
  }

  interface IconView
    extends Accessible,
      Buildable,
      CellLayout,
      ConstraintTarget,
      Scrollable {
    // Own properties of Gtk-4.0.Gtk.IconView

    /**
     * The activate-on-single-click property specifies whether the "item-activated" signal
     * will be emitted after a single click.
     */
    activateOnSingleClick: boolean
    /**
     * The `GtkCellArea` used to layout cell renderers for this view.
     *
     * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
     * a `GtkCellAreaBox` will be used.
     */
    readonly cellArea: CellArea
    /**
     * The column-spacing property specifies the space which is inserted between
     * the columns of the icon view.
     */
    columnSpacing: number
    /**
     * The columns property contains the number of the columns in which the
     * items should be displayed. If it is -1, the number of columns will
     * be chosen automatically to fill the available area.
     */
    columns: number
    /**
     * The item-orientation property specifies how the cells (i.e. the icon and
     * the text) of the item are positioned relative to each other.
     */
    itemOrientation: Orientation
    /**
     * The item-padding property specifies the padding around each
     * of the icon view's item.
     */
    itemPadding: number
    /**
     * The item-width property specifies the width to use for each item.
     * If it is set to -1, the icon view will automatically determine a
     * suitable item size.
     */
    itemWidth: number
    /**
     * The margin property specifies the space which is inserted
     * at the edges of the icon view.
     */
    margin: number
    /**
     * The ::markup-column property contains the number of the model column
     * containing markup information to be displayed. The markup column must be
     * of type `G_TYPE_STRING`. If this property and the :text-column property
     * are both set to column numbers, it overrides the text column.
     * If both are set to -1, no texts are displayed.
     */
    markupColumn: number
    model: TreeModel
    /**
     * The ::pixbuf-column property contains the number of the model column
     * containing the pixbufs which are displayed. The pixbuf column must be
     * of type `GDK_TYPE_PIXBUF`. Setting this property to -1 turns off the
     * display of pixbufs.
     */
    pixbufColumn: number
    /**
     * The reorderable property specifies if the items can be reordered
     * by DND.
     */
    reorderable: boolean
    /**
     * The row-spacing property specifies the space which is inserted between
     * the rows of the icon view.
     */
    rowSpacing: number
    /**
     * The ::selection-mode property specifies the selection mode of
     * icon view. If the mode is %GTK_SELECTION_MULTIPLE, rubberband selection
     * is enabled, for the other modes, only keyboard selection is possible.
     */
    selectionMode: SelectionMode
    /**
     * The spacing property specifies the space which is inserted between
     * the cells (i.e. the icon and the text) of an item.
     */
    spacing: number
    /**
     * The ::text-column property contains the number of the model column
     * containing the texts which are displayed. The text column must be
     * of type `G_TYPE_STRING`. If this property and the :markup-column
     * property are both set to -1, no texts are displayed.
     */
    textColumn: number
    tooltipColumn: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.IconView

    /**
     * Creates a `GdkPaintable` representation of the item at `path`.
     * This image is used for a drag icon.
     * @param path a `GtkTreePath` in `icon_view`
     * @returns a newly-allocated `GdkPaintable` of the drag icon.
     */
    createDragIcon(path: TreePath): Gdk.Paintable | null
    /**
     * Turns `icon_view` into a drop destination for automatic DND. Calling this
     * method sets `GtkIconView`:reorderable to %FALSE.
     * @param formats the formats that the drag will support
     * @param actions the bitmask of possible actions for a drag to this    widget
     */
    enableModelDragDest(
      formats: Gdk.ContentFormats,
      actions: Gdk.DragAction
    ): void
    /**
     * Turns `icon_view` into a drag source for automatic DND. Calling this
     * method sets `GtkIconView`:reorderable to %FALSE.
     * @param startButtonMask Mask of allowed buttons to start drag
     * @param formats the formats that the drag will support
     * @param actions the bitmask of possible actions for a drag from this    widget
     */
    enableModelDragSource(
      startButtonMask: Gdk.ModifierType,
      formats: Gdk.ContentFormats,
      actions: Gdk.DragAction
    ): void
    /**
     * Gets the setting set by gtk_icon_view_set_activate_on_single_click().
     * @returns %TRUE if item-activated will be emitted on a single click
     */
    getActivateOnSingleClick(): boolean
    /**
     * Fills the bounding rectangle in widget coordinates for the cell specified by
     * `path` and `cell`. If `cell` is %NULL the main cell area is used.
     *
     * This function is only valid if `icon_view` is realized.
     * @param path a `GtkTreePath`
     * @param cell a `GtkCellRenderer`
     * @returns %FALSE if there is no such item, %TRUE otherwise
     */
    getCellRect(
      path: TreePath,
      cell: CellRenderer | null
    ): [/* returnType */ boolean, /* rect */ Gdk.Rectangle]
    /**
     * Returns the value of the ::column-spacing property.
     * @returns the space between columns
     */
    getColumnSpacing(): number
    /**
     * Returns the value of the ::columns property.
     * @returns the number of columns, or -1
     */
    getColumns(): number
    /**
     * Fills in `path` and `cell` with the current cursor path and cell.
     * If the cursor isn’t currently set, then *`path` will be %NULL.
     * If no cell currently has focus, then *`cell` will be %NULL.
     *
     * The returned `GtkTreePath` must be freed with gtk_tree_path_free().
     * @returns %TRUE if the cursor is set.
     */
    getCursor(): [
      /* returnType */ boolean,
      /* path */ TreePath,
      /* cell */ CellRenderer,
    ]

    // Overloads of getCursor

    /**
     * Queries the cursor set on `widget`.
     *
     * See [method`Gtk`.Widget.set_cursor] for details.
     * @returns the cursor   currently in use or %NULL if the cursor is inherited
     */
    getCursor(): Gdk.Cursor | null
    /**
     * Determines the destination item for a given position.
     * @param dragX the position to determine the destination item for
     * @param dragY the position to determine the destination item for
     * @returns whether there is an item at the given position.
     */
    getDestItemAtPos(
      dragX: number,
      dragY: number
    ): [
      /* returnType */ boolean,
      /* path */ TreePath,
      /* pos */ IconViewDropPosition,
    ]
    /**
     * Gets information about the item that is highlighted for feedback.
     */
    getDragDestItem(): [
      /* path */ TreePath | null,
      /* pos */ IconViewDropPosition,
    ]
    /**
     * Gets the path and cell for the icon at the given position.
     * @param x The x position to be identified
     * @param y The y position to be identified
     * @returns %TRUE if an item exists at the specified position
     */
    getItemAtPos(
      x: number,
      y: number
    ): [/* returnType */ boolean, /* path */ TreePath, /* cell */ CellRenderer]
    /**
     * Gets the column in which the item `path` is currently
     * displayed. Column numbers start at 0.
     * @param path the `GtkTreePath` of the item
     * @returns The column in which the item is displayed
     */
    getItemColumn(path: TreePath): number
    /**
     * Returns the value of the ::item-orientation property which determines
     * whether the labels are drawn beside the icons instead of below.
     * @returns the relative position of texts and icons
     */
    getItemOrientation(): Orientation
    /**
     * Returns the value of the ::item-padding property.
     * @returns the padding around items
     */
    getItemPadding(): number
    /**
     * Gets the row in which the item `path` is currently
     * displayed. Row numbers start at 0.
     * @param path the `GtkTreePath` of the item
     * @returns The row in which the item is displayed
     */
    getItemRow(path: TreePath): number
    /**
     * Returns the value of the ::item-width property.
     * @returns the width of a single item, or -1
     */
    getItemWidth(): number
    /**
     * Returns the value of the ::margin property.
     * @returns the space at the borders
     */
    getMargin(): number
    /**
     * Returns the column with markup text for `icon_view`.
     * @returns the markup column, or -1 if it’s unset.
     */
    getMarkupColumn(): number
    /**
     * Returns the model the `GtkIconView` is based on.  Returns %NULL if the
     * model is unset.
     * @returns The currently used `GtkTreeModel`
     */
    getModel(): TreeModel | null
    /**
     * Gets the path for the icon at the given position.
     * @param x The x position to be identified
     * @param y The y position to be identified
     * @returns The `GtkTreePath` corresponding to the icon or %NULL if no icon exists at that position.
     */
    getPathAtPos(x: number, y: number): TreePath | null
    /**
     * Returns the column with pixbufs for `icon_view`.
     * @returns the pixbuf column, or -1 if it’s unset.
     */
    getPixbufColumn(): number
    /**
     * Retrieves whether the user can reorder the list via drag-and-drop.
     * See gtk_icon_view_set_reorderable().
     * @returns %TRUE if the list can be reordered.
     */
    getReorderable(): boolean
    /**
     * Returns the value of the ::row-spacing property.
     * @returns the space between rows
     */
    getRowSpacing(): number
    /**
     * Creates a list of paths of all selected items. Additionally, if you are
     * planning on modifying the model after calling this function, you may
     * want to convert the returned list into a list of `GtkTreeRowReferences`.
     * To do this, you can use gtk_tree_row_reference_new().
     *
     * To free the return value, use `g_list_free_full`:
     *
     * ```c
     * GtkWidget *icon_view = gtk_icon_view_new ();
     * // Use icon_view
     *
     * GList *list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (icon_view));
     *
     * // use list
     *
     * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
     * ```
     *
     * @returns A `GList` containing a `GtkTreePath` for each selected row.
     */
    getSelectedItems(): TreePath[]
    /**
     * Gets the selection mode of the `icon_view`.
     * @returns the current selection mode
     */
    getSelectionMode(): SelectionMode
    /**
     * Returns the value of the ::spacing property.
     * @returns the space between cells
     */
    getSpacing(): number
    /**
     * Returns the column with text for `icon_view`.
     * @returns the text column, or -1 if it’s unset.
     */
    getTextColumn(): number
    /**
     * Returns the column of `icon_view’`s model which is being used for
     * displaying tooltips on `icon_view’`s rows.
     * @returns the index of the tooltip column that is currently being used, or -1 if this is disabled.
     */
    getTooltipColumn(): number
    /**
     * This function is supposed to be used in a `GtkWidget::query-tooltip`
     * signal handler for `GtkIconView`. The `x,` `y` and `keyboard_tip` values
     * which are received in the signal handler, should be passed to this
     * function without modification.
     *
     * The return value indicates whether there is an icon view item at the given
     * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
     * tooltips the item returned will be the cursor item. When %TRUE, then any of
     * `model,` `path` and `iter` which have been provided will be set to point to
     * that row and the corresponding model.
     * @param x the x coordinate (relative to widget coordinates)
     * @param y the y coordinate (relative to widget coordinates)
     * @param keyboardTip whether this is a keyboard tooltip or not
     * @returns whether or not the given tooltip context points to an item
     */
    getTooltipContext(
      x: number,
      y: number,
      keyboardTip: boolean
    ): [
      /* returnType */ boolean,
      /* model */ TreeModel,
      /* path */ TreePath,
      /* iter */ TreeIter,
    ]
    /**
     * Sets `start_path` and `end_path` to be the first and last visible path.
     * Note that there may be invisible paths in between.
     *
     * Both paths should be freed with gtk_tree_path_free() after use.
     * @returns %TRUE, if valid paths were placed in @start_path and @end_path
     */
    getVisibleRange(): [
      /* returnType */ boolean,
      /* startPath */ TreePath,
      /* endPath */ TreePath,
    ]
    /**
     * Activates the item determined by `path`.
     * @param path The `GtkTreePath` to be activated
     */
    itemActivated(path: TreePath): void
    /**
     * Returns %TRUE if the icon pointed to by `path` is currently
     * selected. If `path` does not point to a valid location, %FALSE is returned.
     * @param path A `GtkTreePath` to check selection on.
     * @returns %TRUE if @path is selected.
     */
    pathIsSelected(path: TreePath): boolean
    /**
     * Moves the alignments of `icon_view` to the position specified by `path`.
     * `row_align` determines where the row is placed, and `col_align` determines
     * where `column` is placed.  Both are expected to be between 0.0 and 1.0.
     * 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means
     * center.
     *
     * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
     * tree does the minimum amount of work to scroll the item onto the screen.
     * This means that the item will be scrolled to the edge closest to its current
     * position.  If the item is currently visible on the screen, nothing is done.
     *
     * This function only works if the model is set, and `path` is a valid row on
     * the model. If the model changes before the `icon_view` is realized, the
     * centered path will be modified to reflect this change.
     * @param path The path of the item to move to.
     * @param useAlign whether to use alignment arguments, or %FALSE.
     * @param rowAlign The vertical alignment of the item specified by `path`.
     * @param colAlign The horizontal alignment of the item specified by `path`.
     */
    scrollToPath(
      path: TreePath,
      useAlign: boolean,
      rowAlign: number,
      colAlign: number
    ): void
    /**
     * Selects all the icons. `icon_view` must has its selection mode set
     * to %GTK_SELECTION_MULTIPLE.
     */
    selectAll(): void
    /**
     * Selects the row at `path`.
     * @param path The `GtkTreePath` to be selected.
     */
    selectPath(path: TreePath): void
    /**
     * Calls a function for each selected icon. Note that the model or
     * selection cannot be modified from within this function.
     * @param func The function to call for each selected icon.
     */
    selectedForeach(func: IconViewForeachFunc): void
    /**
     * Causes the `GtkIconView`::item-activated signal to be emitted on
     * a single click instead of a double click.
     * @param single %TRUE to emit item-activated on a single click
     */
    setActivateOnSingleClick(single: boolean): void
    /**
     * Sets the ::column-spacing property which specifies the space
     * which is inserted between the columns of the icon view.
     * @param columnSpacing the column spacing
     */
    setColumnSpacing(columnSpacing: number): void
    /**
     * Sets the ::columns property which determines in how
     * many columns the icons are arranged. If `columns` is
     * -1, the number of columns will be chosen automatically
     * to fill the available area.
     * @param columns the number of columns
     */
    setColumns(columns: number): void
    /**
     * Sets the current keyboard focus to be at `path,` and selects it.  This is
     * useful when you want to focus the user’s attention on a particular item.
     * If `cell` is not %NULL, then focus is given to the cell specified by
     * it. Additionally, if `start_editing` is %TRUE, then editing should be
     * started in the specified cell.
     *
     * This function is often followed by `gtk_widget_grab_focus
     * (icon_view)` in order to give keyboard focus to the widget.
     * Please note that editing can only happen when the widget is realized.
     * @param path A `GtkTreePath`
     * @param cell One of the cell renderers of `icon_view`
     * @param startEditing %TRUE if the specified cell should start being edited.
     */
    setCursor(
      path: TreePath,
      cell: CellRenderer | null,
      startEditing: boolean
    ): void

    // Overloads of setCursor

    /**
     * Sets the cursor to be shown when pointer devices point
     * towards `widget`.
     *
     * If the `cursor` is NULL, `widget` will use the cursor
     * inherited from the parent widget.
     * @param cursor the new cursor
     */
    setCursor(cursor: Gdk.Cursor | null): void
    /**
     * Sets the item that is highlighted for feedback.
     * @param path The path of the item to highlight
     * @param pos Specifies where to drop, relative to the item
     */
    setDragDestItem(path: TreePath | null, pos: IconViewDropPosition): void
    /**
     * Sets the ::item-orientation property which determines whether the labels
     * are drawn beside the icons instead of below.
     * @param orientation the relative position of texts and icons
     */
    setItemOrientation(orientation: Orientation): void
    /**
     * Sets the `GtkIconView`:item-padding property which specifies the padding
     * around each of the icon view’s items.
     * @param itemPadding the item padding
     */
    setItemPadding(itemPadding: number): void
    /**
     * Sets the ::item-width property which specifies the width
     * to use for each item. If it is set to -1, the icon view will
     * automatically determine a suitable item size.
     * @param itemWidth the width for each item
     */
    setItemWidth(itemWidth: number): void
    /**
     * Sets the ::margin property which specifies the space
     * which is inserted at the top, bottom, left and right
     * of the icon view.
     * @param margin the margin
     */
    setMargin(margin: number): void
    /**
     * Sets the column with markup information for `icon_view` to be
     * `column`. The markup column must be of type `G_TYPE_STRING`.
     * If the markup column is set to something, it overrides
     * the text column set by gtk_icon_view_set_text_column().
     * @param column A column in the currently used model, or -1 to display no text
     */
    setMarkupColumn(column: number): void
    /**
     * Sets the model for a `GtkIconView`.
     * If the `icon_view` already has a model set, it will remove
     * it before setting the new model.  If `model` is %NULL, then
     * it will unset the old model.
     * @param model The model.
     */
    setModel(model: TreeModel | null): void
    /**
     * Sets the column with pixbufs for `icon_view` to be `column`. The pixbuf
     * column must be of type `GDK_TYPE_PIXBUF`
     * @param column A column in the currently used model, or -1 to disable
     */
    setPixbufColumn(column: number): void
    /**
     * This function is a convenience function to allow you to reorder models that
     * support the `GtkTreeDragSourceIface` and the `GtkTreeDragDestIface`. Both
     * `GtkTreeStore` and `GtkListStore` support these. If `reorderable` is %TRUE, then
     * the user can reorder the model by dragging and dropping rows.  The
     * developer can listen to these changes by connecting to the model's
     * row_inserted and row_deleted signals. The reordering is implemented by setting up
     * the icon view as a drag source and destination. Therefore, drag and
     * drop can not be used in a reorderable view for any other purpose.
     *
     * This function does not give you any degree of control over the order -- any
     * reordering is allowed.  If more control is needed, you should probably
     * handle drag and drop manually.
     * @param reorderable %TRUE, if the list of items can be reordered.
     */
    setReorderable(reorderable: boolean): void
    /**
     * Sets the ::row-spacing property which specifies the space
     * which is inserted between the rows of the icon view.
     * @param rowSpacing the row spacing
     */
    setRowSpacing(rowSpacing: number): void
    /**
     * Sets the selection mode of the `icon_view`.
     * @param mode The selection mode
     */
    setSelectionMode(mode: SelectionMode): void
    /**
     * Sets the ::spacing property which specifies the space
     * which is inserted between the cells (i.e. the icon and
     * the text) of an item.
     * @param spacing the spacing
     */
    setSpacing(spacing: number): void
    /**
     * Sets the column with text for `icon_view` to be `column`. The text
     * column must be of type `G_TYPE_STRING`.
     * @param column A column in the currently used model, or -1 to display no text
     */
    setTextColumn(column: number): void
    /**
     * Sets the tip area of `tooltip` to the area which `cell` occupies in
     * the item pointed to by `path`. See also gtk_tooltip_set_tip_area().
     *
     * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
     * @param tooltip a `GtkTooltip`
     * @param path a `GtkTreePath`
     * @param cell a `GtkCellRenderer`
     */
    setTooltipCell(
      tooltip: Tooltip,
      path: TreePath,
      cell: CellRenderer | null
    ): void
    /**
     * If you only plan to have simple (text-only) tooltips on full items, you
     * can use this function to have `GtkIconView` handle these automatically
     * for you. `column` should be set to the column in `icon_view’`s model
     * containing the tooltip texts, or -1 to disable this feature.
     *
     * When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
     * `icon_view` will connect a `GtkWidget::query-tooltip` signal handler.
     *
     * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
     * so &, <, etc have to be escaped in the text.
     * @param column an integer, which is a valid column number for `icon_view’`s model
     */
    setTooltipColumn(column: number): void
    /**
     * Sets the tip area of `tooltip` to be the area covered by the item at `path`.
     * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
     * See also gtk_tooltip_set_tip_area().
     * @param tooltip a `GtkTooltip`
     * @param path a `GtkTreePath`
     */
    setTooltipItem(tooltip: Tooltip, path: TreePath): void
    /**
     * Unselects all the icons.
     */
    unselectAll(): void
    /**
     * Unselects the row at `path`.
     * @param path The `GtkTreePath` to be unselected.
     */
    unselectPath(path: TreePath): void
    /**
     * Undoes the effect of gtk_icon_view_enable_model_drag_dest(). Calling this
     * method sets `GtkIconView`:reorderable to %FALSE.
     */
    unsetModelDragDest(): void
    /**
     * Undoes the effect of gtk_icon_view_enable_model_drag_source(). Calling this
     * method sets `GtkIconView`:reorderable to %FALSE.
     */
    unsetModelDragSource(): void

    // Own signals of Gtk-4.0.Gtk.IconView

    connect(
      sigName: "activate-cursor-item",
      callback: IconView.ActivateCursorItemSignalCallback
    ): number
    on(
      sigName: "activate-cursor-item",
      callback: IconView.ActivateCursorItemSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-cursor-item",
      callback: IconView.ActivateCursorItemSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-cursor-item",
      callback: IconView.ActivateCursorItemSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-cursor-item", ...args: any[]): void
    connect(
      sigName: "item-activated",
      callback: IconView.ItemActivatedSignalCallback
    ): number
    on(
      sigName: "item-activated",
      callback: IconView.ItemActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "item-activated",
      callback: IconView.ItemActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "item-activated",
      callback: IconView.ItemActivatedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "item-activated", ...args: any[]): void
    connect(
      sigName: "move-cursor",
      callback: IconView.MoveCursorSignalCallback
    ): number
    on(
      sigName: "move-cursor",
      callback: IconView.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-cursor",
      callback: IconView.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-cursor",
      callback: IconView.MoveCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "move-cursor",
      count: number,
      extend: boolean,
      modify: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "select-all",
      callback: IconView.SelectAllSignalCallback
    ): number
    on(
      sigName: "select-all",
      callback: IconView.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-all",
      callback: IconView.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-all",
      callback: IconView.SelectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-all", ...args: any[]): void
    connect(
      sigName: "select-cursor-item",
      callback: IconView.SelectCursorItemSignalCallback
    ): number
    on(
      sigName: "select-cursor-item",
      callback: IconView.SelectCursorItemSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-cursor-item",
      callback: IconView.SelectCursorItemSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-cursor-item",
      callback: IconView.SelectCursorItemSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-cursor-item", ...args: any[]): void
    connect(
      sigName: "selection-changed",
      callback: IconView.SelectionChangedSignalCallback
    ): number
    on(
      sigName: "selection-changed",
      callback: IconView.SelectionChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "selection-changed",
      callback: IconView.SelectionChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "selection-changed",
      callback: IconView.SelectionChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "selection-changed", ...args: any[]): void
    connect(
      sigName: "toggle-cursor-item",
      callback: IconView.ToggleCursorItemSignalCallback
    ): number
    on(
      sigName: "toggle-cursor-item",
      callback: IconView.ToggleCursorItemSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggle-cursor-item",
      callback: IconView.ToggleCursorItemSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggle-cursor-item",
      callback: IconView.ToggleCursorItemSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggle-cursor-item", ...args: any[]): void
    connect(
      sigName: "unselect-all",
      callback: IconView.UnselectAllSignalCallback
    ): number
    on(
      sigName: "unselect-all",
      callback: IconView.UnselectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unselect-all",
      callback: IconView.UnselectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unselect-all",
      callback: IconView.UnselectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unselect-all", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.IconView

    connect(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activate-on-single-click", ...args: any[]): void
    connect(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-area", ...args: any[]): void
    connect(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::column-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::column-spacing", ...args: any[]): void
    connect(
      sigName: "notify::columns",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::columns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::columns",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::columns",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::columns", ...args: any[]): void
    connect(
      sigName: "notify::item-orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-orientation", ...args: any[]): void
    connect(
      sigName: "notify::item-padding",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-padding",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-padding",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-padding",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-padding", ...args: any[]): void
    connect(
      sigName: "notify::item-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-width", ...args: any[]): void
    connect(
      sigName: "notify::margin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin", ...args: any[]): void
    connect(
      sigName: "notify::markup-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::markup-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::markup-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::markup-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::markup-column", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::pixbuf-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixbuf-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixbuf-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixbuf-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixbuf-column", ...args: any[]): void
    connect(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::reorderable", ...args: any[]): void
    connect(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::row-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::row-spacing", ...args: any[]): void
    connect(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-mode", ...args: any[]): void
    connect(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::spacing", ...args: any[]): void
    connect(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-column", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-column", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkIconView` is a widget which displays data in a grid of icons.
   *
   * `GtkIconView` provides an alternative view on a `GtkTreeModel`.
   * It displays the model as a grid of icons with labels. Like
   * [class`Gtk`.TreeView], it allows to select one or multiple items
   * (depending on the selection mode, see [method`Gtk`.IconView.set_selection_mode]).
   * In addition to selection with the arrow keys, `GtkIconView` supports
   * rubberband selection, which is controlled by dragging the pointer.
   *
   * Note that if the tree model is backed by an actual tree store (as
   * opposed to a flat list where the mapping to icons is obvious),
   * `GtkIconView` will only display the first level of the tree and
   * ignore the tree’s branches.
   *
   * ## CSS nodes
   *
   * ```
   * iconview.view
   * ╰── [rubberband]
   * ```
   *
   * `GtkIconView` has a single CSS node with name iconview and style class .view.
   * For rubberband selection, a subnode with name rubberband is used.
   * @class
   */
  class IconView extends Widget {
    // Own properties of Gtk-4.0.Gtk.IconView

    static name: string

    // Constructors of Gtk-4.0.Gtk.IconView

    constructor(config?: IconView.ConstructorProperties)
    /**
     * Creates a new `GtkIconView` widget
     * @constructor
     * @returns A newly created `GtkIconView` widget
     */
    constructor()
    /**
     * Creates a new `GtkIconView` widget
     * @constructor
     * @returns A newly created `GtkIconView` widget
     */
    static new(): IconView
    /**
     * Creates a new `GtkIconView` widget using the
     * specified `area` to layout cells inside the icons.
     * @constructor
     * @param area the `GtkCellArea` to use to layout cells
     * @returns A newly created `GtkIconView` widget
     */
    static newWithArea(area: CellArea): IconView
    /**
     * Creates a new `GtkIconView` widget with the model `model`.
     * @constructor
     * @param model The model.
     * @returns A newly created `GtkIconView` widget.
     */
    static newWithModel(model: TreeModel): IconView
    _init(config?: IconView.ConstructorProperties): void
  }

  module Image {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Image

      /**
       * A path to the file to display.
       */
      file?: string | null
      /**
       * The `GIcon` displayed in the GtkImage.
       *
       * For themed icons, If the icon theme is changed, the image will be updated
       * automatically.
       */
      gicon?: Gio.Icon | null
      /**
       * The name of the icon in the icon theme.
       *
       * If the icon theme is changed, the image will be updated automatically.
       */
      icon_name?: string | null
      /**
       * The symbolic size to display icons at.
       */
      icon_size?: IconSize | null
      /**
       * The `GdkPaintable` to display.
       */
      paintable?: Gdk.Paintable | null
      /**
       * The size in pixels to display icons at.
       *
       * If set to a value != -1, this property overrides the
       * [property`Gtk`.Image:icon-size] property for images of type
       * `GTK_IMAGE_ICON_NAME`.
       */
      pixel_size?: number | null
      /**
       * A path to a resource file to display.
       */
      resource?: string | null
      /**
       * Whether the icon displayed in the `GtkImage` will use
       * standard icon names fallback.
       *
       * The value of this property is only relevant for images of type
       * %GTK_IMAGE_ICON_NAME and %GTK_IMAGE_GICON.
       */
      use_fallback?: boolean | null
    }
  }

  interface Image extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Image

    /**
     * A path to the file to display.
     */
    file: string | null
    /**
     * The `GIcon` displayed in the GtkImage.
     *
     * For themed icons, If the icon theme is changed, the image will be updated
     * automatically.
     */
    gicon: Gio.Icon
    /**
     * The name of the icon in the icon theme.
     *
     * If the icon theme is changed, the image will be updated automatically.
     */
    iconName: string | null
    /**
     * The symbolic size to display icons at.
     */
    iconSize: IconSize
    /**
     * The `GdkPaintable` to display.
     */
    paintable: Gdk.Paintable
    /**
     * The size in pixels to display icons at.
     *
     * If set to a value != -1, this property overrides the
     * [property`Gtk`.Image:icon-size] property for images of type
     * `GTK_IMAGE_ICON_NAME`.
     */
    pixelSize: number
    /**
     * A path to a resource file to display.
     */
    resource: string | null
    /**
     * The representation being used for image data.
     */
    readonly storageType: ImageType
    /**
     * Whether the icon displayed in the `GtkImage` will use
     * standard icon names fallback.
     *
     * The value of this property is only relevant for images of type
     * %GTK_IMAGE_ICON_NAME and %GTK_IMAGE_GICON.
     */
    useFallback: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Image

    /**
     * Resets the image to be empty.
     */
    clear(): void
    /**
     * Gets the `GIcon` being displayed by the `GtkImage`.
     *
     * The storage type of the image must be %GTK_IMAGE_EMPTY or
     * %GTK_IMAGE_GICON (see [method`Gtk`.Image.get_storage_type]).
     * The caller of this function does not own a reference to the
     * returned `GIcon`.
     * @returns a `GIcon`
     */
    getGicon(): Gio.Icon | null
    /**
     * Gets the icon name and size being displayed by the `GtkImage`.
     *
     * The storage type of the image must be %GTK_IMAGE_EMPTY or
     * %GTK_IMAGE_ICON_NAME (see [method`Gtk`.Image.get_storage_type]).
     * The returned string is owned by the `GtkImage` and should not
     * be freed.
     * @returns the icon name
     */
    getIconName(): string | null
    /**
     * Gets the icon size used by the `image` when rendering icons.
     * @returns the image size used by icons
     */
    getIconSize(): IconSize
    /**
     * Gets the image `GdkPaintable` being displayed by the `GtkImage`.
     *
     * The storage type of the image must be %GTK_IMAGE_EMPTY or
     * %GTK_IMAGE_PAINTABLE (see [method`Gtk`.Image.get_storage_type]).
     * The caller of this function does not own a reference to the
     * returned paintable.
     * @returns the displayed paintable
     */
    getPaintable(): Gdk.Paintable | null
    /**
     * Gets the pixel size used for named icons.
     * @returns the pixel size used for named icons.
     */
    getPixelSize(): number
    /**
     * Gets the type of representation being used by the `GtkImage`
     * to store image data.
     *
     * If the `GtkImage` has no image data, the return value will
     * be %GTK_IMAGE_EMPTY.
     * @returns image representation being used
     */
    getStorageType(): ImageType
    /**
     * Sets a `GtkImage` to show a file.
     *
     * See [ctor`Gtk`.Image.new_from_file] for details.
     * @param filename a filename
     */
    setFromFile(filename: string | null): void
    /**
     * Sets a `GtkImage` to show a `GIcon`.
     *
     * See [ctor`Gtk`.Image.new_from_gicon] for details.
     * @param icon an icon
     */
    setFromGicon(icon: Gio.Icon): void
    /**
     * Sets a `GtkImage` to show a named icon.
     *
     * See [ctor`Gtk`.Image.new_from_icon_name] for details.
     * @param iconName an icon name
     */
    setFromIconName(iconName: string | null): void
    /**
     * Sets a `GtkImage` to show a `GdkPaintable`.
     *
     * See [ctor`Gtk`.Image.new_from_paintable] for details.
     * @param paintable a `GdkPaintable`
     */
    setFromPaintable(paintable: Gdk.Paintable | null): void
    /**
     * Sets a `GtkImage` to show a `GdkPixbuf`.
     *
     * See [ctor`Gtk`.Image.new_from_pixbuf] for details.
     *
     * Note: This is a helper for [method`Gtk`.Image.set_from_paintable],
     * and you can't get back the exact pixbuf once this is called,
     * only a paintable.
     * @param pixbuf a `GdkPixbuf` or `NULL`
     */
    setFromPixbuf(pixbuf: GdkPixbuf.Pixbuf | null): void
    /**
     * Sets a `GtkImage` to show a resource.
     *
     * See [ctor`Gtk`.Image.new_from_resource] for details.
     * @param resourcePath a resource path
     */
    setFromResource(resourcePath: string | null): void
    /**
     * Suggests an icon size to the theme for named icons.
     * @param iconSize the new icon size
     */
    setIconSize(iconSize: IconSize): void
    /**
     * Sets the pixel size to use for named icons.
     *
     * If the pixel size is set to a value != -1, it is used instead
     * of the icon size set by [method`Gtk`.Image.set_from_icon_name].
     * @param pixelSize the new pixel size
     */
    setPixelSize(pixelSize: number): void

    // Class property signals of Gtk-4.0.Gtk.Image

    connect(sigName: "notify::file", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file", ...args: any[]): void
    connect(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gicon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gicon", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::icon-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-size", ...args: any[]): void
    connect(
      sigName: "notify::paintable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::paintable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::paintable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::paintable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::paintable", ...args: any[]): void
    connect(
      sigName: "notify::pixel-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixel-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixel-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixel-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixel-size", ...args: any[]): void
    connect(
      sigName: "notify::resource",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resource",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resource",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resource",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resource", ...args: any[]): void
    connect(
      sigName: "notify::storage-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::storage-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::storage-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::storage-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::storage-type", ...args: any[]): void
    connect(
      sigName: "notify::use-fallback",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-fallback",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-fallback", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkImage` widget displays an image.
   *
   * ![An example GtkImage](image.png)
   *
   * Various kinds of object can be displayed as an image; most typically,
   * you would load a `GdkTexture` from a file, using the convenience function
   * [ctor`Gtk`.Image.new_from_file], for instance:
   *
   * ```c
   * GtkWidget *image = gtk_image_new_from_file ("myfile.png");
   * ```
   *
   * If the file isn’t loaded successfully, the image will contain a
   * “broken image” icon similar to that used in many web browsers.
   *
   * If you want to handle errors in loading the file yourself,
   * for example by displaying an error message, then load the image with
   * [ctor`Gdk`.Texture.new_from_file], then create the `GtkImage` with
   * [ctor`Gtk`.Image.new_from_paintable].
   *
   * Sometimes an application will want to avoid depending on external data
   * files, such as image files. See the documentation of `GResource` inside
   * GIO, for details. In this case, [property`Gtk`.Image:resource],
   * [ctor`Gtk`.Image.new_from_resource], and [method`Gtk`.Image.set_from_resource]
   * should be used.
   *
   * `GtkImage` displays its image as an icon, with a size that is determined
   * by the application. See [class`Gtk`.Picture] if you want to show an image
   * at is actual size.
   *
   * ## CSS nodes
   *
   * `GtkImage` has a single CSS node with the name `image`. The style classes
   * `.normal-icons` or `.large-icons` may appear, depending on the
   * [property`Gtk`.Image:icon-size] property.
   *
   * ## Accessibility
   *
   * `GtkImage` uses the `GTK_ACCESSIBLE_ROLE_IMG` role.
   * @class
   */
  class Image extends Widget {
    // Own properties of Gtk-4.0.Gtk.Image

    static name: string

    // Constructors of Gtk-4.0.Gtk.Image

    constructor(config?: Image.ConstructorProperties)
    /**
     * Creates a new empty `GtkImage` widget.
     * @constructor
     * @returns a newly created `GtkImage` widget.
     */
    constructor()
    /**
     * Creates a new empty `GtkImage` widget.
     * @constructor
     * @returns a newly created `GtkImage` widget.
     */
    static new(): Image
    /**
     * Creates a new `GtkImage` displaying the file `filename`.
     *
     * If the file isn’t found or can’t be loaded, the resulting `GtkImage`
     * will display a “broken image” icon. This function never returns %NULL,
     * it always returns a valid `GtkImage` widget.
     *
     * If you need to detect failures to load the file, use
     * [ctor`Gdk`.Texture.new_from_file] to load the file yourself,
     * then create the `GtkImage` from the texture.
     *
     * The storage type (see [method`Gtk`.Image.get_storage_type])
     * of the returned image is not defined, it will be whatever
     * is appropriate for displaying the file.
     * @constructor
     * @param filename a filename
     * @returns a new `GtkImage`
     */
    static newFromFile(filename: string): Image
    /**
     * Creates a `GtkImage` displaying an icon from the current icon theme.
     *
     * If the icon name isn’t known, a “broken image” icon will be
     * displayed instead. If the current icon theme is changed, the icon
     * will be updated appropriately.
     * @constructor
     * @param icon an icon
     * @returns a new `GtkImage` displaying the themed icon
     */
    static newFromGicon(icon: Gio.Icon): Image
    /**
     * Creates a `GtkImage` displaying an icon from the current icon theme.
     *
     * If the icon name isn’t known, a “broken image” icon will be
     * displayed instead. If the current icon theme is changed, the icon
     * will be updated appropriately.
     * @constructor
     * @param iconName an icon name
     * @returns a new `GtkImage` displaying the themed icon
     */
    static newFromIconName(iconName: string | null): Image
    /**
     * Creates a new `GtkImage` displaying `paintable`.
     *
     * The `GtkImage` does not assume a reference to the paintable; you still
     * need to unref it if you own references. `GtkImage` will add its own
     * reference rather than adopting yours.
     *
     * The `GtkImage` will track changes to the `paintable` and update
     * its size and contents in response to it.
     * @constructor
     * @param paintable a `GdkPaintable`
     * @returns a new `GtkImage`
     */
    static newFromPaintable(paintable: Gdk.Paintable | null): Image
    /**
     * Creates a new `GtkImage` displaying `pixbuf`.
     *
     * The `GtkImage` does not assume a reference to the pixbuf; you still
     * need to unref it if you own references. `GtkImage` will add its own
     * reference rather than adopting yours.
     *
     * This is a helper for [ctor`Gtk`.Image.new_from_paintable], and you can't
     * get back the exact pixbuf once this is called, only a texture.
     *
     * Note that this function just creates an `GtkImage` from the pixbuf.
     * The `GtkImage` created will not react to state changes. Should you
     * want that, you should use [ctor`Gtk`.Image.new_from_icon_name].
     * @constructor
     * @param pixbuf a `GdkPixbuf`
     * @returns a new `GtkImage`
     */
    static newFromPixbuf(pixbuf: GdkPixbuf.Pixbuf | null): Image
    /**
     * Creates a new `GtkImage` displaying the resource file `resource_path`.
     *
     * If the file isn’t found or can’t be loaded, the resulting `GtkImage` will
     * display a “broken image” icon. This function never returns %NULL,
     * it always returns a valid `GtkImage` widget.
     *
     * If you need to detect failures to load the file, use
     * [ctor`GdkPixbuf`.Pixbuf.new_from_file] to load the file yourself,
     * then create the `GtkImage` from the pixbuf.
     *
     * The storage type (see [method`Gtk`.Image.get_storage_type]) of
     * the returned image is not defined, it will be whatever is
     * appropriate for displaying the file.
     * @constructor
     * @param resourcePath a resource path
     * @returns a new `GtkImage`
     */
    static newFromResource(resourcePath: string): Image
    _init(config?: Image.ConstructorProperties): void
  }

  module InfoBar {
    // Signal callback interfaces

    /**
     * Signal callback interface for `close`
     */
    interface CloseSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `response`
     */
    interface ResponseSignalCallback {
      (responseId: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.InfoBar

      /**
       * The type of the message.
       *
       * The type may be used to determine the appearance of the info bar.
       */
      message_type?: MessageType | null
      /**
       * Whether the info bar shows its contents.
       */
      revealed?: boolean | null
      /**
       * Whether to include a standard close button.
       */
      show_close_button?: boolean | null
    }
  }

  interface InfoBar extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.InfoBar

    /**
     * The type of the message.
     *
     * The type may be used to determine the appearance of the info bar.
     */
    messageType: MessageType
    /**
     * Whether the info bar shows its contents.
     */
    revealed: boolean
    /**
     * Whether to include a standard close button.
     */
    showCloseButton: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.InfoBar

    /**
     * Add an activatable widget to the action area of a `GtkInfoBar`.
     *
     * This also connects a signal handler that will emit the
     * [signal`Gtk`.InfoBar::response] signal on the message area
     * when the widget is activated. The widget is appended to the
     * end of the message areas action area.
     * @param child an activatable widget
     * @param responseId response ID for `child`
     */
    addActionWidget(child: Widget, responseId: number): void
    /**
     * Adds a button with the given text.
     *
     * Clicking the button will emit the [signal`Gtk`.InfoBar::response]
     * signal with the given response_id. The button is appended to the
     * end of the info bar's action area. The button widget is returned,
     * but usually you don't need it.
     * @param buttonText text of button
     * @param responseId response ID for the button
     * @returns the `GtkButton` widget that was added
     */
    addButton(buttonText: string, responseId: number): Button
    /**
     * Adds a widget to the content area of the info bar.
     * @param widget the child to be added
     */
    addChild(widget: Widget): void

    // Overloads of addChild

    /**
     * Adds a child to `buildable`. `type` is an optional string
     * describing how the child should be added.
     * @virtual
     * @param builder a `GtkBuilder`
     * @param child child to add
     * @param type kind of child or %NULL
     */
    addChild(builder: Builder, child: GObject.Object, type: string | null): void
    /**
     * Returns the message type of the message area.
     * @returns the message type of the message area.
     */
    getMessageType(): MessageType
    /**
     * Returns whether the info bar is currently revealed.
     * @returns the current value of the [property@Gtk.InfoBar:revealed] property
     */
    getRevealed(): boolean
    /**
     * Returns whether the widget will display a standard close button.
     * @returns %TRUE if the widget displays standard close button
     */
    getShowCloseButton(): boolean
    /**
     * Removes a widget from the action area of `info_bar`.
     *
     * The widget must have been put there by a call to
     * [method`Gtk`.InfoBar.add_action_widget] or [method`Gtk`.InfoBar.add_button].
     * @param widget an action widget to remove
     */
    removeActionWidget(widget: Widget): void
    /**
     * Removes a widget from the content area of the info bar.
     * @param widget a child that has been added to the content area
     */
    removeChild(widget: Widget): void
    /**
     * Emits the “response” signal with the given `response_id`.
     * @param responseId a response ID
     */
    response(responseId: number): void
    /**
     * Sets the last widget in the info bar’s action area with
     * the given response_id as the default widget for the dialog.
     *
     * Pressing “Enter” normally activates the default widget.
     *
     * Note that this function currently requires `info_bar` to
     * be added to a widget hierarchy.
     * @param responseId a response ID
     */
    setDefaultResponse(responseId: number): void
    /**
     * Sets the message type of the message area.
     *
     * GTK uses this type to determine how the message is displayed.
     * @param messageType a `GtkMessageType`
     */
    setMessageType(messageType: MessageType): void
    /**
     * Sets the sensitivity of action widgets for `response_id`.
     *
     * Calls `gtk_widget_set_sensitive (widget, setting)` for each
     * widget in the info bars’s action area with the given `response_id`.
     * A convenient way to sensitize/desensitize buttons.
     * @param responseId a response ID
     * @param setting TRUE for sensitive
     */
    setResponseSensitive(responseId: number, setting: boolean): void
    /**
     * Sets whether the `GtkInfoBar` is revealed.
     *
     * Changing this will make `info_bar` reveal or conceal
     * itself via a sliding transition.
     *
     * Note: this does not show or hide `info_bar` in the
     * [property`Gtk`.Widget:visible] sense, so revealing has no effect
     * if [property`Gtk`.Widget:visible] is %FALSE.
     * @param revealed The new value of the property
     */
    setRevealed(revealed: boolean): void
    /**
     * If true, a standard close button is shown.
     *
     * When clicked it emits the response %GTK_RESPONSE_CLOSE.
     * @param setting %TRUE to include a close button
     */
    setShowCloseButton(setting: boolean): void

    // Own signals of Gtk-4.0.Gtk.InfoBar

    connect(sigName: "close", callback: InfoBar.CloseSignalCallback): number
    on(
      sigName: "close",
      callback: InfoBar.CloseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "close",
      callback: InfoBar.CloseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "close",
      callback: InfoBar.CloseSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "close", ...args: any[]): void
    connect(
      sigName: "response",
      callback: InfoBar.ResponseSignalCallback
    ): number
    on(
      sigName: "response",
      callback: InfoBar.ResponseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "response",
      callback: InfoBar.ResponseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "response",
      callback: InfoBar.ResponseSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "response", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.InfoBar

    connect(
      sigName: "notify::message-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::message-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::message-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::message-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::message-type", ...args: any[]): void
    connect(
      sigName: "notify::revealed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::revealed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::revealed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::revealed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::revealed", ...args: any[]): void
    connect(
      sigName: "notify::show-close-button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-close-button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-close-button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-close-button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-close-button", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkInfoBar` can be used to show messages to the user without a dialog.
   *
   * ![An example GtkInfoBar](info-bar.png)
   *
   * It is often temporarily shown at the top or bottom of a document.
   * In contrast to [class`Gtk`.Dialog], which has an action area at the
   * bottom, `GtkInfoBar` has an action area at the side.
   *
   * The API of `GtkInfoBar` is very similar to `GtkDialog`, allowing you
   * to add buttons to the action area with [method`Gtk`.InfoBar.add_button]
   * or [ctor`Gtk`.InfoBar.new_with_buttons]. The sensitivity of action widgets
   * can be controlled with [method`Gtk`.InfoBar.set_response_sensitive].
   *
   * To add widgets to the main content area of a `GtkInfoBar`, use
   * [method`Gtk`.InfoBar.add_child].
   *
   * Similar to [class`Gtk`.MessageDialog], the contents of a `GtkInfoBar`
   * can by classified as error message, warning, informational message, etc,
   * by using [method`Gtk`.InfoBar.set_message_type]. GTK may use the message
   * type to determine how the message is displayed.
   *
   * A simple example for using a `GtkInfoBar`:
   * ```c
   * GtkWidget *message_label;
   * GtkWidget *widget;
   * GtkWidget *grid;
   * GtkInfoBar *bar;
   *
   * // set up info bar
   * widget = gtk_info_bar_new ();
   * bar = GTK_INFO_BAR (widget);
   * grid = gtk_grid_new ();
   *
   * message_label = gtk_label_new ("");
   * gtk_info_bar_add_child (bar, message_label);
   * gtk_info_bar_add_button (bar,
   *                          _("_OK"),
   *                          GTK_RESPONSE_OK);
   * g_signal_connect (bar,
   *                   "response",
   *                   G_CALLBACK (gtk_widget_hide),
   *                   NULL);
   * gtk_grid_attach (GTK_GRID (grid),
   *                  widget,
   *                  0, 2, 1, 1);
   *
   * // ...
   *
   * // show an error message
   * gtk_label_set_text (GTK_LABEL (message_label), "An error occurred!");
   * gtk_info_bar_set_message_type (bar, GTK_MESSAGE_ERROR);
   * gtk_widget_show (bar);
   * ```
   *
   * # GtkInfoBar as GtkBuildable
   *
   * `GtkInfoBar` supports a custom `<action-widgets>` element, which can contain
   * multiple `<action-widget>` elements. The “response” attribute specifies a
   * numeric response, and the content of the element is the id of widget
   * (which should be a child of the dialogs `action_area)`.
   *
   * `GtkInfoBar` supports adding action widgets by specifying “action” as
   * the “type” attribute of a `<child>` element. The widget will be added
   * either to the action area. The response id has to be associated
   * with the action widget using the `<action-widgets>` element.
   *
   * # CSS nodes
   *
   * `GtkInfoBar` has a single CSS node with name infobar. The node may get
   * one of the style classes .info, .warning, .error or .question, depending
   * on the message type.
   * If the info bar shows a close button, that button will have the .close
   * style class applied.
   * @class
   */
  class InfoBar extends Widget {
    // Own properties of Gtk-4.0.Gtk.InfoBar

    static name: string

    // Constructors of Gtk-4.0.Gtk.InfoBar

    constructor(config?: InfoBar.ConstructorProperties)
    /**
     * Creates a new `GtkInfoBar` object.
     * @constructor
     * @returns a new `GtkInfoBar` object
     */
    constructor()
    /**
     * Creates a new `GtkInfoBar` object.
     * @constructor
     * @returns a new `GtkInfoBar` object
     */
    static new(): InfoBar
    _init(config?: InfoBar.ConstructorProperties): void
  }

  module Inscription {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleText.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Inscription

      /**
       * A list of style attributes to apply to the text of the inscription.
       */
      attributes?: Pango.AttrList | null
      /**
       * Utility property that sets both the [property`Gtk`.Inscription:text] and
       * [property`Gtk`.Inscription:attributes] properties, mainly intended for use in
       * GtkBuilder ui files to ease translation support and bindings.
       *
       * This function uses [func`Pango`.parse_markup] to parse the markup into text and
       * attributes. The markup must be valid. If you cannot ensure that, consider using
       * [func`Pango`.parse_markup] and setting the two properties yourself.
       */
      markup?: string | null
      /**
       * The number of characters that should fit into the inscription at minimum.
       *
       * This influences the requested width, not the width actually given to the widget,
       * which might turn out to be larger.
       *
       * Note that this is an approximate character width, so some characters might be
       * wider and some might be thinner, so do not expect the number of characters to
       * exactly match.
       *
       * If you set this property to 0, the inscription will not request any width at all
       * and its width will be determined entirely by its surroundings.
       */
      min_chars?: number | null
      /**
       * The number of lines that should fit into the inscription at minimum.
       *
       * This influences the requested height, not the height actually given to the widget,
       * which might turn out to be larger.
       *
       * Note that this is an approximate line height, so if the text uses things like fancy
       * Unicode or attribute that influence the height, the text might not fit.
       *
       * If you set this property to 0, the inscription will not request any height at all
       * and its height will be determined entirely by its surroundings.
       */
      min_lines?: number | null
      /**
       * The number of characters that should ideally fit into the inscription.
       *
       * This influences the requested width, not the width actually given to the widget.
       * The widget might turn out larger as well as smaller.
       *
       * If this property is set to a value smaller than [property`Gtk`.Inscription:min-chars],
       * that value will be used. In particular, for the default value of 0, this will always
       * be the case.
       */
      nat_chars?: number | null
      /**
       * The number of lines that should ideally fit into the inscription.
       *
       * This influences the requested height, not the height actually given to the widget.
       * The widget might turn out larger as well as smaller.
       *
       * If this property is set to a value smaller than [property`Gtk`.Inscription:min-lines],
       * that value will be used. In particular, for the default value of 0, this will always
       * be the case.
       */
      nat_lines?: number | null
      /**
       * The displayed text.
       */
      text?: string | null
      /**
       * The overflow method to use for the text.
       */
      text_overflow?: InscriptionOverflow | null
      /**
       * Controls how the line wrapping is done.
       *
       * Note that unlike `GtkLabel`, the default here is %PANGO_WRAP_WORD_CHAR.
       */
      wrap_mode?: Pango.WrapMode | null
      /**
       * The horizontal alignment of the text inside the allocated size.
       *
       * Compare this to [property`Gtk`.Widget:halign], which determines how the
       * inscription's size allocation is positioned in the available space.
       */
      xalign?: number | null
      /**
       * The vertical alignment of the text inside the allocated size.
       *
       * Compare this to [property`Gtk`.Widget:valign], which determines how the
       * inscription's size allocation is positioned in the available space.
       */
      yalign?: number | null
    }
  }

  interface Inscription
    extends Accessible,
      AccessibleText,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Inscription

    /**
     * A list of style attributes to apply to the text of the inscription.
     */
    attributes: Pango.AttrList
    /**
     * Utility property that sets both the [property`Gtk`.Inscription:text] and
     * [property`Gtk`.Inscription:attributes] properties, mainly intended for use in
     * GtkBuilder ui files to ease translation support and bindings.
     *
     * This function uses [func`Pango`.parse_markup] to parse the markup into text and
     * attributes. The markup must be valid. If you cannot ensure that, consider using
     * [func`Pango`.parse_markup] and setting the two properties yourself.
     */
    markup: string | null
    /**
     * The number of characters that should fit into the inscription at minimum.
     *
     * This influences the requested width, not the width actually given to the widget,
     * which might turn out to be larger.
     *
     * Note that this is an approximate character width, so some characters might be
     * wider and some might be thinner, so do not expect the number of characters to
     * exactly match.
     *
     * If you set this property to 0, the inscription will not request any width at all
     * and its width will be determined entirely by its surroundings.
     */
    minChars: number
    /**
     * The number of lines that should fit into the inscription at minimum.
     *
     * This influences the requested height, not the height actually given to the widget,
     * which might turn out to be larger.
     *
     * Note that this is an approximate line height, so if the text uses things like fancy
     * Unicode or attribute that influence the height, the text might not fit.
     *
     * If you set this property to 0, the inscription will not request any height at all
     * and its height will be determined entirely by its surroundings.
     */
    minLines: number
    /**
     * The number of characters that should ideally fit into the inscription.
     *
     * This influences the requested width, not the width actually given to the widget.
     * The widget might turn out larger as well as smaller.
     *
     * If this property is set to a value smaller than [property`Gtk`.Inscription:min-chars],
     * that value will be used. In particular, for the default value of 0, this will always
     * be the case.
     */
    natChars: number
    /**
     * The number of lines that should ideally fit into the inscription.
     *
     * This influences the requested height, not the height actually given to the widget.
     * The widget might turn out larger as well as smaller.
     *
     * If this property is set to a value smaller than [property`Gtk`.Inscription:min-lines],
     * that value will be used. In particular, for the default value of 0, this will always
     * be the case.
     */
    natLines: number
    /**
     * The displayed text.
     */
    text: string | null
    /**
     * The overflow method to use for the text.
     */
    textOverflow: InscriptionOverflow
    /**
     * Controls how the line wrapping is done.
     *
     * Note that unlike `GtkLabel`, the default here is %PANGO_WRAP_WORD_CHAR.
     */
    wrapMode: Pango.WrapMode
    /**
     * The horizontal alignment of the text inside the allocated size.
     *
     * Compare this to [property`Gtk`.Widget:halign], which determines how the
     * inscription's size allocation is positioned in the available space.
     */
    xalign: number
    /**
     * The vertical alignment of the text inside the allocated size.
     *
     * Compare this to [property`Gtk`.Widget:valign], which determines how the
     * inscription's size allocation is positioned in the available space.
     */
    yalign: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Inscription

    /**
     * Gets the inscription's attribute list.
     * @returns the attribute list
     */
    getAttributes(): Pango.AttrList | null

    // Overloads of getAttributes

    /**
     * Retrieves the text attributes inside the accessible object.
     *
     * Each attribute is composed by:
     *
     * - a range
     * - a name
     * - a value
     *
     * It is left to the implementation to determine the serialization format
     * of the value to a string.
     *
     * GTK provides support for various text attribute names and values, but
     * implementations of this interface are free to add their own attributes.
     *
     * If this function returns true, `n_ranges` will be set to a value
     * greater than or equal to one, `ranges` will be set to a newly
     * allocated array of [struct#Gtk.AccessibleTextRange].
     * @virtual
     * @param offset the offset, in characters
     * @returns true if the accessible object has at least an attribute,   and false otherwise
     */
    getAttributes(
      offset: number
    ): [
      /* returnType */ boolean,
      /* ranges */ AccessibleTextRange[],
      /* attributeNames */ string[],
      /* attributeValues */ string[],
    ]
    /**
     * Gets the `min-chars` of the inscription.
     *
     * See the [property`Gtk`.Inscription:min-chars] property.
     * @returns the min-chars property
     */
    getMinChars(): number
    /**
     * Gets the `min-lines` of the inscription.
     *
     * See the [property`Gtk`.Inscription:min-lines] property.
     * @returns the min-lines property
     */
    getMinLines(): number
    /**
     * Gets the `nat-chars` of the inscription.
     *
     * See the [property`Gtk`.Inscription:nat-chars] property.
     * @returns the nat-chars property
     */
    getNatChars(): number
    /**
     * Gets the `nat-lines` of the inscription.
     *
     * See the [property`Gtk`.Inscription:nat-lines] property.
     * @returns the nat-lines property
     */
    getNatLines(): number
    /**
     * Gets the text that is displayed.
     * @returns The displayed text
     */
    getText(): string | null
    /**
     * Gets the inscription's overflow method.
     * @returns the overflow method
     */
    getTextOverflow(): InscriptionOverflow
    /**
     * Returns line wrap mode used by the inscription.
     *
     * See [method`Gtk`.Inscription.set_wrap_mode].
     * @returns the line wrap mode
     */
    getWrapMode(): Pango.WrapMode
    /**
     * Gets the `xalign` of the inscription.
     *
     * See the [property`Gtk`.Inscription:xalign] property.
     * @returns the xalign property
     */
    getXalign(): number
    /**
     * Gets the `yalign` of the inscription.
     *
     * See the [property`Gtk`.Inscription:yalign] property.
     * @returns the yalign property
     */
    getYalign(): number
    /**
     * Apply attributes to the inscription text.
     *
     * These attributes will not be evaluated for sizing the inscription.
     * @param attrs a [struct`Pango`.AttrList]
     */
    setAttributes(attrs: Pango.AttrList | null): void
    /**
     * Utility function to set the text and attributes to be displayed.
     *
     * See the [property`Gtk`.Inscription:markup] property.
     * @param markup The markup to display
     */
    setMarkup(markup: string | null): void
    /**
     * Sets the `min-chars` of the inscription.
     *
     * See the [property`Gtk`.Inscription:min-chars] property.
     * @param minChars the minimum number of characters that should fit, approximately
     */
    setMinChars(minChars: number): void
    /**
     * Sets the `min-lines` of the inscription.
     *
     * See the [property`Gtk`.Inscription:min-lines] property.
     * @param minLines the minimum number of lines that should fit, approximately
     */
    setMinLines(minLines: number): void
    /**
     * Sets the `nat-chars` of the inscription.
     *
     * See the [property`Gtk`.Inscription:nat-chars] property.
     * @param natChars the number of characters that should ideally fit, approximately
     */
    setNatChars(natChars: number): void
    /**
     * Sets the `nat-lines` of the inscription.
     *
     * See the [property`Gtk`.Inscription:nat-lines] property.
     * @param natLines the number of lines that should ideally fit
     */
    setNatLines(natLines: number): void
    /**
     * Sets the text to be displayed.
     * @param text The text to display
     */
    setText(text: string | null): void
    /**
     * Sets what to do when the text doesn't fit.
     * @param overflow the overflow method to use
     */
    setTextOverflow(overflow: InscriptionOverflow): void
    /**
     * Controls how line wrapping is done.
     * @param wrapMode the line wrapping mode
     */
    setWrapMode(wrapMode: Pango.WrapMode): void
    /**
     * Sets the `xalign` of the inscription.
     *
     * See the [property`Gtk`.Inscription:xalign] property.
     * @param xalign the new xalign value, between 0 and 1
     */
    setXalign(xalign: number): void
    /**
     * Sets the `yalign` of the inscription.
     *
     * See the [property`Gtk`.Inscription:yalign] property.
     * @param yalign the new yalign value, between 0 and 1
     */
    setYalign(yalign: number): void

    // Class property signals of Gtk-4.0.Gtk.Inscription

    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::markup", ...args: any[]): void
    connect(
      sigName: "notify::min-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-chars", ...args: any[]): void
    connect(
      sigName: "notify::min-lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-lines", ...args: any[]): void
    connect(
      sigName: "notify::nat-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::nat-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::nat-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::nat-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::nat-chars", ...args: any[]): void
    connect(
      sigName: "notify::nat-lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::nat-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::nat-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::nat-lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::nat-lines", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::text-overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-overflow", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkInscription` is a widget to show text in a predefined area.
   *
   * You likely want to use `GtkLabel` instead as this widget is intended only
   * for a small subset of use cases. The main scenario envisaged is inside lists
   * such as `GtkColumnView`.
   *
   * While a `GtkLabel` sizes itself depending on the text that is displayed,
   * `GtkInscription` is given a size and inscribes the given text into that
   * space as well as it can.
   *
   * Users of this widget should take care to plan behaviour for the common case
   * where the text doesn't fit exactly in the allocated space.
   * @class
   */
  class Inscription extends Widget {
    // Own properties of Gtk-4.0.Gtk.Inscription

    static name: string

    // Constructors of Gtk-4.0.Gtk.Inscription

    constructor(config?: Inscription.ConstructorProperties)
    /**
     * Creates a new `GtkInscription` with the given text.
     * @constructor
     * @param text The text to display.
     * @returns a new `GtkInscription`
     */
    constructor(text: string | null)
    /**
     * Creates a new `GtkInscription` with the given text.
     * @constructor
     * @param text The text to display.
     * @returns a new `GtkInscription`
     */
    static new(text: string | null): Inscription
    _init(config?: Inscription.ConstructorProperties): void
  }

  module KeyvalTrigger {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutTrigger.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.KeyvalTrigger

      /**
       * The key value for the trigger.
       */
      keyval?: number | null
      /**
       * The key modifiers for the trigger.
       */
      modifiers?: Gdk.ModifierType | null
    }
  }

  interface KeyvalTrigger {
    // Own properties of Gtk-4.0.Gtk.KeyvalTrigger

    /**
     * The key value for the trigger.
     */
    readonly keyval: number
    /**
     * The key modifiers for the trigger.
     */
    readonly modifiers: Gdk.ModifierType
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.KeyvalTrigger

    /**
     * Gets the keyval that must be pressed to succeed
     * triggering `self`.
     * @returns the keyval
     */
    getKeyval(): number
    /**
     * Gets the modifiers that must be present to succeed
     * triggering `self`.
     * @returns the modifiers
     */
    getModifiers(): Gdk.ModifierType

    // Class property signals of Gtk-4.0.Gtk.KeyvalTrigger

    connect(
      sigName: "notify::keyval",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::keyval",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::keyval",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::keyval",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::keyval", ...args: any[]): void
    connect(
      sigName: "notify::modifiers",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modifiers",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modifiers",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modifiers",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modifiers", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutTrigger` that triggers when a specific keyval and modifiers are pressed.
   * @class
   */
  class KeyvalTrigger extends ShortcutTrigger {
    // Own properties of Gtk-4.0.Gtk.KeyvalTrigger

    static name: string

    // Constructors of Gtk-4.0.Gtk.KeyvalTrigger

    constructor(config?: KeyvalTrigger.ConstructorProperties)
    /**
     * Creates a `GtkShortcutTrigger` that will trigger whenever
     * the key with the given `keyval` and `modifiers` is pressed.
     * @constructor
     * @param keyval The keyval to trigger for
     * @param modifiers the modifiers that need to be present
     * @returns A new `GtkShortcutTrigger`
     */
    constructor(keyval: number, modifiers: Gdk.ModifierType)
    /**
     * Creates a `GtkShortcutTrigger` that will trigger whenever
     * the key with the given `keyval` and `modifiers` is pressed.
     * @constructor
     * @param keyval The keyval to trigger for
     * @param modifiers the modifiers that need to be present
     * @returns A new `GtkShortcutTrigger`
     */
    static new(keyval: number, modifiers: Gdk.ModifierType): KeyvalTrigger
    _init(config?: KeyvalTrigger.ConstructorProperties): void
  }

  module Label {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate-current-link`
     */
    interface ActivateCurrentLinkSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `activate-link`
     */
    interface ActivateLinkSignalCallback {
      (uri: string | null): boolean
    }

    /**
     * Signal callback interface for `copy-clipboard`
     */
    interface CopyClipboardSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `move-cursor`
     */
    interface MoveCursorSignalCallback {
      (step: MovementStep, count: number, extendSelection: boolean): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleText.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Label

      /**
       * A list of style attributes to apply to the text of the label.
       */
      attributes?: Pango.AttrList | null
      /**
       * The preferred place to ellipsize the string, if the label does
       * not have enough room to display the entire string.
       *
       * Note that setting this property to a value other than
       * %PANGO_ELLIPSIZE_NONE has the side-effect that the label requests
       * only enough space to display the ellipsis "...". In particular, this
       * means that ellipsizing labels do not work well in notebook tabs, unless
       * the [property`Gtk`.NotebookPage:tab-expand] child property is set to %TRUE.
       * Other ways to set a label's width are [method`Gtk`.Widget.set_size_request]
       * and [method`Gtk`.Label.set_width_chars].
       */
      ellipsize?: Pango.EllipsizeMode | null
      /**
       * A menu model whose contents will be appended to the context menu.
       */
      extra_menu?: Gio.MenuModel | null
      /**
       * The alignment of the lines in the text of the label, relative to each other.
       *
       * This does *not* affect the alignment of the label within its allocation.
       * See [property`Gtk`.Label:xalign] for that.
       */
      justify?: Justification | null
      /**
       * The contents of the label.
       *
       * If the string contains Pango markup (see [func`Pango`.parse_markup]),
       * you will have to set the [property`Gtk`.Label:use-markup] property to
       * %TRUE in order for the label to display the markup attributes. See also
       * [method`Gtk`.Label.set_markup] for a convenience function that sets both
       * this property and the [property`Gtk`.Label:use-markup] property at the
       * same time.
       *
       * If the string contains underlines acting as mnemonics, you will have to
       * set the [property`Gtk`.Label:use-underline] property to %TRUE in order
       * for the label to display them.
       */
      label?: string | null
      /**
       * The number of lines to which an ellipsized, wrapping label
       * should be limited.
       *
       * This property has no effect if the label is not wrapping or ellipsized.
       * Set this property to -1 if you don't want to limit the number of lines.
       */
      lines?: number | null
      /**
       * The desired maximum width of the label, in characters.
       *
       * If this property is set to -1, the width will be calculated automatically.
       *
       * See the section on [text layout](class.Label.html#text-layout) for details of how
       * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
       * determine the width of ellipsized and wrapped labels.
       */
      max_width_chars?: number | null
      /**
       * The widget to be activated when the labels mnemonic key is pressed.
       */
      mnemonic_widget?: Widget | null
      /**
       * Select the line wrapping for the natural size request.
       *
       * This only affects the natural size requested. For the actual wrapping used,
       * see the [property`Gtk`.Label:wrap-mode] property.
       *
       * The default is %GTK_NATURAL_WRAP_INHERIT, which inherits the behavior of the
       * [property`Gtk`.Label:wrap-mode] property.
       */
      natural_wrap_mode?: NaturalWrapMode | null
      /**
       * Whether the label text can be selected with the mouse.
       */
      selectable?: boolean | null
      /**
       * Whether the label is in single line mode.
       *
       * In single line mode, the height of the label does not depend on the
       * actual text, it is always set to ascent + descent of the font. This
       * can be an advantage in situations where resizing the label because
       * of text changes would be distracting, e.g. in a statusbar.
       */
      single_line_mode?: boolean | null
      /**
       * Custom tabs for this label.
       */
      tabs?: Pango.TabArray | null
      /**
       * %TRUE if the text of the label includes Pango markup.
       *
       * See [func`Pango`.parse_markup].
       */
      use_markup?: boolean | null
      /**
       * %TRUE if the text of the label indicates a mnemonic with an _
       * before the mnemonic character.
       */
      use_underline?: boolean | null
      /**
       * The desired width of the label, in characters.
       *
       * If this property is set to -1, the width will be calculated automatically.
       *
       * See the section on [text layout](class.Label.html#text-layout) for details of how
       * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
       * determine the width of ellipsized and wrapped labels.
       */
      width_chars?: number | null
      /**
       * %TRUE if the label text will wrap if it gets too wide.
       */
      wrap?: boolean | null
      /**
       * Controls how the line wrapping is done.
       *
       * This only affects the formatting if line wrapping is on (see the
       * [property`Gtk`.Label:wrap] property). The default is %PANGO_WRAP_WORD,
       * which means wrap on word boundaries.
       *
       * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
       * property.
       */
      wrap_mode?: Pango.WrapMode | null
      /**
       * The horizontal alignment of the label text inside its size allocation.
       *
       * Compare this to [property`Gtk`.Widget:halign], which determines how the
       * labels size allocation is positioned in the space available for the label.
       */
      xalign?: number | null
      /**
       * The vertical alignment of the label text inside its size allocation.
       *
       * Compare this to [property`Gtk`.Widget:valign], which determines how the
       * labels size allocation is positioned in the space available for the label.
       */
      yalign?: number | null
    }
  }

  interface Label
    extends Accessible,
      AccessibleText,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Label

    /**
     * A list of style attributes to apply to the text of the label.
     */
    attributes: Pango.AttrList
    /**
     * The preferred place to ellipsize the string, if the label does
     * not have enough room to display the entire string.
     *
     * Note that setting this property to a value other than
     * %PANGO_ELLIPSIZE_NONE has the side-effect that the label requests
     * only enough space to display the ellipsis "...". In particular, this
     * means that ellipsizing labels do not work well in notebook tabs, unless
     * the [property`Gtk`.NotebookPage:tab-expand] child property is set to %TRUE.
     * Other ways to set a label's width are [method`Gtk`.Widget.set_size_request]
     * and [method`Gtk`.Label.set_width_chars].
     */
    ellipsize: Pango.EllipsizeMode
    /**
     * A menu model whose contents will be appended to the context menu.
     */
    extraMenu: Gio.MenuModel
    /**
     * The alignment of the lines in the text of the label, relative to each other.
     *
     * This does *not* affect the alignment of the label within its allocation.
     * See [property`Gtk`.Label:xalign] for that.
     */
    justify: Justification
    /**
     * The contents of the label.
     *
     * If the string contains Pango markup (see [func`Pango`.parse_markup]),
     * you will have to set the [property`Gtk`.Label:use-markup] property to
     * %TRUE in order for the label to display the markup attributes. See also
     * [method`Gtk`.Label.set_markup] for a convenience function that sets both
     * this property and the [property`Gtk`.Label:use-markup] property at the
     * same time.
     *
     * If the string contains underlines acting as mnemonics, you will have to
     * set the [property`Gtk`.Label:use-underline] property to %TRUE in order
     * for the label to display them.
     */
    label: string | null
    /**
     * The number of lines to which an ellipsized, wrapping label
     * should be limited.
     *
     * This property has no effect if the label is not wrapping or ellipsized.
     * Set this property to -1 if you don't want to limit the number of lines.
     */
    lines: number
    /**
     * The desired maximum width of the label, in characters.
     *
     * If this property is set to -1, the width will be calculated automatically.
     *
     * See the section on [text layout](class.Label.html#text-layout) for details of how
     * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
     * determine the width of ellipsized and wrapped labels.
     */
    maxWidthChars: number
    /**
     * The mnemonic accelerator key for the label.
     */
    readonly mnemonicKeyval: number
    /**
     * The widget to be activated when the labels mnemonic key is pressed.
     */
    mnemonicWidget: Widget
    /**
     * Select the line wrapping for the natural size request.
     *
     * This only affects the natural size requested. For the actual wrapping used,
     * see the [property`Gtk`.Label:wrap-mode] property.
     *
     * The default is %GTK_NATURAL_WRAP_INHERIT, which inherits the behavior of the
     * [property`Gtk`.Label:wrap-mode] property.
     */
    naturalWrapMode: NaturalWrapMode
    /**
     * Whether the label text can be selected with the mouse.
     */
    selectable: boolean
    /**
     * Whether the label is in single line mode.
     *
     * In single line mode, the height of the label does not depend on the
     * actual text, it is always set to ascent + descent of the font. This
     * can be an advantage in situations where resizing the label because
     * of text changes would be distracting, e.g. in a statusbar.
     */
    singleLineMode: boolean
    /**
     * Custom tabs for this label.
     */
    tabs: Pango.TabArray
    /**
     * %TRUE if the text of the label includes Pango markup.
     *
     * See [func`Pango`.parse_markup].
     */
    useMarkup: boolean
    /**
     * %TRUE if the text of the label indicates a mnemonic with an _
     * before the mnemonic character.
     */
    useUnderline: boolean
    /**
     * The desired width of the label, in characters.
     *
     * If this property is set to -1, the width will be calculated automatically.
     *
     * See the section on [text layout](class.Label.html#text-layout) for details of how
     * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
     * determine the width of ellipsized and wrapped labels.
     */
    widthChars: number
    /**
     * %TRUE if the label text will wrap if it gets too wide.
     */
    wrap: boolean
    /**
     * Controls how the line wrapping is done.
     *
     * This only affects the formatting if line wrapping is on (see the
     * [property`Gtk`.Label:wrap] property). The default is %PANGO_WRAP_WORD,
     * which means wrap on word boundaries.
     *
     * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
     * property.
     */
    wrapMode: Pango.WrapMode
    /**
     * The horizontal alignment of the label text inside its size allocation.
     *
     * Compare this to [property`Gtk`.Widget:halign], which determines how the
     * labels size allocation is positioned in the space available for the label.
     */
    xalign: number
    /**
     * The vertical alignment of the label text inside its size allocation.
     *
     * Compare this to [property`Gtk`.Widget:valign], which determines how the
     * labels size allocation is positioned in the space available for the label.
     */
    yalign: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Label

    /**
     * Gets the label's attribute list.
     *
     * This is the [struct`Pango`.AttrList] that was set on the label using
     * [method`Gtk`.Label.set_attributes], if any. This function does not
     * reflect attributes that come from the label's markup (see
     * [method`Gtk`.Label.set_markup]). If you want to get the effective
     * attributes for the label, use
     * `pango_layout_get_attributes (gtk_label_get_layout (self))`.
     * @returns the attribute list
     */
    getAttributes(): Pango.AttrList | null

    // Overloads of getAttributes

    /**
     * Retrieves the text attributes inside the accessible object.
     *
     * Each attribute is composed by:
     *
     * - a range
     * - a name
     * - a value
     *
     * It is left to the implementation to determine the serialization format
     * of the value to a string.
     *
     * GTK provides support for various text attribute names and values, but
     * implementations of this interface are free to add their own attributes.
     *
     * If this function returns true, `n_ranges` will be set to a value
     * greater than or equal to one, `ranges` will be set to a newly
     * allocated array of [struct#Gtk.AccessibleTextRange].
     * @virtual
     * @param offset the offset, in characters
     * @returns true if the accessible object has at least an attribute,   and false otherwise
     */
    getAttributes(
      offset: number
    ): [
      /* returnType */ boolean,
      /* ranges */ AccessibleTextRange[],
      /* attributeNames */ string[],
      /* attributeValues */ string[],
    ]
    /**
     * Returns the URI for the currently active link in the label.
     *
     * The active link is the one under the mouse pointer or, in a
     * selectable label, the link in which the text cursor is currently
     * positioned.
     *
     * This function is intended for use in a [signal`Gtk`.Label::activate-link]
     * handler or for use in a [signal`Gtk`.Widget::query-tooltip] handler.
     * @returns the currently active URI
     */
    getCurrentUri(): string | null
    /**
     * Returns the ellipsizing position of the label.
     *
     * See [method`Gtk`.Label.set_ellipsize].
     * @returns `PangoEllipsizeMode`
     */
    getEllipsize(): Pango.EllipsizeMode
    /**
     * Gets the extra menu model of `label`.
     *
     * See [method`Gtk`.Label.set_extra_menu].
     * @returns the menu model
     */
    getExtraMenu(): Gio.MenuModel | null
    /**
     * Returns the justification of the label.
     *
     * See [method`Gtk`.Label.set_justify].
     * @returns `GtkJustification`
     */
    getJustify(): Justification
    /**
     * Fetches the text from a label.
     *
     * The returned text includes any embedded underlines indicating
     * mnemonics and Pango markup. (See [method`Gtk`.Label.get_text]).
     * @returns the text of the label widget. This string is   owned by the widget and must not be modified or freed.
     */
    getLabel(): string
    /**
     * Gets the `PangoLayout` used to display the label.
     *
     * The layout is useful to e.g. convert text positions to pixel
     * positions, in combination with [method`Gtk`.Label.get_layout_offsets].
     * The returned layout is owned by the `label` so need not be
     * freed by the caller. The `label` is free to recreate its layout
     * at any time, so it should be considered read-only.
     * @returns the [class@Pango.Layout] for this label
     */
    getLayout(): Pango.Layout
    /**
     * Obtains the coordinates where the label will draw its `PangoLayout`.
     *
     * The coordinates are useful to convert mouse events into coordinates
     * inside the [class`Pango`.Layout], e.g. to take some action if some part
     * of the label is clicked. Remember when using the [class`Pango`.Layout]
     * functions you need to convert to and from pixels using PANGO_PIXELS()
     * or [const`Pango`.SCALE].
     */
    getLayoutOffsets(): [/* x */ number, /* y */ number]
    /**
     * Gets the number of lines to which an ellipsized, wrapping
     * label should be limited.
     *
     * See [method`Gtk`.Label.set_lines].
     * @returns The number of lines
     */
    getLines(): number
    /**
     * Retrieves the desired maximum width of `label,` in characters.
     *
     * See [method`Gtk`.Label.set_width_chars].
     * @returns the maximum width of the label in characters.
     */
    getMaxWidthChars(): number
    /**
     * Return the mnemonic accelerator.
     *
     * If the label has been set so that it has a mnemonic key this function
     * returns the keyval used for the mnemonic accelerator. If there is no
     * mnemonic set up it returns `GDK_KEY_VoidSymbol`.
     * @returns GDK keyval usable for accelerators, or `GDK_KEY_VoidSymbol`
     */
    getMnemonicKeyval(): number
    /**
     * Retrieves the target of the mnemonic (keyboard shortcut) of this
     * label.
     *
     * See [method`Gtk`.Label.set_mnemonic_widget].
     * @returns the target of the label’s mnemonic,   or %NULL if none has been set and the default algorithm will be used.
     */
    getMnemonicWidget(): Widget | null
    /**
     * Returns line wrap mode used by the label.
     *
     * See [method`Gtk`.Label.set_natural_wrap_mode].
     * @returns the natural line wrap mode
     */
    getNaturalWrapMode(): NaturalWrapMode
    /**
     * Returns whether the label is selectable.
     * @returns %TRUE if the user can copy text from the label
     */
    getSelectable(): boolean
    /**
     * Gets the selected range of characters in the label.
     * @returns %TRUE if selection is non-empty
     */
    getSelectionBounds(): [
      /* returnType */ boolean,
      /* start */ number,
      /* end */ number,
    ]
    /**
     * Returns whether the label is in single line mode.
     * @returns %TRUE when the label is in single line mode.
     */
    getSingleLineMode(): boolean
    /**
     * Gets the tabs for `self`.
     *
     * The returned array will be %NULL if “standard” (8-space) tabs are used.
     * Free the return value with [method`Pango`.TabArray.free].
     * @returns copy of default tab array,   or %NULL if standard tabs are used; must be freed with   [method@Pango.TabArray.free].
     */
    getTabs(): Pango.TabArray | null
    /**
     * Fetches the text from a label.
     *
     * The returned text is as it appears on screen. This does not include
     * any embedded underlines indicating mnemonics or Pango markup. (See
     * [method`Gtk`.Label.get_label])
     * @returns the text in the label widget. This is the internal   string used by the label, and must not be modified.
     */
    getText(): string
    /**
     * Returns whether the label’s text is interpreted as Pango markup.
     *
     * See [method`Gtk`.Label.set_use_markup].
     * @returns %TRUE if the label’s text will be parsed for markup.
     */
    getUseMarkup(): boolean
    /**
     * Returns whether an embedded underlines in the label indicate mnemonics.
     *
     * See [method`Gtk`.Label.set_use_underline].
     * @returns %TRUE whether an embedded underline in the label indicates   the mnemonic accelerator keys.
     */
    getUseUnderline(): boolean
    /**
     * Retrieves the desired width of `label,` in characters.
     *
     * See [method`Gtk`.Label.set_width_chars].
     * @returns the width of the label in characters.
     */
    getWidthChars(): number
    /**
     * Returns whether lines in the label are automatically wrapped.
     *
     * See [method`Gtk`.Label.set_wrap].
     * @returns %TRUE if the lines of the label are automatically wrapped.
     */
    getWrap(): boolean
    /**
     * Returns line wrap mode used by the label.
     *
     * See [method`Gtk`.Label.set_wrap_mode].
     * @returns the line wrap mode
     */
    getWrapMode(): Pango.WrapMode
    /**
     * Gets the `xalign` of the label.
     *
     * See the [property`Gtk`.Label:xalign] property.
     * @returns the xalign property
     */
    getXalign(): number
    /**
     * Gets the `yalign` of the label.
     *
     * See the [property`Gtk`.Label:yalign] property.
     * @returns the yalign property
     */
    getYalign(): number
    /**
     * Selects a range of characters in the label, if the label is selectable.
     *
     * See [method`Gtk`.Label.set_selectable]. If the label is not selectable,
     * this function has no effect. If `start_offset` or
     * `end_offset` are -1, then the end of the label will be substituted.
     * @param startOffset start offset (in characters not bytes)
     * @param endOffset end offset (in characters not bytes)
     */
    selectRegion(startOffset: number, endOffset: number): void
    /**
     * Apply attributes to the label text.
     *
     * The attributes set with this function will be applied and merged with
     * any other attributes previously effected by way of the
     * [property`Gtk`.Label:use-underline] or [property`Gtk`.Label:use-markup]
     * properties. While it is not recommended to mix markup strings with
     * manually set attributes, if you must; know that the attributes will
     * be applied to the label after the markup string is parsed.
     * @param attrs a [struct`Pango`.AttrList]
     */
    setAttributes(attrs: Pango.AttrList | null): void
    /**
     * Sets the mode used to ellipsize the text.
     *
     * The text will be ellipsized if there is not enough space
     * to render the entire string.
     * @param mode a `PangoEllipsizeMode`
     */
    setEllipsize(mode: Pango.EllipsizeMode): void
    /**
     * Sets a menu model to add when constructing
     * the context menu for `label`.
     * @param model a `GMenuModel`
     */
    setExtraMenu(model: Gio.MenuModel | null): void
    /**
     * Sets the alignment of the lines in the text of the label relative to
     * each other.
     *
     * %GTK_JUSTIFY_LEFT is the default value when the widget is first created
     * with [ctor`Gtk`.Label.new]. If you instead want to set the alignment of
     * the label as a whole, use [method`Gtk`.Widget.set_halign] instead.
     * [method`Gtk`.Label.set_justify] has no effect on labels containing
     * only a single line.
     * @param jtype a `GtkJustification`
     */
    setJustify(jtype: Justification): void
    /**
     * Sets the text of the label.
     *
     * The label is interpreted as including embedded underlines and/or Pango
     * markup depending on the values of the [property`Gtk`.Label:use-underline]
     * and [property`Gtk`.Label:use-markup] properties.
     * @param str the new text to set for the label
     */
    setLabel(str: string): void
    /**
     * Sets the number of lines to which an ellipsized, wrapping label
     * should be limited.
     *
     * This has no effect if the label is not wrapping or ellipsized.
     * Set this to -1 if you don’t want to limit the number of lines.
     * @param lines the desired number of lines, or -1
     */
    setLines(lines: number): void
    /**
     * Sets the labels text and attributes from markup.
     *
     * The string must be marked up with Pango markup
     * (see [func`Pango`.parse_markup]).
     *
     * If the `str` is external data, you may need to escape it
     * with g_markup_escape_text() or g_markup_printf_escaped():
     *
     * ```c
     * GtkWidget *self = gtk_label_new (NULL);
     * const char *str = "...";
     * const char *format = "<span style=\"italic\">\%s</span>";
     * char *markup;
     *
     * markup = g_markup_printf_escaped (format, str);
     * gtk_label_set_markup (GTK_LABEL (self), markup);
     * g_free (markup);
     * ```
     *
     * This function will set the [property`Gtk`.Label:use-markup] property
     * to %TRUE as a side effect.
     *
     * If you set the label contents using the [property`Gtk`.Label:label]
     * property you should also ensure that you set the
     * [property`Gtk`.Label:use-markup] property accordingly.
     *
     * See also: [method`Gtk`.Label.set_text]
     * @param str a markup string
     */
    setMarkup(str: string): void
    /**
     * Sets the labels text, attributes and mnemonic from markup.
     *
     * Parses `str` which is marked up with Pango markup (see [func`Pango`.parse_markup]),
     * setting the label’s text and attribute list based on the parse results.
     * If characters in `str` are preceded by an underscore, they are underlined
     * indicating that they represent a keyboard accelerator called a mnemonic.
     *
     * The mnemonic key can be used to activate another widget, chosen
     * automatically, or explicitly using [method`Gtk`.Label.set_mnemonic_widget].
     * @param str a markup string
     */
    setMarkupWithMnemonic(str: string): void
    /**
     * Sets the desired maximum width in characters of `label` to `n_chars`.
     * @param nChars the new desired maximum width, in characters.
     */
    setMaxWidthChars(nChars: number): void
    /**
     * Associate the label with its mnemonic target.
     *
     * If the label has been set so that it has a mnemonic key (using
     * i.e. [method`Gtk`.Label.set_markup_with_mnemonic],
     * [method`Gtk`.Label.set_text_with_mnemonic],
     * [ctor`Gtk`.Label.new_with_mnemonic]
     * or the [property`Gtk`.Label:use_underline] property) the label can be
     * associated with a widget that is the target of the mnemonic. When the
     * label is inside a widget (like a [class`Gtk`.Button] or a
     * [class`Gtk`.Notebook] tab) it is automatically associated with the correct
     * widget, but sometimes (i.e. when the target is a [class`Gtk`.Entry] next to
     * the label) you need to set it explicitly using this function.
     *
     * The target widget will be accelerated by emitting the
     * [signal`Gtk`.Widget::mnemonic-activate] signal on it. The default handler for
     * this signal will activate the widget if there are no mnemonic collisions
     * and toggle focus between the colliding widgets otherwise.
     * @param widget the target `GtkWidget`, or %NULL to unset
     */
    setMnemonicWidget(widget: Widget | null): void
    /**
     * Select the line wrapping for the natural size request.
     *
     * This only affects the natural size requested, for the actual wrapping used,
     * see the [property`Gtk`.Label:wrap-mode] property.
     * @param wrapMode the line wrapping mode
     */
    setNaturalWrapMode(wrapMode: NaturalWrapMode): void
    /**
     * Makes text in the label selectable.
     *
     * Selectable labels allow the user to select text from the label,
     * for copy-and-paste.
     * @param setting %TRUE to allow selecting text in the label
     */
    setSelectable(setting: boolean): void
    /**
     * Sets whether the label is in single line mode.
     * @param singleLineMode %TRUE if the label should be in single line mode
     */
    setSingleLineMode(singleLineMode: boolean): void
    /**
     * Sets the default tab stops for paragraphs in `self`.
     * @param tabs tabs as a `PangoTabArray`
     */
    setTabs(tabs: Pango.TabArray | null): void
    /**
     * Sets the text within the `GtkLabel` widget.
     *
     * It overwrites any text that was there before.
     *
     * This function will clear any previously set mnemonic accelerators,
     * and set the [property`Gtk`.Label:use-underline] property to %FALSE as
     * a side effect.
     *
     * This function will set the [property`Gtk`.Label:use-markup] property
     * to %FALSE as a side effect.
     *
     * See also: [method`Gtk`.Label.set_markup]
     * @param str The text you want to set
     */
    setText(str: string): void
    /**
     * Sets the label’s text from the string `str`.
     *
     * If characters in `str` are preceded by an underscore, they are underlined
     * indicating that they represent a keyboard accelerator called a mnemonic.
     * The mnemonic key can be used to activate another widget, chosen
     * automatically, or explicitly using [method`Gtk`.Label.set_mnemonic_widget].
     * @param str a string
     */
    setTextWithMnemonic(str: string): void
    /**
     * Sets whether the text of the label contains markup.
     *
     * See [method`Gtk`.Label.set_markup].
     * @param setting %TRUE if the label’s text should be parsed for markup.
     */
    setUseMarkup(setting: boolean): void
    /**
     * Sets whether underlines in the text indicate mnemonics.
     * @param setting %TRUE if underlines in the text indicate mnemonics
     */
    setUseUnderline(setting: boolean): void
    /**
     * Sets the desired width in characters of `label` to `n_chars`.
     * @param nChars the new desired width, in characters.
     */
    setWidthChars(nChars: number): void
    /**
     * Toggles line wrapping within the `GtkLabel` widget.
     *
     * %TRUE makes it break lines if text exceeds the widget’s size.
     * %FALSE lets the text get cut off by the edge of the widget if
     * it exceeds the widget size.
     *
     * Note that setting line wrapping to %TRUE does not make the label
     * wrap at its parent container’s width, because GTK widgets
     * conceptually can’t make their requisition depend on the parent
     * container’s size. For a label that wraps at a specific position,
     * set the label’s width using [method`Gtk`.Widget.set_size_request].
     * @param wrap the setting
     */
    setWrap(wrap: boolean): void
    /**
     * Controls how line wrapping is done.
     *
     * This only affects the label if line wrapping is on. (See
     * [method`Gtk`.Label.set_wrap]) The default is %PANGO_WRAP_WORD
     * which means wrap on word boundaries.
     *
     * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
     * property.
     * @param wrapMode the line wrapping mode
     */
    setWrapMode(wrapMode: Pango.WrapMode): void
    /**
     * Sets the `xalign` of the label.
     *
     * See the [property`Gtk`.Label:xalign] property.
     * @param xalign the new xalign value, between 0 and 1
     */
    setXalign(xalign: number): void
    /**
     * Sets the `yalign` of the label.
     *
     * See the [property`Gtk`.Label:yalign] property.
     * @param yalign the new yalign value, between 0 and 1
     */
    setYalign(yalign: number): void

    // Own signals of Gtk-4.0.Gtk.Label

    connect(
      sigName: "activate-current-link",
      callback: Label.ActivateCurrentLinkSignalCallback
    ): number
    on(
      sigName: "activate-current-link",
      callback: Label.ActivateCurrentLinkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-current-link",
      callback: Label.ActivateCurrentLinkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-current-link",
      callback: Label.ActivateCurrentLinkSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-current-link", ...args: any[]): void
    connect(
      sigName: "activate-link",
      callback: Label.ActivateLinkSignalCallback
    ): number
    on(
      sigName: "activate-link",
      callback: Label.ActivateLinkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-link",
      callback: Label.ActivateLinkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-link",
      callback: Label.ActivateLinkSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-link", ...args: any[]): void
    connect(
      sigName: "copy-clipboard",
      callback: Label.CopyClipboardSignalCallback
    ): number
    on(
      sigName: "copy-clipboard",
      callback: Label.CopyClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "copy-clipboard",
      callback: Label.CopyClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "copy-clipboard",
      callback: Label.CopyClipboardSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "copy-clipboard", ...args: any[]): void
    connect(
      sigName: "move-cursor",
      callback: Label.MoveCursorSignalCallback
    ): number
    on(
      sigName: "move-cursor",
      callback: Label.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-cursor",
      callback: Label.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-cursor",
      callback: Label.MoveCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "move-cursor",
      count: number,
      extendSelection: boolean,
      ...args: any[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.Label

    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize", ...args: any[]): void
    connect(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::extra-menu", ...args: any[]): void
    connect(
      sigName: "notify::justify",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::justify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::justify",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::justify",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::justify", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::lines", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::mnemonic-keyval",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonic-keyval",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonic-keyval",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonic-keyval",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonic-keyval", ...args: any[]): void
    connect(
      sigName: "notify::mnemonic-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonic-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonic-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonic-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonic-widget", ...args: any[]): void
    connect(
      sigName: "notify::natural-wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::natural-wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::natural-wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::natural-wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::natural-wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selectable", ...args: any[]): void
    connect(
      sigName: "notify::single-line-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::single-line-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::single-line-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::single-line-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::single-line-mode", ...args: any[]): void
    connect(sigName: "notify::tabs", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tabs", ...args: any[]): void
    connect(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-markup", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(sigName: "notify::wrap", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::wrap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::yalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::yalign", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkLabel` widget displays a small amount of text.
   *
   * As the name implies, most labels are used to label another widget
   * such as a [class`Button]`.
   *
   * ![An example GtkLabel](label.png)
   *
   * ## CSS nodes
   *
   * ```
   * label
   * ├── [selection]
   * ├── [link]
   * ┊
   * ╰── [link]
   * ```
   *
   * `GtkLabel` has a single CSS node with the name label. A wide variety
   * of style classes may be applied to labels, such as .title, .subtitle,
   * .dim-label, etc. In the `GtkShortcutsWindow`, labels are used with the
   * .keycap style class.
   *
   * If the label has a selection, it gets a subnode with name selection.
   *
   * If the label has links, there is one subnode per link. These subnodes
   * carry the link or visited state depending on whether they have been
   * visited. In this case, label node also gets a .link style class.
   *
   * ## GtkLabel as GtkBuildable
   *
   * The GtkLabel implementation of the GtkBuildable interface supports a
   * custom `<attributes>` element, which supports any number of `<attribute>`
   * elements. The `<attribute>` element has attributes named “name“, “value“,
   * “start“ and “end“ and allows you to specify [struct`Pango`.Attribute]
   * values for this label.
   *
   * An example of a UI definition fragment specifying Pango attributes:
   *
   * ```xml
   * <object class="GtkLabel">
   *   <attributes>
   *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
   *     <attribute name="background" value="red" start="5" end="10"/>
   *   </attributes>
   * </object>
   * ```
   *
   * The start and end attributes specify the range of characters to which the
   * Pango attribute applies. If start and end are not specified, the attribute is
   * applied to the whole text. Note that specifying ranges does not make much
   * sense with translatable attributes. Use markup embedded in the translatable
   * content instead.
   *
   * ## Accessibility
   *
   * `GtkLabel` uses the %GTK_ACCESSIBLE_ROLE_LABEL role.
   *
   * ## Mnemonics
   *
   * Labels may contain “mnemonics”. Mnemonics are underlined characters in the
   * label, used for keyboard navigation. Mnemonics are created by providing a
   * string with an underscore before the mnemonic character, such as `"_File"`,
   * to the functions [ctor`Gtk`.Label.new_with_mnemonic] or
   * [method`Gtk`.Label.set_text_with_mnemonic].
   *
   * Mnemonics automatically activate any activatable widget the label is
   * inside, such as a [class`Gtk`.Button]; if the label is not inside the
   * mnemonic’s target widget, you have to tell the label about the target
   * using [method`Gtk`.Label.set_mnemonic_widget].
   *
   * Here’s a simple example where the label is inside a button:
   *
   * ```c
   * // Pressing Alt+H will activate this button
   * GtkWidget *button = gtk_button_new ();
   * GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
   * gtk_button_set_child (GTK_BUTTON (button), label);
   * ```
   *
   * There’s a convenience function to create buttons with a mnemonic label
   * already inside:
   *
   * ```c
   * // Pressing Alt+H will activate this button
   * GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello");
   * ```
   *
   * To create a mnemonic for a widget alongside the label, such as a
   * [class`Gtk`.Entry], you have to point the label at the entry with
   * [method`Gtk`.Label.set_mnemonic_widget]:
   *
   * ```c
   * // Pressing Alt+H will focus the entry
   * GtkWidget *entry = gtk_entry_new ();
   * GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
   * gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
   * ```
   *
   * ## Markup (styled text)
   *
   * To make it easy to format text in a label (changing colors,
   * fonts, etc.), label text can be provided in a simple
   * markup format:
   *
   * Here’s how to create a label with a small font:
   * ```c
   * GtkWidget *label = gtk_label_new (NULL);
   * gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");
   * ```
   *
   * (See the Pango manual for complete documentation] of available
   * tags, [func`Pango`.parse_markup])
   *
   * The markup passed to [method`Gtk`.Label.set_markup] must be valid; for example,
   * literal `<`, `>` and `&` characters must be escaped as `&lt;`, `&gt;`, and `&amp;`.
   * If you pass text obtained from the user, file, or a network to
   * [method`Gtk`.Label.set_markup], you’ll want to escape it with
   * [func`GLib`.markup_escape_text] or [func`GLib`.markup_printf_escaped].
   *
   * Markup strings are just a convenient way to set the [struct`Pango`.AttrList]
   * on a label; [method`Gtk`.Label.set_attributes] may be a simpler way to set
   * attributes in some cases. Be careful though; [struct`Pango`.AttrList] tends
   * to cause internationalization problems, unless you’re applying attributes
   * to the entire string (i.e. unless you set the range of each attribute
   * to [0, %G_MAXINT)). The reason is that specifying the start_index and
   * end_index for a [struct`Pango`.Attribute] requires knowledge of the exact
   * string being displayed, so translations will cause problems.
   *
   * ## Selectable labels
   *
   * Labels can be made selectable with [method`Gtk`.Label.set_selectable].
   * Selectable labels allow the user to copy the label contents to
   * the clipboard. Only labels that contain useful-to-copy information—such
   * as error messages—should be made selectable.
   *
   * ## Text layout
   *
   * A label can contain any number of paragraphs, but will have
   * performance problems if it contains more than a small number.
   * Paragraphs are separated by newlines or other paragraph separators
   * understood by Pango.
   *
   * Labels can automatically wrap text if you call [method`Gtk`.Label.set_wrap].
   *
   * [method`Gtk`.Label.set_justify] sets how the lines in a label align
   * with one another. If you want to set how the label as a whole aligns
   * in its available space, see the [property`Gtk`.Widget:halign] and
   * [property`Gtk`.Widget:valign] properties.
   *
   * The [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
   * properties can be used to control the size allocation of ellipsized or
   * wrapped labels. For ellipsizing labels, if either is specified (and less
   * than the actual text size), it is used as the minimum width, and the actual
   * text size is used as the natural width of the label. For wrapping labels,
   * width-chars is used as the minimum width, if specified, and max-width-chars
   * is used as the natural width. Even if max-width-chars specified, wrapping
   * labels will be rewrapped to use all of the available width.
   *
   * ## Links
   *
   * GTK supports markup for clickable hyperlinks in addition to regular Pango
   * markup. The markup for links is borrowed from HTML, using the `<a>` with
   * “href“, “title“ and “class“ attributes. GTK renders links similar to the
   * way they appear in web browsers, with colored, underlined text. The “title“
   * attribute is displayed as a tooltip on the link. The “class“ attribute is
   * used as style class on the CSS node for the link.
   *
   * An example of inline links looks like this:
   *
   * ```c
   * const char *text =
   * "Go to the "
   * "<a href=\"https://www.gtk.org\" title=\"&lt;i&gt;Our&lt;/i&gt; website\">"
   * "GTK website</a> for more...";
   * GtkWidget *label = gtk_label_new (NULL);
   * gtk_label_set_markup (GTK_LABEL (label), text);
   * ```
   *
   * It is possible to implement custom handling for links and their tooltips
   * with the [signal`Gtk`.Label::activate-link] signal and the
   * [method`Gtk`.Label.get_current_uri] function.
   * @class
   */
  class Label extends Widget {
    // Own properties of Gtk-4.0.Gtk.Label

    static name: string

    // Constructors of Gtk-4.0.Gtk.Label

    constructor(config?: Label.ConstructorProperties)
    /**
     * Creates a new label with the given text inside it.
     *
     * You can pass %NULL to get an empty label widget.
     * @constructor
     * @param str The text of the label
     * @returns the new `GtkLabel`
     */
    constructor(str: string | null)
    /**
     * Creates a new label with the given text inside it.
     *
     * You can pass %NULL to get an empty label widget.
     * @constructor
     * @param str The text of the label
     * @returns the new `GtkLabel`
     */
    static new(str: string | null): Label
    /**
     * Creates a new `GtkLabel`, containing the text in `str`.
     *
     * If characters in `str` are preceded by an underscore, they are
     * underlined. If you need a literal underscore character in a label, use
     * '__' (two underscores). The first underlined character represents a
     * keyboard accelerator called a mnemonic. The mnemonic key can be used
     * to activate another widget, chosen automatically, or explicitly using
     * [method`Gtk`.Label.set_mnemonic_widget].
     *
     * If [method`Gtk`.Label.set_mnemonic_widget] is not called, then the first
     * activatable ancestor of the `GtkLabel` will be chosen as the mnemonic
     * widget. For instance, if the label is inside a button or menu item,
     * the button or menu item will automatically become the mnemonic widget
     * and be activated by the mnemonic.
     * @constructor
     * @param str The text of the label, with an underscore in front of the   mnemonic character
     * @returns the new `GtkLabel`
     */
    static newWithMnemonic(str: string | null): Label
    _init(config?: Label.ConstructorProperties): void
  }

  module LayoutChild {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.LayoutChild

      /**
       * The widget that is associated to the `GtkLayoutChild` instance.
       */
      child_widget?: Widget | null
      /**
       * The layout manager that created the `GtkLayoutChild` instance.
       */
      layout_manager?: LayoutManager | null
    }
  }

  interface LayoutChild {
    // Own properties of Gtk-4.0.Gtk.LayoutChild

    /**
     * The widget that is associated to the `GtkLayoutChild` instance.
     */
    readonly childWidget: Widget
    /**
     * The layout manager that created the `GtkLayoutChild` instance.
     */
    readonly layoutManager: LayoutManager
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.LayoutChild

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.LayoutChild

    /**
     * Retrieves the `GtkWidget` associated to the given `layout_child`.
     * @returns a `GtkWidget`
     */
    getChildWidget(): Widget
    /**
     * Retrieves the `GtkLayoutManager` instance that created the
     * given `layout_child`.
     * @returns a `GtkLayoutManager`
     */
    getLayoutManager(): LayoutManager

    // Class property signals of Gtk-4.0.Gtk.LayoutChild

    connect(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child-widget", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkLayoutChild` is the base class for objects that are meant to hold
   * layout properties.
   *
   * If a `GtkLayoutManager` has per-child properties, like their packing type,
   * or the horizontal and vertical span, or the icon name, then the layout
   * manager should use a `GtkLayoutChild` implementation to store those properties.
   *
   * A `GtkLayoutChild` instance is only ever valid while a widget is part
   * of a layout.
   * @class
   */
  class LayoutChild extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.LayoutChild

    static name: string

    // Constructors of Gtk-4.0.Gtk.LayoutChild

    constructor(config?: LayoutChild.ConstructorProperties)
    _init(config?: LayoutChild.ConstructorProperties): void
  }

  module LayoutManager {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface LayoutManager {
    // Own properties of Gtk-4.0.Gtk.LayoutManager

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.LayoutManager

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.LayoutManager

    // Has conflict: allocate(widget: Widget, width: number, height: number, baseline: number): void
    /**
     * Retrieves a `GtkLayoutChild` instance for the `GtkLayoutManager`,
     * creating one if necessary.
     *
     * The `child` widget must be a child of the widget using `manager`.
     *
     * The `GtkLayoutChild` instance is owned by the `GtkLayoutManager`,
     * and is guaranteed to exist as long as `child` is a child of the
     * `GtkWidget` using the given `GtkLayoutManager`.
     * @param child a `GtkWidget`
     * @returns a `GtkLayoutChild`
     */
    getLayoutChild(child: Widget): LayoutChild
    // Has conflict: getRequestMode(): SizeRequestMode
    /**
     * Retrieves the `GtkWidget` using the given `GtkLayoutManager`.
     * @returns a `GtkWidget`
     */
    getWidget(): Widget | null
    /**
     * Queues a resize on the `GtkWidget` using `manager,` if any.
     *
     * This function should be called by subclasses of `GtkLayoutManager`
     * in response to changes to their layout management policies.
     */
    layoutChanged(): void
    // Has conflict: measure(widget: Widget, orientation: Orientation, forSize: number): [ /* minimum */ number, /* natural */ number, /* minimumBaseline */ number, /* naturalBaseline */ number ]

    // Own virtual methods of Gtk-4.0.Gtk.LayoutManager

    /**
     * Assigns the given `width,` `height,` and `baseline` to
     * a `widget,` and computes the position and sizes of the children of
     * the `widget` using the layout management policy of `manager`.
     * @virtual
     * @param widget the `GtkWidget` using `manager`
     * @param width the new width of the `widget`
     * @param height the new height of the `widget`
     * @param baseline the baseline position of the `widget,` or -1
     */
    allocate(
      widget: Widget,
      width: number,
      height: number,
      baseline: number
    ): void
    /**
     * Create a `GtkLayoutChild` instance for the given `for_child` widget.
     * @virtual
     * @param widget the widget using the `manager`
     * @param forChild the child of `widget`
     * @returns a `GtkLayoutChild`
     */
    createLayoutChild(widget: Widget, forChild: Widget): LayoutChild
    /**
     * a virtual function, used to return the preferred
     *   request mode for the layout manager; for instance, "width for height"
     *   or "height for width"; see `GtkSizeRequestMode`
     * @virtual
     * @param widget
     */
    getRequestMode(widget: Widget): SizeRequestMode
    /**
     * Measures the size of the `widget` using `manager,` for the
     * given `orientation` and size.
     *
     * See the [class`Gtk`.Widget] documentation on layout management for
     * more details.
     * @virtual
     * @param widget the `GtkWidget` using `manager`
     * @param orientation the orientation to measure
     * @param forSize Size for the opposite of `orientation;` for instance, if   the `orientation` is %GTK_ORIENTATION_HORIZONTAL, this is the height   of the widget; if the `orientation` is %GTK_ORIENTATION_VERTICAL, this   is the width of the widget. This allows to measure the height for the   given width, and the width for the given height. Use -1 if the size   is not known
     */
    measure(
      widget: Widget,
      orientation: Orientation,
      forSize: number
    ): [
      /* minimum */ number,
      /* natural */ number,
      /* minimumBaseline */ number,
      /* naturalBaseline */ number,
    ]
    /**
     * a virtual function, called when the widget using the layout
     *   manager is attached to a `GtkRoot`
     * @virtual
     */
    root(): void
    /**
     * a virtual function, called when the widget using the layout
     *   manager is detached from a `GtkRoot`
     * @virtual
     */
    unroot(): void

    // Class property signals of Gtk-4.0.Gtk.LayoutManager

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Layout managers are delegate classes that handle the preferred size
   * and the allocation of a widget.
   *
   * You typically subclass `GtkLayoutManager` if you want to implement a
   * layout policy for the children of a widget, or if you want to determine
   * the size of a widget depending on its contents.
   *
   * Each `GtkWidget` can only have a `GtkLayoutManager` instance associated
   * to it at any given time; it is possible, though, to replace the layout
   * manager instance using [method`Gtk`.Widget.set_layout_manager].
   *
   * ## Layout properties
   *
   * A layout manager can expose properties for controlling the layout of
   * each child, by creating an object type derived from [class`Gtk`.LayoutChild]
   * and installing the properties on it as normal `GObject` properties.
   *
   * Each `GtkLayoutChild` instance storing the layout properties for a
   * specific child is created through the [method`Gtk`.LayoutManager.get_layout_child]
   * method; a `GtkLayoutManager` controls the creation of its `GtkLayoutChild`
   * instances by overriding the GtkLayoutManagerClass.create_layout_child()
   * virtual function. The typical implementation should look like:
   *
   * ```c
   * static GtkLayoutChild *
   * create_layout_child (GtkLayoutManager *manager,
   *                      GtkWidget        *container,
   *                      GtkWidget        *child)
   * {
   *   return g_object_new (your_layout_child_get_type (),
   *                        "layout-manager", manager,
   *                        "child-widget", child,
   *                        NULL);
   * }
   * ```
   *
   * The [property`Gtk`.LayoutChild:layout-manager] and
   * [property`Gtk`.LayoutChild:child-widget] properties
   * on the newly created `GtkLayoutChild` instance are mandatory. The
   * `GtkLayoutManager` will cache the newly created `GtkLayoutChild` instance
   * until the widget is removed from its parent, or the parent removes the
   * layout manager.
   *
   * Each `GtkLayoutManager` instance creating a `GtkLayoutChild` should use
   * [method`Gtk`.LayoutManager.get_layout_child] every time it needs to query
   * the layout properties; each `GtkLayoutChild` instance should call
   * [method`Gtk`.LayoutManager.layout_changed] every time a property is
   * updated, in order to queue a new size measuring and allocation.
   * @class
   */
  class LayoutManager extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.LayoutManager

    static name: string

    // Constructors of Gtk-4.0.Gtk.LayoutManager

    constructor(config?: LayoutManager.ConstructorProperties)
    _init(config?: LayoutManager.ConstructorProperties): void
  }

  module LevelBar {
    // Signal callback interfaces

    /**
     * Signal callback interface for `offset-changed`
     */
    interface OffsetChangedSignalCallback {
      (name: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleRange.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.LevelBar

      /**
       * Whether the `GtkLeveBar` is inverted.
       *
       * Level bars normally grow from top to bottom or left to right.
       * Inverted level bars grow in the opposite direction.
       */
      inverted?: boolean | null
      /**
       * Determines the maximum value of the interval that can be displayed by the bar.
       */
      max_value?: number | null
      /**
       * Determines the minimum value of the interval that can be displayed by the bar.
       */
      min_value?: number | null
      /**
       * Determines the way `GtkLevelBar` interprets the value properties to draw the
       * level fill area.
       *
       * Specifically, when the value is %GTK_LEVEL_BAR_MODE_CONTINUOUS,
       * `GtkLevelBar` will draw a single block representing the current value in
       * that area; when the value is %GTK_LEVEL_BAR_MODE_DISCRETE,
       * the widget will draw a succession of separate blocks filling the
       * draw area, with the number of blocks being equal to the units separating
       * the integral roundings of [property`Gtk`.LevelBar:min-value] and
       * [property`Gtk`.LevelBar:max-value].
       */
      mode?: LevelBarMode | null
      /**
       * Determines the currently filled value of the level bar.
       */
      value?: number | null
    }
  }

  interface LevelBar
    extends Accessible,
      AccessibleRange,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.LevelBar

    /**
     * Whether the `GtkLeveBar` is inverted.
     *
     * Level bars normally grow from top to bottom or left to right.
     * Inverted level bars grow in the opposite direction.
     */
    inverted: boolean
    /**
     * Determines the maximum value of the interval that can be displayed by the bar.
     */
    maxValue: number
    /**
     * Determines the minimum value of the interval that can be displayed by the bar.
     */
    minValue: number
    /**
     * Determines the way `GtkLevelBar` interprets the value properties to draw the
     * level fill area.
     *
     * Specifically, when the value is %GTK_LEVEL_BAR_MODE_CONTINUOUS,
     * `GtkLevelBar` will draw a single block representing the current value in
     * that area; when the value is %GTK_LEVEL_BAR_MODE_DISCRETE,
     * the widget will draw a succession of separate blocks filling the
     * draw area, with the number of blocks being equal to the units separating
     * the integral roundings of [property`Gtk`.LevelBar:min-value] and
     * [property`Gtk`.LevelBar:max-value].
     */
    mode: LevelBarMode
    /**
     * Determines the currently filled value of the level bar.
     */
    value: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.LevelBar

    /**
     * Adds a new offset marker on `self` at the position specified by `value`.
     *
     * When the bar value is in the interval topped by `value` (or between `value`
     * and [property`Gtk`.LevelBar:max-value] in case the offset is the last one
     * on the bar) a style class named `level-``name` will be applied
     * when rendering the level bar fill.
     *
     * If another offset marker named `name` exists, its value will be
     * replaced by `value`.
     * @param name the name of the new offset
     * @param value the value for the new offset
     */
    addOffsetValue(name: string, value: number): void
    /**
     * Returns whether the levelbar is inverted.
     * @returns %TRUE if the level bar is inverted
     */
    getInverted(): boolean
    /**
     * Returns the `max-value` of the `GtkLevelBar`.
     * @returns a positive value
     */
    getMaxValue(): number
    /**
     * Returns the `min-value` of the `GtkLevelBar`.
     * @returns a positive value
     */
    getMinValue(): number
    /**
     * Returns the `mode` of the `GtkLevelBar`.
     * @returns a `GtkLevelBarMode`
     */
    getMode(): LevelBarMode
    /**
     * Fetches the value specified for the offset marker `name` in `self`.
     * @param name the name of an offset in the bar
     * @returns %TRUE if the specified offset is found
     */
    getOffsetValue(
      name: string | null
    ): [/* returnType */ boolean, /* value */ number]
    /**
     * Returns the `value` of the `GtkLevelBar`.
     * @returns a value in the interval between   [property@Gtk.LevelBar:min-value] and [property@Gtk.LevelBar:max-value]
     */
    getValue(): number
    /**
     * Removes an offset marker from a `GtkLevelBar`.
     *
     * The marker must have been previously added with
     * [method`Gtk`.LevelBar.add_offset_value].
     * @param name the name of an offset in the bar
     */
    removeOffsetValue(name: string | null): void
    /**
     * Sets whether the `GtkLevelBar` is inverted.
     * @param inverted %TRUE to invert the level bar
     */
    setInverted(inverted: boolean): void
    /**
     * Sets the `max-value` of the `GtkLevelBar`.
     *
     * You probably want to update preexisting level offsets after calling
     * this function.
     * @param value a positive value
     */
    setMaxValue(value: number): void
    /**
     * Sets the `min-value` of the `GtkLevelBar`.
     *
     * You probably want to update preexisting level offsets after calling
     * this function.
     * @param value a positive value
     */
    setMinValue(value: number): void
    /**
     * Sets the `mode` of the `GtkLevelBar`.
     * @param mode a `GtkLevelBarMode`
     */
    setMode(mode: LevelBarMode): void
    /**
     * Sets the value of the `GtkLevelBar`.
     * @param value a value in the interval between   [property`Gtk`.LevelBar:min-value] and [property`Gtk`.LevelBar:max-value]
     */
    setValue(value: number): void

    // Own signals of Gtk-4.0.Gtk.LevelBar

    connect(
      sigName: "offset-changed",
      callback: LevelBar.OffsetChangedSignalCallback
    ): number
    on(
      sigName: "offset-changed",
      callback: LevelBar.OffsetChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "offset-changed",
      callback: LevelBar.OffsetChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "offset-changed",
      callback: LevelBar.OffsetChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "offset-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.LevelBar

    connect(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inverted", ...args: any[]): void
    connect(
      sigName: "notify::max-value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-value", ...args: any[]): void
    connect(
      sigName: "notify::min-value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-value", ...args: any[]): void
    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::value", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkLevelBar` is a widget that can be used as a level indicator.
   *
   * Typical use cases are displaying the strength of a password, or
   * showing the charge level of a battery.
   *
   * ![An example GtkLevelBar](levelbar.png)
   *
   * Use [method`Gtk`.LevelBar.set_value] to set the current value, and
   * [method`Gtk`.LevelBar.add_offset_value] to set the value offsets at which
   * the bar will be considered in a different state. GTK will add a few
   * offsets by default on the level bar: %GTK_LEVEL_BAR_OFFSET_LOW,
   * %GTK_LEVEL_BAR_OFFSET_HIGH and %GTK_LEVEL_BAR_OFFSET_FULL, with
   * values 0.25, 0.75 and 1.0 respectively.
   *
   * Note that it is your responsibility to update preexisting offsets
   * when changing the minimum or maximum value. GTK will simply clamp
   * them to the new range.
   *
   * ## Adding a custom offset on the bar
   *
   * ```c
   * static GtkWidget *
   * create_level_bar (void)
   * {
   *   GtkWidget *widget;
   *   GtkLevelBar *bar;
   *
   *   widget = gtk_level_bar_new ();
   *   bar = GTK_LEVEL_BAR (widget);
   *
   *   // This changes the value of the default low offset
   *
   *   gtk_level_bar_add_offset_value (bar,
   *                                   GTK_LEVEL_BAR_OFFSET_LOW,
   *                                   0.10);
   *
   *   // This adds a new offset to the bar; the application will
   *   // be able to change its color CSS like this:
   *   //
   *   // levelbar block.my-offset {
   *   //   background-color: magenta;
   *   //   border-style: solid;
   *   //   border-color: black;
   *   //   border-width: 1px;
   *   // }
   *
   *   gtk_level_bar_add_offset_value (bar, "my-offset", 0.60);
   *
   *   return widget;
   * }
   * ```
   *
   * The default interval of values is between zero and one, but it’s possible
   * to modify the interval using [method`Gtk`.LevelBar.set_min_value] and
   * [method`Gtk`.LevelBar.set_max_value]. The value will be always drawn in
   * proportion to the admissible interval, i.e. a value of 15 with a specified
   * interval between 10 and 20 is equivalent to a value of 0.5 with an interval
   * between 0 and 1. When %GTK_LEVEL_BAR_MODE_DISCRETE is used, the bar level
   * is rendered as a finite number of separated blocks instead of a single one.
   * The number of blocks that will be rendered is equal to the number of units
   * specified by the admissible interval.
   *
   * For instance, to build a bar rendered with five blocks, it’s sufficient to
   * set the minimum value to 0 and the maximum value to 5 after changing the
   * indicator mode to discrete.
   *
   * # GtkLevelBar as GtkBuildable
   *
   * The `GtkLevelBar` implementation of the `GtkBuildable` interface supports a
   * custom `<offsets>` element, which can contain any number of `<offset>` elements,
   * each of which must have "name" and "value" attributes.
   *
   * # CSS nodes
   *
   * ```
   * levelbar[.discrete]
   * ╰── trough
   *     ├── block.filled.level-name
   *     ┊
   *     ├── block.empty
   *     ┊
   * ```
   *
   * `GtkLevelBar` has a main CSS node with name levelbar and one of the style
   * classes .discrete or .continuous and a subnode with name trough. Below the
   * trough node are a number of nodes with name block and style class .filled
   * or .empty. In continuous mode, there is exactly one node of each, in discrete
   * mode, the number of filled and unfilled nodes corresponds to blocks that are
   * drawn. The block.filled nodes also get a style class .level-name corresponding
   * to the level for the current value.
   *
   * In horizontal orientation, the nodes are always arranged from left to right,
   * regardless of text direction.
   *
   * # Accessibility
   *
   * `GtkLevelBar` uses the %GTK_ACCESSIBLE_ROLE_METER role.
   * @class
   */
  class LevelBar extends Widget {
    // Own properties of Gtk-4.0.Gtk.LevelBar

    static name: string

    // Constructors of Gtk-4.0.Gtk.LevelBar

    constructor(config?: LevelBar.ConstructorProperties)
    /**
     * Creates a new `GtkLevelBar`.
     * @constructor
     * @returns a `GtkLevelBar`.
     */
    constructor()
    /**
     * Creates a new `GtkLevelBar`.
     * @constructor
     * @returns a `GtkLevelBar`.
     */
    static new(): LevelBar
    /**
     * Creates a new `GtkLevelBar` for the specified interval.
     * @constructor
     * @param minValue a positive value
     * @param maxValue a positive value
     * @returns a `GtkLevelBar`
     */
    static newForInterval(minValue: number, maxValue: number): LevelBar
    _init(config?: LevelBar.ConstructorProperties): void
  }

  module LinkButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate-link`
     */
    interface ActivateLinkSignalCallback {
      (): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Actionable.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Button.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.LinkButton

      /**
       * The URI bound to this button.
       */
      uri?: string | null
      /**
       * The 'visited' state of this button.
       *
       * A visited link is drawn in a different color.
       */
      visited?: boolean | null
    }
  }

  interface LinkButton
    extends Accessible,
      Actionable,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.LinkButton

    /**
     * The URI bound to this button.
     */
    uri: string | null
    /**
     * The 'visited' state of this button.
     *
     * A visited link is drawn in a different color.
     */
    visited: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.LinkButton

    /**
     * Retrieves the URI of the `GtkLinkButton`.
     * @returns a valid URI. The returned string is owned by the link button   and should not be modified or freed.
     */
    getUri(): string
    /**
     * Retrieves the “visited” state of the `GtkLinkButton`.
     *
     * The button becomes visited when it is clicked. If the URI
     * is changed on the button, the “visited” state is unset again.
     *
     * The state may also be changed using [method`Gtk`.LinkButton.set_visited].
     * @returns %TRUE if the link has been visited, %FALSE otherwise
     */
    getVisited(): boolean
    /**
     * Sets `uri` as the URI where the `GtkLinkButton` points.
     *
     * As a side-effect this unsets the “visited” state of the button.
     * @param uri a valid URI
     */
    setUri(uri: string): void
    /**
     * Sets the “visited” state of the `GtkLinkButton`.
     *
     * See [method`Gtk`.LinkButton.get_visited] for more details.
     * @param visited the new “visited” state
     */
    setVisited(visited: boolean): void

    // Conflicting methods

    /**
     * Signal that causes the button to animate press then
     *    release. Applications should never connect to this signal, but use
     *    the `clicked` signal.
     * @virtual
     */
    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean
    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean

    // Own signals of Gtk-4.0.Gtk.LinkButton

    connect(
      sigName: "activate-link",
      callback: LinkButton.ActivateLinkSignalCallback
    ): number
    on(
      sigName: "activate-link",
      callback: LinkButton.ActivateLinkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-link",
      callback: LinkButton.ActivateLinkSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-link",
      callback: LinkButton.ActivateLinkSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-link", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.LinkButton

    connect(sigName: "notify::uri", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::uri",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::uri", ...args: any[]): void
    connect(
      sigName: "notify::visited",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visited",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visited",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visited",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visited", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-shrink", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-target", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkLinkButton` is a button with a hyperlink.
   *
   * ![An example GtkLinkButton](link-button.png)
   *
   * It is useful to show quick links to resources.
   *
   * A link button is created by calling either [ctor`Gtk`.LinkButton.new] or
   * [ctor`Gtk`.LinkButton.new_with_label]. If using the former, the URI you
   * pass to the constructor is used as a label for the widget.
   *
   * The URI bound to a `GtkLinkButton` can be set specifically using
   * [method`Gtk`.LinkButton.set_uri].
   *
   * By default, `GtkLinkButton` calls [method`Gtk`.FileLauncher.launch] when the button
   * is clicked. This behaviour can be overridden by connecting to the
   * [signal`Gtk`.LinkButton::activate-link] signal and returning %TRUE from
   * the signal handler.
   *
   * # CSS nodes
   *
   * `GtkLinkButton` has a single CSS node with name button. To differentiate
   * it from a plain `GtkButton`, it gets the .link style class.
   *
   * # Accessibility
   *
   * `GtkLinkButton` uses the %GTK_ACCESSIBLE_ROLE_LINK role.
   * @class
   */
  class LinkButton extends Button {
    // Own properties of Gtk-4.0.Gtk.LinkButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.LinkButton

    constructor(config?: LinkButton.ConstructorProperties)
    /**
     * Creates a new `GtkLinkButton` with the URI as its text.
     * @constructor
     * @param uri a valid URI
     * @returns a new link button widget.
     */
    constructor(uri: string)
    /**
     * Creates a new `GtkLinkButton` with the URI as its text.
     * @constructor
     * @param uri a valid URI
     * @returns a new link button widget.
     */
    static new(uri: string): LinkButton

    // Overloads of new

    /**
     * Creates a new `GtkButton` widget.
     *
     * To add a child widget to the button, use [method`Gtk`.Button.set_child].
     * @constructor
     * @returns The newly created `GtkButton` widget.
     */
    static new(): Button
    /**
     * Creates a new `GtkLinkButton` containing a label.
     * @constructor
     * @param uri a valid URI
     * @param label the text of the button
     * @returns a new link button widget.
     */
    static newWithLabel(uri: string, label: string | null): LinkButton

    // Overloads of newWithLabel

    /**
     * Creates a `GtkButton` widget with a `GtkLabel` child.
     * @constructor
     * @param label The text you want the `GtkLabel` to hold
     * @returns The newly created `GtkButton` widget
     */
    static newWithLabel(label: string): Button
    _init(config?: LinkButton.ConstructorProperties): void
  }

  module ListBase {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Scrollable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ListBase

      /**
       * The orientation of the list. See GtkOrientable:orientation
       * for details.
       */
      orientation?: Orientation | null
    }
  }

  interface ListBase
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable,
      Scrollable {
    // Own properties of Gtk-4.0.Gtk.ListBase

    /**
     * The orientation of the list. See GtkOrientable:orientation
     * for details.
     */
    orientation: Orientation
    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.ListBase

    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkListBase` is the abstract base class for GTK's list widgets.
   * @class
   */
  class ListBase extends Widget {
    // Own properties of Gtk-4.0.Gtk.ListBase

    static name: string

    // Constructors of Gtk-4.0.Gtk.ListBase

    constructor(config?: ListBase.ConstructorProperties)
    _init(config?: ListBase.ConstructorProperties): void
  }

  module ListBox {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate-cursor-row`
     */
    interface ActivateCursorRowSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `move-cursor`
     */
    interface MoveCursorSignalCallback {
      (object: MovementStep, p0: number, p1: boolean, p2: boolean): void
    }

    /**
     * Signal callback interface for `row-activated`
     */
    interface RowActivatedSignalCallback {
      (row: ListBoxRow): void
    }

    /**
     * Signal callback interface for `row-selected`
     */
    interface RowSelectedSignalCallback {
      (row: ListBoxRow | null): void
    }

    /**
     * Signal callback interface for `select-all`
     */
    interface SelectAllSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `selected-rows-changed`
     */
    interface SelectedRowsChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `toggle-cursor-row`
     */
    interface ToggleCursorRowSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `unselect-all`
     */
    interface UnselectAllSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ListBox

      /**
       * Whether to accept unpaired release events.
       */
      accept_unpaired_release?: boolean | null
      /**
       * Determines whether children can be activated with a single
       * click, or require a double-click.
       */
      activate_on_single_click?: boolean | null
      /**
       * The selection mode used by the list box.
       */
      selection_mode?: SelectionMode | null
      /**
       * Whether to show separators between rows.
       */
      show_separators?: boolean | null
    }
  }

  interface ListBox extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ListBox

    /**
     * Whether to accept unpaired release events.
     */
    acceptUnpairedRelease: boolean
    /**
     * Determines whether children can be activated with a single
     * click, or require a double-click.
     */
    activateOnSingleClick: boolean
    /**
     * The selection mode used by the list box.
     */
    selectionMode: SelectionMode
    /**
     * Whether to show separators between rows.
     */
    showSeparators: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ListBox

    /**
     * Append a widget to the list.
     *
     * If a sort function is set, the widget will
     * actually be inserted at the calculated position.
     * @param child the `GtkWidget` to add
     */
    append(child: Widget): void
    /**
     * Binds `model` to `box`.
     *
     * If `box` was already bound to a model, that previous binding is
     * destroyed.
     *
     * The contents of `box` are cleared and then filled with widgets that
     * represent items from `model`. `box` is updated whenever `model` changes.
     * If `model` is %NULL, `box` is left empty.
     *
     * It is undefined to add or remove widgets directly (for example, with
     * [method`Gtk`.ListBox.insert]) while `box` is bound to a model.
     *
     * Note that using a model is incompatible with the filtering and sorting
     * functionality in `GtkListBox`. When using a model, filtering and sorting
     * should be implemented by the model.
     * @param model the `GListModel` to be bound to `box`
     * @param createWidgetFunc a function that creates widgets for items   or %NULL in case you also passed %NULL as `model`
     */
    bindModel(
      model: Gio.ListModel | null,
      createWidgetFunc: ListBoxCreateWidgetFunc | null
    ): void
    /**
     * Add a drag highlight to a row.
     *
     * This is a helper function for implementing DnD onto a `GtkListBox`.
     * The passed in `row` will be highlighted by setting the
     * %GTK_STATE_FLAG_DROP_ACTIVE state and any previously highlighted
     * row will be unhighlighted.
     *
     * The row will also be unhighlighted when the widget gets
     * a drag leave event.
     * @param row a `GtkListBoxRow`
     */
    dragHighlightRow(row: ListBoxRow): void
    /**
     * If a row has previously been highlighted via gtk_list_box_drag_highlight_row(),
     * it will have the highlight removed.
     */
    dragUnhighlightRow(): void
    /**
     * Returns whether rows activate on single clicks.
     * @returns %TRUE if rows are activated on single click, %FALSE otherwise
     */
    getActivateOnSingleClick(): boolean
    /**
     * Gets the adjustment (if any) that the widget uses to
     * for vertical scrolling.
     * @returns the adjustment
     */
    getAdjustment(): Adjustment | null
    /**
     * Gets the n-th child in the list (not counting headers).
     *
     * If `index_` is negative or larger than the number of items in the
     * list, %NULL is returned.
     * @param index the index of the row
     * @returns the child `GtkWidget`
     */
    getRowAtIndex(index: number): ListBoxRow | null
    /**
     * Gets the row at the `y` position.
     * @param y position
     * @returns the row
     */
    getRowAtY(y: number): ListBoxRow | null
    /**
     * Gets the selected row, or %NULL if no rows are selected.
     *
     * Note that the box may allow multiple selection, in which
     * case you should use [method`Gtk`.ListBox.selected_foreach] to
     * find all selected rows.
     * @returns the selected row
     */
    getSelectedRow(): ListBoxRow | null
    /**
     * Creates a list of all selected children.
     * @returns A `GList` containing the `GtkWidget` for each selected child.   Free with g_list_free() when done.
     */
    getSelectedRows(): ListBoxRow[]
    /**
     * Gets the selection mode of the listbox.
     * @returns a `GtkSelectionMode`
     */
    getSelectionMode(): SelectionMode
    /**
     * Returns whether the list box should show separators
     * between rows.
     * @returns %TRUE if the list box shows separators
     */
    getShowSeparators(): boolean
    /**
     * Insert the `child` into the `box` at `position`.
     *
     * If a sort function is
     * set, the widget will actually be inserted at the calculated position.
     *
     * If `position` is -1, or larger than the total number of items in the
     * `box,` then the `child` will be appended to the end.
     * @param child the `GtkWidget` to add
     * @param position the position to insert `child` in
     */
    insert(child: Widget, position: number): void
    /**
     * Update the filtering for all rows.
     *
     * Call this when result
     * of the filter function on the `box` is changed due
     * to an external factor. For instance, this would be used
     * if the filter function just looked for a specific search
     * string and the entry with the search string has changed.
     */
    invalidateFilter(): void
    /**
     * Update the separators for all rows.
     *
     * Call this when result
     * of the header function on the `box` is changed due
     * to an external factor.
     */
    invalidateHeaders(): void
    /**
     * Update the sorting for all rows.
     *
     * Call this when result
     * of the sort function on the `box` is changed due
     * to an external factor.
     */
    invalidateSort(): void
    /**
     * Prepend a widget to the list.
     *
     * If a sort function is set, the widget will
     * actually be inserted at the calculated position.
     * @param child the `GtkWidget` to add
     */
    prepend(child: Widget): void
    /**
     * Removes a child from `box`.
     * @param child the child to remove
     */
    remove(child: Widget): void
    /**
     * Removes all rows from `box`.
     *
     * This function does nothing if `box` is backed by a model.
     */
    removeAll(): void
    /**
     * Select all children of `box,` if the selection mode allows it.
     */
    selectAll(): void
    /**
     * Make `row` the currently selected row.
     * @param row The row to select
     */
    selectRow(row: ListBoxRow | null): void
    /**
     * Calls a function for each selected child.
     *
     * Note that the selection cannot be modified from within this function.
     * @param func the function to call for each selected child
     */
    selectedForeach(func: ListBoxForeachFunc): void
    /**
     * If `single` is %TRUE, rows will be activated when you click on them,
     * otherwise you need to double-click.
     * @param single a boolean
     */
    setActivateOnSingleClick(single: boolean): void
    /**
     * Sets the adjustment (if any) that the widget uses to
     * for vertical scrolling.
     *
     * For instance, this is used to get the page size for
     * PageUp/Down key handling.
     *
     * In the normal case when the `box` is packed inside
     * a `GtkScrolledWindow` the adjustment from that will
     * be picked up automatically, so there is no need
     * to manually do that.
     * @param adjustment the adjustment
     */
    setAdjustment(adjustment: Adjustment | null): void
    /**
     * By setting a filter function on the `box` one can decide dynamically which
     * of the rows to show.
     *
     * For instance, to implement a search function on a list that
     * filters the original list to only show the matching rows.
     *
     * The `filter_func` will be called for each row after the call, and
     * it will continue to be called each time a row changes (via
     * [method`Gtk`.ListBoxRow.changed]) or when [method`Gtk`.ListBox.invalidate_filter]
     * is called.
     *
     * Note that using a filter function is incompatible with using a model
     * (see [method`Gtk`.ListBox.bind_model]).
     * @param filterFunc callback that lets you filter which rows to show
     */
    setFilterFunc(filterFunc: ListBoxFilterFunc | null): void
    /**
     * Sets a header function.
     *
     * By setting a header function on the `box` one can dynamically add headers
     * in front of rows, depending on the contents of the row and its position
     * in the list.
     *
     * For instance, one could use it to add headers in front of the first item
     * of a new kind, in a list sorted by the kind.
     *
     * The `update_header` can look at the current header widget using
     * [method`Gtk`.ListBoxRow.get_header] and either update the state of the widget
     * as needed, or set a new one using [method`Gtk`.ListBoxRow.set_header]. If no
     * header is needed, set the header to %NULL.
     *
     * Note that you may get many calls `update_header` to this for a particular
     * row when e.g. changing things that don’t affect the header. In this case
     * it is important for performance to not blindly replace an existing header
     * with an identical one.
     *
     * The `update_header` function will be called for each row after the call,
     * and it will continue to be called each time a row changes (via
     * [method`Gtk`.ListBoxRow.changed]) and when the row before changes (either
     * by [method`Gtk`.ListBoxRow.changed] on the previous row, or when the previous
     * row becomes a different row). It is also called for all rows when
     * [method`Gtk`.ListBox.invalidate_headers] is called.
     * @param updateHeader callback that lets you add row headers
     */
    setHeaderFunc(updateHeader: ListBoxUpdateHeaderFunc | null): void
    /**
     * Sets the placeholder widget that is shown in the list when
     * it doesn't display any visible children.
     * @param placeholder a `GtkWidget`
     */
    setPlaceholder(placeholder: Widget | null): void
    /**
     * Sets how selection works in the listbox.
     * @param mode The `GtkSelectionMode`
     */
    setSelectionMode(mode: SelectionMode): void
    /**
     * Sets whether the list box should show separators
     * between rows.
     * @param showSeparators %TRUE to show separators
     */
    setShowSeparators(showSeparators: boolean): void
    /**
     * Sets a sort function.
     *
     * By setting a sort function on the `box` one can dynamically reorder
     * the rows of the list, based on the contents of the rows.
     *
     * The `sort_func` will be called for each row after the call, and will
     * continue to be called each time a row changes (via
     * [method`Gtk`.ListBoxRow.changed]) and when [method`Gtk`.ListBox.invalidate_sort]
     * is called.
     *
     * Note that using a sort function is incompatible with using a model
     * (see [method`Gtk`.ListBox.bind_model]).
     * @param sortFunc the sort function
     */
    setSortFunc(sortFunc: ListBoxSortFunc | null): void
    /**
     * Unselect all children of `box,` if the selection mode allows it.
     */
    unselectAll(): void
    /**
     * Unselects a single row of `box,` if the selection mode allows it.
     * @param row the row to unselect
     */
    unselectRow(row: ListBoxRow): void

    // Own signals of Gtk-4.0.Gtk.ListBox

    connect(
      sigName: "activate-cursor-row",
      callback: ListBox.ActivateCursorRowSignalCallback
    ): number
    on(
      sigName: "activate-cursor-row",
      callback: ListBox.ActivateCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-cursor-row",
      callback: ListBox.ActivateCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-cursor-row",
      callback: ListBox.ActivateCursorRowSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-cursor-row", ...args: any[]): void
    connect(
      sigName: "move-cursor",
      callback: ListBox.MoveCursorSignalCallback
    ): number
    on(
      sigName: "move-cursor",
      callback: ListBox.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-cursor",
      callback: ListBox.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-cursor",
      callback: ListBox.MoveCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "move-cursor",
      p0: number,
      p1: boolean,
      p2: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "row-activated",
      callback: ListBox.RowActivatedSignalCallback
    ): number
    on(
      sigName: "row-activated",
      callback: ListBox.RowActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-activated",
      callback: ListBox.RowActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-activated",
      callback: ListBox.RowActivatedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "row-activated", ...args: any[]): void
    connect(
      sigName: "row-selected",
      callback: ListBox.RowSelectedSignalCallback
    ): number
    on(
      sigName: "row-selected",
      callback: ListBox.RowSelectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-selected",
      callback: ListBox.RowSelectedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-selected",
      callback: ListBox.RowSelectedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "row-selected", ...args: any[]): void
    connect(
      sigName: "select-all",
      callback: ListBox.SelectAllSignalCallback
    ): number
    on(
      sigName: "select-all",
      callback: ListBox.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-all",
      callback: ListBox.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-all",
      callback: ListBox.SelectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-all", ...args: any[]): void
    connect(
      sigName: "selected-rows-changed",
      callback: ListBox.SelectedRowsChangedSignalCallback
    ): number
    on(
      sigName: "selected-rows-changed",
      callback: ListBox.SelectedRowsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "selected-rows-changed",
      callback: ListBox.SelectedRowsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "selected-rows-changed",
      callback: ListBox.SelectedRowsChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "selected-rows-changed", ...args: any[]): void
    connect(
      sigName: "toggle-cursor-row",
      callback: ListBox.ToggleCursorRowSignalCallback
    ): number
    on(
      sigName: "toggle-cursor-row",
      callback: ListBox.ToggleCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggle-cursor-row",
      callback: ListBox.ToggleCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggle-cursor-row",
      callback: ListBox.ToggleCursorRowSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggle-cursor-row", ...args: any[]): void
    connect(
      sigName: "unselect-all",
      callback: ListBox.UnselectAllSignalCallback
    ): number
    on(
      sigName: "unselect-all",
      callback: ListBox.UnselectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unselect-all",
      callback: ListBox.UnselectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unselect-all",
      callback: ListBox.UnselectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unselect-all", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ListBox

    connect(
      sigName: "notify::accept-unpaired-release",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accept-unpaired-release",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accept-unpaired-release",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accept-unpaired-release",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accept-unpaired-release", ...args: any[]): void
    connect(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activate-on-single-click", ...args: any[]): void
    connect(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-mode", ...args: any[]): void
    connect(
      sigName: "notify::show-separators",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-separators",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-separators",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-separators",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-separators", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkListBox` is a vertical list.
   *
   * A `GtkListBox` only contains `GtkListBoxRow` children. These rows can
   * by dynamically sorted and filtered, and headers can be added dynamically
   * depending on the row content. It also allows keyboard and mouse navigation
   * and selection like a typical list.
   *
   * Using `GtkListBox` is often an alternative to `GtkTreeView`, especially
   * when the list contents has a more complicated layout than what is allowed
   * by a `GtkCellRenderer`, or when the contents is interactive (i.e. has a
   * button in it).
   *
   * Although a `GtkListBox` must have only `GtkListBoxRow` children, you can
   * add any kind of widget to it via [method`Gtk`.ListBox.prepend],
   * [method`Gtk`.ListBox.append] and [method`Gtk`.ListBox.insert] and a
   * `GtkListBoxRow` widget will automatically be inserted between the list
   * and the widget.
   *
   * `GtkListBoxRows` can be marked as activatable or selectable. If a row is
   * activatable, [signal`Gtk`.ListBox::row-activated] will be emitted for it when
   * the user tries to activate it. If it is selectable, the row will be marked
   * as selected when the user tries to select it.
   *
   * # GtkListBox as GtkBuildable
   *
   * The `GtkListBox` implementation of the `GtkBuildable` interface supports
   * setting a child as the placeholder by specifying “placeholder” as the “type”
   * attribute of a `<child>` element. See [method`Gtk`.ListBox.set_placeholder]
   * for info.
   *
   * # CSS nodes
   *
   *
   * ```<!-- language="plain" -->
   * list[.separators][.rich-list][.navigation-sidebar][.boxed-list]
   * ╰── row[.activatable]
   * ```
   *
   *
   * `GtkListBox` uses a single CSS node named list. It may carry the .separators
   * style class, when the [property`Gtk`.ListBox:show-separators] property is set.
   * Each `GtkListBoxRow` uses a single CSS node named row. The row nodes get the
   * .activatable style class added when appropriate.
   *
   * It may also carry the .boxed-list style class. In this case, the list will be
   * automatically surrounded by a frame and have separators.
   *
   * The main list node may also carry style classes to select
   * the style of [list presentation](section-list-widget.html#list-styles):
   * .rich-list, .navigation-sidebar or .data-table.
   *
   * # Accessibility
   *
   * `GtkListBox` uses the %GTK_ACCESSIBLE_ROLE_LIST role and `GtkListBoxRow` uses
   * the %GTK_ACCESSIBLE_ROLE_LIST_ITEM role.
   * @class
   */
  class ListBox extends Widget {
    // Own properties of Gtk-4.0.Gtk.ListBox

    static name: string

    // Constructors of Gtk-4.0.Gtk.ListBox

    constructor(config?: ListBox.ConstructorProperties)
    /**
     * Creates a new `GtkListBox` container.
     * @constructor
     * @returns a new `GtkListBox`
     */
    constructor()
    /**
     * Creates a new `GtkListBox` container.
     * @constructor
     * @returns a new `GtkListBox`
     */
    static new(): ListBox
    _init(config?: ListBox.ConstructorProperties): void
  }

  module ListBoxRow {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Actionable.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ListBoxRow

      /**
       * Determines whether the ::row-activated
       * signal will be emitted for this row.
       */
      activatable?: boolean | null
      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Determines whether this row can be selected.
       */
      selectable?: boolean | null
    }
  }

  interface ListBoxRow
    extends Accessible,
      Actionable,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ListBoxRow

    /**
     * Determines whether the ::row-activated
     * signal will be emitted for this row.
     */
    activatable: boolean
    /**
     * The child widget.
     */
    child: Widget
    /**
     * Determines whether this row can be selected.
     */
    selectable: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.ListBoxRow

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.ListBoxRow

    /**
     * Marks `row` as changed, causing any state that depends on this
     * to be updated.
     *
     * This affects sorting, filtering and headers.
     *
     * Note that calls to this method must be in sync with the data
     * used for the row functions. For instance, if the list is
     * mirroring some external data set, and *two* rows changed in the
     * external data set then when you call gtk_list_box_row_changed()
     * on the first row the sort function must only read the new data
     * for the first of the two changed rows, otherwise the resorting
     * of the rows will be wrong.
     *
     * This generally means that if you don’t fully control the data
     * model you have to duplicate the data that affects the listbox
     * row functions into the row widgets themselves. Another alternative
     * is to call [method`Gtk`.ListBox.invalidate_sort] on any model change,
     * but that is more expensive.
     */
    changed(): void
    /**
     * Gets whether the row is activatable.
     * @returns %TRUE if the row is activatable
     */
    getActivatable(): boolean
    /**
     * Gets the child widget of `row`.
     * @returns the child widget of @row
     */
    getChild(): Widget | null
    /**
     * Returns the current header of the `row`.
     *
     * This can be used
     * in a [callback`Gtk`.ListBoxUpdateHeaderFunc] to see if
     * there is a header set already, and if so to update
     * the state of it.
     * @returns the current header
     */
    getHeader(): Widget | null
    /**
     * Gets the current index of the `row` in its `GtkListBox` container.
     * @returns the index of the @row, or -1 if the @row is not in a listbox
     */
    getIndex(): number
    /**
     * Gets whether the row can be selected.
     * @returns %TRUE if the row is selectable
     */
    getSelectable(): boolean
    /**
     * Returns whether the child is currently selected in its
     * `GtkListBox` container.
     * @returns %TRUE if @row is selected
     */
    isSelected(): boolean
    /**
     * Set whether the row is activatable.
     * @param activatable %TRUE to mark the row as activatable
     */
    setActivatable(activatable: boolean): void
    /**
     * Sets the child widget of `self`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets the current header of the `row`.
     *
     * This is only allowed to be called
     * from a [callback`Gtk`.ListBoxUpdateHeaderFunc].
     * It will replace any existing header in the row,
     * and be shown in front of the row in the listbox.
     * @param header the header
     */
    setHeader(header: Widget | null): void
    /**
     * Set whether the row can be selected.
     * @param selectable %TRUE to mark the row as selectable
     */
    setSelectable(selectable: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.ListBoxRow

    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean

    // Own signals of Gtk-4.0.Gtk.ListBoxRow

    connect(
      sigName: "activate",
      callback: ListBoxRow.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: ListBoxRow.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: ListBoxRow.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: ListBoxRow.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ListBoxRow

    connect(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activatable", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selectable", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-target", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkListBoxRow` is the kind of widget that can be added to a `GtkListBox`.
   * @class
   */
  class ListBoxRow extends Widget {
    // Own properties of Gtk-4.0.Gtk.ListBoxRow

    static name: string

    // Constructors of Gtk-4.0.Gtk.ListBoxRow

    constructor(config?: ListBoxRow.ConstructorProperties)
    /**
     * Creates a new `GtkListBoxRow`.
     * @constructor
     * @returns a new `GtkListBoxRow`
     */
    constructor()
    /**
     * Creates a new `GtkListBoxRow`.
     * @constructor
     * @returns a new `GtkListBoxRow`
     */
    static new(): ListBoxRow
    _init(config?: ListBoxRow.ConstructorProperties): void
  }

  module ListHeader {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ListHeader

      /**
       * Widget used for display.
       */
      child?: Widget | null
    }
  }

  interface ListHeader {
    // Own properties of Gtk-4.0.Gtk.ListHeader

    /**
     * Widget used for display.
     */
    child: Widget
    /**
     * The first position no longer part of this section.
     */
    readonly end: number
    /**
     * The item at the start of the section.
     */
    readonly item: GObject.Object
    /**
     * Number of items in this section.
     */
    readonly nItems: number
    /**
     * First position of items in this section.
     */
    readonly start: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ListHeader

    /**
     * Gets the child previously set via gtk_list_header_set_child() or
     * %NULL if none was set.
     * @returns The child
     */
    getChild(): Widget | null
    /**
     * Gets the end position in the model of the section that `self` is
     * currently the header for.
     *
     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
     * @returns The end position of the section
     */
    getEnd(): number
    /**
     * Gets the model item at the start of the section.
     * This is the item that occupies the list model at position
     * [property`Gtk`.ListHeader:start].
     *
     * If `self` is unbound, this function returns %NULL.
     * @returns The item displayed
     */
    getItem(): GObject.Object | null
    /**
     * Gets the the number of items in the section.
     *
     * If `self` is unbound, 0 is returned.
     * @returns The number of items in the section
     */
    getNItems(): number
    /**
     * Gets the start position in the model of the section that `self` is
     * currently the header for.
     *
     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
     * @returns The start position of the section
     */
    getStart(): number
    /**
     * Sets the child to be used for this listitem.
     *
     * This function is typically called by applications when
     * setting up a header so that the widget can be reused when
     * binding it multiple times.
     * @param child The list item's child or %NULL to unset
     */
    setChild(child: Widget | null): void

    // Class property signals of Gtk-4.0.Gtk.ListHeader

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(sigName: "notify::end", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::end", ...args: any[]): void
    connect(sigName: "notify::item", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::start", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkListHeader` is used by list widgets to represent the headers they
   * display.
   *
   * `GtkListHeader` objects are managed just like [class`Gtk`.ListItem]
   * objects via their factory, but provide a different set of properties suitable
   * for managing the header instead of individual items.
   * @class
   */
  class ListHeader extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ListHeader

    static name: string

    // Constructors of Gtk-4.0.Gtk.ListHeader

    constructor(config?: ListHeader.ConstructorProperties)
    _init(config?: ListHeader.ConstructorProperties): void
  }

  module ListItem {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ListItem

      /**
       * The accessible description to set on the list item.
       */
      accessible_description?: string | null
      /**
       * The accessible label to set on the list item.
       */
      accessible_label?: string | null
      /**
       * If the item can be activated by the user.
       */
      activatable?: boolean | null
      /**
       * Widget used for display.
       */
      child?: Widget | null
      /**
       * If the item can be focused with the keyboard.
       */
      focusable?: boolean | null
      /**
       * If the item can be selected by the user.
       */
      selectable?: boolean | null
    }
  }

  interface ListItem {
    // Own properties of Gtk-4.0.Gtk.ListItem

    /**
     * The accessible description to set on the list item.
     */
    accessibleDescription: string | null
    /**
     * The accessible label to set on the list item.
     */
    accessibleLabel: string | null
    /**
     * If the item can be activated by the user.
     */
    activatable: boolean
    /**
     * Widget used for display.
     */
    child: Widget
    /**
     * If the item can be focused with the keyboard.
     */
    focusable: boolean
    /**
     * Displayed item.
     */
    readonly item: GObject.Object
    /**
     * Position of the item.
     */
    readonly position: number
    /**
     * If the item can be selected by the user.
     */
    selectable: boolean
    /**
     * If the item is currently selected.
     */
    readonly selected: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ListItem

    /**
     * Gets the accessible description of `self`.
     * @returns the accessible description
     */
    getAccessibleDescription(): string
    /**
     * Gets the accessible label of `self`.
     * @returns the accessible label
     */
    getAccessibleLabel(): string
    /**
     * Checks if a list item has been set to be activatable via
     * gtk_list_item_set_activatable().
     * @returns %TRUE if the item is activatable
     */
    getActivatable(): boolean
    /**
     * Gets the child previously set via gtk_list_item_set_child() or
     * %NULL if none was set.
     * @returns The child
     */
    getChild(): Widget | null
    /**
     * Checks if a list item has been set to be focusable via
     * gtk_list_item_set_focusable().
     * @returns %TRUE if the item is focusable
     */
    getFocusable(): boolean
    /**
     * Gets the model item that associated with `self`.
     *
     * If `self` is unbound, this function returns %NULL.
     * @returns The item displayed
     */
    getItem(): GObject.Object | null
    /**
     * Gets the position in the model that `self` currently displays.
     *
     * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
     * @returns The position of this item
     */
    getPosition(): number
    /**
     * Checks if a list item has been set to be selectable via
     * gtk_list_item_set_selectable().
     *
     * Do not confuse this function with [method`Gtk`.ListItem.get_selected].
     * @returns %TRUE if the item is selectable
     */
    getSelectable(): boolean
    /**
     * Checks if the item is displayed as selected.
     *
     * The selected state is maintained by the liste widget and its model
     * and cannot be set otherwise.
     * @returns %TRUE if the item is selected.
     */
    getSelected(): boolean
    /**
     * Sets the accessible description for the list item,
     * which may be used by e.g. screen readers.
     * @param description the description
     */
    setAccessibleDescription(description: string): void
    /**
     * Sets the accessible label for the list item,
     * which may be used by e.g. screen readers.
     * @param label the label
     */
    setAccessibleLabel(label: string): void
    /**
     * Sets `self` to be activatable.
     *
     * If an item is activatable, double-clicking on the item, using
     * the Return key or calling gtk_widget_activate() will activate
     * the item. Activating instructs the containing view to handle
     * activation. `GtkListView` for example will be emitting the
     * [signal`Gtk`.ListView::activate] signal.
     *
     * By default, list items are activatable.
     * @param activatable if the item should be activatable
     */
    setActivatable(activatable: boolean): void
    /**
     * Sets the child to be used for this listitem.
     *
     * This function is typically called by applications when
     * setting up a listitem so that the widget can be reused when
     * binding it multiple times.
     * @param child The list item's child or %NULL to unset
     */
    setChild(child: Widget | null): void
    /**
     * Sets `self` to be focusable.
     *
     * If an item is focusable, it can be focused using the keyboard.
     * This works similar to [method`Gtk`.Widget.set_focusable].
     *
     * Note that if items are not focusable, the keyboard cannot be used to activate
     * them and selecting only works if one of the listitem's children is focusable.
     *
     * By default, list items are focusable.
     * @param focusable if the item should be focusable
     */
    setFocusable(focusable: boolean): void
    /**
     * Sets `self` to be selectable.
     *
     * If an item is selectable, clicking on the item or using the keyboard
     * will try to select or unselect the item. If this succeeds is up to
     * the model to determine, as it is managing the selected state.
     *
     * Note that this means that making an item non-selectable has no
     * influence on the selected state at all. A non-selectable item
     * may still be selected.
     *
     * By default, list items are selectable. When rebinding them to
     * a new item, they will also be reset to be selectable by GTK.
     * @param selectable if the item should be selectable
     */
    setSelectable(selectable: boolean): void

    // Class property signals of Gtk-4.0.Gtk.ListItem

    connect(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-description",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-description", ...args: any[]): void
    connect(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-label", ...args: any[]): void
    connect(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activatable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activatable", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(sigName: "notify::item", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item", ...args: any[]): void
    connect(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position", ...args: any[]): void
    connect(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selectable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selectable", ...args: any[]): void
    connect(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkListItem` is used by list widgets to represent items in a
   * [iface`Gio`.ListModel].
   *
   * `GtkListItem` objects are managed by the list widget (with its factory)
   * and cannot be created by applications, but they need to be populated
   * by application code. This is done by calling [method`Gtk`.ListItem.set_child].
   *
   * `GtkListItem` objects exist in 2 stages:
   *
   * 1. The unbound stage where the listitem is not currently connected to
   *    an item in the list. In that case, the [property`Gtk`.ListItem:item]
   *    property is set to %NULL.
   *
   * 2. The bound stage where the listitem references an item from the list.
   *    The [property`Gtk`.ListItem:item] property is not %NULL.
   * @class
   */
  class ListItem extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ListItem

    static name: string

    // Constructors of Gtk-4.0.Gtk.ListItem

    constructor(config?: ListItem.ConstructorProperties)
    _init(config?: ListItem.ConstructorProperties): void
  }

  module ListItemFactory {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ListItemFactory {
    // Own properties of Gtk-4.0.Gtk.ListItemFactory

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.ListItemFactory

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkListItemFactory` creates widgets for the items taken from a `GListModel`.
   *
   * This is one of the core concepts of handling list widgets such
   * as [class`Gtk`.ListView] or [class`Gtk`.GridView].
   *
   * The `GtkListItemFactory` is tasked with creating widgets for items
   * taken from the model when the views need them and updating them as
   * the items displayed by the view change.
   *
   * A view is usually only able to display anything after both a factory
   * and a model have been set on the view. So it is important that you do
   * not skip this step when setting up your first view.
   *
   * Because views do not display the whole list at once but only a few
   * items, they only need to maintain a few widgets at a time. They will
   * instruct the `GtkListItemFactory` to create these widgets and bind them
   * to the items that are currently displayed.
   *
   * As the list model changes or the user scrolls to the list, the items will
   * change and the view will instruct the factory to bind the widgets to those
   * new items.
   *
   * The actual widgets used for displaying those widgets is provided by you.
   *
   * When the factory needs widgets created, it will create a `GtkListItem`
   * and hand it to your code to set up a widget for. This list item will provide
   * various properties with information about what item to display and provide
   * you with some opportunities to configure its behavior. See the
   * [class`Gtk`.ListItem] documentation for further details.
   *
   * Various implementations of `GtkListItemFactory` exist to allow you different
   * ways to provide those widgets. The most common implementations are
   * [class`Gtk`.BuilderListItemFactory] which takes a `GtkBuilder` .ui file
   * and then creates widgets and manages everything automatically from the
   * information in that file and [class`Gtk`.SignalListItemFactory] which allows
   * you to connect to signals with your own code and retain full control over
   * how the widgets are setup and managed.
   *
   * A `GtkListItemFactory` is supposed to be final - that means its behavior should
   * not change and the first widget created from it should behave the same way as
   * the last widget created from it.
   * If you intend to do changes to the behavior, it is recommended that you create
   * a new `GtkListItemFactory` which will allow the views to recreate its widgets.
   *
   * Once you have chosen your factory and created it, you need to set it
   * on the view widget you want to use it with, such as via
   * [method`Gtk`.ListView.set_factory]. Reusing factories across different
   * views is allowed, but very uncommon.
   * @class
   */
  class ListItemFactory extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ListItemFactory

    static name: string

    // Constructors of Gtk-4.0.Gtk.ListItemFactory

    constructor(config?: ListItemFactory.ConstructorProperties)
    _init(config?: ListItemFactory.ConstructorProperties): void
  }

  module ListStore {
    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        TreeDragDest.ConstructorProperties,
        TreeDragSource.ConstructorProperties,
        TreeModel.ConstructorProperties,
        TreeSortable.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface ListStore
    extends Buildable,
      TreeDragDest,
      TreeDragSource,
      TreeModel,
      TreeSortable {
    // Own properties of Gtk-4.0.Gtk.ListStore

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.ListStore

    parent: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.ListStore

    /**
     * Appends a new row to `list_store`.  `iter` will be changed to point to this new
     * row.  The row will be empty after this function is called.  To fill in
     * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
     */
    append(): /* iter */ TreeIter
    /**
     * Removes all rows from the list store.
     */
    clear(): void
    /**
     * Creates a new row at `position`.  `iter` will be changed to point to this new
     * row.  If `position` is -1 or is larger than the number of rows on the list,
     * then the new row will be appended to the list. The row will be empty after
     * this function is called.  To fill in values, you need to call
     * gtk_list_store_set() or gtk_list_store_set_value().
     * @param position position to insert the new row, or -1 for last
     */
    insert(position: number): /* iter */ TreeIter
    /**
     * Inserts a new row after `sibling`. If `sibling` is %NULL, then the row will be
     * prepended to the beginning of the list. `iter` will be changed to point to
     * this new row. The row will be empty after this function is called. To fill
     * in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
     * @param sibling A valid `GtkTreeIter`
     */
    insertAfter(sibling: TreeIter | null): /* iter */ TreeIter
    /**
     * Inserts a new row before `sibling`. If `sibling` is %NULL, then the row will
     * be appended to the end of the list. `iter` will be changed to point to this
     * new row. The row will be empty after this function is called. To fill in
     * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
     * @param sibling A valid `GtkTreeIter`
     */
    insertBefore(sibling: TreeIter | null): /* iter */ TreeIter
    /**
     * A variant of gtk_list_store_insert_with_values() which
     * takes the columns and values as two arrays, instead of
     * varargs.
     *
     * This function is mainly intended for language-bindings.
     * @param position position to insert the new row, or -1 for last
     * @param columns an array of column numbers
     * @param values an array of GValues
     */
    insertWithValues(
      position: number,
      columns: number[],
      values: any[]
    ): /* iter */ TreeIter
    /**
     * Checks if the given iter is a valid iter for this `GtkListStore`.
     *
     * This function is slow. Only use it for debugging and/or testing
     * purposes.
     * @param iter the iterator to check
     * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
     */
    iterIsValid(iter: TreeIter): boolean
    /**
     * Moves `iter` in `store` to the position after `position`. Note that this
     * function only works with unsorted stores. If `position` is %NULL, `iter`
     * will be moved to the start of the list.
     * @param iter A `GtkTreeIter`
     * @param position A `GtkTreeIter`
     */
    moveAfter(iter: TreeIter, position: TreeIter | null): void
    /**
     * Moves `iter` in `store` to the position before `position`. Note that this
     * function only works with unsorted stores. If `position` is %NULL, `iter`
     * will be moved to the end of the list.
     * @param iter A `GtkTreeIter`
     * @param position A `GtkTreeIter`
     */
    moveBefore(iter: TreeIter, position: TreeIter | null): void
    /**
     * Prepends a new row to `list_store`. `iter` will be changed to point to this new
     * row. The row will be empty after this function is called. To fill in
     * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
     */
    prepend(): /* iter */ TreeIter
    /**
     * Removes the given row from the list store.  After being removed,
     * `iter` is set to be the next valid row, or invalidated if it pointed
     * to the last row in `list_store`.
     * @param iter A valid `GtkTreeIter`
     * @returns %TRUE if @iter is valid, %FALSE if not.
     */
    remove(iter: TreeIter): boolean
    /**
     * Reorders `store` to follow the order indicated by `new_order`. Note that
     * this function only works with unsorted stores.
     * @param newOrder an array of integers mapping the new   position of each child to its old position before the re-ordering,   i.e. `new_order``[newpos] = oldpos`. It must have   exactly as many items as the list store’s length.
     */
    reorder(newOrder: number[]): void
    /**
     * Sets the types of the columns of a list store.
     *
     * This function is meant primarily for objects that inherit
     * from `GtkListStore`, and should only be used when constructing
     * a new instance.
     *
     * This function cannot be called after a row has been added, or
     * a method on the `GtkTreeModel` interface is called.
     * @param types An array length n of `GType`s
     */
    setColumnTypes(types: GObject.GType[]): void
    /**
     * Sets the data in the cell specified by `iter` and `column`.
     * The type of `value` must be convertible to the type of the
     * column.
     * @param iter A valid `GtkTreeIter` for the row being modified
     * @param column column number to modify
     * @param value new value for the cell
     */
    setValue(iter: TreeIter, column: number, value: any): void
    /**
     * A variant of gtk_list_store_set_valist() which
     * takes the columns and values as two arrays, instead of
     * varargs. This function is mainly intended for
     * language-bindings and in case the number of columns to
     * change is not known until run-time.
     * @param iter A valid `GtkTreeIter` for the row being modified
     * @param columns an array of column numbers
     * @param values an array of GValues
     */
    set(iter: TreeIter, columns: number[], values: any[]): void
    /**
     * Swaps `a` and `b` in `store`. Note that this function only works with
     * unsorted stores.
     * @param a A `GtkTreeIter`
     * @param b Another `GtkTreeIter`
     */
    swap(a: TreeIter, b: TreeIter): void

    // Class property signals of Gtk-4.0.Gtk.ListStore

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A list-like data structure that can be used with the [class`Gtk`.TreeView].
   *
   * The `GtkListStore` object is a list model for use with a `GtkTreeView`
   * widget.  It implements the `GtkTreeModel` interface, and consequentialy,
   * can use all of the methods available there.  It also implements the
   * `GtkTreeSortable` interface so it can be sorted by the view.
   * Finally, it also implements the tree
   * [drag](iface.TreeDragSource.html) and [drop](iface.TreeDragDest.html)
   * interfaces.
   *
   * The `GtkListStore` can accept most `GType`s as a column type, though
   * it can’t accept all custom types.  Internally, it will keep a copy of
   * data passed in (such as a string or a boxed pointer).  Columns that
   * accept `GObject`s are handled a little differently.  The
   * `GtkListStore` will keep a reference to the object instead of copying the
   * value.  As a result, if the object is modified, it is up to the
   * application writer to call [method`Gtk`.TreeModel.row_changed] to emit the
   * [signal`Gtk`.TreeModel::row_changed] signal. This most commonly affects lists
   * with [class`Gdk`.Texture]s stored.
   *
   * An example for creating a simple list store:
   *
   * ```c
   * enum {
   *   COLUMN_STRING,
   *   COLUMN_INT,
   *   COLUMN_BOOLEAN,
   *   N_COLUMNS
   * };
   *
   * {
   *   GtkListStore *list_store;
   *   GtkTreePath *path;
   *   GtkTreeIter iter;
   *   int i;
   *
   *   list_store = gtk_list_store_new (N_COLUMNS,
   *                                    G_TYPE_STRING,
   *                                    G_TYPE_INT,
   *                                    G_TYPE_BOOLEAN);
   *
   *   for (i = 0; i < 10; i++)
   *     {
   *       char *some_data;
   *
   *       some_data = get_some_data (i);
   *
   *       // Add a new row to the model
   *       gtk_list_store_append (list_store, &iter);
   *       gtk_list_store_set (list_store, &iter,
   *                           COLUMN_STRING, some_data,
   *                           COLUMN_INT, i,
   *                           COLUMN_BOOLEAN,  FALSE,
   *                           -1);
   *
   *       // As the store will keep a copy of the string internally,
   *       // we free some_data.
   *       g_free (some_data);
   *     }
   *
   *   // Modify a particular row
   *   path = gtk_tree_path_new_from_string ("4");
   *   gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store),
   *                            &iter,
   *                            path);
   *   gtk_tree_path_free (path);
   *   gtk_list_store_set (list_store, &iter,
   *                       COLUMN_BOOLEAN, TRUE,
   *                       -1);
   * }
   * ```
   *
   * `GtkListStore` is deprecated since GTK 4.10, and should not be used in newly
   * written code. You should use [class`Gio`.ListStore] instead, and the various
   * list models provided by GTK.
   *
   * ## Performance Considerations
   *
   * Internally, the `GtkListStore` was originally implemented with a linked list
   * with a tail pointer.  As a result, it was fast at data insertion and deletion,
   * and not fast at random data access.  The `GtkListStore` sets the
   * `GTK_TREE_MODEL_ITERS_PERSIST` flag, which means that `GtkTreeIter`s can be
   * cached while the row exists.  Thus, if access to a particular row is needed
   * often and your code is expected to run on older versions of GTK, it is worth
   * keeping the iter around.
   *
   * ## Atomic Operations
   *
   * It is important to note that only the methods
   * gtk_list_store_insert_with_values() and gtk_list_store_insert_with_valuesv()
   * are atomic, in the sense that the row is being appended to the store and the
   * values filled in in a single operation with regard to `GtkTreeModel` signaling.
   * In contrast, using e.g. gtk_list_store_append() and then gtk_list_store_set()
   * will first create a row, which triggers the `GtkTreeModel::row-inserted` signal
   * on `GtkListStore`. The row, however, is still empty, and any signal handler
   * connecting to `GtkTreeModel::row-inserted` on this particular store should be prepared
   * for the situation that the row might be empty. This is especially important
   * if you are wrapping the `GtkListStore` inside a `GtkTreeModel`Filter and are
   * using a `GtkTreeModel`FilterVisibleFunc. Using any of the non-atomic operations
   * to append rows to the `GtkListStore` will cause the
   * `GtkTreeModel`FilterVisibleFunc to be visited with an empty row first; the
   * function must be prepared for that.
   *
   * ## GtkListStore as GtkBuildable
   *
   * The GtkListStore implementation of the [iface`Gtk`.Buildable] interface allows
   * to specify the model columns with a `<columns>` element that may contain
   * multiple `<column>` elements, each specifying one model column. The “type”
   * attribute specifies the data type for the column.
   *
   * Additionally, it is possible to specify content for the list store
   * in the UI definition, with the `<data>` element. It can contain multiple
   * `<row>` elements, each specifying to content for one row of the list model.
   * Inside a `<row>`, the `<col>` elements specify the content for individual cells.
   *
   * Note that it is probably more common to define your models in the code,
   * and one might consider it a layering violation to specify the content of
   * a list store in a UI definition, data, not presentation, and common wisdom
   * is to separate the two, as far as possible.
   *
   * An example of a UI Definition fragment for a list store:
   *
   * ```xml
   * <object class="GtkListStore">
   *   <columns>
   *     <column type="gchararray"/>
   *     <column type="gchararray"/>
   *     <column type="gint"/>
   *   </columns>
   *   <data>
   *     <row>
   *       <col id="0">John</col>
   *       <col id="1">Doe</col>
   *       <col id="2">25</col>
   *     </row>
   *     <row>
   *       <col id="0">Johan</col>
   *       <col id="1">Dahlin</col>
   *       <col id="2">50</col>
   *     </row>
   *   </data>
   * </object>
   * ```
   * @class
   */
  class ListStore extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ListStore

    static name: string

    // Constructors of Gtk-4.0.Gtk.ListStore

    constructor(config?: ListStore.ConstructorProperties)
    /**
     * Creates a new `GtkListStore`.
     *
     * This function is meant to be used by language bindings.
     * @constructor
     * @param types an array of `GType` types for the columns, from first to last
     * @returns a new `GtkListStore`
     */
    constructor(types: GObject.GType[])
    /**
     * Creates a new `GtkListStore`.
     *
     * This function is meant to be used by language bindings.
     * @constructor
     * @param types an array of `GType` types for the columns, from first to last
     * @returns a new `GtkListStore`
     */
    static new(types: GObject.GType[]): ListStore
    _init(config?: ListStore.ConstructorProperties): void
  }

  module ListView {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (position: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Scrollable.ConstructorProperties,
        ListBase.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ListView

      /**
       * Allow rubberband selection.
       */
      enable_rubberband?: boolean | null
      /**
       * Factory for populating list items.
       */
      factory?: ListItemFactory | null
      /**
       * Factory for creating header widgets.
       */
      header_factory?: ListItemFactory | null
      /**
       * Model for the items displayed.
       */
      model?: SelectionModel | null
      /**
       * Show separators between rows.
       */
      show_separators?: boolean | null
      /**
       * Activate rows on single click and select them on hover.
       */
      single_click_activate?: boolean | null
      /**
       * Behavior of the <kbd>Tab</kbd> key
       */
      tab_behavior?: ListTabBehavior | null
    }
  }

  interface ListView
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable,
      Scrollable {
    // Own properties of Gtk-4.0.Gtk.ListView

    /**
     * Allow rubberband selection.
     */
    enableRubberband: boolean
    /**
     * Factory for populating list items.
     */
    factory: ListItemFactory
    /**
     * Factory for creating header widgets.
     */
    headerFactory: ListItemFactory
    /**
     * Model for the items displayed.
     */
    model: SelectionModel
    /**
     * Show separators between rows.
     */
    showSeparators: boolean
    /**
     * Activate rows on single click and select them on hover.
     */
    singleClickActivate: boolean
    /**
     * Behavior of the <kbd>Tab</kbd> key
     */
    tabBehavior: ListTabBehavior
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ListView

    /**
     * Returns whether rows can be selected by dragging with the mouse.
     * @returns %TRUE if rubberband selection is enabled
     */
    getEnableRubberband(): boolean
    /**
     * Gets the factory that's currently used to populate list items.
     * @returns The factory in use
     */
    getFactory(): ListItemFactory | null
    /**
     * Gets the factory that's currently used to populate section headers.
     * @returns The factory in use
     */
    getHeaderFactory(): ListItemFactory | null
    /**
     * Gets the model that's currently used to read the items displayed.
     * @returns The model in use
     */
    getModel(): SelectionModel | null
    /**
     * Returns whether the list box should show separators
     * between rows.
     * @returns %TRUE if the list box shows separators
     */
    getShowSeparators(): boolean
    /**
     * Returns whether rows will be activated on single click and
     * selected on hover.
     * @returns %TRUE if rows are activated on single click
     */
    getSingleClickActivate(): boolean
    /**
     * Gets the behavior set for the <kbd>Tab</kbd> key.
     * @returns The behavior of the <kbd>Tab</kbd> key
     */
    getTabBehavior(): ListTabBehavior
    /**
     * Scrolls to the item at the given position and performs the actions
     * specified in `flags`.
     *
     * This function works no matter if the listview is shown or focused.
     * If it isn't, then the changes will take effect once that happens.
     * @param pos position of the item
     * @param flags actions to perform
     * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
     */
    scrollTo(
      pos: number,
      flags: ListScrollFlags,
      scroll: ScrollInfo | null
    ): void
    /**
     * Sets whether selections can be changed by dragging with the mouse.
     * @param enableRubberband %TRUE to enable rubberband selection
     */
    setEnableRubberband(enableRubberband: boolean): void
    /**
     * Sets the `GtkListItemFactory` to use for populating list items.
     * @param factory the factory to use
     */
    setFactory(factory: ListItemFactory | null): void
    /**
     * Sets the `GtkListItemFactory` to use for populating the
     * [class`Gtk`.ListHeader] objects used in section headers.
     *
     * If this factory is set to %NULL, the list will not show section headers.
     * @param factory the factory to use
     */
    setHeaderFactory(factory: ListItemFactory | null): void
    /**
     * Sets the model to use.
     *
     * This must be a [iface`Gtk`.SelectionModel] to use.
     * @param model the model to use
     */
    setModel(model: SelectionModel | null): void
    /**
     * Sets whether the list box should show separators
     * between rows.
     * @param showSeparators %TRUE to show separators
     */
    setShowSeparators(showSeparators: boolean): void
    /**
     * Sets whether rows should be activated on single click and
     * selected on hover.
     * @param singleClickActivate %TRUE to activate items on single click
     */
    setSingleClickActivate(singleClickActivate: boolean): void
    /**
     * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
     * @param tabBehavior The desired tab behavior
     */
    setTabBehavior(tabBehavior: ListTabBehavior): void

    // Own signals of Gtk-4.0.Gtk.ListView

    connect(
      sigName: "activate",
      callback: ListView.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: ListView.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: ListView.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: ListView.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ListView

    connect(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-rubberband",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-rubberband", ...args: any[]): void
    connect(
      sigName: "notify::factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::factory", ...args: any[]): void
    connect(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::header-factory",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::header-factory", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::show-separators",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-separators",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-separators",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-separators",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-separators", ...args: any[]): void
    connect(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::single-click-activate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::single-click-activate", ...args: any[]): void
    connect(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tab-behavior",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tab-behavior", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkListView` presents a large dynamic list of items.
   *
   * `GtkListView` uses its factory to generate one row widget for each visible
   * item and shows them in a linear display, either vertically or horizontally.
   *
   * The [property`Gtk`.ListView:show-separators] property offers a simple way to
   * display separators between the rows.
   *
   * `GtkListView` allows the user to select items according to the selection
   * characteristics of the model. For models that allow multiple selected items,
   * it is possible to turn on _rubberband selection_, using
   * [property`Gtk`.ListView:enable-rubberband].
   *
   * If you need multiple columns with headers, see [class`Gtk`.ColumnView].
   *
   * To learn more about the list widget framework, see the
   * [overview](section-list-widget.html).
   *
   * An example of using `GtkListView`:
   * ```c
   * static void
   * setup_listitem_cb (GtkListItemFactory *factory,
   *                    GtkListItem        *list_item)
   * {
   *   GtkWidget *image;
   *
   *   image = gtk_image_new ();
   *   gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
   *   gtk_list_item_set_child (list_item, image);
   * }
   *
   * static void
   * bind_listitem_cb (GtkListItemFactory *factory,
   *                   GtkListItem        *list_item)
   * {
   *   GtkWidget *image;
   *   GAppInfo *app_info;
   *
   *   image = gtk_list_item_get_child (list_item);
   *   app_info = gtk_list_item_get_item (list_item);
   *   gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
   * }
   *
   * static void
   * activate_cb (GtkListView  *list,
   *              guint         position,
   *              gpointer      unused)
   * {
   *   GAppInfo *app_info;
   *
   *   app_info = g_list_model_get_item (G_LIST_MODEL (gtk_list_view_get_model (list)), position);
   *   g_app_info_launch (app_info, NULL, NULL, NULL);
   *   g_object_unref (app_info);
   * }
   *
   * ...
   *
   *   model = create_application_list ();
   *
   *   factory = gtk_signal_list_item_factory_new ();
   *   g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
   *   g_signal_connect (factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);
   *
   *   list = gtk_list_view_new (GTK_SELECTION_MODEL (gtk_single_selection_new (model)), factory);
   *
   *   g_signal_connect (list, "activate", G_CALLBACK (activate_cb), NULL);
   *
   *   gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), list);
   * ```
   *
   * # CSS nodes
   *
   * ```
   * listview[.separators][.rich-list][.navigation-sidebar][.data-table]
   * ├── row[.activatable]
   * │
   * ├── row[.activatable]
   * │
   * ┊
   * ╰── [rubberband]
   * ```
   *
   * `GtkListView` uses a single CSS node named `listview`. It may carry the
   * `.separators` style class, when [property`Gtk`.ListView:show-separators]
   * property is set. Each child widget uses a single CSS node named `row`.
   * If the [property`Gtk`.ListItem:activatable] property is set, the
   * corresponding row will have the `.activatable` style class. For
   * rubberband selection, a node with name `rubberband` is used.
   *
   * The main listview node may also carry style classes to select
   * the style of [list presentation](ListContainers.html#list-styles):
   * .rich-list, .navigation-sidebar or .data-table.
   *
   * # Accessibility
   *
   * `GtkListView` uses the %GTK_ACCESSIBLE_ROLE_LIST role, and the list
   * items use the %GTK_ACCESSIBLE_ROLE_LIST_ITEM role.
   * @class
   */
  class ListView extends ListBase {
    // Own properties of Gtk-4.0.Gtk.ListView

    static name: string

    // Constructors of Gtk-4.0.Gtk.ListView

    constructor(config?: ListView.ConstructorProperties)
    /**
     * Creates a new `GtkListView` that uses the given `factory` for
     * mapping items to widgets.
     *
     * The function takes ownership of the
     * arguments, so you can write code like
     * ```c
     * list_view = gtk_list_view_new (create_model (),
     *   gtk_builder_list_item_factory_new_from_resource ("/resource.ui"));
     * ```
     * @constructor
     * @param model the model to use
     * @param factory The factory to populate items with
     * @returns a new `GtkListView` using the given @model and @factory
     */
    constructor(model: SelectionModel | null, factory: ListItemFactory | null)
    /**
     * Creates a new `GtkListView` that uses the given `factory` for
     * mapping items to widgets.
     *
     * The function takes ownership of the
     * arguments, so you can write code like
     * ```c
     * list_view = gtk_list_view_new (create_model (),
     *   gtk_builder_list_item_factory_new_from_resource ("/resource.ui"));
     * ```
     * @constructor
     * @param model the model to use
     * @param factory The factory to populate items with
     * @returns a new `GtkListView` using the given @model and @factory
     */
    static new(
      model: SelectionModel | null,
      factory: ListItemFactory | null
    ): ListView
    _init(config?: ListView.ConstructorProperties): void
  }

  module LockButton {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Actionable.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Button.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.LockButton

      /**
       * The `GPermission object controlling this button.
       */
      permission?: Gio.Permission | null
      /**
       * The text to display when prompting the user to lock.
       */
      text_lock?: string | null
      /**
       * The text to display when prompting the user to unlock.
       */
      text_unlock?: string | null
      /**
       * The tooltip to display when prompting the user to lock.
       */
      tooltip_lock?: string | null
      /**
       * The tooltip to display when the user cannot obtain authorization.
       */
      tooltip_not_authorized?: string | null
      /**
       * The tooltip to display when prompting the user to unlock.
       */
      tooltip_unlock?: string | null
    }
  }

  interface LockButton
    extends Accessible,
      Actionable,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.LockButton

    /**
     * The `GPermission object controlling this button.
     */
    permission: Gio.Permission
    /**
     * The text to display when prompting the user to lock.
     */
    textLock: string | null
    /**
     * The text to display when prompting the user to unlock.
     */
    textUnlock: string | null
    /**
     * The tooltip to display when prompting the user to lock.
     */
    tooltipLock: string | null
    /**
     * The tooltip to display when the user cannot obtain authorization.
     */
    tooltipNotAuthorized: string | null
    /**
     * The tooltip to display when prompting the user to unlock.
     */
    tooltipUnlock: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.LockButton

    /**
     * Obtains the `GPermission` object that controls `button`.
     * @returns the `GPermission` of @button
     */
    getPermission(): Gio.Permission | null
    /**
     * Sets the `GPermission` object that controls `button`.
     * @param permission a `GPermission` object
     */
    setPermission(permission: Gio.Permission | null): void

    // Conflicting methods

    /**
     * Signal that causes the button to animate press then
     *    release. Applications should never connect to this signal, but use
     *    the `clicked` signal.
     * @virtual
     */
    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean
    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean

    // Class property signals of Gtk-4.0.Gtk.LockButton

    connect(
      sigName: "notify::permission",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::permission",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::permission",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::permission",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::permission", ...args: any[]): void
    connect(
      sigName: "notify::text-lock",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-lock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-lock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-lock",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-lock", ...args: any[]): void
    connect(
      sigName: "notify::text-unlock",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-unlock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-unlock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-unlock",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-unlock", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-lock",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-lock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-lock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-lock",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-lock", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-not-authorized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-not-authorized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-not-authorized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-not-authorized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-not-authorized", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-unlock",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-unlock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-unlock",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-unlock",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-unlock", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-shrink", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-target", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkLockButton` is a widget to obtain and revoke authorizations
   * needed to operate the controls.
   *
   * ![An example GtkLockButton](lock-button.png)
   *
   * It is typically used in preference dialogs or control panels.
   *
   * The required authorization is represented by a `GPermission` object.
   * Concrete implementations of `GPermission` may use PolicyKit or some
   * other authorization framework. To obtain a PolicyKit-based
   * `GPermission`, use `polkit_permission_new()`.
   *
   * If the user is not currently allowed to perform the action, but can
   * obtain the permission, the widget looks like this:
   *
   * ![](lockbutton-locked.png)
   *
   * and the user can click the button to request the permission. Depending
   * on the platform, this may pop up an authentication dialog or ask the user
   * to authenticate in some other way. Once the user has obtained the permission,
   * the widget changes to this:
   *
   * ![](lockbutton-unlocked.png)
   *
   * and the permission can be dropped again by clicking the button. If the user
   * is not able to obtain the permission at all, the widget looks like this:
   *
   * ![](lockbutton-sorry.png)
   *
   * If the user has the permission and cannot drop it, the button is hidden.
   *
   * The text (and tooltips) that are shown in the various cases can be adjusted
   * with the [property`Gtk`.LockButton:text-lock],
   * [property`Gtk`.LockButton:text-unlock],
   * [property`Gtk`.LockButton:tooltip-lock],
   * [property`Gtk`.LockButton:tooltip-unlock] and
   * [property`Gtk`.LockButton:tooltip-not-authorized] properties.
   * @class
   */
  class LockButton extends Button {
    // Own properties of Gtk-4.0.Gtk.LockButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.LockButton

    constructor(config?: LockButton.ConstructorProperties)
    /**
     * Creates a new lock button which reflects the `permission`.
     * @constructor
     * @param permission a `GPermission`
     * @returns a new `GtkLockButton`
     */
    constructor(permission: Gio.Permission | null)
    /**
     * Creates a new lock button which reflects the `permission`.
     * @constructor
     * @param permission a `GPermission`
     * @returns a new `GtkLockButton`
     */
    static new(permission: Gio.Permission | null): LockButton

    // Overloads of new

    /**
     * Creates a new `GtkButton` widget.
     *
     * To add a child widget to the button, use [method`Gtk`.Button.set_child].
     * @constructor
     * @returns The newly created `GtkButton` widget.
     */
    static new(): Button
    _init(config?: LockButton.ConstructorProperties): void
  }

  module MapListModel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        SectionModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MapListModel

      /**
       * The model being mapped.
       */
      model?: Gio.ListModel | null
    }
  }

  interface MapListModel extends Gio.ListModel, SectionModel {
    // Own properties of Gtk-4.0.Gtk.MapListModel

    /**
     * If a map is set for this model
     */
    readonly hasMap: boolean
    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The model being mapped.
     */
    readonly model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.MapListModel

    /**
     * Gets the model that is currently being mapped or %NULL if none.
     * @returns The model that gets mapped
     */
    getModel(): Gio.ListModel | null
    /**
     * Sets the function used to map items.
     *
     * The function will be called whenever an item needs to be mapped
     * and must return the item to use for the given input item.
     *
     * Note that `GtkMapListModel` may call this function multiple times
     * on the same item, because it may delete items it doesn't need anymore.
     *
     * GTK makes no effort to ensure that `map_func` conforms to the item type
     * of `self`. It assumes that the caller knows what they are doing and the map
     * function returns items of the appropriate type.
     * @param mapFunc map function
     */
    setMapFunc(mapFunc: MapListModelMapFunc | null): void
    /**
     * Sets the model to be mapped.
     *
     * GTK makes no effort to ensure that `model` conforms to the item type
     * expected by the map function. It assumes that the caller knows what
     * they are doing and have set up an appropriate map function.
     * @param model The model to be mapped
     */
    setModel(model: Gio.ListModel | null): void

    // Class property signals of Gtk-4.0.Gtk.MapListModel

    connect(
      sigName: "notify::has-map",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-map",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-map",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-map",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-map", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkMapListModel` maps the items in a list model to different items.
   *
   * `GtkMapListModel` uses a [callback`Gtk`.MapListModelMapFunc].
   *
   * Example: Create a list of `GtkEventControllers`
   * ```c
   * static gpointer
   * map_to_controllers (gpointer widget,
   *                     gpointer data)
   * {
   *   gpointer result = gtk_widget_observe_controllers (widget);
   *   g_object_unref (widget);
   *   return result;
   * }
   *
   * widgets = gtk_widget_observe_children (widget);
   *
   * controllers = gtk_map_list_model_new (widgets,
   *                                       map_to_controllers,
   *                                       NULL, NULL);
   *
   * model = gtk_flatten_list_model_new (GTK_TYPE_EVENT_CONTROLLER,
   *                                     controllers);
   * ```
   *
   * `GtkMapListModel` will attempt to discard the mapped objects as soon as
   * they are no longer needed and recreate them if necessary.
   *
   * `GtkMapListModel` passes through sections from the underlying model.
   * @class
   */
  class MapListModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.MapListModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.MapListModel

    constructor(config?: MapListModel.ConstructorProperties)
    /**
     * Creates a new `GtkMapListModel` for the given arguments.
     * @constructor
     * @param model The model to map
     * @param mapFunc map function
     * @returns a new `GtkMapListModel`
     */
    constructor(
      model: Gio.ListModel | null,
      mapFunc: MapListModelMapFunc | null
    )
    /**
     * Creates a new `GtkMapListModel` for the given arguments.
     * @constructor
     * @param model The model to map
     * @param mapFunc map function
     * @returns a new `GtkMapListModel`
     */
    static new(
      model: Gio.ListModel | null,
      mapFunc: MapListModelMapFunc | null
    ): MapListModel
    _init(config?: MapListModel.ConstructorProperties): void
  }

  module MediaControls {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MediaControls

      /**
       * The media-stream managed by this object or %NULL if none.
       */
      media_stream?: MediaStream | null
    }
  }

  interface MediaControls extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.MediaControls

    /**
     * The media-stream managed by this object or %NULL if none.
     */
    mediaStream: MediaStream
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.MediaControls

    /**
     * Gets the media stream managed by `controls` or %NULL if none.
     * @returns The media stream managed by @controls
     */
    getMediaStream(): MediaStream | null
    /**
     * Sets the stream that is controlled by `controls`.
     * @param stream a `GtkMediaStream`
     */
    setMediaStream(stream: MediaStream | null): void

    // Class property signals of Gtk-4.0.Gtk.MediaControls

    connect(
      sigName: "notify::media-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::media-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::media-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::media-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::media-stream", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkMediaControls` is a widget to show controls for a video.
   *
   * ![An example GtkMediaControls](media-controls.png)
   *
   * Usually, `GtkMediaControls` is used as part of [class`Gtk`.Video].
   * @class
   */
  class MediaControls extends Widget {
    // Own properties of Gtk-4.0.Gtk.MediaControls

    static name: string

    // Constructors of Gtk-4.0.Gtk.MediaControls

    constructor(config?: MediaControls.ConstructorProperties)
    /**
     * Creates a new `GtkMediaControls` managing the `stream` passed to it.
     * @constructor
     * @param stream a `GtkMediaStream` to manage
     * @returns a new `GtkMediaControls`
     */
    constructor(stream: MediaStream | null)
    /**
     * Creates a new `GtkMediaControls` managing the `stream` passed to it.
     * @constructor
     * @param stream a `GtkMediaStream` to manage
     * @returns a new `GtkMediaControls`
     */
    static new(stream: MediaStream | null): MediaControls
    _init(config?: MediaControls.ConstructorProperties): void
  }

  module MediaFile {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gdk.Paintable.ConstructorProperties,
        MediaStream.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MediaFile

      /**
       * The file being played back or %NULL if not playing a file.
       */
      file?: Gio.File | null
      /**
       * The stream being played back or %NULL if not playing a stream.
       *
       * This is %NULL when playing a file.
       */
      input_stream?: Gio.InputStream | null
    }
  }

  interface MediaFile extends Gdk.Paintable {
    // Own properties of Gtk-4.0.Gtk.MediaFile

    /**
     * The file being played back or %NULL if not playing a file.
     */
    file: Gio.File
    /**
     * The stream being played back or %NULL if not playing a stream.
     *
     * This is %NULL when playing a file.
     */
    inputStream: Gio.InputStream
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.MediaFile

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.MediaFile

    /**
     * Resets the media file to be empty.
     */
    clear(): void
    /**
     * Returns the file that `self` is currently playing from.
     *
     * When `self` is not playing or not playing from a file,
     * %NULL is returned.
     * @returns The currently playing file
     */
    getFile(): Gio.File | null
    /**
     * Returns the stream that `self` is currently playing from.
     *
     * When `self` is not playing or not playing from a stream,
     * %NULL is returned.
     * @returns The currently playing stream
     */
    getInputStream(): Gio.InputStream | null
    /**
     * Sets the `GtkMediaFile` to play the given file.
     *
     * If any file is still playing, stop playing it.
     * @param file the file to play
     */
    setFile(file: Gio.File | null): void
    /**
     * Sets the `GtkMediaFile to play the given file.
     *
     * This is a utility function that converts the given `filename`
     * to a `GFile` and calls [method`Gtk`.MediaFile.set_file].
     * @param filename name of file to play
     */
    setFilename(filename: string | null): void
    /**
     * Sets the `GtkMediaFile` to play the given stream.
     *
     * If anything is still playing, stop playing it.
     *
     * Full control about the `stream` is assumed for the duration of
     * playback. The stream will not be closed.
     * @param stream the stream to play from
     */
    setInputStream(stream: Gio.InputStream | null): void
    /**
     * Sets the `GtkMediaFile to play the given resource.
     *
     * This is a utility function that converts the given `resource_path`
     * to a `GFile` and calls [method`Gtk`.MediaFile.set_file].
     * @param resourcePath path to resource to play
     */
    setResource(resourcePath: string | null): void

    // Own virtual methods of Gtk-4.0.Gtk.MediaFile

    close(): void
    open(): void

    // Class property signals of Gtk-4.0.Gtk.MediaFile

    connect(sigName: "notify::file", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file", ...args: any[]): void
    connect(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-stream", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::duration",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::duration",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::duration",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::duration",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::duration", ...args: any[]): void
    connect(
      sigName: "notify::ended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ended", ...args: any[]): void
    connect(
      sigName: "notify::error",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::error",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::error",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::error",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::error", ...args: any[]): void
    connect(
      sigName: "notify::has-audio",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-audio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-audio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-audio",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-audio", ...args: any[]): void
    connect(
      sigName: "notify::has-video",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-video",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-video",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-video",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-video", ...args: any[]): void
    connect(sigName: "notify::loop", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::loop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::loop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::loop",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::loop", ...args: any[]): void
    connect(
      sigName: "notify::muted",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::muted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::muted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::muted",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::muted", ...args: any[]): void
    connect(
      sigName: "notify::playing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::playing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::playing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::playing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::playing", ...args: any[]): void
    connect(
      sigName: "notify::prepared",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::prepared",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::prepared",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::prepared",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::prepared", ...args: any[]): void
    connect(
      sigName: "notify::seekable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::seekable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::seekable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::seekable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::seekable", ...args: any[]): void
    connect(
      sigName: "notify::seeking",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::seeking",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::seeking",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::seeking",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::seeking", ...args: any[]): void
    connect(
      sigName: "notify::timestamp",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::timestamp",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::timestamp",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::timestamp",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::timestamp", ...args: any[]): void
    connect(
      sigName: "notify::volume",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::volume",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::volume", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkMediaFile` implements `GtkMediaStream` for files.
   *
   * This provides a simple way to play back video files with GTK.
   *
   * GTK provides a GIO extension point for `GtkMediaFile` implementations
   * to allow for external implementations using various media frameworks.
   *
   * GTK itself includes an implementation using GStreamer.
   * @class
   */
  class MediaFile extends MediaStream {
    // Own properties of Gtk-4.0.Gtk.MediaFile

    static name: string

    // Constructors of Gtk-4.0.Gtk.MediaFile

    constructor(config?: MediaFile.ConstructorProperties)
    /**
     * Creates a new empty media file.
     * @constructor
     * @returns a new `GtkMediaFile`
     */
    constructor()
    /**
     * Creates a new empty media file.
     * @constructor
     * @returns a new `GtkMediaFile`
     */
    static new(): MediaFile
    /**
     * Creates a new media file to play `file`.
     * @constructor
     * @param file The file to play
     * @returns a new `GtkMediaFile` playing @file
     */
    static newForFile(file: Gio.File): MediaFile
    /**
     * Creates a new media file for the given filename.
     *
     * This is a utility function that converts the given `filename`
     * to a `GFile` and calls [ctor`Gtk`.MediaFile.new_for_file].
     * @constructor
     * @param filename filename to open
     * @returns a new `GtkMediaFile` playing @filename
     */
    static newForFilename(filename: string): MediaFile
    /**
     * Creates a new media file to play `stream`.
     *
     * If you want the resulting media to be seekable,
     * the stream should implement the `GSeekable` interface.
     * @constructor
     * @param stream The stream to play
     * @returns a new `GtkMediaFile`
     */
    static newForInputStream(stream: Gio.InputStream): MediaFile
    /**
     * Creates a new new media file for the given resource.
     *
     * This is a utility function that converts the given `resource`
     * to a `GFile` and calls [ctor`Gtk`.MediaFile.new_for_file].
     * @constructor
     * @param resourcePath resource path to open
     * @returns a new `GtkMediaFile` playing @resource_path
     */
    static newForResource(resourcePath: string): MediaFile
    _init(config?: MediaFile.ConstructorProperties): void
  }

  module MediaStream {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gdk.Paintable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MediaStream

      /**
       * Try to restart the media from the beginning once it ended.
       */
      loop?: boolean | null
      /**
       * Whether the audio stream should be muted.
       */
      muted?: boolean | null
      /**
       * Whether the stream is currently playing.
       */
      playing?: boolean | null
      /**
       * Whether the stream has finished initializing and existence of
       * audio and video is known.
       */
      prepared?: boolean | null
      /**
       * Volume of the audio stream.
       */
      volume?: number | null
    }
  }

  interface MediaStream extends Gdk.Paintable {
    // Own properties of Gtk-4.0.Gtk.MediaStream

    /**
     * The stream's duration in microseconds or 0 if unknown.
     */
    readonly duration: number
    /**
     * Set when playback has finished.
     */
    readonly ended: boolean
    /**
     * %NULL for a properly working stream or the `GError`
     * that the stream is in.
     */
    readonly error: GLib.Error
    /**
     * Whether the stream contains audio.
     */
    readonly hasAudio: boolean
    /**
     * Whether the stream contains video.
     */
    readonly hasVideo: boolean
    /**
     * Try to restart the media from the beginning once it ended.
     */
    loop: boolean
    /**
     * Whether the audio stream should be muted.
     */
    muted: boolean
    /**
     * Whether the stream is currently playing.
     */
    playing: boolean
    /**
     * Whether the stream has finished initializing and existence of
     * audio and video is known.
     */
    prepared: boolean
    /**
     * Set unless the stream is known to not support seeking.
     */
    readonly seekable: boolean
    /**
     * Set while a seek is in progress.
     */
    readonly seeking: boolean
    /**
     * The current presentation timestamp in microseconds.
     */
    readonly timestamp: number
    /**
     * Volume of the audio stream.
     */
    volume: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.MediaStream

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.MediaStream

    /**
     * Sets `self` into an error state.
     *
     * This will pause the stream (you can check for an error
     * via [method`Gtk`.MediaStream.get_error] in your
     * GtkMediaStream.pause() implementation), abort pending
     * seeks and mark the stream as prepared.
     *
     * if the stream is already in an error state, this call
     * will be ignored and the existing error will be retained.
     *
     * To unset an error, the stream must be reset via a call to
     * [method`Gtk`.MediaStream.unprepared].
     * @param error the `GError` to set
     */
    gerror(error: GLib.Error): void
    /**
     * Gets the duration of the stream.
     *
     * If the duration is not known, 0 will be returned.
     * @returns the duration of the stream or 0 if not known.
     */
    getDuration(): number
    /**
     * Returns whether the streams playback is finished.
     * @returns %TRUE if playback is finished
     */
    getEnded(): boolean
    /**
     * If the stream is in an error state, returns the `GError`
     * explaining that state.
     *
     * Any type of error can be reported here depending on the
     * implementation of the media stream.
     *
     * A media stream in an error cannot be operated on, calls
     * like [method`Gtk`.MediaStream.play] or
     * [method`Gtk`.MediaStream.seek] will not have any effect.
     *
     * `GtkMediaStream` itself does not provide a way to unset
     * an error, but implementations may provide options. For example,
     * a [class`Gtk`.MediaFile] will unset errors when a new source is
     * set, e.g. with [method`Gtk`.MediaFile.set_file].
     * @returns %NULL if not in an   error state or the `GError` of the stream
     */
    getError(): GLib.Error | null
    /**
     * Returns whether the stream is set to loop.
     *
     * See [method`Gtk`.MediaStream.set_loop] for details.
     * @returns %TRUE if the stream should loop
     */
    getLoop(): boolean
    /**
     * Returns whether the audio for the stream is muted.
     *
     * See [method`Gtk`.MediaStream.set_muted] for details.
     * @returns %TRUE if the stream is muted
     */
    getMuted(): boolean
    /**
     * Return whether the stream is currently playing.
     * @returns %TRUE if the stream is playing
     */
    getPlaying(): boolean
    /**
     * Returns the current presentation timestamp in microseconds.
     * @returns the timestamp in microseconds
     */
    getTimestamp(): number
    /**
     * Returns the volume of the audio for the stream.
     *
     * See [method`Gtk`.MediaStream.set_volume] for details.
     * @returns volume of the stream from 0.0 to 1.0
     */
    getVolume(): number
    /**
     * Returns whether the stream has finished initializing.
     *
     * At this point the existence of audio and video is known.
     * @returns %TRUE if the stream is prepared
     */
    isPrepared(): boolean
    /**
     * Checks if a stream may be seekable.
     *
     * This is meant to be a hint. Streams may not allow seeking even if
     * this function returns %TRUE. However, if this function returns
     * %FALSE, streams are guaranteed to not be seekable and user interfaces
     * may hide controls that allow seeking.
     *
     * It is allowed to call [method`Gtk`.MediaStream.seek] on a non-seekable
     * stream, though it will not do anything.
     * @returns %TRUE if the stream may support seeking
     */
    isSeekable(): boolean
    /**
     * Checks if there is currently a seek operation going on.
     * @returns %TRUE if a seek operation is ongoing.
     */
    isSeeking(): boolean
    // Has conflict: pause(): void
    // Has conflict: play(): void
    // Has conflict: realize(surface: Gdk.Surface): void
    // Has conflict: seek(timestamp: number): void
    /**
     * Ends a seek operation started via GtkMediaStream.seek() as a failure.
     *
     * This will not cause an error on the stream and will assume that
     * playback continues as if no seek had happened.
     *
     * See [method`Gtk`.MediaStream.seek_success] for the other way of
     * ending a seek.
     */
    seekFailed(): void
    /**
     * Ends a seek operation started via GtkMediaStream.seek() successfully.
     *
     * This function will unset the GtkMediaStream:ended property
     * if it was set.
     *
     * See [method`Gtk`.MediaStream.seek_failed] for the other way of
     * ending a seek.
     */
    seekSuccess(): void
    /**
     * Sets whether the stream should loop.
     *
     * In this case, it will attempt to restart playback
     * from the beginning instead of stopping at the end.
     *
     * Not all streams may support looping, in particular
     * non-seekable streams. Those streams will ignore the
     * loop setting and just end.
     * @param loop %TRUE if the stream should loop
     */
    setLoop(loop: boolean): void
    /**
     * Sets whether the audio stream should be muted.
     *
     * Muting a stream will cause no audio to be played, but it
     * does not modify the volume. This means that muting and
     * then unmuting the stream will restore the volume settings.
     *
     * If the stream has no audio, calling this function will
     * still work but it will not have an audible effect.
     * @param muted %TRUE if the stream should be muted
     */
    setMuted(muted: boolean): void
    /**
     * Starts or pauses playback of the stream.
     * @param playing whether to start or pause playback
     */
    setPlaying(playing: boolean): void
    /**
     * Sets the volume of the audio stream.
     *
     * This function call will work even if the stream is muted.
     *
     * The given `volume` should range from 0.0 for silence to 1.0
     * for as loud as possible. Values outside of this range will
     * be clamped to the nearest value.
     *
     * If the stream has no audio or is muted, calling this function
     * will still work but it will not have an immediate audible effect.
     * When the stream is unmuted, the new volume setting will take effect.
     * @param volume New volume of the stream from 0.0 to 1.0
     */
    setVolume(volume: number): void
    /**
     * Pauses the media stream and marks it as ended.
     *
     * This is a hint only, calls to [method`Gtk`.MediaStream.play]
     * may still happen.
     *
     * The media stream must be prepared when this function is called.
     */
    streamEnded(): void
    /**
     * Called by `GtkMediaStream` implementations to advertise the stream
     * being ready to play and providing details about the stream.
     *
     * Note that the arguments are hints. If the stream implementation
     * cannot determine the correct values, it is better to err on the
     * side of caution and return %TRUE. User interfaces will use those
     * values to determine what controls to show.
     *
     * This function may not be called again until the stream has been
     * reset via [method`Gtk`.MediaStream.stream_unprepared].
     * @param hasAudio %TRUE if the stream should advertise audio support
     * @param hasVideo %TRUE if the stream should advertise video support
     * @param seekable %TRUE if the stream should advertise seekability
     * @param duration The duration of the stream or 0 if unknown
     */
    streamPrepared(
      hasAudio: boolean,
      hasVideo: boolean,
      seekable: boolean,
      duration: number
    ): void
    /**
     * Resets a given media stream implementation.
     *
     * [method`Gtk`.MediaStream.stream_prepared] can then be called again.
     *
     * This function will also reset any error state the stream was in.
     */
    streamUnprepared(): void
    // Has conflict: unrealize(surface: Gdk.Surface): void
    /**
     * Media stream implementations should regularly call this
     * function to update the timestamp reported by the stream.
     *
     * It is up to implementations to call this at the frequency
     * they deem appropriate.
     *
     * The media stream must be prepared when this function is called.
     * @param timestamp the new timestamp
     */
    update(timestamp: number): void

    // Own virtual methods of Gtk-4.0.Gtk.MediaStream

    /**
     * Pauses playback of the stream.
     *
     * If the stream is not playing, do nothing.
     * @virtual
     */
    pause(): void
    play(): boolean
    /**
     * Called by users to attach the media stream to a `GdkSurface` they manage.
     *
     * The stream can then access the resources of `surface` for its
     * rendering purposes. In particular, media streams might want to
     * create a `GdkGLContext` or sync to the `GdkFrameClock`.
     *
     * Whoever calls this function is responsible for calling
     * [method`Gtk`.MediaStream.unrealize] before either the stream
     * or `surface` get destroyed.
     *
     * Multiple calls to this function may happen from different
     * users of the video, even with the same `surface`. Each of these
     * calls must be followed by its own call to
     * [method`Gtk`.MediaStream.unrealize].
     *
     * It is not required to call this function to make a media stream work.
     * @virtual
     * @param surface a `GdkSurface`
     */
    realize(surface: Gdk.Surface): void
    /**
     * Start a seek operation on `self` to `timestamp`.
     *
     * If `timestamp` is out of range, it will be clamped.
     *
     * Seek operations may not finish instantly. While a
     * seek operation is in process, the [property`Gtk`.MediaStream:seeking]
     * property will be set.
     *
     * When calling gtk_media_stream_seek() during an
     * ongoing seek operation, the new seek will override
     * any pending seek.
     * @virtual
     * @param timestamp timestamp to seek to.
     */
    seek(timestamp: number): void
    /**
     * Undoes a previous call to gtk_media_stream_realize().
     *
     * This causes the stream to release all resources it had
     * allocated from `surface`.
     * @virtual
     * @param surface the `GdkSurface` the stream was realized with
     */
    unrealize(surface: Gdk.Surface): void
    updateAudio(muted: boolean, volume: number): void

    // Class property signals of Gtk-4.0.Gtk.MediaStream

    connect(
      sigName: "notify::duration",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::duration",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::duration",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::duration",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::duration", ...args: any[]): void
    connect(
      sigName: "notify::ended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ended", ...args: any[]): void
    connect(
      sigName: "notify::error",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::error",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::error",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::error",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::error", ...args: any[]): void
    connect(
      sigName: "notify::has-audio",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-audio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-audio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-audio",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-audio", ...args: any[]): void
    connect(
      sigName: "notify::has-video",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-video",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-video",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-video",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-video", ...args: any[]): void
    connect(sigName: "notify::loop", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::loop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::loop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::loop",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::loop", ...args: any[]): void
    connect(
      sigName: "notify::muted",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::muted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::muted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::muted",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::muted", ...args: any[]): void
    connect(
      sigName: "notify::playing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::playing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::playing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::playing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::playing", ...args: any[]): void
    connect(
      sigName: "notify::prepared",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::prepared",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::prepared",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::prepared",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::prepared", ...args: any[]): void
    connect(
      sigName: "notify::seekable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::seekable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::seekable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::seekable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::seekable", ...args: any[]): void
    connect(
      sigName: "notify::seeking",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::seeking",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::seeking",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::seeking",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::seeking", ...args: any[]): void
    connect(
      sigName: "notify::timestamp",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::timestamp",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::timestamp",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::timestamp",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::timestamp", ...args: any[]): void
    connect(
      sigName: "notify::volume",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::volume",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::volume", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkMediaStream` is the integration point for media playback inside GTK.
   *
   * GTK provides an implementation of the `GtkMediaStream` interface that
   * is called [class`Gtk`.MediaFile].
   *
   * Apart from application-facing API for stream playback, `GtkMediaStream`
   * has a number of APIs that are only useful for implementations and should
   * not be used in applications:
   * [method`Gtk`.MediaStream.prepared],
   * [method`Gtk`.MediaStream.unprepared],
   * [method`Gtk`.MediaStream.update],
   * [method`Gtk`.MediaStream.ended],
   * [method`Gtk`.MediaStream.seek_success],
   * [method`Gtk`.MediaStream.seek_failed],
   * [method`Gtk`.MediaStream.gerror],
   * [method`Gtk`.MediaStream.error],
   * [method`Gtk`.MediaStream.error_valist].
   * @class
   */
  class MediaStream extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.MediaStream

    static name: string

    // Constructors of Gtk-4.0.Gtk.MediaStream

    constructor(config?: MediaStream.ConstructorProperties)
    _init(config?: MediaStream.ConstructorProperties): void
  }

  module MenuButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MenuButton

      /**
       * Whether the menu button is active.
       */
      active?: boolean | null
      /**
       * Whether to show a dropdown arrow even when using an icon or a custom child.
       */
      always_show_arrow?: boolean | null
      /**
       * Whether the size of the button can be made smaller than the natural
       * size of its contents.
       */
      can_shrink?: boolean | null
      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * The `GtkArrowType` representing the direction in which the
       * menu or popover will be popped out.
       */
      direction?: ArrowType | null
      /**
       * Whether the button has a frame.
       */
      has_frame?: boolean | null
      /**
       * The name of the icon used to automatically populate the button.
       */
      icon_name?: string | null
      /**
       * The label for the button.
       */
      label?: string | null
      /**
       * The `GMenuModel` from which the popup will be created.
       *
       * See [method`Gtk`.MenuButton.set_menu_model] for the interaction
       * with the [property`Gtk`.MenuButton:popover] property.
       */
      menu_model?: Gio.MenuModel | null
      /**
       * The `GtkPopover` that will be popped up when the button is clicked.
       */
      popover?: Popover | null
      /**
       * Whether the menu button acts as a primary menu.
       *
       * Primary menus can be opened using the <kbd>F10</kbd> key
       */
      primary?: boolean | null
      /**
       * If set an underscore in the text indicates a mnemonic.
       */
      use_underline?: boolean | null
    }
  }

  interface MenuButton extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.MenuButton

    /**
     * Whether the menu button is active.
     */
    active: boolean
    /**
     * Whether to show a dropdown arrow even when using an icon or a custom child.
     */
    alwaysShowArrow: boolean
    /**
     * Whether the size of the button can be made smaller than the natural
     * size of its contents.
     */
    canShrink: boolean
    /**
     * The child widget.
     */
    child: Widget
    /**
     * The `GtkArrowType` representing the direction in which the
     * menu or popover will be popped out.
     */
    direction: ArrowType
    /**
     * Whether the button has a frame.
     */
    hasFrame: boolean
    /**
     * The name of the icon used to automatically populate the button.
     */
    iconName: string | null
    /**
     * The label for the button.
     */
    label: string | null
    /**
     * The `GMenuModel` from which the popup will be created.
     *
     * See [method`Gtk`.MenuButton.set_menu_model] for the interaction
     * with the [property`Gtk`.MenuButton:popover] property.
     */
    menuModel: Gio.MenuModel
    /**
     * The `GtkPopover` that will be popped up when the button is clicked.
     */
    popover: Popover
    /**
     * Whether the menu button acts as a primary menu.
     *
     * Primary menus can be opened using the <kbd>F10</kbd> key
     */
    primary: boolean
    /**
     * If set an underscore in the text indicates a mnemonic.
     */
    useUnderline: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.MenuButton

    /**
     * Returns whether the menu button is active.
     * @returns TRUE if the button is active
     */
    getActive(): boolean
    /**
     * Gets whether to show a dropdown arrow even when using an icon or a custom
     * child.
     * @returns whether to show a dropdown arrow even when using an icon or a custom child.
     */
    getAlwaysShowArrow(): boolean
    /**
     * Retrieves whether the button can be smaller than the natural
     * size of its contents.
     * @returns true if the button can shrink, and false otherwise
     */
    getCanShrink(): boolean
    /**
     * Gets the child widget of `menu_button`.
     * @returns the child widget of @menu_button
     */
    getChild(): Widget | null
    /**
     * Returns the direction the popup will be pointing at when popped up.
     * @returns a `GtkArrowType` value
     */
    getDirection(): ArrowType

    // Overloads of getDirection

    /**
     * Gets the reading direction for a particular widget.
     *
     * See [method`Gtk`.Widget.set_direction].
     * @returns the reading direction for the widget.
     */
    getDirection(): TextDirection
    /**
     * Returns whether the button has a frame.
     * @returns %TRUE if the button has a frame
     */
    getHasFrame(): boolean
    /**
     * Gets the name of the icon shown in the button.
     * @returns the name of the icon shown in the button
     */
    getIconName(): string | null
    /**
     * Gets the label shown in the button
     * @returns the label shown in the button
     */
    getLabel(): string | null
    /**
     * Returns the `GMenuModel` used to generate the popup.
     * @returns a `GMenuModel`
     */
    getMenuModel(): Gio.MenuModel | null
    /**
     * Returns the `GtkPopover` that pops out of the button.
     *
     * If the button is not using a `GtkPopover`, this function
     * returns %NULL.
     * @returns a `GtkPopover` or %NULL
     */
    getPopover(): Popover | null
    /**
     * Returns whether the menu button acts as a primary menu.
     * @returns %TRUE if the button is a primary menu
     */
    getPrimary(): boolean
    /**
     * Returns whether an embedded underline in the text indicates a
     * mnemonic.
     * @returns %TRUE whether an embedded underline in the text indicates   the mnemonic accelerator keys.
     */
    getUseUnderline(): boolean
    /**
     * Dismiss the menu.
     */
    popdown(): void
    /**
     * Pop up the menu.
     */
    popup(): void
    /**
     * Sets whether the menu button is active.
     * @param active whether the menu button is active
     */
    setActive(active: boolean): void
    /**
     * Sets whether to show a dropdown arrow even when using an icon or a custom
     * child.
     * @param alwaysShowArrow whether to show a dropdown arrow even when using an icon or a custom child
     */
    setAlwaysShowArrow(alwaysShowArrow: boolean): void
    /**
     * Sets whether the button size can be smaller than the natural size of
     * its contents.
     *
     * For text buttons, setting `can_shrink` to true will ellipsize the label.
     *
     * For icon buttons, this function has no effect.
     * @param canShrink whether the button can shrink
     */
    setCanShrink(canShrink: boolean): void
    /**
     * Sets the child widget of `menu_button`.
     *
     * Setting a child resets [property`Gtk`.MenuButton:label] and
     * [property`Gtk`.MenuButton:icon-name].
     *
     * If [property`Gtk`.MenuButton:always-show-arrow] is set to `TRUE` and
     * [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown arrow
     * will be shown next to the child.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets `func` to be called when a popup is about to be shown.
     *
     * `func` should use one of
     *
     *  - [method`Gtk`.MenuButton.set_popover]
     *  - [method`Gtk`.MenuButton.set_menu_model]
     *
     * to set a popup for `menu_button`.
     * If `func` is non-%NULL, `menu_button` will always be sensitive.
     *
     * Using this function will not reset the menu widget attached to
     * `menu_button`. Instead, this can be done manually in `func`.
     * @param func function to call when a popup is about to   be shown, but none has been provided via other means, or %NULL   to reset to default behavior.
     */
    setCreatePopupFunc(func: MenuButtonCreatePopupFunc | null): void
    /**
     * Sets the direction in which the popup will be popped up.
     *
     * If the button is automatically populated with an arrow icon,
     * its direction will be changed to match.
     *
     * If the does not fit in the available space in the given direction,
     * GTK will its best to keep it inside the screen and fully visible.
     *
     * If you pass %GTK_ARROW_NONE for a `direction,` the popup will behave
     * as if you passed %GTK_ARROW_DOWN (although you won’t see any arrows).
     * @param direction a `GtkArrowType`
     */
    setDirection(direction: ArrowType): void

    // Overloads of setDirection

    /**
     * Sets the reading direction on a particular widget.
     *
     * This direction controls the primary direction for widgets
     * containing text, and also the direction in which the children
     * of a container are packed. The ability to set the direction is
     * present in order so that correct localization into languages with
     * right-to-left reading directions can be done. Generally, applications
     * will let the default reading direction present, except for containers
     * where the containers are arranged in an order that is explicitly
     * visual rather than logical (such as buttons for text justification).
     *
     * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
     * set by [func`Gtk`.Widget.set_default_direction] will be used.
     * @param dir the new direction
     */
    setDirection(dir: TextDirection): void
    /**
     * Sets the style of the button.
     * @param hasFrame whether the button should have a visible frame
     */
    setHasFrame(hasFrame: boolean): void
    /**
     * Sets the name of an icon to show inside the menu button.
     *
     * Setting icon name resets [property`Gtk`.MenuButton:label] and
     * [property`Gtk`.MenuButton:child].
     *
     * If [property`Gtk`.MenuButton:always-show-arrow] is set to `TRUE` and
     * [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown arrow
     * will be shown next to the icon.
     * @param iconName the icon name
     */
    setIconName(iconName: string): void
    /**
     * Sets the label to show inside the menu button.
     *
     * Setting a label resets [property`Gtk`.MenuButton:icon-name] and
     * [property`Gtk`.MenuButton:child].
     *
     * If [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown
     * arrow will be shown next to the label.
     * @param label the label
     */
    setLabel(label: string): void
    /**
     * Sets the `GMenuModel` from which the popup will be constructed.
     *
     * If `menu_model` is %NULL, the button is disabled.
     *
     * A [class`Gtk`.Popover] will be created from the menu model with
     * [ctor`Gtk`.PopoverMenu.new_from_model]. Actions will be connected
     * as documented for this function.
     *
     * If [property`Gtk`.MenuButton:popover] is already set, it will be
     * dissociated from the `menu_button,` and the property is set to %NULL.
     * @param menuModel a `GMenuModel`, or %NULL to unset and disable the   button
     */
    setMenuModel(menuModel: Gio.MenuModel | null): void
    /**
     * Sets the `GtkPopover` that will be popped up when the `menu_button` is clicked.
     *
     * If `popover` is %NULL, the button is disabled.
     *
     * If [property`Gtk`.MenuButton:menu-model] is set, the menu model is dissociated
     * from the `menu_button,` and the property is set to %NULL.
     * @param popover a `GtkPopover`, or %NULL to unset and disable the button
     */
    setPopover(popover: Widget | null): void
    /**
     * Sets whether menu button acts as a primary menu.
     *
     * Primary menus can be opened with the <kbd>F10</kbd> key.
     * @param primary whether the menubutton should act as a primary menu
     */
    setPrimary(primary: boolean): void
    /**
     * If true, an underline in the text indicates a mnemonic.
     * @param useUnderline %TRUE if underlines in the text indicate mnemonics
     */
    setUseUnderline(useUnderline: boolean): void

    // Own signals of Gtk-4.0.Gtk.MenuButton

    connect(
      sigName: "activate",
      callback: MenuButton.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: MenuButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: MenuButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: MenuButton.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.MenuButton

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::always-show-arrow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::always-show-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::always-show-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::always-show-arrow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::always-show-arrow", ...args: any[]): void
    connect(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-shrink", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::direction", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::menu-model", ...args: any[]): void
    connect(
      sigName: "notify::popover",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::popover",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::popover",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::popover",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::popover", ...args: any[]): void
    connect(
      sigName: "notify::primary",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::primary",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::primary",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::primary",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::primary", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkMenuButton` widget is used to display a popup when clicked.
   *
   * ![An example GtkMenuButton](menu-button.png)
   *
   * This popup can be provided either as a `GtkPopover` or as an abstract
   * `GMenuModel`.
   *
   * The `GtkMenuButton` widget can show either an icon (set with the
   * [property`Gtk`.MenuButton:icon-name] property) or a label (set with the
   * [property`Gtk`.MenuButton:label] property). If neither is explicitly set,
   * a [class`Gtk`.Image] is automatically created, using an arrow image oriented
   * according to [property`Gtk`.MenuButton:direction] or the generic
   * “open-menu-symbolic” icon if the direction is not set.
   *
   * The positioning of the popup is determined by the
   * [property`Gtk`.MenuButton:direction] property of the menu button.
   *
   * For menus, the [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
   * properties of the menu are also taken into account. For example, when the
   * direction is %GTK_ARROW_DOWN and the horizontal alignment is %GTK_ALIGN_START,
   * the menu will be positioned below the button, with the starting edge
   * (depending on the text direction) of the menu aligned with the starting
   * edge of the button. If there is not enough space below the button, the
   * menu is popped up above the button instead. If the alignment would move
   * part of the menu offscreen, it is “pushed in”.
   *
   * |           | start                | center                | end                |
   * | -         | ---                  | ---                   | ---                |
   * | **down**  | ![](down-start.png)  | ![](down-center.png)  | ![](down-end.png)  |
   * | **up**    | ![](up-start.png)    | ![](up-center.png)    | ![](up-end.png)    |
   * | **left**  | ![](left-start.png)  | ![](left-center.png)  | ![](left-end.png)  |
   * | **right** | ![](right-start.png) | ![](right-center.png) | ![](right-end.png) |
   *
   * # CSS nodes
   *
   * ```
   * menubutton
   * ╰── button.toggle
   *     ╰── <content>
   *          ╰── [arrow]
   * ```
   *
   * `GtkMenuButton` has a single CSS node with name `menubutton`
   * which contains a `button` node with a `.toggle` style class.
   *
   * If the button contains an icon, it will have the `.image-button` style class,
   * if it contains text, it will have `.text-button` style class. If an arrow is
   * visible in addition to an icon, text or a custom child, it will also have
   * `.arrow-button` style class.
   *
   * Inside the toggle button content, there is an `arrow` node for
   * the indicator, which will carry one of the `.none`, `.up`, `.down`,
   * `.left` or `.right` style classes to indicate the direction that
   * the menu will appear in. The CSS is expected to provide a suitable
   * image for each of these cases using the `-gtk-icon-source` property.
   *
   * Optionally, the `menubutton` node can carry the `.circular` style class
   * to request a round appearance.
   *
   * # Accessibility
   *
   * `GtkMenuButton` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
   * @class
   */
  class MenuButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.MenuButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.MenuButton

    constructor(config?: MenuButton.ConstructorProperties)
    /**
     * Creates a new `GtkMenuButton` widget with downwards-pointing
     * arrow as the only child.
     *
     * You can replace the child widget with another `GtkWidget`
     * should you wish to.
     * @constructor
     * @returns The newly created `GtkMenuButton`
     */
    constructor()
    /**
     * Creates a new `GtkMenuButton` widget with downwards-pointing
     * arrow as the only child.
     *
     * You can replace the child widget with another `GtkWidget`
     * should you wish to.
     * @constructor
     * @returns The newly created `GtkMenuButton`
     */
    static new(): MenuButton
    _init(config?: MenuButton.ConstructorProperties): void
  }

  module MessageDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Dialog.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MessageDialog

      buttons?: ButtonsType | null
      /**
       * The type of the message.
       */
      message_type?: MessageType | null
      /**
       * The secondary text of the message dialog.
       */
      secondary_text?: string | null
      /**
       * %TRUE if the secondary text of the dialog includes Pango markup.
       *
       * See [func`Pango`.parse_markup].
       */
      secondary_use_markup?: boolean | null
      /**
       * The primary text of the message dialog.
       *
       * If the dialog has a secondary text, this will appear as the title.
       */
      text?: string | null
      /**
       * %TRUE if the primary text of the dialog includes Pango markup.
       *
       * See [func`Pango`.parse_markup].
       */
      use_markup?: boolean | null
    }
  }

  interface MessageDialog
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.MessageDialog

    readonly buttons: ButtonsType
    /**
     * The `GtkBox` that corresponds to the message area of this dialog.
     *
     * See [method`Gtk`.MessageDialog.get_message_area] for a detailed
     * description of this area.
     */
    readonly messageArea: Widget
    /**
     * The type of the message.
     */
    messageType: MessageType
    /**
     * The secondary text of the message dialog.
     */
    secondaryText: string | null
    /**
     * %TRUE if the secondary text of the dialog includes Pango markup.
     *
     * See [func`Pango`.parse_markup].
     */
    secondaryUseMarkup: boolean
    /**
     * The primary text of the message dialog.
     *
     * If the dialog has a secondary text, this will appear as the title.
     */
    text: string | null
    /**
     * %TRUE if the primary text of the dialog includes Pango markup.
     *
     * See [func`Pango`.parse_markup].
     */
    useMarkup: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.MessageDialog

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.MessageDialog

    /**
     * Returns the message area of the dialog.
     *
     * This is the box where the dialog’s primary and secondary labels
     * are packed. You can add your own extra content to that box and it
     * will appear below those labels. See [method`Gtk`.Dialog.get_content_area]
     * for the corresponding function in the parent [class`Gtk`.Dialog].
     * @returns A `GtkBox` corresponding to the   “message area” in the @message_dialog
     */
    getMessageArea(): Widget
    /**
     * Sets the text of the message dialog.
     * @param str string with Pango markup
     */
    setMarkup(str: string): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void
    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @virtual
     */
    close(): void

    // Overloads of close

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void

    // Class property signals of Gtk-4.0.Gtk.MessageDialog

    connect(
      sigName: "notify::buttons",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::buttons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::buttons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::buttons",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::buttons", ...args: any[]): void
    connect(
      sigName: "notify::message-area",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::message-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::message-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::message-area",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::message-area", ...args: any[]): void
    connect(
      sigName: "notify::message-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::message-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::message-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::message-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::message-type", ...args: any[]): void
    connect(
      sigName: "notify::secondary-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-text", ...args: any[]): void
    connect(
      sigName: "notify::secondary-use-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::secondary-use-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::secondary-use-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::secondary-use-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::secondary-use-markup", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-markup", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkMessageDialog` presents a dialog with some message text.
   *
   * ![An example GtkMessageDialog](messagedialog.png)
   *
   * It’s simply a convenience widget; you could construct the equivalent of
   * `GtkMessageDialog` from `GtkDialog` without too much effort, but
   * `GtkMessageDialog` saves typing.
   *
   * The easiest way to do a modal message dialog is to use the %GTK_DIALOG_MODAL
   * flag, which will call [method`Gtk`.Window.set_modal] internally. The dialog will
   * prevent interaction with the parent window until it's hidden or destroyed.
   * You can use the [signal`Gtk`.Dialog::response] signal to know when the user
   * dismissed the dialog.
   *
   * An example for using a modal dialog:
   * ```c
   * GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL;
   * dialog = gtk_message_dialog_new (parent_window,
   *                                  flags,
   *                                  GTK_MESSAGE_ERROR,
   *                                  GTK_BUTTONS_CLOSE,
   *                                  "Error reading “%s”: %s",
   *                                  filename,
   *                                  g_strerror (errno));
   * // Destroy the dialog when the user responds to it
   * // (e.g. clicks a button)
   *
   * g_signal_connect (dialog, "response",
   *                   G_CALLBACK (gtk_window_destroy),
   *                   NULL);
   * ```
   *
   * You might do a non-modal `GtkMessageDialog` simply by omitting the
   * %GTK_DIALOG_MODAL flag:
   *
   * ```c
   * GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
   * dialog = gtk_message_dialog_new (parent_window,
   *                                  flags,
   *                                  GTK_MESSAGE_ERROR,
   *                                  GTK_BUTTONS_CLOSE,
   *                                  "Error reading “%s”: %s",
   *                                  filename,
   *                                  g_strerror (errno));
   *
   * // Destroy the dialog when the user responds to it
   * // (e.g. clicks a button)
   * g_signal_connect (dialog, "response",
   *                   G_CALLBACK (gtk_window_destroy),
   *                   NULL);
   * ```
   *
   * # GtkMessageDialog as GtkBuildable
   *
   * The `GtkMessageDialog` implementation of the `GtkBuildable` interface exposes
   * the message area as an internal child with the name “message_area”.
   * @class
   */
  class MessageDialog extends Dialog {
    // Own properties of Gtk-4.0.Gtk.MessageDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.MessageDialog

    constructor(config?: MessageDialog.ConstructorProperties)
    _init(config?: MessageDialog.ConstructorProperties): void
  }

  module MnemonicAction {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutAction.ConstructorProperties {}
  }

  interface MnemonicAction {
    // Own properties of Gtk-4.0.Gtk.MnemonicAction

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.MnemonicAction

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutAction` that calls gtk_widget_mnemonic_activate().
   * @class
   */
  class MnemonicAction extends ShortcutAction {
    // Own properties of Gtk-4.0.Gtk.MnemonicAction

    static name: string

    // Constructors of Gtk-4.0.Gtk.MnemonicAction

    constructor(config?: MnemonicAction.ConstructorProperties)
    _init(config?: MnemonicAction.ConstructorProperties): void
    /**
     * Gets the mnemonic action.
     *
     * This is an action that calls gtk_widget_mnemonic_activate()
     * on the given widget upon activation.
     * @returns The mnemonic action
     */
    static get(): MnemonicAction
  }

  module MnemonicTrigger {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutTrigger.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MnemonicTrigger

      /**
       * The key value for the trigger.
       */
      keyval?: number | null
    }
  }

  interface MnemonicTrigger {
    // Own properties of Gtk-4.0.Gtk.MnemonicTrigger

    /**
     * The key value for the trigger.
     */
    readonly keyval: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.MnemonicTrigger

    /**
     * Gets the keyval that must be pressed to succeed triggering `self`.
     * @returns the keyval
     */
    getKeyval(): number

    // Class property signals of Gtk-4.0.Gtk.MnemonicTrigger

    connect(
      sigName: "notify::keyval",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::keyval",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::keyval",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::keyval",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::keyval", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutTrigger` that triggers when a specific mnemonic is pressed.
   *
   * Mnemonics require a *mnemonic modifier* (typically <kbd>Alt</kbd>) to be
   * pressed together with the mnemonic key.
   * @class
   */
  class MnemonicTrigger extends ShortcutTrigger {
    // Own properties of Gtk-4.0.Gtk.MnemonicTrigger

    static name: string

    // Constructors of Gtk-4.0.Gtk.MnemonicTrigger

    constructor(config?: MnemonicTrigger.ConstructorProperties)
    /**
     * Creates a `GtkShortcutTrigger` that will trigger whenever the key with
     * the given `keyval` is pressed and mnemonics have been activated.
     *
     * Mnemonics are activated by calling code when a key event with the right
     * modifiers is detected.
     * @constructor
     * @param keyval The keyval to trigger for
     * @returns A new `GtkShortcutTrigger`
     */
    constructor(keyval: number)
    /**
     * Creates a `GtkShortcutTrigger` that will trigger whenever the key with
     * the given `keyval` is pressed and mnemonics have been activated.
     *
     * Mnemonics are activated by calling code when a key event with the right
     * modifiers is detected.
     * @constructor
     * @param keyval The keyval to trigger for
     * @returns A new `GtkShortcutTrigger`
     */
    static new(keyval: number): MnemonicTrigger
    _init(config?: MnemonicTrigger.ConstructorProperties): void
  }

  module MountOperation {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.MountOperation.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MountOperation

      /**
       * The display where dialogs will be shown.
       */
      display?: Gdk.Display | null
      /**
       * The parent window.
       */
      parent?: Window | null
    }
  }

  interface MountOperation {
    // Own properties of Gtk-4.0.Gtk.MountOperation

    /**
     * The display where dialogs will be shown.
     */
    display: Gdk.Display
    /**
     * Whether a dialog is currently shown.
     */
    readonly isShowing: boolean
    /**
     * The parent window.
     */
    parent: Window
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.MountOperation

    parentInstance: any
    priv: any

    // Owm methods of Gtk-4.0.Gtk.MountOperation

    /**
     * Gets the display on which windows of the `GtkMountOperation`
     * will be shown.
     * @returns the display on which windows of @op are shown
     */
    getDisplay(): Gdk.Display
    /**
     * Gets the transient parent used by the `GtkMountOperation`.
     * @returns the transient parent for windows shown by @op
     */
    getParent(): Window | null
    /**
     * Sets the display to show windows of the `GtkMountOperation` on.
     * @param display a `GdkDisplay`
     */
    setDisplay(display: Gdk.Display): void
    /**
     * Sets the transient parent for windows shown by the
     * `GtkMountOperation`.
     * @param parent transient parent of the window
     */
    setParent(parent: Window | null): void

    // Class property signals of Gtk-4.0.Gtk.MountOperation

    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::is-showing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-showing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-showing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-showing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-showing", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::anonymous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::anonymous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::anonymous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::anonymous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::anonymous", ...args: any[]): void
    connect(
      sigName: "notify::choice",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::choice",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::choice",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::choice",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::choice", ...args: any[]): void
    connect(
      sigName: "notify::domain",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::domain",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::domain",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::domain",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::domain", ...args: any[]): void
    connect(
      sigName: "notify::is-tcrypt-hidden-volume",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-tcrypt-hidden-volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-tcrypt-hidden-volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-tcrypt-hidden-volume",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-tcrypt-hidden-volume", ...args: any[]): void
    connect(
      sigName: "notify::is-tcrypt-system-volume",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-tcrypt-system-volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-tcrypt-system-volume",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-tcrypt-system-volume",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-tcrypt-system-volume", ...args: any[]): void
    connect(
      sigName: "notify::password",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::password",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::password",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::password",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::password", ...args: any[]): void
    connect(
      sigName: "notify::password-save",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::password-save",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::password-save",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::password-save",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::password-save", ...args: any[]): void
    connect(sigName: "notify::pim", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::pim",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pim",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pim",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pim", ...args: any[]): void
    connect(
      sigName: "notify::username",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::username",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::username",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::username",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::username", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkMountOperation` is an implementation of `GMountOperation`.
   *
   * The functions and objects described here make working with GTK and
   * GIO more convenient.
   *
   * `GtkMountOperation` is needed when mounting volumes:
   * It is an implementation of `GMountOperation` that can be used with
   * GIO functions for mounting volumes such as
   * g_file_mount_enclosing_volume(), g_file_mount_mountable(),
   * g_volume_mount(), g_mount_unmount_with_operation() and others.
   *
   * When necessary, `GtkMountOperation` shows dialogs to let the user
   * enter passwords, ask questions or show processes blocking unmount.
   * @class
   */
  class MountOperation extends Gio.MountOperation {
    // Own properties of Gtk-4.0.Gtk.MountOperation

    static name: string

    // Constructors of Gtk-4.0.Gtk.MountOperation

    constructor(config?: MountOperation.ConstructorProperties)
    /**
     * Creates a new `GtkMountOperation`.
     * @constructor
     * @param parent transient parent of the window
     * @returns a new `GtkMountOperation`
     */
    constructor(parent: Window | null)
    /**
     * Creates a new `GtkMountOperation`.
     * @constructor
     * @param parent transient parent of the window
     * @returns a new `GtkMountOperation`
     */
    static new(parent: Window | null): MountOperation

    // Overloads of new

    /**
     * Creates a new mount operation.
     * @constructor
     * @returns a #GMountOperation.
     */
    static new(): Gio.MountOperation
    _init(config?: MountOperation.ConstructorProperties): void
  }

  module MultiFilter {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        Buildable.ConstructorProperties,
        Filter.ConstructorProperties {}
  }

  interface MultiFilter extends Gio.ListModel, Buildable {
    // Own properties of Gtk-4.0.Gtk.MultiFilter

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.MultiFilter

    /**
     * Adds a `filter` to `self` to use for matching.
     * @param filter A new filter to use
     */
    append(filter: Filter): void
    /**
     * Removes the filter at the given `position` from the list of filters used
     * by `self`.
     *
     * If `position` is larger than the number of filters, nothing happens and
     * the function returns.
     * @param position position of filter to remove
     */
    remove(position: number): void

    // Class property signals of Gtk-4.0.Gtk.MultiFilter

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkMultiFilter` is the base class for filters that combine multiple filters.
   * @class
   */
  class MultiFilter extends Filter {
    // Own properties of Gtk-4.0.Gtk.MultiFilter

    static name: string

    // Constructors of Gtk-4.0.Gtk.MultiFilter

    constructor(config?: MultiFilter.ConstructorProperties)
    _init(config?: MultiFilter.ConstructorProperties): void
  }

  module MultiSelection {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        SectionModel.ConstructorProperties,
        SelectionModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.MultiSelection

      /**
       * The list managed by this selection.
       */
      model?: Gio.ListModel | null
    }
  }

  interface MultiSelection extends Gio.ListModel, SectionModel, SelectionModel {
    // Own properties of Gtk-4.0.Gtk.MultiSelection

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The list managed by this selection.
     */
    model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.MultiSelection

    /**
     * Returns the underlying model of `self`.
     * @returns the underlying model
     */
    getModel(): Gio.ListModel | null
    /**
     * Sets the model that `self` should wrap.
     *
     * If `model` is %NULL, `self` will be empty.
     * @param model A `GListModel` to wrap
     */
    setModel(model: Gio.ListModel | null): void

    // Class property signals of Gtk-4.0.Gtk.MultiSelection

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkMultiSelection` is a `GtkSelectionModel` that allows selecting multiple
   * elements.
   * @class
   */
  class MultiSelection extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.MultiSelection

    static name: string

    // Constructors of Gtk-4.0.Gtk.MultiSelection

    constructor(config?: MultiSelection.ConstructorProperties)
    /**
     * Creates a new selection to handle `model`.
     * @constructor
     * @param model the `GListModel` to manage
     * @returns a new `GtkMultiSelection`
     */
    constructor(model: Gio.ListModel | null)
    /**
     * Creates a new selection to handle `model`.
     * @constructor
     * @param model the `GListModel` to manage
     * @returns a new `GtkMultiSelection`
     */
    static new(model: Gio.ListModel | null): MultiSelection
    _init(config?: MultiSelection.ConstructorProperties): void
  }

  module MultiSorter {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        Buildable.ConstructorProperties,
        Sorter.ConstructorProperties {}
  }

  interface MultiSorter extends Gio.ListModel, Buildable {
    // Own properties of Gtk-4.0.Gtk.MultiSorter

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.MultiSorter

    /**
     * Add `sorter` to `self` to use for sorting at the end.
     *
     * `self` will consult all existing sorters before it will
     * sort with the given `sorter`.
     * @param sorter a sorter to add
     */
    append(sorter: Sorter): void
    /**
     * Removes the sorter at the given `position` from the list of sorter
     * used by `self`.
     *
     * If `position` is larger than the number of sorters, nothing happens.
     * @param position position of sorter to remove
     */
    remove(position: number): void

    // Class property signals of Gtk-4.0.Gtk.MultiSorter

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkMultiSorter` combines multiple sorters by trying them
   * in turn.
   *
   * If the first sorter compares two items as equal,
   * the second is tried next, and so on.
   * @class
   */
  class MultiSorter extends Sorter {
    // Own properties of Gtk-4.0.Gtk.MultiSorter

    static name: string

    // Constructors of Gtk-4.0.Gtk.MultiSorter

    constructor(config?: MultiSorter.ConstructorProperties)
    /**
     * Creates a new multi sorter.
     *
     * This sorter compares items by trying each of the sorters
     * in turn, until one returns non-zero. In particular, if
     * no sorter has been added to it, it will always compare
     * items as equal.
     * @constructor
     * @returns a new `GtkMultiSorter`
     */
    constructor()
    /**
     * Creates a new multi sorter.
     *
     * This sorter compares items by trying each of the sorters
     * in turn, until one returns non-zero. In particular, if
     * no sorter has been added to it, it will always compare
     * items as equal.
     * @constructor
     * @returns a new `GtkMultiSorter`
     */
    static new(): MultiSorter
    _init(config?: MultiSorter.ConstructorProperties): void
  }

  module NamedAction {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutAction.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.NamedAction

      /**
       * The name of the action to activate.
       */
      action_name?: string | null
    }
  }

  interface NamedAction {
    // Own properties of Gtk-4.0.Gtk.NamedAction

    /**
     * The name of the action to activate.
     */
    readonly actionName: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.NamedAction

    /**
     * Returns the name of the action that will be activated.
     * @returns the name of the action to activate
     */
    getActionName(): string

    // Class property signals of Gtk-4.0.Gtk.NamedAction

    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutAction` that activates an action by name.
   * @class
   */
  class NamedAction extends ShortcutAction {
    // Own properties of Gtk-4.0.Gtk.NamedAction

    static name: string

    // Constructors of Gtk-4.0.Gtk.NamedAction

    constructor(config?: NamedAction.ConstructorProperties)
    /**
     * Creates an action that when activated, activates
     * the named action on the widget.
     *
     * It also passes the given arguments to it.
     *
     * See [method`Gtk`.Widget.insert_action_group] for
     * how to add actions to widgets.
     * @constructor
     * @param name the detailed name of the action
     * @returns a new `GtkShortcutAction`
     */
    constructor(name: string)
    /**
     * Creates an action that when activated, activates
     * the named action on the widget.
     *
     * It also passes the given arguments to it.
     *
     * See [method`Gtk`.Widget.insert_action_group] for
     * how to add actions to widgets.
     * @constructor
     * @param name the detailed name of the action
     * @returns a new `GtkShortcutAction`
     */
    static new(name: string): NamedAction
    _init(config?: NamedAction.ConstructorProperties): void
  }

  module NativeDialog {
    // Signal callback interfaces

    /**
     * Signal callback interface for `response`
     */
    interface ResponseSignalCallback {
      (responseId: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.NativeDialog

      /**
       * Whether the window should be modal with respect to its transient parent.
       */
      modal?: boolean | null
      /**
       * The title of the dialog window
       */
      title?: string | null
      /**
       * The transient parent of the dialog, or %NULL for none.
       */
      transient_for?: Window | null
      /**
       * Whether the window is currently visible.
       */
      visible?: boolean | null
    }
  }

  interface NativeDialog {
    // Own properties of Gtk-4.0.Gtk.NativeDialog

    /**
     * Whether the window should be modal with respect to its transient parent.
     */
    modal: boolean
    /**
     * The title of the dialog window
     */
    title: string | null
    /**
     * The transient parent of the dialog, or %NULL for none.
     */
    transientFor: Window
    /**
     * Whether the window is currently visible.
     */
    visible: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.NativeDialog

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.NativeDialog

    /**
     * Destroys a dialog.
     *
     * When a dialog is destroyed, it will break any references it holds
     * to other objects.
     *
     * If it is visible it will be hidden and any underlying window system
     * resources will be destroyed.
     *
     * Note that this does not release any reference to the object (as opposed
     * to destroying a `GtkWindow`) because there is no reference from the
     * windowing system to the `GtkNativeDialog`.
     */
    destroy(): void
    /**
     * Returns whether the dialog is modal.
     * @returns %TRUE if the dialog is set to be modal
     */
    getModal(): boolean
    /**
     * Gets the title of the `GtkNativeDialog`.
     * @returns the title of the dialog, or %NULL if none has    been set explicitly. The returned string is owned by the widget    and must not be modified or freed.
     */
    getTitle(): string | null
    /**
     * Fetches the transient parent for this window.
     * @returns the transient parent for this window,   or %NULL if no transient parent has been set.
     */
    getTransientFor(): Window | null
    /**
     * Determines whether the dialog is visible.
     * @returns %TRUE if the dialog is visible
     */
    getVisible(): boolean
    // Has conflict: hide(): void
    /**
     * Sets a dialog modal or non-modal.
     *
     * Modal dialogs prevent interaction with other windows in the same
     * application. To keep modal dialogs on top of main application
     * windows, use [method`Gtk`.NativeDialog.set_transient_for] to make
     * the dialog transient for the parent; most window managers will
     * then disallow lowering the dialog below the parent.
     * @param modal whether the window is modal
     */
    setModal(modal: boolean): void
    /**
     * Sets the title of the `GtkNativeDialog.`
     * @param title title of the dialog
     */
    setTitle(title: string): void
    /**
     * Dialog windows should be set transient for the main application
     * window they were spawned from.
     *
     * This allows window managers to e.g. keep the dialog on top of the
     * main window, or center the dialog over the main window.
     *
     * Passing %NULL for `parent` unsets the current transient window.
     * @param parent parent window
     */
    setTransientFor(parent: Window | null): void
    // Has conflict: show(): void

    // Own virtual methods of Gtk-4.0.Gtk.NativeDialog

    /**
     * Hides the dialog if it is visible, aborting any interaction.
     *
     * Once this is called the [signal`Gtk`.NativeDialog::response] signal
     * will *not* be emitted until after the next call to
     * [method`Gtk`.NativeDialog.show].
     *
     * If the dialog is not visible this does nothing.
     * @virtual
     */
    hide(): void
    /**
     * class handler for the `GtkNativeDialog::response` signal
     * @virtual
     * @param responseId
     */
    response(responseId: number): void
    /**
     * Shows the dialog on the display.
     *
     * When the user accepts the state of the dialog the dialog will
     * be automatically hidden and the [signal`Gtk`.NativeDialog::response]
     * signal will be emitted.
     *
     * Multiple calls while the dialog is visible will be ignored.
     * @virtual
     */
    show(): void

    // Own signals of Gtk-4.0.Gtk.NativeDialog

    connect(
      sigName: "response",
      callback: NativeDialog.ResponseSignalCallback
    ): number
    on(
      sigName: "response",
      callback: NativeDialog.ResponseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "response",
      callback: NativeDialog.ResponseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "response",
      callback: NativeDialog.ResponseSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "response", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.NativeDialog

    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Native dialogs are platform dialogs that don't use `GtkDialog`.
   *
   * They are used in order to integrate better with a platform, by
   * looking the same as other native applications and supporting
   * platform specific features.
   *
   * The [class`Gtk`.Dialog] functions cannot be used on such objects,
   * but we need a similar API in order to drive them. The `GtkNativeDialog`
   * object is an API that allows you to do this. It allows you to set
   * various common properties on the dialog, as well as show and hide
   * it and get a [signal`Gtk`.NativeDialog::response] signal when the user
   * finished with the dialog.
   *
   * Note that unlike `GtkDialog`, `GtkNativeDialog` objects are not
   * toplevel widgets, and GTK does not keep them alive. It is your
   * responsibility to keep a reference until you are done with the
   * object.
   * @class
   */
  class NativeDialog extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.NativeDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.NativeDialog

    constructor(config?: NativeDialog.ConstructorProperties)
    _init(config?: NativeDialog.ConstructorProperties): void
  }

  module NeverTrigger {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutTrigger.ConstructorProperties {}
  }

  interface NeverTrigger {
    // Own properties of Gtk-4.0.Gtk.NeverTrigger

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.NeverTrigger

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutTrigger` that never triggers.
   * @class
   */
  class NeverTrigger extends ShortcutTrigger {
    // Own properties of Gtk-4.0.Gtk.NeverTrigger

    static name: string

    // Constructors of Gtk-4.0.Gtk.NeverTrigger

    constructor(config?: NeverTrigger.ConstructorProperties)
    _init(config?: NeverTrigger.ConstructorProperties): void
    /**
     * Gets the never trigger.
     *
     * This is a singleton for a trigger that never triggers.
     * Use this trigger instead of %NULL because it implements
     * all virtual functions.
     * @returns The never trigger
     */
    static get(): NeverTrigger
  }

  module NoSelection {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        SectionModel.ConstructorProperties,
        SelectionModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.NoSelection

      /**
       * The model being managed.
       */
      model?: Gio.ListModel | null
    }
  }

  interface NoSelection extends Gio.ListModel, SectionModel, SelectionModel {
    // Own properties of Gtk-4.0.Gtk.NoSelection

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The model being managed.
     */
    model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.NoSelection

    /**
     * Gets the model that `self` is wrapping.
     * @returns The model being wrapped
     */
    getModel(): Gio.ListModel | null
    /**
     * Sets the model that `self` should wrap.
     *
     * If `model` is %NULL, this model will be empty.
     * @param model A `GListModel` to wrap
     */
    setModel(model: Gio.ListModel | null): void

    // Class property signals of Gtk-4.0.Gtk.NoSelection

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkNoSelection` is a `GtkSelectionModel` that does not allow selecting
   * anything.
   *
   * This model is meant to be used as a simple wrapper around a `GListModel`
   * when a `GtkSelectionModel` is required.
   *
   * `GtkNoSelection` passes through sections from the underlying model.
   * @class
   */
  class NoSelection extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.NoSelection

    static name: string

    // Constructors of Gtk-4.0.Gtk.NoSelection

    constructor(config?: NoSelection.ConstructorProperties)
    /**
     * Creates a new selection to handle `model`.
     * @constructor
     * @param model the `GListModel` to manage
     * @returns a new `GtkNoSelection`
     */
    constructor(model: Gio.ListModel | null)
    /**
     * Creates a new selection to handle `model`.
     * @constructor
     * @param model the `GListModel` to manage
     * @returns a new `GtkNoSelection`
     */
    static new(model: Gio.ListModel | null): NoSelection
    _init(config?: NoSelection.ConstructorProperties): void
  }

  module Notebook {
    // Signal callback interfaces

    /**
     * Signal callback interface for `change-current-page`
     */
    interface ChangeCurrentPageSignalCallback {
      (object: number): boolean
    }

    /**
     * Signal callback interface for `create-window`
     */
    interface CreateWindowSignalCallback {
      (page: Widget): Notebook | null
    }

    /**
     * Signal callback interface for `focus-tab`
     */
    interface FocusTabSignalCallback {
      (object: NotebookTab): boolean
    }

    /**
     * Signal callback interface for `move-focus-out`
     */
    interface MoveFocusOutSignalCallback {
      (object: DirectionType): void
    }

    /**
     * Signal callback interface for `page-added`
     */
    interface PageAddedSignalCallback {
      (child: Widget, pageNum: number): void
    }

    /**
     * Signal callback interface for `page-removed`
     */
    interface PageRemovedSignalCallback {
      (child: Widget, pageNum: number): void
    }

    /**
     * Signal callback interface for `page-reordered`
     */
    interface PageReorderedSignalCallback {
      (child: Widget, pageNum: number): void
    }

    /**
     * Signal callback interface for `reorder-tab`
     */
    interface ReorderTabSignalCallback {
      (object: DirectionType, p0: boolean): boolean
    }

    /**
     * Signal callback interface for `select-page`
     */
    interface SelectPageSignalCallback {
      (object: boolean): boolean
    }

    /**
     * Signal callback interface for `switch-page`
     */
    interface SwitchPageSignalCallback {
      (page: Widget, pageNum: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Notebook

      /**
       * If %TRUE, pressing the right mouse button on the notebook shows a page switching menu.
       */
      enable_popup?: boolean | null
      /**
       * Group name for tab drag and drop.
       */
      group_name?: string | null
      /**
       * The index of the current page.
       */
      page?: number | null
      /**
       * If %TRUE, scroll arrows are added if there are too many pages to fit.
       */
      scrollable?: boolean | null
      /**
       * Whether the border should be shown.
       */
      show_border?: boolean | null
      /**
       * Whether tabs should be shown.
       */
      show_tabs?: boolean | null
      /**
       * Which side of the notebook holds the tabs.
       */
      tab_pos?: PositionType | null
    }
  }

  interface Notebook extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Notebook

    /**
     * If %TRUE, pressing the right mouse button on the notebook shows a page switching menu.
     */
    enablePopup: boolean
    /**
     * Group name for tab drag and drop.
     */
    groupName: string | null
    /**
     * The index of the current page.
     */
    page: number
    /**
     * A selection model with the pages.
     */
    readonly pages: Gio.ListModel
    /**
     * If %TRUE, scroll arrows are added if there are too many pages to fit.
     */
    scrollable: boolean
    /**
     * Whether the border should be shown.
     */
    showBorder: boolean
    /**
     * Whether tabs should be shown.
     */
    showTabs: boolean
    /**
     * Which side of the notebook holds the tabs.
     */
    tabPos: PositionType
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Notebook

    /**
     * Appends a page to `notebook`.
     * @param child the `GtkWidget` to use as the contents of the page
     * @param tabLabel the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
     * @returns the index (starting from 0) of the appended   page in the notebook, or -1 if function fails
     */
    appendPage(child: Widget, tabLabel: Widget | null): number
    /**
     * Appends a page to `notebook,` specifying the widget to use as the
     * label in the popup menu.
     * @param child the `GtkWidget` to use as the contents of the page
     * @param tabLabel the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
     * @param menuLabel the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and `tab_label`   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as `tab_label;` if `tab_label`   is not a `GtkLabel`, `menu_label` must be specified if the   page-switch menu is to be used.
     * @returns the index (starting from 0) of the appended   page in the notebook, or -1 if function fails
     */
    appendPageMenu(
      child: Widget,
      tabLabel: Widget | null,
      menuLabel: Widget | null
    ): number
    /**
     * Removes the child from the notebook.
     *
     * This function is very similar to [method`Gtk`.Notebook.remove_page],
     * but additionally informs the notebook that the removal
     * is happening as part of a tab DND operation, which should
     * not be cancelled.
     * @param child a child
     */
    detachTab(child: Widget): void
    /**
     * Gets one of the action widgets.
     *
     * See [method`Gtk`.Notebook.set_action_widget].
     * @param packType pack type of the action widget to receive
     * @returns The action widget   with the given @pack_type or %NULL when this action   widget has not been set
     */
    getActionWidget(packType: PackType): Widget | null
    /**
     * Returns the page number of the current page.
     * @returns the index (starting from 0) of the current   page in the notebook. If the notebook has no pages,   then -1 will be returned.
     */
    getCurrentPage(): number
    /**
     * Gets the current group name for `notebook`.
     * @returns the group name,   or %NULL if none is set
     */
    getGroupName(): string | null
    /**
     * Retrieves the menu label widget of the page containing `child`.
     * @param child a widget contained in a page of `notebook`
     * @returns the menu label, or %NULL   if the notebook page does not have a menu label other than   the default (the tab label).
     */
    getMenuLabel(child: Widget): Widget | null
    /**
     * Retrieves the text of the menu label for the page containing
     * `child`.
     * @param child the child widget of a page of the notebook.
     * @returns the text of the tab label, or %NULL if   the widget does not have a menu label other than the default   menu label, or the menu label widget is not a `GtkLabel`.   The string is owned by the widget and must not be freed.
     */
    getMenuLabelText(child: Widget): string | null
    /**
     * Gets the number of pages in a notebook.
     * @returns the number of pages in the notebook
     */
    getNPages(): number
    /**
     * Returns the child widget contained in page number `page_num`.
     * @param pageNum the index of a page in the notebook, or -1   to get the last page
     * @returns the child widget, or %NULL if @page_num is out of bounds
     */
    getNthPage(pageNum: number): Widget | null
    /**
     * Returns the `GtkNotebookPage` for `child`.
     * @param child a child of `notebook`
     * @returns the `GtkNotebookPage` for @child
     */
    getPage(child: Widget): NotebookPage
    /**
     * Returns a `GListModel` that contains the pages of the notebook.
     *
     * This can be used to keep an up-to-date view. The model also
     * implements [iface`Gtk`.SelectionModel] and can be used to track
     * and modify the visible page.
     * @returns a   `GListModel` for the notebook's children
     */
    getPages(): Gio.ListModel
    /**
     * Returns whether the tab label area has arrows for scrolling.
     * @returns %TRUE if arrows for scrolling are present
     */
    getScrollable(): boolean
    /**
     * Returns whether a bevel will be drawn around the notebook pages.
     * @returns %TRUE if the bevel is drawn
     */
    getShowBorder(): boolean
    /**
     * Returns whether the tabs of the notebook are shown.
     * @returns %TRUE if the tabs are shown
     */
    getShowTabs(): boolean
    /**
     * Returns whether the tab contents can be detached from `notebook`.
     * @param child a child `GtkWidget`
     * @returns %TRUE if the tab is detachable.
     */
    getTabDetachable(child: Widget): boolean
    /**
     * Returns the tab label widget for the page `child`.
     *
     * %NULL is returned if `child` is not in `notebook` or
     * if no tab label has specifically been set for `child`.
     * @param child the page
     * @returns the tab label
     */
    getTabLabel(child: Widget): Widget | null
    /**
     * Retrieves the text of the tab label for the page containing
     * `child`.
     * @param child a widget contained in a page of `notebook`
     * @returns the text of the tab label, or %NULL if   the tab label widget is not a `GtkLabel`. The string is owned   by the widget and must not be freed.
     */
    getTabLabelText(child: Widget): string | null
    /**
     * Gets the edge at which the tabs are drawn.
     * @returns the edge at which the tabs are drawn
     */
    getTabPos(): PositionType
    /**
     * Gets whether the tab can be reordered via drag and drop or not.
     * @param child a child `GtkWidget`
     * @returns %TRUE if the tab is reorderable.
     */
    getTabReorderable(child: Widget): boolean
    /**
     * Insert a page into `notebook` at the given position.
     * @param child the `GtkWidget` to use as the contents of the page
     * @param tabLabel the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
     * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page after all other pages
     * @returns the index (starting from 0) of the inserted   page in the notebook, or -1 if function fails
     */
    insertPage(child: Widget, tabLabel: Widget | null, position: number): number
    /**
     * Insert a page into `notebook` at the given position, specifying
     * the widget to use as the label in the popup menu.
     * @param child the `GtkWidget` to use as the contents of the page
     * @param tabLabel the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
     * @param menuLabel the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and `tab_label`   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as `tab_label;` if `tab_label`   is not a `GtkLabel`, `menu_label` must be specified if the   page-switch menu is to be used.
     * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page after all other pages.
     * @returns the index (starting from 0) of the inserted   page in the notebook
     */
    insertPageMenu(
      child: Widget,
      tabLabel: Widget | null,
      menuLabel: Widget | null,
      position: number
    ): number
    /**
     * Switches to the next page.
     *
     * Nothing happens if the current page is the last page.
     */
    nextPage(): void
    /**
     * Finds the index of the page which contains the given child
     * widget.
     * @param child a `GtkWidget`
     * @returns the index of the page containing @child, or   -1 if @child is not in the notebook
     */
    pageNum(child: Widget): number
    /**
     * Disables the popup menu.
     */
    popupDisable(): void
    /**
     * Enables the popup menu.
     *
     * If the user clicks with the right mouse button on the tab labels,
     * a menu with all the pages will be popped up.
     */
    popupEnable(): void
    /**
     * Prepends a page to `notebook`.
     * @param child the `GtkWidget` to use as the contents of the page
     * @param tabLabel the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
     * @returns the index (starting from 0) of the prepended   page in the notebook, or -1 if function fails
     */
    prependPage(child: Widget, tabLabel: Widget | null): number
    /**
     * Prepends a page to `notebook,` specifying the widget to use as the
     * label in the popup menu.
     * @param child the `GtkWidget` to use as the contents of the page
     * @param tabLabel the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
     * @param menuLabel the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and `tab_label`   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as `tab_label;` if `tab_label`   is not a `GtkLabel`, `menu_label` must be specified if the   page-switch menu is to be used.
     * @returns the index (starting from 0) of the prepended   page in the notebook, or -1 if function fails
     */
    prependPageMenu(
      child: Widget,
      tabLabel: Widget | null,
      menuLabel: Widget | null
    ): number
    /**
     * Switches to the previous page.
     *
     * Nothing happens if the current page is the first page.
     */
    prevPage(): void
    /**
     * Removes a page from the notebook given its index
     * in the notebook.
     * @param pageNum the index of a notebook page, starting   from 0. If -1, the last page will be removed.
     */
    removePage(pageNum: number): void
    /**
     * Reorders the page containing `child,` so that it appears in position
     * `position`.
     *
     * If `position` is greater than or equal to the number of children in
     * the list or negative, `child` will be moved to the end of the list.
     * @param child the child to move
     * @param position the new position, or -1 to move to the end
     */
    reorderChild(child: Widget, position: number): void
    /**
     * Sets `widget` as one of the action widgets.
     *
     * Depending on the pack type the widget will be placed before
     * or after the tabs. You can use a `GtkBox` if you need to pack
     * more than one widget on the same side.
     * @param widget a `GtkWidget`
     * @param packType pack type of the action widget
     */
    setActionWidget(widget: Widget, packType: PackType): void
    /**
     * Switches to the page number `page_num`.
     *
     * Note that due to historical reasons, GtkNotebook refuses
     * to switch to a page unless the child widget is visible.
     * Therefore, it is recommended to show child widgets before
     * adding them to a notebook.
     * @param pageNum index of the page to switch to, starting from 0.   If negative, the last page will be used. If greater   than the number of pages in the notebook, nothing   will be done.
     */
    setCurrentPage(pageNum: number): void
    /**
     * Sets a group name for `notebook`.
     *
     * Notebooks with the same name will be able to exchange tabs
     * via drag and drop. A notebook with a %NULL group name will
     * not be able to exchange tabs with any other notebook.
     * @param groupName the name of the notebook group,   or %NULL to unset it
     */
    setGroupName(groupName: string | null): void
    /**
     * Changes the menu label for the page containing `child`.
     * @param child the child widget
     * @param menuLabel the menu label, or %NULL for default
     */
    setMenuLabel(child: Widget, menuLabel: Widget | null): void
    /**
     * Creates a new label and sets it as the menu label of `child`.
     * @param child the child widget
     * @param menuText the label text
     */
    setMenuLabelText(child: Widget, menuText: string): void
    /**
     * Sets whether the tab label area will have arrows for
     * scrolling if there are too many tabs to fit in the area.
     * @param scrollable %TRUE if scroll arrows should be added
     */
    setScrollable(scrollable: boolean): void
    /**
     * Sets whether a bevel will be drawn around the notebook pages.
     *
     * This only has a visual effect when the tabs are not shown.
     * @param showBorder %TRUE if a bevel should be drawn around the notebook
     */
    setShowBorder(showBorder: boolean): void
    /**
     * Sets whether to show the tabs for the notebook or not.
     * @param showTabs %TRUE if the tabs should be shown
     */
    setShowTabs(showTabs: boolean): void
    /**
     * Sets whether the tab can be detached from `notebook` to another
     * notebook or widget.
     *
     * Note that two notebooks must share a common group identifier
     * (see [method`Gtk`.Notebook.set_group_name]) to allow automatic tabs
     * interchange between them.
     *
     * If you want a widget to interact with a notebook through DnD
     * (i.e.: accept dragged tabs from it) it must be set as a drop
     * destination by adding to it a [class`Gtk`.DropTarget] controller that accepts
     * the GType `GTK_TYPE_NOTEBOOK_PAGE`. The `:value` of said drop target will be
     * preloaded with a [class`Gtk`.NotebookPage] object that corresponds to the
     * dropped tab, so you can process the value via `::accept` or `::drop` signals.
     *
     * Note that you should use [method`Gtk`.Notebook.detach_tab] instead
     * of [method`Gtk`.Notebook.remove_page] if you want to remove the tab
     * from the source notebook as part of accepting a drop. Otherwise,
     * the source notebook will think that the dragged tab was removed
     * from underneath the ongoing drag operation, and will initiate a
     * drag cancel animation.
     *
     * ```c
     * static void
     * on_drag_data_received (GtkWidget        *widget,
     *                        GdkDrop          *drop,
     *                        GtkSelectionData *data,
     *                        guint             time,
     *                        gpointer          user_data)
     * {
     *   GtkDrag *drag;
     *   GtkWidget *notebook;
     *   GtkWidget **child;
     *
     *   drag = gtk_drop_get_drag (drop);
     *   notebook = g_object_get_data (drag, "gtk-notebook-drag-origin");
     *   child = (void*) gtk_selection_data_get_data (data);
     *
     *   // process_widget (*child);
     *
     *   gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child);
     * }
     * ```
     *
     * If you want a notebook to accept drags from other widgets,
     * you will have to set your own DnD code to do it.
     * @param child a child `GtkWidget`
     * @param detachable whether the tab is detachable or not
     */
    setTabDetachable(child: Widget, detachable: boolean): void
    /**
     * Changes the tab label for `child`.
     *
     * If %NULL is specified for `tab_label,` then the page will
     * have the label “page N”.
     * @param child the page
     * @param tabLabel the tab label widget to use, or %NULL   for default tab label
     */
    setTabLabel(child: Widget, tabLabel: Widget | null): void
    /**
     * Creates a new label and sets it as the tab label for the page
     * containing `child`.
     * @param child the page
     * @param tabText the label text
     */
    setTabLabelText(child: Widget, tabText: string): void
    /**
     * Sets the edge at which the tabs are drawn.
     * @param pos the edge to draw the tabs at
     */
    setTabPos(pos: PositionType): void
    /**
     * Sets whether the notebook tab can be reordered
     * via drag and drop or not.
     * @param child a child `GtkWidget`
     * @param reorderable whether the tab is reorderable or not
     */
    setTabReorderable(child: Widget, reorderable: boolean): void

    // Own signals of Gtk-4.0.Gtk.Notebook

    connect(
      sigName: "change-current-page",
      callback: Notebook.ChangeCurrentPageSignalCallback
    ): number
    on(
      sigName: "change-current-page",
      callback: Notebook.ChangeCurrentPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "change-current-page",
      callback: Notebook.ChangeCurrentPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "change-current-page",
      callback: Notebook.ChangeCurrentPageSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "change-current-page", ...args: any[]): void
    connect(
      sigName: "create-window",
      callback: Notebook.CreateWindowSignalCallback
    ): number
    on(
      sigName: "create-window",
      callback: Notebook.CreateWindowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "create-window",
      callback: Notebook.CreateWindowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "create-window",
      callback: Notebook.CreateWindowSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "create-window", ...args: any[]): void
    connect(
      sigName: "focus-tab",
      callback: Notebook.FocusTabSignalCallback
    ): number
    on(
      sigName: "focus-tab",
      callback: Notebook.FocusTabSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "focus-tab",
      callback: Notebook.FocusTabSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "focus-tab",
      callback: Notebook.FocusTabSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "focus-tab", ...args: any[]): void
    connect(
      sigName: "move-focus-out",
      callback: Notebook.MoveFocusOutSignalCallback
    ): number
    on(
      sigName: "move-focus-out",
      callback: Notebook.MoveFocusOutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-focus-out",
      callback: Notebook.MoveFocusOutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-focus-out",
      callback: Notebook.MoveFocusOutSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "move-focus-out", ...args: any[]): void
    connect(
      sigName: "page-added",
      callback: Notebook.PageAddedSignalCallback
    ): number
    on(
      sigName: "page-added",
      callback: Notebook.PageAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "page-added",
      callback: Notebook.PageAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "page-added",
      callback: Notebook.PageAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "page-added", pageNum: number, ...args: any[]): void
    connect(
      sigName: "page-removed",
      callback: Notebook.PageRemovedSignalCallback
    ): number
    on(
      sigName: "page-removed",
      callback: Notebook.PageRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "page-removed",
      callback: Notebook.PageRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "page-removed",
      callback: Notebook.PageRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "page-removed", pageNum: number, ...args: any[]): void
    connect(
      sigName: "page-reordered",
      callback: Notebook.PageReorderedSignalCallback
    ): number
    on(
      sigName: "page-reordered",
      callback: Notebook.PageReorderedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "page-reordered",
      callback: Notebook.PageReorderedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "page-reordered",
      callback: Notebook.PageReorderedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "page-reordered", pageNum: number, ...args: any[]): void
    connect(
      sigName: "reorder-tab",
      callback: Notebook.ReorderTabSignalCallback
    ): number
    on(
      sigName: "reorder-tab",
      callback: Notebook.ReorderTabSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "reorder-tab",
      callback: Notebook.ReorderTabSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "reorder-tab",
      callback: Notebook.ReorderTabSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "reorder-tab", p0: boolean, ...args: any[]): void
    connect(
      sigName: "select-page",
      callback: Notebook.SelectPageSignalCallback
    ): number
    on(
      sigName: "select-page",
      callback: Notebook.SelectPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-page",
      callback: Notebook.SelectPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-page",
      callback: Notebook.SelectPageSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-page", ...args: any[]): void
    connect(
      sigName: "switch-page",
      callback: Notebook.SwitchPageSignalCallback
    ): number
    on(
      sigName: "switch-page",
      callback: Notebook.SwitchPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "switch-page",
      callback: Notebook.SwitchPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "switch-page",
      callback: Notebook.SwitchPageSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "switch-page", pageNum: number, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Notebook

    connect(
      sigName: "notify::enable-popup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-popup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-popup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-popup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-popup", ...args: any[]): void
    connect(
      sigName: "notify::group-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::group-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::group-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::group-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::group-name", ...args: any[]): void
    connect(sigName: "notify::page", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::page",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::page",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::page",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::page", ...args: any[]): void
    connect(
      sigName: "notify::pages",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pages",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pages",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pages",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pages", ...args: any[]): void
    connect(
      sigName: "notify::scrollable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scrollable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scrollable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scrollable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scrollable", ...args: any[]): void
    connect(
      sigName: "notify::show-border",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-border",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-border",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-border",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-border", ...args: any[]): void
    connect(
      sigName: "notify::show-tabs",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-tabs",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-tabs", ...args: any[]): void
    connect(
      sigName: "notify::tab-pos",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tab-pos",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tab-pos",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tab-pos",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tab-pos", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkNotebook` is a container whose children are pages switched
   * between using tabs.
   *
   * ![An example GtkNotebook](notebook.png)
   *
   * There are many configuration options for `GtkNotebook`. Among
   * other things, you can choose on which edge the tabs appear
   * (see [method`Gtk`.Notebook.set_tab_pos]), whether, if there are
   * too many tabs to fit the notebook should be made bigger or scrolling
   * arrows added (see [method`Gtk`.Notebook.set_scrollable]), and whether
   * there will be a popup menu allowing the users to switch pages.
   * (see [method`Gtk`.Notebook.popup_enable]).
   *
   * # GtkNotebook as GtkBuildable
   *
   * The `GtkNotebook` implementation of the `GtkBuildable` interface
   * supports placing children into tabs by specifying “tab” as the
   * “type” attribute of a `<child>` element. Note that the content
   * of the tab must be created before the tab can be filled.
   * A tab child can be specified without specifying a `<child>`
   * type attribute.
   *
   * To add a child widget in the notebooks action area, specify
   * "action-start" or “action-end” as the “type” attribute of the
   * `<child>` element.
   *
   * An example of a UI definition fragment with `GtkNotebook`:
   *
   * ```xml
   * <object class="GtkNotebook">
   *   <child>
   *     <object class="GtkLabel" id="notebook-content">
   *       <property name="label">Content</property>
   *     </object>
   *   </child>
   *   <child type="tab">
   *     <object class="GtkLabel" id="notebook-tab">
   *       <property name="label">Tab</property>
   *     </object>
   *   </child>
   * </object>
   * ```
   *
   * # CSS nodes
   *
   * ```
   * notebook
   * ├── header.top
   * │   ├── [<action widget>]
   * │   ├── tabs
   * │   │   ├── [arrow]
   * │   │   ├── tab
   * │   │   │   ╰── <tab label>
   * ┊   ┊   ┊
   * │   │   ├── tab[.reorderable-page]
   * │   │   │   ╰── <tab label>
   * │   │   ╰── [arrow]
   * │   ╰── [<action widget>]
   * │
   * ╰── stack
   *     ├── <child>
   *     ┊
   *     ╰── <child>
   * ```
   *
   * `GtkNotebook` has a main CSS node with name `notebook`, a subnode
   * with name `header` and below that a subnode with name `tabs` which
   * contains one subnode per tab with name `tab`.
   *
   * If action widgets are present, their CSS nodes are placed next
   * to the `tabs` node. If the notebook is scrollable, CSS nodes with
   * name `arrow` are placed as first and last child of the `tabs` node.
   *
   * The main node gets the `.frame` style class when the notebook
   * has a border (see [method`Gtk`.Notebook.set_show_border]).
   *
   * The header node gets one of the style class `.top`, `.bottom`,
   * `.left` or `.right`, depending on where the tabs are placed. For
   * reorderable pages, the tab node gets the `.reorderable-page` class.
   *
   * A `tab` node gets the `.dnd` style class while it is moved with drag-and-drop.
   *
   * The nodes are always arranged from left-to-right, regardless of text direction.
   *
   * # Accessibility
   *
   * `GtkNotebook` uses the following roles:
   *
   *  - %GTK_ACCESSIBLE_ROLE_GROUP for the notebook widget
   *  - %GTK_ACCESSIBLE_ROLE_TAB_LIST for the list of tabs
   *  - %GTK_ACCESSIBLE_ROLE_TAB role for each tab
   *  - %GTK_ACCESSIBLE_ROLE_TAB_PANEL for each page
   * @class
   */
  class Notebook extends Widget {
    // Own properties of Gtk-4.0.Gtk.Notebook

    static name: string

    // Constructors of Gtk-4.0.Gtk.Notebook

    constructor(config?: Notebook.ConstructorProperties)
    /**
     * Creates a new `GtkNotebook` widget with no pages.
     * @constructor
     * @returns the newly created `GtkNotebook`
     */
    constructor()
    /**
     * Creates a new `GtkNotebook` widget with no pages.
     * @constructor
     * @returns the newly created `GtkNotebook`
     */
    static new(): Notebook
    _init(config?: Notebook.ConstructorProperties): void
  }

  module NotebookPage {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.NotebookPage

      /**
       * The child for this page.
       */
      child?: Widget | null
      /**
       * Whether the tab is detachable.
       */
      detachable?: boolean | null
      /**
       * The label widget displayed in the child's menu entry.
       */
      menu?: Widget | null
      /**
       * The text of the menu widget.
       */
      menu_label?: string | null
      /**
       * The index of the child in the parent.
       */
      position?: number | null
      /**
       * Whether the tab is reorderable by user action.
       */
      reorderable?: boolean | null
      /**
       * The tab widget for this page.
       */
      tab?: Widget | null
      /**
       * Whether to expand the child's tab.
       */
      tab_expand?: boolean | null
      /**
       * Whether the child's tab should fill the allocated area.
       */
      tab_fill?: boolean | null
      /**
       * The text of the tab widget.
       */
      tab_label?: string | null
    }
  }

  interface NotebookPage {
    // Own properties of Gtk-4.0.Gtk.NotebookPage

    /**
     * The child for this page.
     */
    readonly child: Widget
    /**
     * Whether the tab is detachable.
     */
    detachable: boolean
    /**
     * The label widget displayed in the child's menu entry.
     */
    readonly menu: Widget
    /**
     * The text of the menu widget.
     */
    menuLabel: string | null
    /**
     * The index of the child in the parent.
     */
    position: number
    /**
     * Whether the tab is reorderable by user action.
     */
    reorderable: boolean
    /**
     * The tab widget for this page.
     */
    readonly tab: Widget
    /**
     * Whether to expand the child's tab.
     */
    tabExpand: boolean
    /**
     * Whether the child's tab should fill the allocated area.
     */
    tabFill: boolean
    /**
     * The text of the tab widget.
     */
    tabLabel: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.NotebookPage

    /**
     * Returns the notebook child to which `page` belongs.
     * @returns the child to which @page belongs
     */
    getChild(): Widget

    // Class property signals of Gtk-4.0.Gtk.NotebookPage

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::detachable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::detachable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::detachable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::detachable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::detachable", ...args: any[]): void
    connect(sigName: "notify::menu", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::menu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::menu", ...args: any[]): void
    connect(
      sigName: "notify::menu-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::menu-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::menu-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::menu-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::menu-label", ...args: any[]): void
    connect(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position", ...args: any[]): void
    connect(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::reorderable", ...args: any[]): void
    connect(sigName: "notify::tab", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tab",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tab",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tab",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tab", ...args: any[]): void
    connect(
      sigName: "notify::tab-expand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tab-expand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tab-expand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tab-expand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tab-expand", ...args: any[]): void
    connect(
      sigName: "notify::tab-fill",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tab-fill",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tab-fill",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tab-fill",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tab-fill", ...args: any[]): void
    connect(
      sigName: "notify::tab-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tab-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tab-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tab-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tab-label", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkNotebookPage` is an auxiliary object used by `GtkNotebook`.
   * @class
   */
  class NotebookPage extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.NotebookPage

    static name: string

    // Constructors of Gtk-4.0.Gtk.NotebookPage

    constructor(config?: NotebookPage.ConstructorProperties)
    _init(config?: NotebookPage.ConstructorProperties): void
  }

  module NothingAction {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutAction.ConstructorProperties {}
  }

  interface NothingAction {
    // Own properties of Gtk-4.0.Gtk.NothingAction

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.NothingAction

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutAction` that does nothing.
   * @class
   */
  class NothingAction extends ShortcutAction {
    // Own properties of Gtk-4.0.Gtk.NothingAction

    static name: string

    // Constructors of Gtk-4.0.Gtk.NothingAction

    constructor(config?: NothingAction.ConstructorProperties)
    _init(config?: NothingAction.ConstructorProperties): void
    /**
     * Gets the nothing action.
     *
     * This is an action that does nothing and where
     * activating it always fails.
     * @returns The nothing action
     */
    static get(): NothingAction
  }

  module NumericSorter {
    // Constructor properties interface

    interface ConstructorProperties extends Sorter.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.NumericSorter

      /**
       * The expression to evaluate on items to get a number to compare with.
       */
      expression?: Expression | null
      /**
       * Whether the sorter will sort smaller numbers first.
       */
      sort_order?: SortType | null
    }
  }

  interface NumericSorter {
    // Own properties of Gtk-4.0.Gtk.NumericSorter

    /**
     * The expression to evaluate on items to get a number to compare with.
     */
    expression: Expression
    /**
     * Whether the sorter will sort smaller numbers first.
     */
    sortOrder: SortType
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.NumericSorter

    /**
     * Gets the expression that is evaluated to obtain numbers from items.
     * @returns a `GtkExpression`
     */
    getExpression(): Expression | null
    /**
     * Gets whether this sorter will sort smaller numbers first.
     * @returns the order of the numbers
     */
    getSortOrder(): SortType
    /**
     * Sets the expression that is evaluated to obtain numbers from items.
     *
     * Unless an expression is set on `self,` the sorter will always
     * compare items as invalid.
     *
     * The expression must have a return type that can be compared
     * numerically, such as %G_TYPE_INT or %G_TYPE_DOUBLE.
     * @param expression a `GtkExpression`
     */
    setExpression(expression: Expression | null): void
    /**
     * Sets whether to sort smaller numbers before larger ones.
     * @param sortOrder whether to sort smaller numbers first
     */
    setSortOrder(sortOrder: SortType): void

    // Class property signals of Gtk-4.0.Gtk.NumericSorter

    connect(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expression", ...args: any[]): void
    connect(
      sigName: "notify::sort-order",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sort-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sort-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sort-order",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sort-order", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkNumericSorter` is a `GtkSorter` that compares numbers.
   *
   * To obtain the numbers to compare, this sorter evaluates a
   * [class`Gtk`.Expression].
   * @class
   */
  class NumericSorter extends Sorter {
    // Own properties of Gtk-4.0.Gtk.NumericSorter

    static name: string

    // Constructors of Gtk-4.0.Gtk.NumericSorter

    constructor(config?: NumericSorter.ConstructorProperties)
    /**
     * Creates a new numeric sorter using the given `expression`.
     *
     * Smaller numbers will be sorted first. You can call
     * [method`Gtk`.NumericSorter.set_sort_order] to change this.
     * @constructor
     * @param expression The expression to evaluate
     * @returns a new `GtkNumericSorter`
     */
    constructor(expression: Expression | null)
    /**
     * Creates a new numeric sorter using the given `expression`.
     *
     * Smaller numbers will be sorted first. You can call
     * [method`Gtk`.NumericSorter.set_sort_order] to change this.
     * @constructor
     * @param expression The expression to evaluate
     * @returns a new `GtkNumericSorter`
     */
    static new(expression: Expression | null): NumericSorter
    _init(config?: NumericSorter.ConstructorProperties): void
  }

  interface ObjectExpression {
    // Owm methods of Gtk-4.0.Gtk.ObjectExpression

    /**
     * Gets the object that the expression evaluates to.
     * @returns the object, or `NULL`
     */
    getObject(): GObject.Object | null
  }

  /**
   * A `GObject` value in a `GtkExpression`.
   * @class
   */
  class ObjectExpression extends Expression {
    // Own properties of Gtk-4.0.Gtk.ObjectExpression

    static name: string

    // Constructors of Gtk-4.0.Gtk.ObjectExpression

    /**
     * Creates an expression evaluating to the given `object` with a weak reference.
     *
     * Once the `object` is disposed, it will fail to evaluate.
     *
     * This expression is meant to break reference cycles.
     *
     * If you want to keep a reference to `object`, use [ctor`Gtk`.ConstantExpression.new].
     * @constructor
     * @param object object to watch
     * @returns a new `GtkExpression`
     */
    constructor(object: GObject.Object)
    /**
     * Creates an expression evaluating to the given `object` with a weak reference.
     *
     * Once the `object` is disposed, it will fail to evaluate.
     *
     * This expression is meant to break reference cycles.
     *
     * If you want to keep a reference to `object`, use [ctor`Gtk`.ConstantExpression.new].
     * @constructor
     * @param object object to watch
     * @returns a new `GtkExpression`
     */
    static new(object: GObject.Object): ObjectExpression
  }

  module Overlay {
    // Signal callback interfaces

    /**
     * Signal callback interface for `get-child-position`
     */
    interface GetChildPositionSignalCallback {
      (widget: Widget): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Overlay

      /**
       * The main child widget.
       */
      child?: Widget | null
    }
  }

  interface Overlay extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Overlay

    /**
     * The main child widget.
     */
    child: Widget
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Overlay

    /**
     * Adds `widget` to `overlay`.
     *
     * The widget will be stacked on top of the main widget
     * added with [method`Gtk`.Overlay.set_child].
     *
     * The position at which `widget` is placed is determined
     * from its [property`Gtk`.Widget:halign] and
     * [property`Gtk`.Widget:valign] properties.
     * @param widget a `GtkWidget` to be added to the container
     */
    addOverlay(widget: Widget): void
    /**
     * Gets the child widget of `overlay`.
     * @returns the child widget of @overlay
     */
    getChild(): Widget | null
    /**
     * Gets whether `widget` should be clipped within the parent.
     * @param widget an overlay child of `GtkOverlay`
     * @returns whether the widget is clipped within the parent.
     */
    getClipOverlay(widget: Widget): boolean
    /**
     * Gets whether `widget'`s size is included in the measurement of
     * `overlay`.
     * @param widget an overlay child of `GtkOverlay`
     * @returns whether the widget is measured
     */
    getMeasureOverlay(widget: Widget): boolean
    /**
     * Removes an overlay that was added with gtk_overlay_add_overlay().
     * @param widget a `GtkWidget` to be removed
     */
    removeOverlay(widget: Widget): void
    /**
     * Sets the child widget of `overlay`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets whether `widget` should be clipped within the parent.
     * @param widget an overlay child of `GtkOverlay`
     * @param clipOverlay whether the child should be clipped
     */
    setClipOverlay(widget: Widget, clipOverlay: boolean): void
    /**
     * Sets whether `widget` is included in the measured size of `overlay`.
     *
     * The overlay will request the size of the largest child that has
     * this property set to %TRUE. Children who are not included may
     * be drawn outside of `overlay'`s allocation if they are too large.
     * @param widget an overlay child of `GtkOverlay`
     * @param measure whether the child should be measured
     */
    setMeasureOverlay(widget: Widget, measure: boolean): void

    // Own signals of Gtk-4.0.Gtk.Overlay

    connect(
      sigName: "get-child-position",
      callback: Overlay.GetChildPositionSignalCallback
    ): number
    on(
      sigName: "get-child-position",
      callback: Overlay.GetChildPositionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "get-child-position",
      callback: Overlay.GetChildPositionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "get-child-position",
      callback: Overlay.GetChildPositionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "get-child-position", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Overlay

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkOverlay` is a container which contains a single main child, on top
   * of which it can place “overlay” widgets.
   *
   * ![An example GtkOverlay](overlay.png)
   *
   * The position of each overlay widget is determined by its
   * [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
   * properties. E.g. a widget with both alignments set to %GTK_ALIGN_START
   * will be placed at the top left corner of the `GtkOverlay` container,
   * whereas an overlay with halign set to %GTK_ALIGN_CENTER and valign set
   * to %GTK_ALIGN_END will be placed a the bottom edge of the `GtkOverlay`,
   * horizontally centered. The position can be adjusted by setting the margin
   * properties of the child to non-zero values.
   *
   * More complicated placement of overlays is possible by connecting
   * to the [signal`Gtk`.Overlay::get-child-position] signal.
   *
   * An overlay’s minimum and natural sizes are those of its main child.
   * The sizes of overlay children are not considered when measuring these
   * preferred sizes.
   *
   * # GtkOverlay as GtkBuildable
   *
   * The `GtkOverlay` implementation of the `GtkBuildable` interface
   * supports placing a child as an overlay by specifying “overlay” as
   * the “type” attribute of a `<child>` element.
   *
   * # CSS nodes
   *
   * `GtkOverlay` has a single CSS node with the name “overlay”. Overlay children
   * whose alignments cause them to be positioned at an edge get the style classes
   * “.left”, “.right”, “.top”, and/or “.bottom” according to their position.
   * @class
   */
  class Overlay extends Widget {
    // Own properties of Gtk-4.0.Gtk.Overlay

    static name: string

    // Constructors of Gtk-4.0.Gtk.Overlay

    constructor(config?: Overlay.ConstructorProperties)
    /**
     * Creates a new `GtkOverlay`.
     * @constructor
     * @returns a new `GtkOverlay` object.
     */
    constructor()
    /**
     * Creates a new `GtkOverlay`.
     * @constructor
     * @returns a new `GtkOverlay` object.
     */
    static new(): Overlay
    _init(config?: Overlay.ConstructorProperties): void
  }

  module OverlayLayout {
    // Constructor properties interface

    interface ConstructorProperties
      extends LayoutManager.ConstructorProperties {}
  }

  interface OverlayLayout {
    // Own properties of Gtk-4.0.Gtk.OverlayLayout

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.OverlayLayout

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkOverlayLayout` is the layout manager used by [class`Gtk`.Overlay].
   *
   * It places widgets as overlays on top of the main child.
   *
   * This is not a reusable layout manager, since it expects its widget
   * to be a `GtkOverlay`. It is only listed here so that its layout
   * properties get documented.
   * @class
   */
  class OverlayLayout extends LayoutManager {
    // Own properties of Gtk-4.0.Gtk.OverlayLayout

    static name: string

    // Constructors of Gtk-4.0.Gtk.OverlayLayout

    constructor(config?: OverlayLayout.ConstructorProperties)
    /**
     * Creates a new `GtkOverlayLayout` instance.
     * @constructor
     * @returns the newly created instance
     */
    constructor()
    /**
     * Creates a new `GtkOverlayLayout` instance.
     * @constructor
     * @returns the newly created instance
     */
    static new(): OverlayLayout
    _init(config?: OverlayLayout.ConstructorProperties): void
  }

  module OverlayLayoutChild {
    // Constructor properties interface

    interface ConstructorProperties extends LayoutChild.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.OverlayLayoutChild

      /**
       * Whether the child should be clipped to fit the parent's size.
       */
      clip_overlay?: boolean | null
      /**
       * Whether the child size should contribute to the `GtkOverlayLayout`'s
       * measurement.
       */
      measure?: boolean | null
    }
  }

  interface OverlayLayoutChild {
    // Own properties of Gtk-4.0.Gtk.OverlayLayoutChild

    /**
     * Whether the child should be clipped to fit the parent's size.
     */
    clipOverlay: boolean
    /**
     * Whether the child size should contribute to the `GtkOverlayLayout`'s
     * measurement.
     */
    measure: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.OverlayLayoutChild

    /**
     * Retrieves whether the child is clipped.
     * @returns whether the child is clipped
     */
    getClipOverlay(): boolean
    /**
     * Retrieves whether the child is measured.
     * @returns whether the child is measured
     */
    getMeasure(): boolean
    /**
     * Sets whether to clip this child.
     * @param clipOverlay whether to clip this child
     */
    setClipOverlay(clipOverlay: boolean): void
    /**
     * Sets whether to measure this child.
     * @param measure whether to measure this child
     */
    setMeasure(measure: boolean): void

    // Class property signals of Gtk-4.0.Gtk.OverlayLayoutChild

    connect(
      sigName: "notify::clip-overlay",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::clip-overlay",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::clip-overlay",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::clip-overlay",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::clip-overlay", ...args: any[]): void
    connect(
      sigName: "notify::measure",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::measure",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::measure",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::measure",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::measure", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child-widget", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkLayoutChild` subclass for children in a `GtkOverlayLayout`.
   * @class
   */
  class OverlayLayoutChild extends LayoutChild {
    // Own properties of Gtk-4.0.Gtk.OverlayLayoutChild

    static name: string

    // Constructors of Gtk-4.0.Gtk.OverlayLayoutChild

    constructor(config?: OverlayLayoutChild.ConstructorProperties)
    _init(config?: OverlayLayoutChild.ConstructorProperties): void
  }

  module PadController {
    // Constructor properties interface

    interface ConstructorProperties
      extends EventController.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.PadController

      action_group?: Gio.ActionGroup | null
      pad?: Gdk.Device | null
    }
  }

  interface PadController {
    // Own properties of Gtk-4.0.Gtk.PadController

    readonly actionGroup: Gio.ActionGroup
    readonly pad: Gdk.Device
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PadController

    /**
     * Adds an individual action to `controller`.
     *
     * This action will only be activated if the given button/ring/strip number
     * in `index` is interacted while the current mode is `mode`. -1 may be used
     * for simple cases, so the action is triggered on all modes.
     *
     * The given `label` should be considered user-visible, so internationalization
     * rules apply. Some windowing systems may be able to use those for user
     * feedback.
     * @param type the type of pad feature that will trigger this action
     * @param index the 0-indexed button/ring/strip number that will trigger this action
     * @param mode the mode that will trigger this action, or -1 for all modes.
     * @param label Human readable description of this action, this string should   be deemed user-visible.
     * @param actionName action name that will be activated in the `GActionGroup`
     */
    setAction(
      type: PadActionType,
      index: number,
      mode: number,
      label: string,
      actionName: string
    ): void
    /**
     * A convenience function to add a group of action entries on
     * `controller`.
     *
     * See [struct`Gtk`.PadActionEntry] and [method`Gtk`.PadController.set_action].
     * @param entries the action entries to set on `controller`
     */
    setActionEntries(entries: PadActionEntry[]): void

    // Class property signals of Gtk-4.0.Gtk.PadController

    connect(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-group", ...args: any[]): void
    connect(sigName: "notify::pad", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::pad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pad",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pad",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pad", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPadController` is an event controller for the pads found in drawing
   * tablets.
   *
   * Pads are the collection of buttons and tactile sensors often found around
   * the stylus-sensitive area.
   *
   * These buttons and sensors have no implicit meaning, and by default they
   * perform no action. `GtkPadController` is provided to map those to
   * [iface`Gio`.Action] objects, thus letting the application give them a more
   * semantic meaning.
   *
   * Buttons and sensors are not constrained to triggering a single action,
   * some %GDK_SOURCE_TABLET_PAD devices feature multiple "modes". All these
   * input elements have one current mode, which may determine the final action
   * being triggered.
   *
   * Pad devices often divide buttons and sensors into groups. All elements
   * in a group share the same current mode, but different groups may have
   * different modes. See [method`Gdk`.DevicePad.get_n_groups] and
   * [method`Gdk`.DevicePad.get_group_n_modes].
   *
   * Each of the actions that a given button/strip/ring performs for a given mode
   * is defined by a [struct`Gtk`.PadActionEntry]. It contains an action name that
   * will be looked up in the given [iface`Gio`.ActionGroup] and activated whenever
   * the specified input element and mode are triggered.
   *
   * A simple example of `GtkPadController` usage: Assigning button 1 in all
   * modes and pad devices to an "invert-selection" action:
   *
   * ```c
   * GtkPadActionEntry *pad_actions[] = {
   *   { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
   *   …
   * };
   *
   * …
   * action_group = g_simple_action_group_new ();
   * action = g_simple_action_new ("pad-actions.invert-selection", NULL);
   * g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
   * g_action_map_add_action (G_ACTION_MAP (action_group), action);
   * …
   * pad_controller = gtk_pad_controller_new (action_group, NULL);
   * ```
   *
   * The actions belonging to rings/strips will be activated with a parameter
   * of type %G_VARIANT_TYPE_DOUBLE bearing the value of the given axis, it
   * is required that those are made stateful and accepting this `GVariantType`.
   * @class
   */
  class PadController extends EventController {
    // Own properties of Gtk-4.0.Gtk.PadController

    static name: string

    // Constructors of Gtk-4.0.Gtk.PadController

    constructor(config?: PadController.ConstructorProperties)
    /**
     * Creates a new `GtkPadController` that will associate events from `pad` to
     * actions.
     *
     * A %NULL pad may be provided so the controller manages all pad devices
     * generically, it is discouraged to mix `GtkPadController` objects with
     * %NULL and non-%NULL `pad` argument on the same toplevel window, as execution
     * order is not guaranteed.
     *
     * The `GtkPadController` is created with no mapped actions. In order to
     * map pad events to actions, use [method`Gtk`.PadController.set_action_entries]
     * or [method`Gtk`.PadController.set_action].
     *
     * Be aware that pad events will only be delivered to `GtkWindow`s, so adding
     * a pad controller to any other type of widget will not have an effect.
     * @constructor
     * @param group `GActionGroup` to trigger actions from
     * @param pad A %GDK_SOURCE_TABLET_PAD device, or %NULL to handle all pads
     * @returns A newly created `GtkPadController`
     */
    constructor(group: Gio.ActionGroup, pad: Gdk.Device | null)
    /**
     * Creates a new `GtkPadController` that will associate events from `pad` to
     * actions.
     *
     * A %NULL pad may be provided so the controller manages all pad devices
     * generically, it is discouraged to mix `GtkPadController` objects with
     * %NULL and non-%NULL `pad` argument on the same toplevel window, as execution
     * order is not guaranteed.
     *
     * The `GtkPadController` is created with no mapped actions. In order to
     * map pad events to actions, use [method`Gtk`.PadController.set_action_entries]
     * or [method`Gtk`.PadController.set_action].
     *
     * Be aware that pad events will only be delivered to `GtkWindow`s, so adding
     * a pad controller to any other type of widget will not have an effect.
     * @constructor
     * @param group `GActionGroup` to trigger actions from
     * @param pad A %GDK_SOURCE_TABLET_PAD device, or %NULL to handle all pads
     * @returns A newly created `GtkPadController`
     */
    static new(group: Gio.ActionGroup, pad: Gdk.Device | null): PadController
    _init(config?: PadController.ConstructorProperties): void
  }

  module PageSetup {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface PageSetup {
    // Own properties of Gtk-4.0.Gtk.PageSetup

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PageSetup

    /**
     * Copies a `GtkPageSetup`.
     * @returns a copy of @other
     */
    copy(): PageSetup
    /**
     * Gets the bottom margin in units of `unit`.
     * @param unit the unit for the return value
     * @returns the bottom margin
     */
    getBottomMargin(unit: Unit): number
    /**
     * Gets the left margin in units of `unit`.
     * @param unit the unit for the return value
     * @returns the left margin
     */
    getLeftMargin(unit: Unit): number
    /**
     * Gets the page orientation of the `GtkPageSetup`.
     * @returns the page orientation
     */
    getOrientation(): PageOrientation
    /**
     * Returns the page height in units of `unit`.
     *
     * Note that this function takes orientation
     * and margins into consideration.
     * See [method`Gtk`.PageSetup.get_paper_height].
     * @param unit the unit for the return value
     * @returns the page height.
     */
    getPageHeight(unit: Unit): number
    /**
     * Returns the page width in units of `unit`.
     *
     * Note that this function takes orientation
     * and margins into consideration.
     * See [method`Gtk`.PageSetup.get_paper_width].
     * @param unit the unit for the return value
     * @returns the page width.
     */
    getPageWidth(unit: Unit): number
    /**
     * Returns the paper height in units of `unit`.
     *
     * Note that this function takes orientation,
     * but not margins into consideration.
     * See [method`Gtk`.PageSetup.get_page_height].
     * @param unit the unit for the return value
     * @returns the paper height.
     */
    getPaperHeight(unit: Unit): number
    /**
     * Gets the paper size of the `GtkPageSetup`.
     * @returns the paper size
     */
    getPaperSize(): PaperSize
    /**
     * Returns the paper width in units of `unit`.
     *
     * Note that this function takes orientation,
     * but not margins into consideration.
     * See [method`Gtk`.PageSetup.get_page_width].
     * @param unit the unit for the return value
     * @returns the paper width.
     */
    getPaperWidth(unit: Unit): number
    /**
     * Gets the right margin in units of `unit`.
     * @param unit the unit for the return value
     * @returns the right margin
     */
    getRightMargin(unit: Unit): number
    /**
     * Gets the top margin in units of `unit`.
     * @param unit the unit for the return value
     * @returns the top margin
     */
    getTopMargin(unit: Unit): number
    /**
     * Reads the page setup from the file `file_name`.
     *
     * See [method`Gtk`.PageSetup.to_file].
     * @param fileName the filename to read the page setup from
     * @returns %TRUE on success
     */
    loadFile(fileName: string): boolean
    /**
     * Reads the page setup from the group `group_name` in the key file
     * `key_file`.
     * @param keyFile the `GKeyFile` to retrieve the page_setup from
     * @param groupName the name of the group in the key_file to read   to use the default name “Page Setup”
     * @returns %TRUE on success
     */
    loadKeyFile(keyFile: GLib.KeyFile, groupName: string | null): boolean
    /**
     * Sets the bottom margin of the `GtkPageSetup`.
     * @param margin the new bottom margin in units of `unit`
     * @param unit the units for `margin`
     */
    setBottomMargin(margin: number, unit: Unit): void
    /**
     * Sets the left margin of the `GtkPageSetup`.
     * @param margin the new left margin in units of `unit`
     * @param unit the units for `margin`
     */
    setLeftMargin(margin: number, unit: Unit): void
    /**
     * Sets the page orientation of the `GtkPageSetup`.
     * @param orientation a `GtkPageOrientation` value
     */
    setOrientation(orientation: PageOrientation): void
    /**
     * Sets the paper size of the `GtkPageSetup` without
     * changing the margins.
     *
     * See [method`Gtk`.PageSetup.set_paper_size_and_default_margins].
     * @param size a `GtkPaperSize`
     */
    setPaperSize(size: PaperSize): void
    /**
     * Sets the paper size of the `GtkPageSetup` and modifies
     * the margins according to the new paper size.
     * @param size a `GtkPaperSize`
     */
    setPaperSizeAndDefaultMargins(size: PaperSize): void
    /**
     * Sets the right margin of the `GtkPageSetup`.
     * @param margin the new right margin in units of `unit`
     * @param unit the units for `margin`
     */
    setRightMargin(margin: number, unit: Unit): void
    /**
     * Sets the top margin of the `GtkPageSetup`.
     * @param margin the new top margin in units of `unit`
     * @param unit the units for `margin`
     */
    setTopMargin(margin: number, unit: Unit): void
    /**
     * This function saves the information from `setup` to `file_name`.
     * @param fileName the file to save to
     * @returns %TRUE on success
     */
    toFile(fileName: string): boolean
    /**
     * Serialize page setup to an a{sv} variant.
     * @returns a new, floating, `GVariant`
     */
    toGvariant(): GLib.Variant
    /**
     * This function adds the page setup from `setup` to `key_file`.
     * @param keyFile the `GKeyFile` to save the page setup to
     * @param groupName the group to add the settings to in `key_file,`   or %NULL to use the default name “Page Setup”
     */
    toKeyFile(keyFile: GLib.KeyFile, groupName: string | null): void

    // Class property signals of Gtk-4.0.Gtk.PageSetup

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkPageSetup` object stores the page size, orientation and margins.
   *
   * The idea is that you can get one of these from the page setup dialog
   * and then pass it to the `GtkPrintOperation` when printing.
   * The benefit of splitting this out of the `GtkPrintSettings` is that
   * these affect the actual layout of the page, and thus need to be set
   * long before user prints.
   *
   * ## Margins
   *
   * The margins specified in this object are the “print margins”, i.e. the
   * parts of the page that the printer cannot print on. These are different
   * from the layout margins that a word processor uses; they are typically
   * used to determine the minimal size for the layout margins.
   *
   * To obtain a `GtkPageSetup` use [ctor`Gtk`.PageSetup.new] to get the defaults,
   * or use [func`Gtk`.print_run_page_setup_dialog] to show the page setup dialog
   * and receive the resulting page setup.
   *
   * ## A page setup dialog
   *
   * ```c
   * static GtkPrintSettings *settings = NULL;
   * static GtkPageSetup *page_setup = NULL;
   *
   * static void
   * do_page_setup (void)
   * {
   *   GtkPageSetup *new_page_setup;
   *
   *   if (settings == NULL)
   *     settings = gtk_print_settings_new ();
   *
   *   new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
   *                                                     page_setup, settings);
   *
   *   if (page_setup)
   *     g_object_unref (page_setup);
   *
   *   page_setup = new_page_setup;
   * }
   * ```
   * @class
   */
  class PageSetup extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.PageSetup

    static name: string

    // Constructors of Gtk-4.0.Gtk.PageSetup

    constructor(config?: PageSetup.ConstructorProperties)
    /**
     * Creates a new `GtkPageSetup`.
     * @constructor
     * @returns a new `GtkPageSetup`.
     */
    constructor()
    /**
     * Creates a new `GtkPageSetup`.
     * @constructor
     * @returns a new `GtkPageSetup`.
     */
    static new(): PageSetup
    /**
     * Reads the page setup from the file `file_name`.
     *
     * Returns a new `GtkPageSetup` object with the restored
     * page setup, or %NULL if an error occurred.
     * See [method`Gtk`.PageSetup.to_file].
     * @constructor
     * @param fileName the filename to read the page setup from
     * @returns the restored `GtkPageSetup`
     */
    static newFromFile(fileName: string): PageSetup
    /**
     * Desrialize a page setup from an a{sv} variant.
     *
     * The variant must be in the format produced by
     * [method`Gtk`.PageSetup.to_gvariant].
     * @constructor
     * @param variant an a{sv} `GVariant`
     * @returns a new `GtkPageSetup` object
     */
    static newFromGvariant(variant: GLib.Variant): PageSetup
    /**
     * Reads the page setup from the group `group_name` in the key file
     * `key_file`.
     *
     * Returns a new `GtkPageSetup` object with the restored
     * page setup, or %NULL if an error occurred.
     * @constructor
     * @param keyFile the `GKeyFile` to retrieve the page_setup from
     * @param groupName the name of the group in the key_file to read    to use the default name “Page Setup”
     * @returns the restored `GtkPageSetup`
     */
    static newFromKeyFile(
      keyFile: GLib.KeyFile,
      groupName: string | null
    ): PageSetup
    _init(config?: PageSetup.ConstructorProperties): void
  }

  module PageSetupUnixDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Dialog.ConstructorProperties {}
  }

  interface PageSetupUnixDialog
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.PageSetupUnixDialog

    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.PageSetupUnixDialog

    /**
     * Gets the currently selected page setup from the dialog.
     * @returns the current page setup
     */
    getPageSetup(): PageSetup
    /**
     * Gets the current print settings from the dialog.
     * @returns the current print settings
     */
    getPrintSettings(): PrintSettings | null
    /**
     * Sets the `GtkPageSetup` from which the page setup
     * dialog takes its values.
     * @param pageSetup a `GtkPageSetup`
     */
    setPageSetup(pageSetup: PageSetup): void
    /**
     * Sets the `GtkPrintSettings` from which the page setup dialog
     * takes its values.
     * @param printSettings a `GtkPrintSettings`
     */
    setPrintSettings(printSettings: PrintSettings | null): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void
    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @virtual
     */
    close(): void

    // Overloads of close

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void

    // Class property signals of Gtk-4.0.Gtk.PageSetupUnixDialog

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPageSetupUnixDialog` implements a page setup dialog for platforms
   * which don’t provide a native page setup dialog, like Unix.
   *
   * ![An example GtkPageSetupUnixDialog](pagesetupdialog.png)
   *
   * It can be used very much like any other GTK dialog, at the
   * cost of the portability offered by the high-level printing
   * API in [class`Gtk`.PrintOperation].
   *
   * ## CSS nodes
   *
   * `GtkPageSetupUnixDialog` has a single CSS node with the name `window` and
   * style class `.pagesetup`.
   * @class
   */
  class PageSetupUnixDialog extends Dialog {
    // Own properties of Gtk-4.0.Gtk.PageSetupUnixDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.PageSetupUnixDialog

    constructor(config?: PageSetupUnixDialog.ConstructorProperties)
    /**
     * Creates a new page setup dialog.
     * @constructor
     * @param title the title of the dialog
     * @param parent transient parent of the dialog
     * @returns the new `GtkPageSetupUnixDialog`
     */
    constructor(title: string | null, parent: Window | null)
    /**
     * Creates a new page setup dialog.
     * @constructor
     * @param title the title of the dialog
     * @param parent transient parent of the dialog
     * @returns the new `GtkPageSetupUnixDialog`
     */
    static new(title: string | null, parent: Window | null): PageSetupUnixDialog

    // Overloads of new

    /**
     * Creates a new dialog box.
     *
     * Widgets should not be packed into the `GtkWindow`
     * directly, but into the `content_area` and `action_area,`
     * as described above.
     * @constructor
     * @returns the new dialog as a `GtkWidget`
     */
    static new(): Dialog
    _init(config?: PageSetupUnixDialog.ConstructorProperties): void
  }

  module Paned {
    // Signal callback interfaces

    /**
     * Signal callback interface for `accept-position`
     */
    interface AcceptPositionSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `cancel-position`
     */
    interface CancelPositionSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `cycle-child-focus`
     */
    interface CycleChildFocusSignalCallback {
      (reversed: boolean): boolean
    }

    /**
     * Signal callback interface for `cycle-handle-focus`
     */
    interface CycleHandleFocusSignalCallback {
      (reversed: boolean): boolean
    }

    /**
     * Signal callback interface for `move-handle`
     */
    interface MoveHandleSignalCallback {
      (scrollType: ScrollType): boolean
    }

    /**
     * Signal callback interface for `toggle-handle-focus`
     */
    interface ToggleHandleFocusSignalCallback {
      (): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleRange.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Paned

      /**
       * The second child.
       */
      end_child?: Widget | null
      /**
       * Position of the separator in pixels, from the left/top.
       */
      position?: number | null
      /**
       * Whether the [property`Gtk`.Paned:position] property has been set.
       */
      position_set?: boolean | null
      /**
       * Determines whether the second child expands and shrinks
       * along with the paned widget.
       */
      resize_end_child?: boolean | null
      /**
       * Determines whether the first child expands and shrinks
       * along with the paned widget.
       */
      resize_start_child?: boolean | null
      /**
       * Determines whether the second child can be made smaller
       * than its requisition.
       */
      shrink_end_child?: boolean | null
      /**
       * Determines whether the first child can be made smaller
       * than its requisition.
       */
      shrink_start_child?: boolean | null
      /**
       * The first child.
       */
      start_child?: Widget | null
      /**
       * Whether the `GtkPaned` should provide a stronger visual separation.
       *
       * For example, this could be set when a paned contains two
       * [class`Gtk`.Notebook]s, whose tab rows would otherwise merge visually.
       */
      wide_handle?: boolean | null
    }
  }

  interface Paned
    extends Accessible,
      AccessibleRange,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.Paned

    /**
     * The second child.
     */
    endChild: Widget
    /**
     * The largest possible value for the [property`Gtk`.Paned:position]
     * property.
     *
     * This property is derived from the size and shrinkability
     * of the widget's children.
     */
    readonly maxPosition: number
    /**
     * The smallest possible value for the [property`Gtk`.Paned:position]
     * property.
     *
     * This property is derived from the size and shrinkability
     * of the widget's children.
     */
    readonly minPosition: number
    /**
     * Position of the separator in pixels, from the left/top.
     */
    position: number
    /**
     * Whether the [property`Gtk`.Paned:position] property has been set.
     */
    positionSet: boolean
    /**
     * Determines whether the second child expands and shrinks
     * along with the paned widget.
     */
    resizeEndChild: boolean
    /**
     * Determines whether the first child expands and shrinks
     * along with the paned widget.
     */
    resizeStartChild: boolean
    /**
     * Determines whether the second child can be made smaller
     * than its requisition.
     */
    shrinkEndChild: boolean
    /**
     * Determines whether the first child can be made smaller
     * than its requisition.
     */
    shrinkStartChild: boolean
    /**
     * The first child.
     */
    startChild: Widget
    /**
     * Whether the `GtkPaned` should provide a stronger visual separation.
     *
     * For example, this could be set when a paned contains two
     * [class`Gtk`.Notebook]s, whose tab rows would otherwise merge visually.
     */
    wideHandle: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Paned

    /**
     * Retrieves the end child of the given `GtkPaned`.
     * @returns the end child widget
     */
    getEndChild(): Widget | null
    /**
     * Obtains the position of the divider between the two panes.
     * @returns the position of the divider, in pixels
     */
    getPosition(): number
    /**
     * Returns whether the [property`Gtk`.Paned:end-child] can be resized.
     * @returns true if the end child is resizable
     */
    getResizeEndChild(): boolean
    /**
     * Returns whether the [property`Gtk`.Paned:start-child] can be resized.
     * @returns true if the start child is resizable
     */
    getResizeStartChild(): boolean
    /**
     * Returns whether the [property`Gtk`.Paned:end-child] can shrink.
     * @returns true if the end child is shrinkable
     */
    getShrinkEndChild(): boolean
    /**
     * Returns whether the [property`Gtk`.Paned:start-child] can shrink.
     * @returns true if the start child is shrinkable
     */
    getShrinkStartChild(): boolean
    /**
     * Retrieves the start child of the given `GtkPaned`.
     * @returns the start child widget
     */
    getStartChild(): Widget | null
    /**
     * Gets whether the separator should be wide.
     * @returns %TRUE if the paned should have a wide handle
     */
    getWideHandle(): boolean
    /**
     * Sets the end child of `paned` to `child`.
     *
     * If `child` is `NULL`, the existing child will be removed.
     * @param child the widget to add
     */
    setEndChild(child: Widget | null): void
    /**
     * Sets the position of the divider between the two panes.
     * @param position pixel position of divider, a negative value means that the position   is unset
     */
    setPosition(position: number): void
    /**
     * Sets whether the [property`Gtk`.Paned:end-child] can be resized.
     * @param resize true to let the end child be resized
     */
    setResizeEndChild(resize: boolean): void
    /**
     * Sets whether the [property`Gtk`.Paned:start-child] can be resized.
     * @param resize true to let the start child be resized
     */
    setResizeStartChild(resize: boolean): void
    /**
     * Sets whether the [property`Gtk`.Paned:end-child] can shrink.
     * @param resize true to let the end child be shrunk
     */
    setShrinkEndChild(resize: boolean): void
    /**
     * Sets whether the [property`Gtk`.Paned:start-child] can shrink.
     * @param resize true to let the start child be shrunk
     */
    setShrinkStartChild(resize: boolean): void
    /**
     * Sets the start child of `paned` to `child`.
     *
     * If `child` is `NULL`, the existing child will be removed.
     * @param child the widget to add
     */
    setStartChild(child: Widget | null): void
    /**
     * Sets whether the separator should be wide.
     * @param wide the new value for the [property`Gtk`.Paned:wide-handle] property
     */
    setWideHandle(wide: boolean): void

    // Own signals of Gtk-4.0.Gtk.Paned

    connect(
      sigName: "accept-position",
      callback: Paned.AcceptPositionSignalCallback
    ): number
    on(
      sigName: "accept-position",
      callback: Paned.AcceptPositionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "accept-position",
      callback: Paned.AcceptPositionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "accept-position",
      callback: Paned.AcceptPositionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "accept-position", ...args: any[]): void
    connect(
      sigName: "cancel-position",
      callback: Paned.CancelPositionSignalCallback
    ): number
    on(
      sigName: "cancel-position",
      callback: Paned.CancelPositionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cancel-position",
      callback: Paned.CancelPositionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cancel-position",
      callback: Paned.CancelPositionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cancel-position", ...args: any[]): void
    connect(
      sigName: "cycle-child-focus",
      callback: Paned.CycleChildFocusSignalCallback
    ): number
    on(
      sigName: "cycle-child-focus",
      callback: Paned.CycleChildFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cycle-child-focus",
      callback: Paned.CycleChildFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cycle-child-focus",
      callback: Paned.CycleChildFocusSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cycle-child-focus", ...args: any[]): void
    connect(
      sigName: "cycle-handle-focus",
      callback: Paned.CycleHandleFocusSignalCallback
    ): number
    on(
      sigName: "cycle-handle-focus",
      callback: Paned.CycleHandleFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cycle-handle-focus",
      callback: Paned.CycleHandleFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cycle-handle-focus",
      callback: Paned.CycleHandleFocusSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cycle-handle-focus", ...args: any[]): void
    connect(
      sigName: "move-handle",
      callback: Paned.MoveHandleSignalCallback
    ): number
    on(
      sigName: "move-handle",
      callback: Paned.MoveHandleSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-handle",
      callback: Paned.MoveHandleSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-handle",
      callback: Paned.MoveHandleSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "move-handle", ...args: any[]): void
    connect(
      sigName: "toggle-handle-focus",
      callback: Paned.ToggleHandleFocusSignalCallback
    ): number
    on(
      sigName: "toggle-handle-focus",
      callback: Paned.ToggleHandleFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggle-handle-focus",
      callback: Paned.ToggleHandleFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggle-handle-focus",
      callback: Paned.ToggleHandleFocusSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggle-handle-focus", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Paned

    connect(
      sigName: "notify::end-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::end-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::end-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::end-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::end-child", ...args: any[]): void
    connect(
      sigName: "notify::max-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-position", ...args: any[]): void
    connect(
      sigName: "notify::min-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-position", ...args: any[]): void
    connect(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position", ...args: any[]): void
    connect(
      sigName: "notify::position-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position-set", ...args: any[]): void
    connect(
      sigName: "notify::resize-end-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resize-end-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resize-end-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resize-end-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resize-end-child", ...args: any[]): void
    connect(
      sigName: "notify::resize-start-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resize-start-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resize-start-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resize-start-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resize-start-child", ...args: any[]): void
    connect(
      sigName: "notify::shrink-end-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shrink-end-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shrink-end-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shrink-end-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shrink-end-child", ...args: any[]): void
    connect(
      sigName: "notify::shrink-start-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shrink-start-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shrink-start-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shrink-start-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shrink-start-child", ...args: any[]): void
    connect(
      sigName: "notify::start-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::start-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::start-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::start-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::start-child", ...args: any[]): void
    connect(
      sigName: "notify::wide-handle",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wide-handle",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wide-handle",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wide-handle",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wide-handle", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A widget with two panes, arranged either horizontally or vertically.
   *
   * ![An example GtkPaned](panes.png)
   *
   * The division between the two panes is adjustable by the user
   * by dragging a handle.
   *
   * Child widgets are added to the panes of the widget with
   * [method`Gtk`.Paned.set_start_child] and [method`Gtk`.Paned.set_end_child].
   * The division between the two children is set by default from the size
   * requests of the children, but it can be adjusted by the user.
   *
   * A paned widget draws a separator between the two child widgets and a
   * small handle that the user can drag to adjust the division. It does not
   * draw any relief around the children or around the separator. (The space
   * in which the separator is called the gutter.) Often, it is useful to put
   * each child inside a [class`Gtk`.Frame] so that the gutter appears as a
   * ridge. No separator is drawn if one of the children is missing.
   *
   * Each child has two options that can be set, "resize" and "shrink". If
   * "resize" is true then, when the `GtkPaned` is resized, that child will
   * expand or shrink along with the paned widget. If "shrink" is true, then
   * that child can be made smaller than its requisition by the user.
   * Setting "shrink" to false allows the application to set a minimum size.
   * If "resize" is false for both children, then this is treated as if
   * "resize" is true for both children.
   *
   * The application can set the position of the slider as if it were set
   * by the user, by calling [method`Gtk`.Paned.set_position].
   *
   * # CSS nodes
   *
   * ```
   * paned
   * ├── <child>
   * ├── separator[.wide]
   * ╰── <child>
   * ```
   *
   * `GtkPaned` has a main CSS node with name paned, and a subnode for
   * the separator with name separator. The subnode gets a .wide style
   * class when the paned is supposed to be wide.
   *
   * In horizontal orientation, the nodes are arranged based on the text
   * direction, so in left-to-right mode, :first-child will select the
   * leftmost child, while it will select the rightmost child in
   * RTL layouts.
   *
   * ## Creating a paned widget with minimum sizes.
   *
   * ```c
   * GtkWidget *hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
   * GtkWidget *frame1 = gtk_frame_new (NULL);
   * GtkWidget *frame2 = gtk_frame_new (NULL);
   *
   * gtk_widget_set_size_request (hpaned, 200, -1);
   *
   * gtk_paned_set_start_child (GTK_PANED (hpaned), frame1);
   * gtk_paned_set_resize_start_child (GTK_PANED (hpaned), TRUE);
   * gtk_paned_set_shrink_start_child (GTK_PANED (hpaned), FALSE);
   * gtk_widget_set_size_request (frame1, 50, -1);
   *
   * gtk_paned_set_end_child (GTK_PANED (hpaned), frame2);
   * gtk_paned_set_resize_end_child (GTK_PANED (hpaned), FALSE);
   * gtk_paned_set_shrink_end_child (GTK_PANED (hpaned), FALSE);
   * gtk_widget_set_size_request (frame2, 50, -1);
   * ```
   * @class
   */
  class Paned extends Widget {
    // Own properties of Gtk-4.0.Gtk.Paned

    static name: string

    // Constructors of Gtk-4.0.Gtk.Paned

    constructor(config?: Paned.ConstructorProperties)
    /**
     * Creates a new `GtkPaned` widget.
     * @constructor
     * @param orientation the paned’s orientation.
     * @returns the newly created paned widget
     */
    constructor(orientation: Orientation)
    /**
     * Creates a new `GtkPaned` widget.
     * @constructor
     * @param orientation the paned’s orientation.
     * @returns the newly created paned widget
     */
    static new(orientation: Orientation): Paned
    _init(config?: Paned.ConstructorProperties): void
  }

  interface ParamSpecExpression {}

  /**
   * A `GParamSpec` for properties holding a `GtkExpression`.
   * @class
   */
  class ParamSpecExpression extends GObject.ParamSpec {
    // Own properties of Gtk-4.0.Gtk.ParamSpecExpression

    static name: string
  }

  module PasswordEntry {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Editable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.PasswordEntry

      /**
       * Whether to activate the default widget when Enter is pressed.
       */
      activates_default?: boolean | null
      /**
       * A menu model whose contents will be appended to
       * the context menu.
       */
      extra_menu?: Gio.MenuModel | null
      /**
       * The text that will be displayed in the `GtkPasswordEntry`
       * when it is empty and unfocused.
       */
      placeholder_text?: string | null
      /**
       * Whether to show an icon for revealing the content.
       */
      show_peek_icon?: boolean | null
    }
  }

  interface PasswordEntry
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Editable {
    // Own properties of Gtk-4.0.Gtk.PasswordEntry

    /**
     * Whether to activate the default widget when Enter is pressed.
     */
    activatesDefault: boolean
    /**
     * A menu model whose contents will be appended to
     * the context menu.
     */
    extraMenu: Gio.MenuModel
    /**
     * The text that will be displayed in the `GtkPasswordEntry`
     * when it is empty and unfocused.
     */
    placeholderText: string | null
    /**
     * Whether to show an icon for revealing the content.
     */
    showPeekIcon: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PasswordEntry

    /**
     * Gets the menu model set with gtk_password_entry_set_extra_menu().
     * @returns the menu model
     */
    getExtraMenu(): Gio.MenuModel | null
    /**
     * Returns whether the entry is showing an icon to
     * reveal the contents.
     * @returns %TRUE if an icon is shown
     */
    getShowPeekIcon(): boolean
    /**
     * Sets a menu model to add when constructing
     * the context menu for `entry`.
     * @param model a `GMenuModel`
     */
    setExtraMenu(model: Gio.MenuModel | null): void
    /**
     * Sets whether the entry should have a clickable icon
     * to reveal the contents.
     *
     * Setting this to %FALSE also hides the text again.
     * @param showPeekIcon whether to show the peek icon
     */
    setShowPeekIcon(showPeekIcon: boolean): void

    // Own signals of Gtk-4.0.Gtk.PasswordEntry

    connect(
      sigName: "activate",
      callback: PasswordEntry.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: PasswordEntry.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: PasswordEntry.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: PasswordEntry.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.PasswordEntry

    connect(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activates-default", ...args: any[]): void
    connect(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::extra-menu", ...args: any[]): void
    connect(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::placeholder-text", ...args: any[]): void
    connect(
      sigName: "notify::show-peek-icon",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-peek-icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-peek-icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-peek-icon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-peek-icon", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-position", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-undo", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-bound", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPasswordEntry` is an entry that has been tailored for entering secrets.
   *
   * ![An example GtkPasswordEntry](password-entry.png)
   *
   * It does not show its contents in clear text, does not allow to copy it
   * to the clipboard, and it shows a warning when Caps Lock is engaged. If
   * the underlying platform allows it, `GtkPasswordEntry` will also place
   * the text in a non-pageable memory area, to avoid it being written out
   * to disk by the operating system.
   *
   * Optionally, it can offer a way to reveal the contents in clear text.
   *
   * `GtkPasswordEntry` provides only minimal API and should be used with
   * the [iface`Gtk`.Editable] API.
   *
   * # CSS Nodes
   *
   * ```
   * entry.password
   * ╰── text
   *     ├── image.caps-lock-indicator
   *     ┊
   * ```
   *
   * `GtkPasswordEntry` has a single CSS node with name entry that carries
   * a .passwordstyle class. The text Css node below it has a child with
   * name image and style class .caps-lock-indicator for the Caps Lock
   * icon, and possibly other children.
   *
   * # Accessibility
   *
   * `GtkPasswordEntry` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
   * @class
   */
  class PasswordEntry extends Widget {
    // Own properties of Gtk-4.0.Gtk.PasswordEntry

    static name: string

    // Constructors of Gtk-4.0.Gtk.PasswordEntry

    constructor(config?: PasswordEntry.ConstructorProperties)
    /**
     * Creates a `GtkPasswordEntry`.
     * @constructor
     * @returns a new `GtkPasswordEntry`
     */
    constructor()
    /**
     * Creates a `GtkPasswordEntry`.
     * @constructor
     * @returns a new `GtkPasswordEntry`
     */
    static new(): PasswordEntry
    _init(config?: PasswordEntry.ConstructorProperties): void
  }

  module PasswordEntryBuffer {
    // Constructor properties interface

    interface ConstructorProperties extends EntryBuffer.ConstructorProperties {}
  }

  interface PasswordEntryBuffer {
    // Own properties of Gtk-4.0.Gtk.PasswordEntryBuffer

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.PasswordEntryBuffer

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::length", ...args: any[]): void
    connect(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-length", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkEntryBuffer` that locks the underlying memory to prevent it
   * from being swapped to disk.
   *
   * `GtkPasswordEntry` uses a `GtkPasswordEntryBuffer`.
   * @class
   */
  class PasswordEntryBuffer extends EntryBuffer {
    // Own properties of Gtk-4.0.Gtk.PasswordEntryBuffer

    static name: string

    // Constructors of Gtk-4.0.Gtk.PasswordEntryBuffer

    constructor(config?: PasswordEntryBuffer.ConstructorProperties)
    /**
     * Creates a new `GtkEntryBuffer` using secure memory allocations.
     * @constructor
     * @returns the newly created instance
     */
    constructor()
    /**
     * Creates a new `GtkEntryBuffer` using secure memory allocations.
     * @constructor
     * @returns the newly created instance
     */
    static new(): PasswordEntryBuffer

    // Overloads of new

    /**
     * Create a new `GtkEntryBuffer` object.
     *
     * Optionally, specify initial text to set in the buffer.
     * @constructor
     * @param initialChars initial buffer text
     * @param nInitialChars number of characters in `initial_chars,` or -1
     * @returns A new `GtkEntryBuffer` object.
     */
    static new(initialChars: string | null, nInitialChars: number): EntryBuffer
    _init(config?: PasswordEntryBuffer.ConstructorProperties): void
  }

  module Picture {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Picture

      /**
       * The alternative textual description for the picture.
       */
      alternative_text?: string | null
      /**
       * If the `GtkPicture` can be made smaller than the natural size of its contents.
       */
      can_shrink?: boolean | null
      /**
       * How the content should be resized to fit inside the `GtkPicture`.
       */
      content_fit?: ContentFit | null
      /**
       * The `GFile` that is displayed or %NULL if none.
       */
      file?: Gio.File | null
      /**
       * Whether the GtkPicture will render its contents trying to preserve the aspect
       * ratio.
       */
      keep_aspect_ratio?: boolean | null
      /**
       * The `GdkPaintable` to be displayed by this `GtkPicture`.
       */
      paintable?: Gdk.Paintable | null
    }
  }

  interface Picture extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Picture

    /**
     * The alternative textual description for the picture.
     */
    alternativeText: string | null
    /**
     * If the `GtkPicture` can be made smaller than the natural size of its contents.
     */
    canShrink: boolean
    /**
     * How the content should be resized to fit inside the `GtkPicture`.
     */
    contentFit: ContentFit
    /**
     * The `GFile` that is displayed or %NULL if none.
     */
    file: Gio.File
    /**
     * Whether the GtkPicture will render its contents trying to preserve the aspect
     * ratio.
     */
    keepAspectRatio: boolean
    /**
     * The `GdkPaintable` to be displayed by this `GtkPicture`.
     */
    paintable: Gdk.Paintable
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Picture

    /**
     * Gets the alternative textual description of the picture.
     *
     * The returned string will be %NULL if the picture cannot be described textually.
     * @returns the alternative textual description of @self.
     */
    getAlternativeText(): string | null
    /**
     * Returns whether the `GtkPicture` respects its contents size.
     * @returns %TRUE if the picture can be made smaller than its contents
     */
    getCanShrink(): boolean
    /**
     * Returns the fit mode for the content of the `GtkPicture`.
     *
     * See [enum`Gtk`.ContentFit] for details.
     * @returns the content fit mode
     */
    getContentFit(): ContentFit
    /**
     * Gets the `GFile` currently displayed if `self` is displaying a file.
     *
     * If `self` is not displaying a file, for example when
     * [method`Gtk`.Picture.set_paintable] was used, then %NULL is returned.
     * @returns The `GFile` displayed by @self.
     */
    getFile(): Gio.File | null
    /**
     * Returns whether the `GtkPicture` preserves its contents aspect ratio.
     * @returns %TRUE if the self tries to keep the contents' aspect ratio
     */
    getKeepAspectRatio(): boolean
    /**
     * Gets the `GdkPaintable` being displayed by the `GtkPicture`.
     * @returns the displayed paintable
     */
    getPaintable(): Gdk.Paintable | null
    /**
     * Sets an alternative textual description for the picture contents.
     *
     * It is equivalent to the "alt" attribute for images on websites.
     *
     * This text will be made available to accessibility tools.
     *
     * If the picture cannot be described textually, set this property to %NULL.
     * @param alternativeText a textual description of the contents
     */
    setAlternativeText(alternativeText: string | null): void
    /**
     * If set to %TRUE, the `self` can be made smaller than its contents.
     *
     * The contents will then be scaled down when rendering.
     *
     * If you want to still force a minimum size manually, consider using
     * [method`Gtk`.Widget.set_size_request].
     *
     * Also of note is that a similar function for growing does not exist
     * because the grow behavior can be controlled via
     * [method`Gtk`.Widget.set_halign] and [method`Gtk`.Widget.set_valign].
     * @param canShrink if `self` can be made smaller than its contents
     */
    setCanShrink(canShrink: boolean): void
    /**
     * Sets how the content should be resized to fit the `GtkPicture`.
     *
     * See [enum`Gtk`.ContentFit] for details.
     * @param contentFit the content fit mode
     */
    setContentFit(contentFit: ContentFit): void
    /**
     * Makes `self` load and display `file`.
     *
     * See [ctor`Gtk`.Picture.new_for_file] for details.
     * @param file a `GFile`
     */
    setFile(file: Gio.File | null): void
    /**
     * Makes `self` load and display the given `filename`.
     *
     * This is a utility function that calls [method`Gtk`.Picture.set_file].
     * @param filename the filename to play
     */
    setFilename(filename: string | null): void
    /**
     * If set to %TRUE, the `self` will render its contents according to
     * their aspect ratio.
     *
     * That means that empty space may show up at the top/bottom or
     * left/right of `self`.
     *
     * If set to %FALSE or if the contents provide no aspect ratio,
     * the contents will be stretched over the picture's whole area.
     * @param keepAspectRatio whether to keep aspect ratio
     */
    setKeepAspectRatio(keepAspectRatio: boolean): void
    /**
     * Makes `self` display the given `paintable`.
     *
     * If `paintable` is %NULL, nothing will be displayed.
     *
     * See [ctor`Gtk`.Picture.new_for_paintable] for details.
     * @param paintable a `GdkPaintable`
     */
    setPaintable(paintable: Gdk.Paintable | null): void
    /**
     * Sets a `GtkPicture` to show a `GdkPixbuf`.
     *
     * See [ctor`Gtk`.Picture.new_for_pixbuf] for details.
     *
     * This is a utility function that calls [method`Gtk`.Picture.set_paintable].
     * @param pixbuf a `GdkPixbuf`
     */
    setPixbuf(pixbuf: GdkPixbuf.Pixbuf | null): void
    /**
     * Makes `self` load and display the resource at the given
     * `resource_path`.
     *
     * This is a utility function that calls [method`Gtk`.Picture.set_file].
     * @param resourcePath the resource to set
     */
    setResource(resourcePath: string | null): void

    // Class property signals of Gtk-4.0.Gtk.Picture

    connect(
      sigName: "notify::alternative-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::alternative-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::alternative-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::alternative-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::alternative-text", ...args: any[]): void
    connect(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-shrink", ...args: any[]): void
    connect(
      sigName: "notify::content-fit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::content-fit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::content-fit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::content-fit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::content-fit", ...args: any[]): void
    connect(sigName: "notify::file", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file", ...args: any[]): void
    connect(
      sigName: "notify::keep-aspect-ratio",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::keep-aspect-ratio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::keep-aspect-ratio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::keep-aspect-ratio",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::keep-aspect-ratio", ...args: any[]): void
    connect(
      sigName: "notify::paintable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::paintable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::paintable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::paintable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::paintable", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkPicture` widget displays a `GdkPaintable`.
   *
   * ![An example GtkPicture](picture.png)
   *
   * Many convenience functions are provided to make pictures simple to use.
   * For example, if you want to load an image from a file, and then display
   * it, there’s a convenience function to do this:
   *
   * ```c
   * GtkWidget *widget = gtk_picture_new_for_filename ("myfile.png");
   * ```
   *
   * If the file isn’t loaded successfully, the picture will contain a
   * “broken image” icon similar to that used in many web browsers.
   * If you want to handle errors in loading the file yourself,
   * for example by displaying an error message, then load the image with
   * [ctor`Gdk`.Texture.new_from_file], then create the `GtkPicture` with
   * [ctor`Gtk`.Picture.new_for_paintable].
   *
   * Sometimes an application will want to avoid depending on external data
   * files, such as image files. See the documentation of `GResource` for details.
   * In this case, [ctor`Gtk`.Picture.new_for_resource] and
   * [method`Gtk`.Picture.set_resource] should be used.
   *
   * `GtkPicture` displays an image at its natural size. See [class`Gtk`.Image]
   * if you want to display a fixed-size image, such as an icon.
   *
   * ## Sizing the paintable
   *
   * You can influence how the paintable is displayed inside the `GtkPicture`
   * by changing [property`Gtk`.Picture:content-fit]. See [enum`Gtk`.ContentFit]
   * for details. [property`Gtk`.Picture:can-shrink] can be unset to make sure
   * that paintables are never made smaller than their ideal size - but
   * be careful if you do not know the size of the paintable in use (like
   * when displaying user-loaded images). This can easily cause the picture to
   * grow larger than the screen. And [property`Gtk`.Widget:halign] and
   * [property`Gtk`.Widget:valign] can be used to make sure the paintable doesn't
   * fill all available space but is instead displayed at its original size.
   *
   * ## CSS nodes
   *
   * `GtkPicture` has a single CSS node with the name `picture`.
   *
   * ## Accessibility
   *
   * `GtkPicture` uses the `GTK_ACCESSIBLE_ROLE_IMG` role.
   * @class
   */
  class Picture extends Widget {
    // Own properties of Gtk-4.0.Gtk.Picture

    static name: string

    // Constructors of Gtk-4.0.Gtk.Picture

    constructor(config?: Picture.ConstructorProperties)
    /**
     * Creates a new empty `GtkPicture` widget.
     * @constructor
     * @returns a newly created `GtkPicture` widget.
     */
    constructor()
    /**
     * Creates a new empty `GtkPicture` widget.
     * @constructor
     * @returns a newly created `GtkPicture` widget.
     */
    static new(): Picture
    /**
     * Creates a new `GtkPicture` displaying the given `file`.
     *
     * If the file isn’t found or can’t be loaded, the resulting
     * `GtkPicture` is empty.
     *
     * If you need to detect failures to load the file, use
     * [ctor`Gdk`.Texture.new_from_file] to load the file yourself,
     * then create the `GtkPicture` from the texture.
     * @constructor
     * @param file a `GFile`
     * @returns a new `GtkPicture`
     */
    static newForFile(file: Gio.File | null): Picture
    /**
     * Creates a new `GtkPicture` displaying the file `filename`.
     *
     * This is a utility function that calls [ctor`Gtk`.Picture.new_for_file].
     * See that function for details.
     * @constructor
     * @param filename a filename
     * @returns a new `GtkPicture`
     */
    static newForFilename(filename: string | null): Picture
    /**
     * Creates a new `GtkPicture` displaying `paintable`.
     *
     * The `GtkPicture` will track changes to the `paintable` and update
     * its size and contents in response to it.
     * @constructor
     * @param paintable a `GdkPaintable`
     * @returns a new `GtkPicture`
     */
    static newForPaintable(paintable: Gdk.Paintable | null): Picture
    /**
     * Creates a new `GtkPicture` displaying `pixbuf`.
     *
     * This is a utility function that calls [ctor`Gtk`.Picture.new_for_paintable],
     * See that function for details.
     *
     * The pixbuf must not be modified after passing it to this function.
     * @constructor
     * @param pixbuf a `GdkPixbuf`
     * @returns a new `GtkPicture`
     */
    static newForPixbuf(pixbuf: GdkPixbuf.Pixbuf | null): Picture
    /**
     * Creates a new `GtkPicture` displaying the resource at `resource_path`.
     *
     * This is a utility function that calls [ctor`Gtk`.Picture.new_for_file].
     * See that function for details.
     * @constructor
     * @param resourcePath resource path to play back
     * @returns a new `GtkPicture`
     */
    static newForResource(resourcePath: string | null): Picture
    _init(config?: Picture.ConstructorProperties): void
  }

  module Popover {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate-default`
     */
    interface ActivateDefaultSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `closed`
     */
    interface ClosedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Popover

      /**
       * Whether to dismiss the popover on outside clicks.
       */
      autohide?: boolean | null
      /**
       * Whether the popover pops down after a child popover.
       *
       * This is used to implement the expected behavior of submenus.
       */
      cascade_popdown?: boolean | null
      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * The default widget inside the popover.
       */
      default_widget?: Widget | null
      /**
       * Whether to draw an arrow.
       */
      has_arrow?: boolean | null
      /**
       * Whether mnemonics are currently visible in this popover.
       */
      mnemonics_visible?: boolean | null
      /**
       * Rectangle in the parent widget that the popover points to.
       */
      pointing_to?: Gdk.Rectangle | null
      /**
       * How to place the popover, relative to its parent.
       */
      position?: PositionType | null
    }
  }

  interface Popover
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.Popover

    /**
     * Whether to dismiss the popover on outside clicks.
     */
    autohide: boolean
    /**
     * Whether the popover pops down after a child popover.
     *
     * This is used to implement the expected behavior of submenus.
     */
    cascadePopdown: boolean
    /**
     * The child widget.
     */
    child: Widget
    /**
     * The default widget inside the popover.
     */
    defaultWidget: Widget
    /**
     * Whether to draw an arrow.
     */
    hasArrow: boolean
    /**
     * Whether mnemonics are currently visible in this popover.
     */
    mnemonicsVisible: boolean
    /**
     * Rectangle in the parent widget that the popover points to.
     */
    pointingTo: Gdk.Rectangle
    /**
     * How to place the popover, relative to its parent.
     */
    position: PositionType
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Popover

    readonly parent: Widget & Widget

    // Owm methods of Gtk-4.0.Gtk.Popover

    /**
     * Returns whether the popover is modal.
     *
     * See [method`Gtk`.Popover.set_autohide] for the
     * implications of this.
     * @returns %TRUE if @popover is modal
     */
    getAutohide(): boolean
    /**
     * Returns whether the popover will close after a modal child is closed.
     * @returns %TRUE if @popover will close after a modal child.
     */
    getCascadePopdown(): boolean
    /**
     * Gets the child widget of `popover`.
     * @returns the child widget of @popover
     */
    getChild(): Widget | null
    /**
     * Gets whether this popover is showing an arrow
     * pointing at the widget that it is relative to.
     * @returns whether the popover has an arrow
     */
    getHasArrow(): boolean
    /**
     * Gets whether mnemonics are visible.
     * @returns %TRUE if mnemonics are supposed to be visible   in this popover
     */
    getMnemonicsVisible(): boolean
    /**
     * Gets the offset previous set with [method`Gtk`.Popover.set_offset()].
     */
    getOffset(): [/* xOffset */ number, /* yOffset */ number]
    /**
     * Gets the rectangle that the popover points to.
     *
     * If a rectangle to point to has been set, this function will
     * return %TRUE and fill in `rect` with such rectangle, otherwise
     * it will return %FALSE and fill in `rect` with the parent
     * widget coordinates.
     * @returns %TRUE if a rectangle to point to was set.
     */
    getPointingTo(): [/* returnType */ boolean, /* rect */ Gdk.Rectangle]
    /**
     * Returns the preferred position of `popover`.
     * @returns The preferred position.
     */
    getPosition(): PositionType
    /**
     * Pops `popover` down.
     *
     * This may have the side-effect of closing a parent popover
     * as well. See [property`Gtk`.Popover:cascade-popdown].
     */
    popdown(): void
    /**
     * Pops `popover` up.
     */
    popup(): void
    /**
     * Allocate a size for the `GtkPopover`.
     *
     * This function needs to be called in size-allocate by widgets
     * who have a `GtkPopover` as child. When using a layout manager,
     * this is happening automatically.
     *
     * To make a popover appear on screen, use [method`Gtk`.Popover.popup].
     */
    present(): void
    /**
     * Sets whether `popover` is modal.
     *
     * A modal popover will grab the keyboard focus on it when being
     * displayed. Focus will wrap around within the popover. Clicking
     * outside the popover area or pressing Esc will dismiss the popover.
     *
     * Called this function on an already showing popup with a new
     * autohide value different from the current one, will cause the
     * popup to be hidden.
     * @param autohide %TRUE to dismiss the popover on outside clicks
     */
    setAutohide(autohide: boolean): void
    /**
     * If `cascade_popdown` is %TRUE, the popover will be
     * closed when a child modal popover is closed.
     *
     * If %FALSE, `popover` will stay visible.
     * @param cascadePopdown %TRUE if the popover should follow a child closing
     */
    setCascadePopdown(cascadePopdown: boolean): void
    /**
     * Sets the child widget of `popover`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets the default widget of a `GtkPopover`.
     *
     * The default widget is the widget that’s activated when the user
     * presses Enter in a dialog (for example). This function sets or
     * unsets the default widget for a `GtkPopover`.
     * @param widget a child widget of `popover` to set as   the default, or %NULL to unset the default widget for the popover
     */
    setDefaultWidget(widget: Widget | null): void
    /**
     * Sets whether this popover should draw an arrow
     * pointing at the widget it is relative to.
     * @param hasArrow %TRUE to draw an arrow
     */
    setHasArrow(hasArrow: boolean): void
    /**
     * Sets whether mnemonics should be visible.
     * @param mnemonicsVisible the new value
     */
    setMnemonicsVisible(mnemonicsVisible: boolean): void
    /**
     * Sets the offset to use when calculating the position
     * of the popover.
     *
     * These values are used when preparing the [struct`Gdk`.PopupLayout]
     * for positioning the popover.
     * @param xOffset the x offset to adjust the position by
     * @param yOffset the y offset to adjust the position by
     */
    setOffset(xOffset: number, yOffset: number): void
    /**
     * Sets the rectangle that `popover` points to.
     *
     * This is in the coordinate space of the `popover` parent.
     * @param rect rectangle to point to
     */
    setPointingTo(rect: Gdk.Rectangle | null): void
    /**
     * Sets the preferred position for `popover` to appear.
     *
     * If the `popover` is currently visible, it will be immediately
     * updated.
     *
     * This preference will be respected where possible, although
     * on lack of space (eg. if close to the window edges), the
     * `GtkPopover` may choose to appear on the opposite side.
     * @param position preferred popover position
     */
    setPosition(position: PositionType): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Own virtual methods of Gtk-4.0.Gtk.Popover

    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    closed(): void

    // Own signals of Gtk-4.0.Gtk.Popover

    connect(
      sigName: "activate-default",
      callback: Popover.ActivateDefaultSignalCallback
    ): number
    on(
      sigName: "activate-default",
      callback: Popover.ActivateDefaultSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-default",
      callback: Popover.ActivateDefaultSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-default",
      callback: Popover.ActivateDefaultSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-default", ...args: any[]): void
    connect(sigName: "closed", callback: Popover.ClosedSignalCallback): number
    on(
      sigName: "closed",
      callback: Popover.ClosedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "closed",
      callback: Popover.ClosedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "closed",
      callback: Popover.ClosedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "closed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Popover

    connect(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::autohide", ...args: any[]): void
    connect(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cascade-popdown", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-arrow", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pointing-to", ...args: any[]): void
    connect(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPopover` is a bubble-like context popup.
   *
   * ![An example GtkPopover](popover.png)
   *
   * It is primarily meant to provide context-dependent information
   * or options. Popovers are attached to a parent widget. By default,
   * they point to the whole widget area, although this behavior can be
   * changed with [method`Gtk`.Popover.set_pointing_to].
   *
   * The position of a popover relative to the widget it is attached to
   * can also be changed with [method`Gtk`.Popover.set_position]
   *
   * By default, `GtkPopover` performs a grab, in order to ensure input
   * events get redirected to it while it is shown, and also so the popover
   * is dismissed in the expected situations (clicks outside the popover,
   * or the Escape key being pressed). If no such modal behavior is desired
   * on a popover, [method`Gtk`.Popover.set_autohide] may be called on it to
   * tweak its behavior.
   *
   * ## GtkPopover as menu replacement
   *
   * `GtkPopover` is often used to replace menus. The best was to do this
   * is to use the [class`Gtk`.PopoverMenu] subclass which supports being
   * populated from a `GMenuModel` with [ctor`Gtk`.PopoverMenu.new_from_model].
   *
   * ```xml
   * <section>
   *   <attribute name="display-hint">horizontal-buttons</attribute>
   *   <item>
   *     <attribute name="label">Cut</attribute>
   *     <attribute name="action">app.cut</attribute>
   *     <attribute name="verb-icon">edit-cut-symbolic</attribute>
   *   </item>
   *   <item>
   *     <attribute name="label">Copy</attribute>
   *     <attribute name="action">app.copy</attribute>
   *     <attribute name="verb-icon">edit-copy-symbolic</attribute>
   *   </item>
   *   <item>
   *     <attribute name="label">Paste</attribute>
   *     <attribute name="action">app.paste</attribute>
   *     <attribute name="verb-icon">edit-paste-symbolic</attribute>
   *   </item>
   * </section>
   * ```
   *
   * # CSS nodes
   *
   * ```
   * popover.background[.menu]
   * ├── arrow
   * ╰── contents
   *     ╰── <child>
   * ```
   *
   * `GtkPopover` has a main node with name `popover`, an arrow with name `arrow`,
   * and another node for the content named `contents`. The `popover` node always
   * gets the `.background` style class. It also gets the `.menu` style class
   * if the popover is menu-like, e.g. is a [class`Gtk`.PopoverMenu].
   *
   * Particular uses of `GtkPopover`, such as touch selection popups or
   * magnifiers in `GtkEntry` or `GtkTextView` get style classes like
   * `.touch-selection` or `.magnifier` to differentiate from plain popovers.
   *
   * When styling a popover directly, the `popover` node should usually
   * not have any background. The visible part of the popover can have
   * a shadow. To specify it in CSS, set the box-shadow of the `contents` node.
   *
   * Note that, in order to accomplish appropriate arrow visuals, `GtkPopover`
   * uses custom drawing for the `arrow` node. This makes it possible for the
   * arrow to change its shape dynamically, but it also limits the possibilities
   * of styling it using CSS. In particular, the `arrow` gets drawn over the
   * `content` node's border and shadow, so they look like one shape, which
   * means that the border width of the `content` node and the `arrow` node should
   * be the same. The arrow also does not support any border shape other than
   * solid, no border-radius, only one border width (border-bottom-width is
   * used) and no box-shadow.
   * @class
   */
  class Popover extends Widget {
    // Own properties of Gtk-4.0.Gtk.Popover

    static name: string

    // Constructors of Gtk-4.0.Gtk.Popover

    constructor(config?: Popover.ConstructorProperties)
    /**
     * Creates a new `GtkPopover`.
     * @constructor
     * @returns the new `GtkPopover`
     */
    constructor()
    /**
     * Creates a new `GtkPopover`.
     * @constructor
     * @returns the new `GtkPopover`
     */
    static new(): Popover
    _init(config?: Popover.ConstructorProperties): void
  }

  module PopoverMenu {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Popover.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.PopoverMenu

      /**
       * The flags that `popover` uses to create/display a menu from its model.
       *
       * If a model is set and the flags change, contents are rebuilt, so if setting
       * properties individually, set flags before model to avoid a redundant rebuild.
       */
      flags?: PopoverMenuFlags | null
      /**
       * The model from which the menu is made.
       */
      menu_model?: Gio.MenuModel | null
      /**
       * The name of the visible submenu.
       */
      visible_submenu?: string | null
    }
  }

  interface PopoverMenu
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.PopoverMenu

    /**
     * The flags that `popover` uses to create/display a menu from its model.
     *
     * If a model is set and the flags change, contents are rebuilt, so if setting
     * properties individually, set flags before model to avoid a redundant rebuild.
     */
    flags: PopoverMenuFlags
    /**
     * The model from which the menu is made.
     */
    menuModel: Gio.MenuModel
    /**
     * The name of the visible submenu.
     */
    visibleSubmenu: string | null
    __gtype__: number

    // Conflicting properties

    readonly parent: Widget & Widget

    // Owm methods of Gtk-4.0.Gtk.PopoverMenu

    /**
     * Adds a custom widget to a generated menu.
     *
     * For this to work, the menu model of `popover` must have
     * an item with a `custom` attribute that matches `id`.
     * @param child the `GtkWidget` to add
     * @param id the ID to insert `child` at
     * @returns %TRUE if @id was found and the widget added
     */
    addChild(child: Widget, id: string): boolean

    // Overloads of addChild

    /**
     * Adds a child to `buildable`. `type` is an optional string
     * describing how the child should be added.
     * @virtual
     * @param builder a `GtkBuilder`
     * @param child child to add
     * @param type kind of child or %NULL
     */
    addChild(builder: Builder, child: GObject.Object, type: string | null): void
    /**
     * Returns the flags that `popover` uses to create/display a menu from its model.
     * @returns the `GtkPopoverMenuFlags`
     */
    getFlags(): PopoverMenuFlags
    /**
     * Returns the menu model used to populate the popover.
     * @returns the menu model of @popover
     */
    getMenuModel(): Gio.MenuModel | null
    /**
     * Removes a widget that has previously been added with
     * [method`Gtk`.PopoverMenu.add_child()]
     * @param child the `GtkWidget` to remove
     * @returns %TRUE if the widget was removed
     */
    removeChild(child: Widget): boolean
    /**
     * Sets the flags that `popover` uses to create/display a menu from its model.
     *
     * If a model is set and the flags change, contents are rebuilt, so if setting
     * properties individually, set flags before model to avoid a redundant rebuild.
     * @param flags a set of `GtkPopoverMenuFlags`
     */
    setFlags(flags: PopoverMenuFlags): void
    /**
     * Sets a new menu model on `popover`.
     *
     * The existing contents of `popover` are removed, and
     * the `popover` is populated with new contents according
     * to `model`.
     * @param model a `GMenuModel`
     */
    setMenuModel(model: Gio.MenuModel | null): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Class property signals of Gtk-4.0.Gtk.PopoverMenu

    connect(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::flags",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::flags",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::flags", ...args: any[]): void
    connect(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::menu-model", ...args: any[]): void
    connect(
      sigName: "notify::visible-submenu",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible-submenu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible-submenu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible-submenu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible-submenu", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::autohide",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::autohide", ...args: any[]): void
    connect(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cascade-popdown",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cascade-popdown", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-arrow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-arrow", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pointing-to",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pointing-to", ...args: any[]): void
    connect(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::position", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPopoverMenu` is a subclass of `GtkPopover` that implements menu
   * behavior.
   *
   * ![An example GtkPopoverMenu](menu.png)
   *
   * `GtkPopoverMenu` treats its children like menus and allows switching
   * between them. It can open submenus as traditional, nested submenus,
   * or in a more touch-friendly sliding fashion.
   * The property [property`Gtk`.PopoverMenu:flags] controls this appearance.
   *
   * `GtkPopoverMenu` is meant to be used primarily with menu models,
   * using [ctor`Gtk`.PopoverMenu.new_from_model]. If you need to put
   * other widgets such as a `GtkSpinButton` or a `GtkSwitch` into a popover,
   * you can use [method`Gtk`.PopoverMenu.add_child].
   *
   * For more dialog-like behavior, use a plain `GtkPopover`.
   *
   * ## Menu models
   *
   * The XML format understood by `GtkBuilder` for `GMenuModel` consists
   * of a toplevel `<menu>` element, which contains one or more `<item>`
   * elements. Each `<item>` element contains `<attribute>` and `<link>`
   * elements with a mandatory name attribute. `<link>` elements have the
   * same content model as `<menu>`. Instead of `<link name="submenu">`
   * or `<link name="section">`, you can use `<submenu>` or `<section>`
   * elements.
   *
   * ```xml
   * <menu id='app-menu'>
   *   <section>
   *     <item>
   *       <attribute name='label' translatable='yes'>_New Window</attribute>
   *       <attribute name='action'>app.new</attribute>
   *     </item>
   *     <item>
   *       <attribute name='label' translatable='yes'>_About Sunny</attribute>
   *       <attribute name='action'>app.about</attribute>
   *     </item>
   *     <item>
   *       <attribute name='label' translatable='yes'>_Quit</attribute>
   *       <attribute name='action'>app.quit</attribute>
   *     </item>
   *   </section>
   * </menu>
   * ```
   *
   * Attribute values can be translated using gettext, like other `GtkBuilder`
   * content. `<attribute>` elements can be marked for translation with a
   * `translatable="yes"` attribute. It is also possible to specify message
   * context and translator comments, using the context and comments attributes.
   * To make use of this, the `GtkBuilder` must have been given the gettext
   * domain to use.
   *
   * The following attributes are used when constructing menu items:
   *
   * - "label": a user-visible string to display
   * - "use-markup": whether the text in the menu item includes [Pango markup](https://docs.gtk.org/Pango/pango_markup.html)
   * - "action": the prefixed name of the action to trigger
   * - "target": the parameter to use when activating the action
   * - "icon" and "verb-icon": names of icons that may be displayed
   * - "submenu-action": name of an action that may be used to track
   *      whether a submenu is open
   * - "hidden-when": a string used to determine when the item will be hidden.
   *      Possible values include "action-disabled", "action-missing", "macos-menubar".
   *      This is mainly useful for exported menus, see [method`Gtk`.Application.set_menubar].
   * - "custom": a string used to match against the ID of a custom child added with
   *      [method`Gtk`.PopoverMenu.add_child], [method`Gtk`.PopoverMenuBar.add_child],
   *      or in the ui file with `<child type="ID">`.
   *
   * The following attributes are used when constructing sections:
   *
   * - "label": a user-visible string to use as section heading
   * - "display-hint": a string used to determine special formatting for the section.
   *     Possible values include "horizontal-buttons", "circular-buttons" and
   *     "inline-buttons". They all indicate that section should be
   *     displayed as a horizontal row of buttons.
   * - "text-direction": a string used to determine the `GtkTextDirection` to use
   *     when "display-hint" is set to "horizontal-buttons". Possible values
   *     include "rtl", "ltr", and "none".
   *
   * The following attributes are used when constructing submenus:
   *
   * - "label": a user-visible string to display
   * - "icon": icon name to display
   *
   * Menu items will also show accelerators, which are usually associated
   * with actions via [method`Gtk`.Application.set_accels_for_action],
   * [method`WidgetClass`.add_binding_action] or
   * [method`Gtk`.ShortcutController.add_shortcut].
   *
   * # CSS Nodes
   *
   * `GtkPopoverMenu` is just a subclass of `GtkPopover` that adds custom content
   * to it, therefore it has the same CSS nodes. It is one of the cases that add
   * a `.menu` style class to the main `popover` node.
   *
   * Menu items have nodes with name `button` and class `.model`. If a section
   * display-hint is set, the section gets a node `box` with class `horizontal`
   * plus a class with the same text as the display hint. Note that said box may
   * not be the direct ancestor of the item `button`s. Thus, for example, to style
   * items in an `inline-buttons` section, select `.inline-buttons button.model`.
   * Other things that may be of interest to style in menus include `label` nodes.
   *
   * # Accessibility
   *
   * `GtkPopoverMenu` uses the %GTK_ACCESSIBLE_ROLE_MENU role, and its
   * items use the %GTK_ACCESSIBLE_ROLE_MENU_ITEM,
   * %GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX or
   * %GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO roles, depending on the
   * action they are connected to.
   * @class
   */
  class PopoverMenu extends Popover {
    // Own properties of Gtk-4.0.Gtk.PopoverMenu

    static name: string

    // Constructors of Gtk-4.0.Gtk.PopoverMenu

    constructor(config?: PopoverMenu.ConstructorProperties)
    /**
     * Creates a `GtkPopoverMenu` and populates it according to `model`.
     *
     * The created buttons are connected to actions found in the
     * `GtkApplicationWindow` to which the popover belongs - typically
     * by means of being attached to a widget that is contained within
     * the `GtkApplicationWindow`s widget hierarchy.
     *
     * Actions can also be added using [method`Gtk`.Widget.insert_action_group]
     * on the menus attach widget or on any of its parent widgets.
     *
     * This function creates menus with sliding submenus.
     * See [ctor`Gtk`.PopoverMenu.new_from_model_full] for a way
     * to control this.
     * @constructor
     * @param model a `GMenuModel`
     * @returns the new `GtkPopoverMenu`
     */
    static newFromModel(model: Gio.MenuModel | null): PopoverMenu
    /**
     * Creates a `GtkPopoverMenu` and populates it according to `model`.
     *
     * The created buttons are connected to actions found in the
     * action groups that are accessible from the parent widget.
     * This includes the `GtkApplicationWindow` to which the popover
     * belongs. Actions can also be added using [method`Gtk`.Widget.insert_action_group]
     * on the parent widget or on any of its parent widgets.
     * @constructor
     * @param model a `GMenuModel`
     * @param flags flags that affect how the menu is created
     * @returns the new `GtkPopoverMenu`
     */
    static newFromModelFull(
      model: Gio.MenuModel,
      flags: PopoverMenuFlags
    ): PopoverMenu
    _init(config?: PopoverMenu.ConstructorProperties): void
  }

  module PopoverMenuBar {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.PopoverMenuBar

      /**
       * The `GMenuModel` from which the menu bar is created.
       *
       * The model should only contain submenus as toplevel elements.
       */
      menu_model?: Gio.MenuModel | null
    }
  }

  interface PopoverMenuBar extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.PopoverMenuBar

    /**
     * The `GMenuModel` from which the menu bar is created.
     *
     * The model should only contain submenus as toplevel elements.
     */
    menuModel: Gio.MenuModel
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PopoverMenuBar

    /**
     * Adds a custom widget to a generated menubar.
     *
     * For this to work, the menu model of `bar` must have an
     * item with a `custom` attribute that matches `id`.
     * @param child the `GtkWidget` to add
     * @param id the ID to insert `child` at
     * @returns %TRUE if @id was found and the widget added
     */
    addChild(child: Widget, id: string): boolean

    // Overloads of addChild

    /**
     * Adds a child to `buildable`. `type` is an optional string
     * describing how the child should be added.
     * @virtual
     * @param builder a `GtkBuilder`
     * @param child child to add
     * @param type kind of child or %NULL
     */
    addChild(builder: Builder, child: GObject.Object, type: string | null): void
    /**
     * Returns the model from which the contents of `bar` are taken.
     * @returns a `GMenuModel`
     */
    getMenuModel(): Gio.MenuModel | null
    /**
     * Removes a widget that has previously been added with
     * gtk_popover_menu_bar_add_child().
     * @param child the `GtkWidget` to remove
     * @returns %TRUE if the widget was removed
     */
    removeChild(child: Widget): boolean
    /**
     * Sets a menu model from which `bar` should take
     * its contents.
     * @param model a `GMenuModel`
     */
    setMenuModel(model: Gio.MenuModel | null): void

    // Class property signals of Gtk-4.0.Gtk.PopoverMenuBar

    connect(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::menu-model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::menu-model", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPopoverMenuBar` presents a horizontal bar of items that pop
   * up popover menus when clicked.
   *
   * ![An example GtkPopoverMenuBar](menubar.png)
   *
   * The only way to create instances of `GtkPopoverMenuBar` is
   * from a `GMenuModel`.
   *
   * # CSS nodes
   *
   * ```
   * menubar
   * ├── item[.active]
   * ┊   ╰── popover
   * ╰── item
   *     ╰── popover
   * ```
   *
   * `GtkPopoverMenuBar` has a single CSS node with name menubar, below which
   * each item has its CSS node, and below that the corresponding popover.
   *
   * The item whose popover is currently open gets the .active
   * style class.
   *
   * # Accessibility
   *
   * `GtkPopoverMenuBar` uses the %GTK_ACCESSIBLE_ROLE_MENU_BAR role,
   * the menu items use the %GTK_ACCESSIBLE_ROLE_MENU_ITEM role and
   * the menus use the %GTK_ACCESSIBLE_ROLE_MENU role.
   * @class
   */
  class PopoverMenuBar extends Widget {
    // Own properties of Gtk-4.0.Gtk.PopoverMenuBar

    static name: string

    // Constructors of Gtk-4.0.Gtk.PopoverMenuBar

    constructor(config?: PopoverMenuBar.ConstructorProperties)
    /**
     * Creates a `GtkPopoverMenuBar` from a `GMenuModel`.
     * @constructor
     * @param model a `GMenuModel`
     * @returns a new `GtkPopoverMenuBar`
     */
    static newFromModel(model: Gio.MenuModel | null): PopoverMenuBar
    _init(config?: PopoverMenuBar.ConstructorProperties): void
  }

  module PrintContext {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface PrintContext {
    // Own properties of Gtk-4.0.Gtk.PrintContext

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PrintContext

    /**
     * Creates a new `PangoContext` that can be used with the
     * `GtkPrintContext`.
     * @returns a new Pango context for @context
     */
    createPangoContext(): Pango.Context
    /**
     * Creates a new `PangoLayout` that is suitable for use
     * with the `GtkPrintContext`.
     * @returns a new Pango layout for @context
     */
    createPangoLayout(): Pango.Layout
    /**
     * Obtains the cairo context that is associated with the
     * `GtkPrintContext`.
     * @returns the cairo context of @context
     */
    getCairoContext(): cairo.Context
    /**
     * Obtains the horizontal resolution of the `GtkPrintContext`,
     * in dots per inch.
     * @returns the horizontal resolution of @context
     */
    getDpiX(): number
    /**
     * Obtains the vertical resolution of the `GtkPrintContext`,
     * in dots per inch.
     * @returns the vertical resolution of @context
     */
    getDpiY(): number
    /**
     * Obtains the hardware printer margins of the `GtkPrintContext`,
     * in units.
     * @returns %TRUE if the hard margins were retrieved
     */
    getHardMargins(): [
      /* returnType */ boolean,
      /* top */ number,
      /* bottom */ number,
      /* left */ number,
      /* right */ number,
    ]
    /**
     * Obtains the height of the `GtkPrintContext`, in pixels.
     * @returns the height of @context
     */
    getHeight(): number
    /**
     * Obtains the `GtkPageSetup` that determines the page
     * dimensions of the `GtkPrintContext`.
     * @returns the page setup of @context
     */
    getPageSetup(): PageSetup
    /**
     * Returns a `PangoFontMap` that is suitable for use
     * with the `GtkPrintContext`.
     * @returns the font map of @context
     */
    getPangoFontmap(): Pango.FontMap
    /**
     * Obtains the width of the `GtkPrintContext`, in pixels.
     * @returns the width of @context
     */
    getWidth(): number
    /**
     * Sets a new cairo context on a print context.
     *
     * This function is intended to be used when implementing
     * an internal print preview, it is not needed for printing,
     * since GTK itself creates a suitable cairo context in that
     * case.
     * @param cr the cairo context
     * @param dpiX the horizontal resolution to use with `cr`
     * @param dpiY the vertical resolution to use with `cr`
     */
    setCairoContext(cr: cairo.Context, dpiX: number, dpiY: number): void

    // Class property signals of Gtk-4.0.Gtk.PrintContext

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkPrintContext` encapsulates context information that is required when
   * drawing pages for printing.
   *
   * This includes the cairo context and important parameters like page size
   * and resolution. It also lets you easily create [class`Pango`.Layout] and
   * [class`Pango`.Context] objects that match the font metrics of the cairo surface.
   *
   * `GtkPrintContext` objects get passed to the
   * [signal`Gtk`.PrintOperation::begin-print],
   * [signal`Gtk`.PrintOperation::end-print],
   * [signal`Gtk`.PrintOperation::request-page-setup] and
   * [signal`Gtk`.PrintOperation::draw-page] signals on the
   * [class`Gtk`.PrintOperation] object.
   *
   * ## Using GtkPrintContext in a ::draw-page callback
   *
   * ```c
   * static void
   * draw_page (GtkPrintOperation *operation,
   *            GtkPrintContext   *context,
   *            int                page_nr)
   * {
   *   cairo_t *cr;
   *   PangoLayout *layout;
   *   PangoFontDescription *desc;
   *
   *   cr = gtk_print_context_get_cairo_context (context);
   *
   *   // Draw a red rectangle, as wide as the paper (inside the margins)
   *   cairo_set_source_rgb (cr, 1.0, 0, 0);
   *   cairo_rectangle (cr, 0, 0, gtk_print_context_get_width (context), 50);
   *
   *   cairo_fill (cr);
   *
   *   // Draw some lines
   *   cairo_move_to (cr, 20, 10);
   *   cairo_line_to (cr, 40, 20);
   *   cairo_arc (cr, 60, 60, 20, 0, M_PI);
   *   cairo_line_to (cr, 80, 20);
   *
   *   cairo_set_source_rgb (cr, 0, 0, 0);
   *   cairo_set_line_width (cr, 5);
   *   cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
   *   cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
   *
   *   cairo_stroke (cr);
   *
   *   // Draw some text
   *   layout = gtk_print_context_create_pango_layout (context);
   *   pango_layout_set_text (layout, "Hello World! Printing is easy", -1);
   *   desc = pango_font_description_from_string ("sans 28");
   *   pango_layout_set_font_description (layout, desc);
   *   pango_font_description_free (desc);
   *
   *   cairo_move_to (cr, 30, 20);
   *   pango_cairo_layout_path (cr, layout);
   *
   *   // Font Outline
   *   cairo_set_source_rgb (cr, 0.93, 1.0, 0.47);
   *   cairo_set_line_width (cr, 0.5);
   *   cairo_stroke_preserve (cr);
   *
   *   // Font Fill
   *   cairo_set_source_rgb (cr, 0, 0.0, 1.0);
   *   cairo_fill (cr);
   *
   *   g_object_unref (layout);
   * }
   * ```
   * @class
   */
  class PrintContext extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.PrintContext

    static name: string

    // Constructors of Gtk-4.0.Gtk.PrintContext

    constructor(config?: PrintContext.ConstructorProperties)
    _init(config?: PrintContext.ConstructorProperties): void
  }

  module PrintDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.PrintDialog

      /**
       * A label that may be shown on the accept button of a print dialog
       * that is presented by [method`Gtk`.PrintDialog.setup].
       */
      accept_label?: string | null
      /**
       * Whether the print dialog is modal.
       */
      modal?: boolean | null
      /**
       * The page setup to use.
       */
      page_setup?: PageSetup | null
      /**
       * The print settings to use.
       */
      print_settings?: PrintSettings | null
      /**
       * A title that may be shown on the print dialog that is
       * presented by [method`Gtk`.PrintDialog.setup].
       */
      title?: string | null
    }
  }

  interface PrintDialog {
    // Own properties of Gtk-4.0.Gtk.PrintDialog

    /**
     * A label that may be shown on the accept button of a print dialog
     * that is presented by [method`Gtk`.PrintDialog.setup].
     */
    acceptLabel: string | null
    /**
     * Whether the print dialog is modal.
     */
    modal: boolean
    /**
     * The page setup to use.
     */
    pageSetup: PageSetup
    /**
     * The print settings to use.
     */
    printSettings: PrintSettings
    /**
     * A title that may be shown on the print dialog that is
     * presented by [method`Gtk`.PrintDialog.setup].
     */
    title: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PrintDialog

    /**
     * Returns the label that will be shown on the
     * accept button of the print dialog.
     * @returns the accept label
     */
    getAcceptLabel(): string
    /**
     * Returns whether the print dialog blocks
     * interaction with the parent window while
     * it is presented.
     * @returns whether the print dialog is modal
     */
    getModal(): boolean
    /**
     * Returns the page setup.
     * @returns the page setup
     */
    getPageSetup(): PageSetup
    /**
     * Returns the print settings for the print dialog.
     * @returns the settings
     */
    getPrintSettings(): PrintSettings
    /**
     * Returns the title that will be shown on the
     * print dialog.
     * @returns the title
     */
    getTitle(): string
    /**
     * This function prints content from a stream.
     *
     * If you pass `NULL` as `setup,` then this method will present a print dialog.
     * Otherwise, it will attempt to print directly, without user interaction.
     *
     * The `callback` will be called when the printing is done. It should call
     * [method`Gtk`.PrintDialog.print_finish] to obtain the results.
     * @param parent the parent `GtkWindow`
     * @param setup the `GtkPrintSetup` to use
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    print(
      parent: Window | null,
      setup: PrintSetup | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * This function prints a file.
     *
     * If you pass `NULL` as `setup,` then this method will present a print dialog.
     * Otherwise, it will attempt to print directly, without user interaction.
     *
     * The `callback` will be called when the printing is done. It should call
     * [method`Gtk`.PrintDialog.print_file_finish] to obtain the results.
     * @param parent the parent `GtkWindow`
     * @param setup the `GtkPrintSetup` to use
     * @param file the `GFile` to print
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    printFile(
      parent: Window | null,
      setup: PrintSetup | null,
      file: Gio.File,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.PrintDialog.print_file] call and
     * returns the results.
     * @param result a `GAsyncResult`
     * @returns Whether the call was successful
     */
    printFileFinish(result: Gio.AsyncResult): boolean
    /**
     * Finishes the [method`Gtk`.PrintDialog.print] call and
     * returns the results.
     *
     * If the call was successful, the content to be printed should be
     * written to the returned output stream. Otherwise, `NULL` is returned.
     *
     * The overall results of the print operation will be returned in the
     * [method`Gio`.OutputStream.close] call, so if you are interested in the
     * results, you need to explicitly close the output stream (it will be
     * closed automatically if you just unref it). Be aware that the close
     * call may not be instant as it operation will for the printer to finish
     * printing.
     * @param result a `GAsyncResult`
     * @returns a [class@Gio.OutputStream]
     */
    printFinish(result: Gio.AsyncResult): Gio.OutputStream | null
    /**
     * Sets the label that will be shown on the
     * accept button of the print dialog shown for
     * [method`Gtk`.PrintDialog.setup].
     * @param acceptLabel the new accept label
     */
    setAcceptLabel(acceptLabel: string): void
    /**
     * Sets whether the print dialog blocks
     * interaction with the parent window while
     * it is presented.
     * @param modal the new value
     */
    setModal(modal: boolean): void
    /**
     * Set the page setup for the print dialog.
     * @param pageSetup the new page setup
     */
    setPageSetup(pageSetup: PageSetup): void
    /**
     * Sets the print settings for the print dialog.
     * @param printSettings the new print settings
     */
    setPrintSettings(printSettings: PrintSettings): void
    /**
     * Sets the title that will be shown on the print dialog.
     * @param title the new title
     */
    setTitle(title: string): void
    /**
     * This function presents a print dialog to let the user select a printer,
     * and set up print settings and page setup.
     *
     * The `callback` will be called when the dialog is dismissed.
     * It should call [method`Gtk`.PrintDialog.setup_finish]
     * to obtain the results in the form of a [struct`Gtk`.PrintSetup],
     * that can then be passed to [method`Gtk`.PrintDialog.print]
     * or [method`Gtk`.PrintDialog.print_file].
     *
     * One possible use for this method is to have the user select a printer,
     * then show a page setup UI in the application (e.g. to arrange images
     * on a page), then call [method`Gtk`.PrintDialog.print] on `self`
     * to do the printing without further user interaction.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    setup(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.PrintDialog.setup] call.
     *
     * If the call was successful, it returns a [struct`Gtk`.PrintSetup]
     * which contains the print settings and page setup information that
     * will be used to print.
     * @param result a `GAsyncResult`
     * @returns The `GtkPrintSetup` object that resulted from the call,   or `NULL` if the call was not successful
     */
    setupFinish(result: Gio.AsyncResult): PrintSetup | null

    // Class property signals of Gtk-4.0.Gtk.PrintDialog

    connect(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accept-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accept-label", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::page-setup", ...args: any[]): void
    connect(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::print-settings", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkPrintDialog` object collects the arguments that
   * are needed to present a print dialog to the user, such
   * as a title for the dialog and whether it should be modal.
   *
   * The dialog is shown with the [method`Gtk`.PrintDialog.setup] function.
   * The actual printing can be done with [method`Gtk`.PrintDialog.print] or
   * [method`Gtk`.PrintDialog.print_file]. These APIs follows the GIO async pattern,
   * and the results can be obtained by calling the corresponding finish methods.
   * @class
   */
  class PrintDialog extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.PrintDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.PrintDialog

    constructor(config?: PrintDialog.ConstructorProperties)
    /**
     * Creates a new `GtkPrintDialog` object.
     * @constructor
     * @returns the new `GtkPrintDialog`
     */
    constructor()
    /**
     * Creates a new `GtkPrintDialog` object.
     * @constructor
     * @returns the new `GtkPrintDialog`
     */
    static new(): PrintDialog
    _init(config?: PrintDialog.ConstructorProperties): void
  }

  module PrintJob {
    // Signal callback interfaces

    /**
     * Signal callback interface for `status-changed`
     */
    interface StatusChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.PrintJob

      /**
       * Page setup.
       */
      page_setup?: PageSetup | null
      /**
       * The printer to send the job to.
       */
      printer?: Printer | null
      /**
       * Printer settings.
       */
      settings?: PrintSettings | null
      /**
       * The title of the print job.
       */
      title?: string | null
      /**
       * %TRUE if the print job will continue to emit status-changed
       * signals after the print data has been setn to the printer.
       */
      track_print_status?: boolean | null
    }
  }

  interface PrintJob {
    // Own properties of Gtk-4.0.Gtk.PrintJob

    /**
     * Page setup.
     */
    readonly pageSetup: PageSetup
    /**
     * The printer to send the job to.
     */
    readonly printer: Printer
    /**
     * Printer settings.
     */
    readonly settings: PrintSettings
    /**
     * The title of the print job.
     */
    readonly title: string | null
    /**
     * %TRUE if the print job will continue to emit status-changed
     * signals after the print data has been setn to the printer.
     */
    trackPrintStatus: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PrintJob

    /**
     * Gets whether this job is printed collated.
     * @returns whether the job is printed collated
     */
    getCollate(): boolean
    /**
     * Gets the n-up setting for this job.
     * @returns the n-up setting
     */
    getNUp(): number
    /**
     * Gets the n-up layout setting for this job.
     * @returns the n-up layout
     */
    getNUpLayout(): NumberUpLayout
    /**
     * Gets the number of copies of this job.
     * @returns the number of copies
     */
    getNumCopies(): number
    /**
     * Gets the page ranges for this job.
     * @returns a pointer to an   array of `GtkPageRange` structs
     */
    getPageRanges(): PageRange[]
    /**
     * Gets the `GtkPageSet` setting for this job.
     * @returns the `GtkPageSet` setting
     */
    getPageSet(): PageSet
    /**
     * Gets the `GtkPrintPages` setting for this job.
     * @returns the `GtkPrintPages` setting
     */
    getPages(): PrintPages
    /**
     * Gets the `GtkPrinter` of the print job.
     * @returns the printer of @job
     */
    getPrinter(): Printer
    /**
     * Gets whether this job is printed reversed.
     * @returns whether the job is printed reversed.
     */
    getReverse(): boolean
    /**
     * Gets whether the job is printed rotated.
     * @returns whether the job is printed rotated
     */
    getRotate(): boolean
    /**
     * Gets the scale for this job.
     * @returns the scale
     */
    getScale(): number
    /**
     * Gets the `GtkPrintSettings` of the print job.
     * @returns the settings of @job
     */
    getSettings(): PrintSettings
    /**
     * Gets the status of the print job.
     * @returns the status of @job
     */
    getStatus(): PrintStatus
    /**
     * Gets a cairo surface onto which the pages of
     * the print job should be rendered.
     * @returns the cairo surface of @job
     */
    getSurface(): cairo.Surface
    /**
     * Gets the job title.
     * @returns the title of @job
     */
    getTitle(): string
    /**
     * Returns whether jobs will be tracked after printing.
     *
     * For details, see [method`Gtk`.PrintJob.set_track_print_status].
     * @returns %TRUE if print job status will be reported after printing
     */
    getTrackPrintStatus(): boolean
    /**
     * Sends the print job off to the printer.
     * @param callback function to call when the job completes or an error occurs
     */
    send(callback: PrintJobCompleteFunc): void
    /**
     * Sets whether this job is printed collated.
     * @param collate whether the job is printed collated
     */
    setCollate(collate: boolean): void
    /**
     * Sets the n-up setting for this job.
     * @param nUp the n-up value
     */
    setNUp(nUp: number): void
    /**
     * Sets the n-up layout setting for this job.
     * @param layout the n-up layout setting
     */
    setNUpLayout(layout: NumberUpLayout): void
    /**
     * Sets the number of copies for this job.
     * @param numCopies the number of copies
     */
    setNumCopies(numCopies: number): void
    /**
     * Sets the page ranges for this job.
     * @param ranges pointer to an array of    `GtkPageRange` structs
     */
    setPageRanges(ranges: PageRange[]): void
    /**
     * Sets the `GtkPageSet` setting for this job.
     * @param pageSet a `GtkPageSet` setting
     */
    setPageSet(pageSet: PageSet): void
    /**
     * Sets the `GtkPrintPages` setting for this job.
     * @param pages the `GtkPrintPages` setting
     */
    setPages(pages: PrintPages): void
    /**
     * Sets whether this job is printed reversed.
     * @param reverse whether the job is printed reversed
     */
    setReverse(reverse: boolean): void
    /**
     * Sets whether this job is printed rotated.
     * @param rotate whether to print rotated
     */
    setRotate(rotate: boolean): void
    /**
     * Sets the scale for this job.
     *
     * 1.0 means unscaled.
     * @param scale the scale
     */
    setScale(scale: number): void
    /**
     * Make the `GtkPrintJob` send an existing document to the
     * printing system.
     *
     * The file can be in any format understood by the platforms
     * printing system (typically PostScript, but on many platforms
     * PDF may work too). See [method`Gtk`.Printer.accepts_pdf] and
     * [method`Gtk`.Printer.accepts_ps].
     *
     * This is similar to [method`Gtk`.PrintJob.set_source_file],
     * but takes expects an open file descriptor for the file,
     * instead of a filename.
     * @param fd a file descriptor
     * @returns %FALSE if an error occurred
     */
    setSourceFd(fd: number): boolean
    /**
     * Make the `GtkPrintJob` send an existing document to the
     * printing system.
     *
     * The file can be in any format understood by the platforms
     * printing system (typically PostScript, but on many platforms
     * PDF may work too). See [method`Gtk`.Printer.accepts_pdf] and
     * [method`Gtk`.Printer.accepts_ps].
     * @param filename the file to be printed
     * @returns %FALSE if an error occurred
     */
    setSourceFile(filename: string): boolean
    /**
     * If track_status is %TRUE, the print job will try to continue report
     * on the status of the print job in the printer queues and printer.
     *
     * This can allow your application to show things like “out of paper”
     * issues, and when the print job actually reaches the printer.
     *
     * This function is often implemented using some form of polling,
     * so it should not be enabled unless needed.
     * @param trackStatus %TRUE to track status after printing
     */
    setTrackPrintStatus(trackStatus: boolean): void

    // Own signals of Gtk-4.0.Gtk.PrintJob

    connect(
      sigName: "status-changed",
      callback: PrintJob.StatusChangedSignalCallback
    ): number
    on(
      sigName: "status-changed",
      callback: PrintJob.StatusChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "status-changed",
      callback: PrintJob.StatusChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "status-changed",
      callback: PrintJob.StatusChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "status-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.PrintJob

    connect(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::page-setup", ...args: any[]): void
    connect(
      sigName: "notify::printer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::printer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::printer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::printer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::printer", ...args: any[]): void
    connect(
      sigName: "notify::settings",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::settings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::settings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::settings",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::settings", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::track-print-status",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::track-print-status",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::track-print-status",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::track-print-status",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::track-print-status", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkPrintJob` object represents a job that is sent to a printer.
   *
   * You only need to deal directly with print jobs if you use the
   * non-portable [class`Gtk`.PrintUnixDialog] API.
   *
   * Use [method`Gtk`.PrintJob.get_surface] to obtain the cairo surface
   * onto which the pages must be drawn. Use [method`Gtk`.PrintJob.send]
   * to send the finished job to the printer. If you don’t use cairo
   * `GtkPrintJob` also supports printing of manually generated PostScript,
   * via [method`Gtk`.PrintJob.set_source_file].
   * @class
   */
  class PrintJob extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.PrintJob

    static name: string

    // Constructors of Gtk-4.0.Gtk.PrintJob

    constructor(config?: PrintJob.ConstructorProperties)
    /**
     * Creates a new `GtkPrintJob`.
     * @constructor
     * @param title the job title
     * @param printer a `GtkPrinter`
     * @param settings a `GtkPrintSettings`
     * @param pageSetup a `GtkPageSetup`
     * @returns a new `GtkPrintJob`
     */
    constructor(
      title: string,
      printer: Printer,
      settings: PrintSettings,
      pageSetup: PageSetup
    )
    /**
     * Creates a new `GtkPrintJob`.
     * @constructor
     * @param title the job title
     * @param printer a `GtkPrinter`
     * @param settings a `GtkPrintSettings`
     * @param pageSetup a `GtkPageSetup`
     * @returns a new `GtkPrintJob`
     */
    static new(
      title: string,
      printer: Printer,
      settings: PrintSettings,
      pageSetup: PageSetup
    ): PrintJob
    _init(config?: PrintJob.ConstructorProperties): void
  }

  module PrintOperation {
    // Signal callback interfaces

    /**
     * Signal callback interface for `begin-print`
     */
    interface BeginPrintSignalCallback {
      (context: PrintContext): void
    }

    /**
     * Signal callback interface for `create-custom-widget`
     */
    interface CreateCustomWidgetSignalCallback {
      (): GObject.Object | null
    }

    /**
     * Signal callback interface for `custom-widget-apply`
     */
    interface CustomWidgetApplySignalCallback {
      (widget: Widget): void
    }

    /**
     * Signal callback interface for `done`
     */
    interface DoneSignalCallback {
      (result: PrintOperationResult): void
    }

    /**
     * Signal callback interface for `draw-page`
     */
    interface DrawPageSignalCallback {
      (context: PrintContext, pageNr: number): void
    }

    /**
     * Signal callback interface for `end-print`
     */
    interface EndPrintSignalCallback {
      (context: PrintContext): void
    }

    /**
     * Signal callback interface for `paginate`
     */
    interface PaginateSignalCallback {
      (context: PrintContext): boolean
    }

    /**
     * Signal callback interface for `preview`
     */
    interface PreviewSignalCallback {
      (
        preview: PrintOperationPreview,
        context: PrintContext,
        parent: Window | null
      ): boolean
    }

    /**
     * Signal callback interface for `request-page-setup`
     */
    interface RequestPageSetupSignalCallback {
      (context: PrintContext, pageNr: number, setup: PageSetup): void
    }

    /**
     * Signal callback interface for `status-changed`
     */
    interface StatusChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `update-custom-widget`
     */
    interface UpdateCustomWidgetSignalCallback {
      (widget: Widget, setup: PageSetup, settings: PrintSettings): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends PrintOperationPreview.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.PrintOperation

      /**
       * Determines whether the print operation may run asynchronously or not.
       *
       * Some systems don't support asynchronous printing, but those that do
       * will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and
       * emit the [signal`Gtk`.PrintOperation::done] signal when the operation
       * is actually done.
       *
       * The Windows port does not support asynchronous operation at all (this
       * is unlikely to change). On other platforms, all actions except for
       * %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation.
       */
      allow_async?: boolean | null
      /**
       * The current page in the document.
       *
       * If this is set before [method`Gtk`.PrintOperation.run],
       * the user will be able to select to print only the current page.
       *
       * Note that this only makes sense for pre-paginated documents.
       */
      current_page?: number | null
      /**
       * Used as the label of the tab containing custom widgets.
       *
       * Note that this property may be ignored on some platforms.
       *
       * If this is %NULL, GTK uses a default label.
       */
      custom_tab_label?: string | null
      /**
       * The `GtkPageSetup` used by default.
       *
       * This page setup will be used by [method`Gtk`.PrintOperation.run],
       * but it can be overridden on a per-page basis by connecting
       * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
       */
      default_page_setup?: PageSetup | null
      /**
       * If %TRUE, page size combo box and orientation combo box
       * are embedded into page setup page.
       */
      embed_page_setup?: boolean | null
      /**
       * The name of a file to generate instead of showing the print dialog.
       *
       * Currently, PDF is the only supported format.
       *
       * The intended use of this property is for implementing
       * “Export to PDF” actions.
       *
       * “Print to PDF” support is independent of this and is done
       * by letting the user pick the “Print to PDF” item from the
       * list of printers in the print dialog.
       */
      export_filename?: string | null
      /**
       * Determines whether there is a selection in your application.
       *
       * This can allow your application to print the selection.
       * This is typically used to make a "Selection" button sensitive.
       */
      has_selection?: boolean | null
      /**
       * A string used to identify the job (e.g. in monitoring
       * applications like eggcups).
       *
       * If you don't set a job name, GTK picks a default one
       * by numbering successive print jobs.
       */
      job_name?: string | null
      /**
       * The number of pages in the document.
       *
       * This must be set to a positive number before the rendering
       * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
       * signal handler.
       *
       * Note that the page numbers passed to the
       * [signal`Gtk`.PrintOperation::request-page-setup] and
       * [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
       * if the user chooses to print all pages, the last ::draw-page signal
       * will be for page `n_pages` - 1.
       */
      n_pages?: number | null
      /**
       * The `GtkPrintSettings` used for initializing the dialog.
       *
       * Setting this property is typically used to re-establish
       * print settings from a previous print operation, see
       * [method`Gtk`.PrintOperation.run].
       */
      print_settings?: PrintSettings | null
      /**
       * Determines whether to show a progress dialog during the
       * print operation.
       */
      show_progress?: boolean | null
      /**
       * If %TRUE, the print operation will support print of selection.
       *
       * This allows the print dialog to show a "Selection" button.
       */
      support_selection?: boolean | null
      /**
       * If %TRUE, the print operation will try to continue report on
       * the status of the print job in the printer queues and printer.
       *
       * This can allow your application to show things like “out of paper”
       * issues, and when the print job actually reaches the printer.
       * However, this is often implemented using polling, and should
       * not be enabled unless needed.
       */
      track_print_status?: boolean | null
      /**
       * The transformation for the cairo context obtained from
       * `GtkPrintContext` is set up in such a way that distances
       * are measured in units of `unit`.
       */
      unit?: Unit | null
      /**
       * If %TRUE, the transformation for the cairo context obtained
       * from `GtkPrintContext` puts the origin at the top left corner
       * of the page.
       *
       * This may not be the top left corner of the sheet, depending on
       * page orientation and the number of pages per sheet. Otherwise,
       * the origin is at the top left corner of the imageable area (i.e.
       * inside the margins).
       */
      use_full_page?: boolean | null
    }
  }

  interface PrintOperation extends PrintOperationPreview {
    // Own properties of Gtk-4.0.Gtk.PrintOperation

    /**
     * Determines whether the print operation may run asynchronously or not.
     *
     * Some systems don't support asynchronous printing, but those that do
     * will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and
     * emit the [signal`Gtk`.PrintOperation::done] signal when the operation
     * is actually done.
     *
     * The Windows port does not support asynchronous operation at all (this
     * is unlikely to change). On other platforms, all actions except for
     * %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation.
     */
    allowAsync: boolean
    /**
     * The current page in the document.
     *
     * If this is set before [method`Gtk`.PrintOperation.run],
     * the user will be able to select to print only the current page.
     *
     * Note that this only makes sense for pre-paginated documents.
     */
    currentPage: number
    /**
     * Used as the label of the tab containing custom widgets.
     *
     * Note that this property may be ignored on some platforms.
     *
     * If this is %NULL, GTK uses a default label.
     */
    customTabLabel: string | null
    /**
     * The `GtkPageSetup` used by default.
     *
     * This page setup will be used by [method`Gtk`.PrintOperation.run],
     * but it can be overridden on a per-page basis by connecting
     * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
     */
    defaultPageSetup: PageSetup
    /**
     * If %TRUE, page size combo box and orientation combo box
     * are embedded into page setup page.
     */
    embedPageSetup: boolean
    /**
     * The name of a file to generate instead of showing the print dialog.
     *
     * Currently, PDF is the only supported format.
     *
     * The intended use of this property is for implementing
     * “Export to PDF” actions.
     *
     * “Print to PDF” support is independent of this and is done
     * by letting the user pick the “Print to PDF” item from the
     * list of printers in the print dialog.
     */
    exportFilename: string | null
    /**
     * Determines whether there is a selection in your application.
     *
     * This can allow your application to print the selection.
     * This is typically used to make a "Selection" button sensitive.
     */
    hasSelection: boolean
    /**
     * A string used to identify the job (e.g. in monitoring
     * applications like eggcups).
     *
     * If you don't set a job name, GTK picks a default one
     * by numbering successive print jobs.
     */
    jobName: string | null
    /**
     * The number of pages in the document.
     *
     * This must be set to a positive number before the rendering
     * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
     * signal handler.
     *
     * Note that the page numbers passed to the
     * [signal`Gtk`.PrintOperation::request-page-setup] and
     * [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
     * if the user chooses to print all pages, the last ::draw-page signal
     * will be for page `n_pages` - 1.
     */
    nPages: number
    /**
     * The number of pages that will be printed.
     *
     * Note that this value is set during print preparation phase
     * (%GTK_PRINT_STATUS_PREPARING), so this value should never be
     * get before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
     * You can connect to the [signal`Gtk`.PrintOperation::status-changed] signal
     * and call [method`Gtk`.PrintOperation.get_n_pages_to_print] when
     * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
     *
     * This is typically used to track the progress of print operation.
     */
    readonly nPagesToPrint: number
    /**
     * The `GtkPrintSettings` used for initializing the dialog.
     *
     * Setting this property is typically used to re-establish
     * print settings from a previous print operation, see
     * [method`Gtk`.PrintOperation.run].
     */
    printSettings: PrintSettings
    /**
     * Determines whether to show a progress dialog during the
     * print operation.
     */
    showProgress: boolean
    /**
     * The status of the print operation.
     */
    readonly status: PrintStatus
    /**
     * A string representation of the status of the print operation.
     *
     * The string is translated and suitable for displaying the print
     * status e.g. in a `GtkStatusbar`.
     *
     * See the [property`Gtk`.PrintOperation:status] property for a status
     * value that is suitable for programmatic use.
     */
    readonly statusString: string | null
    /**
     * If %TRUE, the print operation will support print of selection.
     *
     * This allows the print dialog to show a "Selection" button.
     */
    supportSelection: boolean
    /**
     * If %TRUE, the print operation will try to continue report on
     * the status of the print job in the printer queues and printer.
     *
     * This can allow your application to show things like “out of paper”
     * issues, and when the print job actually reaches the printer.
     * However, this is often implemented using polling, and should
     * not be enabled unless needed.
     */
    trackPrintStatus: boolean
    /**
     * The transformation for the cairo context obtained from
     * `GtkPrintContext` is set up in such a way that distances
     * are measured in units of `unit`.
     */
    unit: Unit
    /**
     * If %TRUE, the transformation for the cairo context obtained
     * from `GtkPrintContext` puts the origin at the top left corner
     * of the page.
     *
     * This may not be the top left corner of the sheet, depending on
     * page orientation and the number of pages per sheet. Otherwise,
     * the origin is at the top left corner of the imageable area (i.e.
     * inside the margins).
     */
    useFullPage: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.PrintOperation

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.PrintOperation

    /**
     * Cancels a running print operation.
     *
     * This function may be called from a [signal`Gtk`.PrintOperation::begin-print],
     * [signal`Gtk`.PrintOperation::paginate] or [signal`Gtk`.PrintOperation::draw-page]
     * signal handler to stop the currently running print operation.
     */
    cancel(): void
    /**
     * Signal that drawing of particular page is complete.
     *
     * It is called after completion of page drawing (e.g. drawing
     * in another thread). If [method`Gtk`.PrintOperation.set_defer_drawing]
     * was called before, then this function has to be called by application.
     * Otherwise it is called by GTK itself.
     */
    drawPageFinish(): void
    /**
     * Returns the default page setup.
     * @returns the default page setup
     */
    getDefaultPageSetup(): PageSetup
    /**
     * Gets whether page setup selection combos are embedded
     * @returns whether page setup selection combos are embedded
     */
    getEmbedPageSetup(): boolean
    /**
     * Call this when the result of a print operation is
     * %GTK_PRINT_OPERATION_RESULT_ERROR.
     *
     * It can be called either after [method`Gtk`.PrintOperation.run]
     * returns, or in the [signal`Gtk`.PrintOperation::done] signal
     * handler.
     *
     * The returned `GError` will contain more details on what went wrong.
     */
    getError(): void
    /**
     * Gets whether there is a selection.
     * @returns whether there is a selection
     */
    getHasSelection(): boolean
    /**
     * Returns the number of pages that will be printed.
     *
     * Note that this value is set during print preparation phase
     * (%GTK_PRINT_STATUS_PREPARING), so this function should never be
     * called before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
     * You can connect to the [signal`Gtk`.PrintOperation::status-changed]
     * signal and call gtk_print_operation_get_n_pages_to_print() when
     * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
     *
     * This is typically used to track the progress of print operation.
     * @returns the number of pages that will be printed
     */
    getNPagesToPrint(): number
    /**
     * Returns the current print settings.
     *
     * Note that the return value is %NULL until either
     * [method`Gtk`.PrintOperation.set_print_settings] or
     * [method`Gtk`.PrintOperation.run] have been called.
     * @returns the current print settings of @op.
     */
    getPrintSettings(): PrintSettings | null
    /**
     * Returns the status of the print operation.
     *
     * Also see [method`Gtk`.PrintOperation.get_status_string].
     * @returns the status of the print operation
     */
    getStatus(): PrintStatus
    /**
     * Returns a string representation of the status of the
     * print operation.
     *
     * The string is translated and suitable for displaying
     * the print status e.g. in a `GtkStatusbar`.
     *
     * Use [method`Gtk`.PrintOperation.get_status] to obtain
     * a status value that is suitable for programmatic use.
     * @returns a string representation of the status    of the print operation
     */
    getStatusString(): string
    /**
     * Gets whether the application supports print of selection
     * @returns whether the application supports print of selection
     */
    getSupportSelection(): boolean
    /**
     * A convenience function to find out if the print operation
     * is finished.
     *
     * a print operation is finished if its status is either
     * %GTK_PRINT_STATUS_FINISHED or %GTK_PRINT_STATUS_FINISHED_ABORTED.
     *
     * Note: when you enable print status tracking the print operation
     * can be in a non-finished state even after done has been called, as
     * the operation status then tracks the print job status on the printer.
     * @returns %TRUE, if the print operation is finished.
     */
    isFinished(): boolean
    /**
     * Runs the print operation.
     *
     * Normally that this function does not return until the rendering
     * of all pages is complete. You can connect to the
     * [signal`Gtk`.PrintOperation::status-changed] signal on `op` to obtain
     * some information about the progress of the print operation.
     *
     * Furthermore, it may use a recursive mainloop to show the print dialog.
     *
     * If you set the [Gtk.PrintOperation:allow-async] property, the operation
     * will run asynchronously if this is supported on the platform. The
     * [signal`Gtk`.PrintOperation::done] signal will be emitted with the result
     * of the operation when the it is done (i.e. when the dialog is canceled,
     * or when the print succeeds or fails).
     *
     * ```c
     * if (settings != NULL)
     *   gtk_print_operation_set_print_settings (print, settings);
     *
     * if (page_setup != NULL)
     *   gtk_print_operation_set_default_page_setup (print, page_setup);
     *
     * g_signal_connect (print, "begin-print",
     *                   G_CALLBACK (begin_print), &data);
     * g_signal_connect (print, "draw-page",
     *                   G_CALLBACK (draw_page), &data);
     *
     * res = gtk_print_operation_run (print,
     *                                GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
     *                                parent,
     *                                &error);
     *
     * if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
     *  {
     *    error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
     *   			                     GTK_DIALOG_DESTROY_WITH_PARENT,
     * 					     GTK_MESSAGE_ERROR,
     * 					     GTK_BUTTONS_CLOSE,
     * 					     "Error printing file:\n%s",
     * 					     error->message);
     *    g_signal_connect (error_dialog, "response",
     *                      G_CALLBACK (gtk_window_destroy), NULL);
     *    gtk_window_present (GTK_WINDOW (error_dialog));
     *    g_error_free (error);
     *  }
     * else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
     *  {
     *    if (settings != NULL)
     * g_object_unref (settings);
     *    settings = g_object_ref (gtk_print_operation_get_print_settings (print));
     *  }
     * ```
     *
     * Note that gtk_print_operation_run() can only be called once on a
     * given `GtkPrintOperation`.
     * @param action the action to start
     * @param parent Transient parent of the dialog
     * @returns the result of the print operation. A return value of   %GTK_PRINT_OPERATION_RESULT_APPLY indicates that the printing was   completed successfully. In this case, it is a good idea to obtain   the used print settings with   [method@Gtk.PrintOperation.get_print_settings]   and store them for reuse with the next print operation. A value of   %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS means the operation is running   asynchronously, and will emit the [signal@Gtk.PrintOperation::done]   signal when done.
     */
    run(
      action: PrintOperationAction,
      parent: Window | null
    ): PrintOperationResult
    /**
     * Sets whether gtk_print_operation_run() may return
     * before the print operation is completed.
     *
     * Note that some platforms may not allow asynchronous
     * operation.
     * @param allowAsync %TRUE to allow asynchronous operation
     */
    setAllowAsync(allowAsync: boolean): void
    /**
     * Sets the current page.
     *
     * If this is called before [method`Gtk`.PrintOperation.run],
     * the user will be able to select to print only the current page.
     *
     * Note that this only makes sense for pre-paginated documents.
     * @param currentPage the current page, 0-based
     */
    setCurrentPage(currentPage: number): void
    /**
     * Sets the label for the tab holding custom widgets.
     * @param label the label to use, or %NULL to use the default label
     */
    setCustomTabLabel(label: string | null): void
    /**
     * Makes `default_page_setup` the default page setup for `op`.
     *
     * This page setup will be used by [method`Gtk`.PrintOperation.run],
     * but it can be overridden on a per-page basis by connecting
     * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
     * @param defaultPageSetup a `GtkPageSetup`
     */
    setDefaultPageSetup(defaultPageSetup: PageSetup | null): void
    /**
     * Sets up the `GtkPrintOperation` to wait for calling of
     * [method`Gtk`.PrintOperation.draw_page_finish from application.
     *
     * This can be used for drawing page in another thread.
     *
     * This function must be called in the callback of the
     * [signal`Gtk`.PrintOperation::draw-page] signal.
     */
    setDeferDrawing(): void
    /**
     * Embed page size combo box and orientation combo box into page setup page.
     *
     * Selected page setup is stored as default page setup in `GtkPrintOperation`.
     * @param embed %TRUE to embed page setup selection in the `GtkPrintUnixDialog`
     */
    setEmbedPageSetup(embed: boolean): void
    /**
     * Sets up the `GtkPrintOperation` to generate a file instead
     * of showing the print dialog.
     *
     * The intended use of this function is for implementing
     * “Export to PDF” actions. Currently, PDF is the only supported
     * format.
     *
     * “Print to PDF” support is independent of this and is done
     * by letting the user pick the “Print to PDF” item from the list
     * of printers in the print dialog.
     * @param filename the filename for the exported file
     */
    setExportFilename(filename: string): void
    /**
     * Sets whether there is a selection to print.
     *
     * Application has to set number of pages to which the selection
     * will draw by [method`Gtk`.PrintOperation.set_n_pages] in a handler
     * for the [signal`Gtk`.PrintOperation::begin-print] signal.
     * @param hasSelection %TRUE indicates that a selection exists
     */
    setHasSelection(hasSelection: boolean): void
    /**
     * Sets the name of the print job.
     *
     * The name is used to identify the job (e.g. in monitoring
     * applications like eggcups).
     *
     * If you don’t set a job name, GTK picks a default one by
     * numbering successive print jobs.
     * @param jobName a string that identifies the print job
     */
    setJobName(jobName: string): void
    /**
     * Sets the number of pages in the document.
     *
     * This must be set to a positive number before the rendering
     * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
     * signal handler.
     *
     * Note that the page numbers passed to the
     * [signal`Gtk`.PrintOperation::request-page-setup]
     * and [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
     * if the user chooses to print all pages, the last ::draw-page signal
     * will be for page `n_pages` - 1.
     * @param nPages the number of pages
     */
    setNPages(nPages: number): void
    /**
     * Sets the print settings for `op`.
     *
     * This is typically used to re-establish print settings
     * from a previous print operation, see [method`Gtk`.PrintOperation.run].
     * @param printSettings `GtkPrintSettings`
     */
    setPrintSettings(printSettings: PrintSettings | null): void
    /**
     * If `show_progress` is %TRUE, the print operation will show
     * a progress dialog during the print operation.
     * @param showProgress %TRUE to show a progress dialog
     */
    setShowProgress(showProgress: boolean): void
    /**
     * Sets whether selection is supported by `GtkPrintOperation`.
     * @param supportSelection %TRUE to support selection
     */
    setSupportSelection(supportSelection: boolean): void
    /**
     * If track_status is %TRUE, the print operation will try to continue
     * report on the status of the print job in the printer queues and printer.
     *
     * This can allow your application to show things like “out of paper”
     * issues, and when the print job actually reaches the printer.
     *
     * This function is often implemented using some form of polling,
     * so it should not be enabled unless needed.
     * @param trackStatus %TRUE to track status after printing
     */
    setTrackPrintStatus(trackStatus: boolean): void
    /**
     * Sets up the transformation for the cairo context obtained from
     * `GtkPrintContext` in such a way that distances are measured in
     * units of `unit`.
     * @param unit the unit to use
     */
    setUnit(unit: Unit): void
    /**
     * If `full_page` is %TRUE, the transformation for the cairo context
     * obtained from `GtkPrintContext` puts the origin at the top left
     * corner of the page.
     *
     * This may not be the top left corner of the sheet, depending on page
     * orientation and the number of pages per sheet). Otherwise, the origin
     * is at the top left corner of the imageable area (i.e. inside the margins).
     * @param fullPage %TRUE to set up the `GtkPrintContext` for the full page
     */
    setUseFullPage(fullPage: boolean): void

    // Own virtual methods of Gtk-4.0.Gtk.PrintOperation

    /**
     * Signal emitted after the user has finished changing
     *    print settings in the dialog, before the actual rendering starts.
     * @virtual
     * @param context
     */
    beginPrint(context: PrintContext): void
    /**
     * Signal emitted right before “begin-print” if
     *    you added a custom widget in the “create-custom-widget” handler.
     * @virtual
     * @param widget
     */
    customWidgetApply(widget: Widget): void
    /**
     * Signal emitted when the print operation run has finished
     *    doing everything required for printing.
     * @virtual
     * @param result
     */
    done(result: PrintOperationResult): void
    /**
     * Signal emitted for every page that is printed.
     * @virtual
     * @param context
     * @param pageNr
     */
    drawPage(context: PrintContext, pageNr: number): void
    /**
     * Signal emitted after all pages have been rendered.
     * @virtual
     * @param context
     */
    endPrint(context: PrintContext): void
    /**
     * Signal emitted after the “begin-print” signal, but
     *    before the actual rendering starts.
     * @virtual
     * @param context
     */
    paginate(context: PrintContext): boolean
    /**
     * Signal emitted when a preview is requested from the
     *    native dialog.
     * @virtual
     * @param preview
     * @param context
     * @param parent
     */
    preview(
      preview: PrintOperationPreview,
      context: PrintContext,
      parent: Window
    ): boolean
    /**
     * Emitted once for every page that is printed,
     *    to give the application a chance to modify the page setup.
     * @virtual
     * @param context
     * @param pageNr
     * @param setup
     */
    requestPageSetup(
      context: PrintContext,
      pageNr: number,
      setup: PageSetup
    ): void
    /**
     * Emitted at between the various phases of the print
     *    operation.
     * @virtual
     */
    statusChanged(): void
    /**
     * Emitted after change of selected printer.
     * @virtual
     * @param widget
     * @param setup
     * @param settings
     */
    updateCustomWidget(
      widget: Widget,
      setup: PageSetup,
      settings: PrintSettings
    ): void

    // Own signals of Gtk-4.0.Gtk.PrintOperation

    connect(
      sigName: "begin-print",
      callback: PrintOperation.BeginPrintSignalCallback
    ): number
    on(
      sigName: "begin-print",
      callback: PrintOperation.BeginPrintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "begin-print",
      callback: PrintOperation.BeginPrintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "begin-print",
      callback: PrintOperation.BeginPrintSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "begin-print", ...args: any[]): void
    connect(
      sigName: "create-custom-widget",
      callback: PrintOperation.CreateCustomWidgetSignalCallback
    ): number
    on(
      sigName: "create-custom-widget",
      callback: PrintOperation.CreateCustomWidgetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "create-custom-widget",
      callback: PrintOperation.CreateCustomWidgetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "create-custom-widget",
      callback: PrintOperation.CreateCustomWidgetSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "create-custom-widget", ...args: any[]): void
    connect(
      sigName: "custom-widget-apply",
      callback: PrintOperation.CustomWidgetApplySignalCallback
    ): number
    on(
      sigName: "custom-widget-apply",
      callback: PrintOperation.CustomWidgetApplySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "custom-widget-apply",
      callback: PrintOperation.CustomWidgetApplySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "custom-widget-apply",
      callback: PrintOperation.CustomWidgetApplySignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "custom-widget-apply", ...args: any[]): void
    connect(
      sigName: "done",
      callback: PrintOperation.DoneSignalCallback
    ): number
    on(
      sigName: "done",
      callback: PrintOperation.DoneSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "done",
      callback: PrintOperation.DoneSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "done",
      callback: PrintOperation.DoneSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "done", ...args: any[]): void
    connect(
      sigName: "draw-page",
      callback: PrintOperation.DrawPageSignalCallback
    ): number
    on(
      sigName: "draw-page",
      callback: PrintOperation.DrawPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "draw-page",
      callback: PrintOperation.DrawPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "draw-page",
      callback: PrintOperation.DrawPageSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "draw-page", pageNr: number, ...args: any[]): void
    connect(
      sigName: "end-print",
      callback: PrintOperation.EndPrintSignalCallback
    ): number
    on(
      sigName: "end-print",
      callback: PrintOperation.EndPrintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "end-print",
      callback: PrintOperation.EndPrintSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "end-print",
      callback: PrintOperation.EndPrintSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "end-print", ...args: any[]): void
    connect(
      sigName: "paginate",
      callback: PrintOperation.PaginateSignalCallback
    ): number
    on(
      sigName: "paginate",
      callback: PrintOperation.PaginateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "paginate",
      callback: PrintOperation.PaginateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "paginate",
      callback: PrintOperation.PaginateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "paginate", ...args: any[]): void
    connect(
      sigName: "preview",
      callback: PrintOperation.PreviewSignalCallback
    ): number
    on(
      sigName: "preview",
      callback: PrintOperation.PreviewSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "preview",
      callback: PrintOperation.PreviewSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "preview",
      callback: PrintOperation.PreviewSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "preview",
      context: PrintContext,
      parent: Window | null,
      ...args: any[]
    ): void
    connect(
      sigName: "request-page-setup",
      callback: PrintOperation.RequestPageSetupSignalCallback
    ): number
    on(
      sigName: "request-page-setup",
      callback: PrintOperation.RequestPageSetupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "request-page-setup",
      callback: PrintOperation.RequestPageSetupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "request-page-setup",
      callback: PrintOperation.RequestPageSetupSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "request-page-setup",
      pageNr: number,
      setup: PageSetup,
      ...args: any[]
    ): void
    connect(
      sigName: "status-changed",
      callback: PrintOperation.StatusChangedSignalCallback
    ): number
    on(
      sigName: "status-changed",
      callback: PrintOperation.StatusChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "status-changed",
      callback: PrintOperation.StatusChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "status-changed",
      callback: PrintOperation.StatusChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "status-changed", ...args: any[]): void
    connect(
      sigName: "update-custom-widget",
      callback: PrintOperation.UpdateCustomWidgetSignalCallback
    ): number
    on(
      sigName: "update-custom-widget",
      callback: PrintOperation.UpdateCustomWidgetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "update-custom-widget",
      callback: PrintOperation.UpdateCustomWidgetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "update-custom-widget",
      callback: PrintOperation.UpdateCustomWidgetSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "update-custom-widget",
      setup: PageSetup,
      settings: PrintSettings,
      ...args: any[]
    ): void

    // Class property signals of Gtk-4.0.Gtk.PrintOperation

    connect(
      sigName: "notify::allow-async",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::allow-async",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::allow-async",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::allow-async",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::allow-async", ...args: any[]): void
    connect(
      sigName: "notify::current-page",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::current-page",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::current-page",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::current-page",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::current-page", ...args: any[]): void
    connect(
      sigName: "notify::custom-tab-label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::custom-tab-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::custom-tab-label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::custom-tab-label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::custom-tab-label", ...args: any[]): void
    connect(
      sigName: "notify::default-page-setup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-page-setup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-page-setup", ...args: any[]): void
    connect(
      sigName: "notify::embed-page-setup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::embed-page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::embed-page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::embed-page-setup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::embed-page-setup", ...args: any[]): void
    connect(
      sigName: "notify::export-filename",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::export-filename",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::export-filename",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::export-filename",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::export-filename", ...args: any[]): void
    connect(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-selection", ...args: any[]): void
    connect(
      sigName: "notify::job-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::job-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::job-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::job-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::job-name", ...args: any[]): void
    connect(
      sigName: "notify::n-pages",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-pages",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-pages",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-pages",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-pages", ...args: any[]): void
    connect(
      sigName: "notify::n-pages-to-print",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-pages-to-print",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-pages-to-print",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-pages-to-print",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-pages-to-print", ...args: any[]): void
    connect(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::print-settings", ...args: any[]): void
    connect(
      sigName: "notify::show-progress",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-progress",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-progress",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-progress",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-progress", ...args: any[]): void
    connect(
      sigName: "notify::status",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::status",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::status",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::status",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::status", ...args: any[]): void
    connect(
      sigName: "notify::status-string",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::status-string",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::status-string",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::status-string",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::status-string", ...args: any[]): void
    connect(
      sigName: "notify::support-selection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::support-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::support-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::support-selection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::support-selection", ...args: any[]): void
    connect(
      sigName: "notify::track-print-status",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::track-print-status",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::track-print-status",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::track-print-status",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::track-print-status", ...args: any[]): void
    connect(sigName: "notify::unit", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::unit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::unit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::unit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::unit", ...args: any[]): void
    connect(
      sigName: "notify::use-full-page",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-full-page",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-full-page",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-full-page",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-full-page", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPrintOperation` is the high-level, portable printing API.
   *
   * It looks a bit different than other GTK dialogs such as the
   * `GtkFileChooser`, since some platforms don’t expose enough
   * infrastructure to implement a good print dialog. On such
   * platforms, `GtkPrintOperation` uses the native print dialog.
   * On platforms which do not provide a native print dialog, GTK
   * uses its own, see [class`Gtk`.PrintUnixDialog].
   *
   * The typical way to use the high-level printing API is to create
   * a `GtkPrintOperation` object with [ctor`Gtk`.PrintOperation.new]
   * when the user selects to print. Then you set some properties on it,
   * e.g. the page size, any [class`Gtk`.PrintSettings] from previous print
   * operations, the number of pages, the current page, etc.
   *
   * Then you start the print operation by calling [method`Gtk`.PrintOperation.run].
   * It will then show a dialog, let the user select a printer and options.
   * When the user finished the dialog, various signals will be emitted on
   * the `GtkPrintOperation`, the main one being
   * [signal`Gtk`.PrintOperation::draw-page], which you are supposed to handle
   * and render the page on the provided [class`Gtk`.PrintContext] using Cairo.
   *
   * # The high-level printing API
   *
   * ```c
   * static GtkPrintSettings *settings = NULL;
   *
   * static void
   * do_print (void)
   * {
   *   GtkPrintOperation *print;
   *   GtkPrintOperationResult res;
   *
   *   print = gtk_print_operation_new ();
   *
   *   if (settings != NULL)
   *     gtk_print_operation_set_print_settings (print, settings);
   *
   *   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), NULL);
   *   g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL);
   *
   *   res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
   *                                  GTK_WINDOW (main_window), NULL);
   *
   *   if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
   *     {
   *       if (settings != NULL)
   *         g_object_unref (settings);
   *       settings = g_object_ref (gtk_print_operation_get_print_settings (print));
   *     }
   *
   *   g_object_unref (print);
   * }
   * ```
   *
   * By default `GtkPrintOperation` uses an external application to do
   * print preview. To implement a custom print preview, an application
   * must connect to the preview signal. The functions
   * [method`Gtk`.PrintOperationPreview.render_page],
   * [method`Gtk`.PrintOperationPreview.end_preview] and
   * [method`Gtk`.PrintOperationPreview.is_selected]
   * are useful when implementing a print preview.
   * @class
   */
  class PrintOperation extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.PrintOperation

    static name: string

    // Constructors of Gtk-4.0.Gtk.PrintOperation

    constructor(config?: PrintOperation.ConstructorProperties)
    /**
     * Creates a new `GtkPrintOperation`.
     * @constructor
     * @returns a new `GtkPrintOperation`
     */
    constructor()
    /**
     * Creates a new `GtkPrintOperation`.
     * @constructor
     * @returns a new `GtkPrintOperation`
     */
    static new(): PrintOperation
    _init(config?: PrintOperation.ConstructorProperties): void
  }

  module PrintSettings {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface PrintSettings {
    // Own properties of Gtk-4.0.Gtk.PrintSettings

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.PrintSettings

    /**
     * Copies a `GtkPrintSettings` object.
     * @returns a newly allocated copy of @other
     */
    copy(): PrintSettings
    /**
     * Calls `func` for each key-value pair of `settings`.
     * @param func the function to call
     */
    foreach(func: PrintSettingsFunc): void
    /**
     * Looks up the string value associated with `key`.
     * @param key a key
     * @returns the string value for @key
     */
    get(key: string): string | null
    /**
     * Returns the boolean represented by the value
     * that is associated with `key`.
     *
     * The string “true” represents %TRUE, any other
     * string %FALSE.
     * @param key a key
     * @returns %TRUE, if @key maps to a true value.
     */
    getBool(key: string): boolean
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_COLLATE.
     * @returns whether to collate the printed pages
     */
    getCollate(): boolean
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
     * @returns the default source
     */
    getDefaultSource(): string | null
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_DITHER.
     * @returns the dithering that is used
     */
    getDither(): string | null
    /**
     * Returns the double value associated with `key,` or 0.
     * @param key a key
     * @returns the double value of @key
     */
    getDouble(key: string): number
    /**
     * Returns the floating point number represented by
     * the value that is associated with `key,` or `default_val`
     * if the value does not represent a floating point number.
     *
     * Floating point numbers are parsed with g_ascii_strtod().
     * @param key a key
     * @param def the default value
     * @returns the floating point number associated with @key
     */
    getDoubleWithDefault(key: string, def: number): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_DUPLEX.
     * @returns whether to print the output in duplex.
     */
    getDuplex(): PrintDuplex
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
     * @returns the finishings
     */
    getFinishings(): string | null
    /**
     * Returns the integer value of `key,` or 0.
     * @param key a key
     * @returns the integer value of @key
     */
    getInt(key: string): number
    /**
     * Returns the value of `key,` interpreted as
     * an integer, or the default value.
     * @param key a key
     * @param def the default value
     * @returns the integer value of @key
     */
    getIntWithDefault(key: string, def: number): number
    /**
     * Returns the value associated with `key,` interpreted
     * as a length.
     *
     * The returned value is converted to `units`.
     * @param key a key
     * @param unit the unit of the return value
     * @returns the length value of @key, converted to @unit
     */
    getLength(key: string, unit: Unit): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
     *
     * The set of media types is defined in PWG 5101.1-2002 PWG.
     * @returns the media type
     */
    getMediaType(): string | null
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_N_COPIES.
     * @returns the number of copies to print
     */
    getNCopies(): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
     * @returns the number of pages per sheet
     */
    getNumberUp(): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
     * @returns layout of page in number-up mode
     */
    getNumberUpLayout(): NumberUpLayout
    /**
     * Get the value of %GTK_PRINT_SETTINGS_ORIENTATION,
     * converted to a `GtkPageOrientation`.
     * @returns the orientation
     */
    getOrientation(): PageOrientation
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
     * @returns the output bin
     */
    getOutputBin(): string | null
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
     * @returns an array   of `GtkPageRange`s. Use g_free() to free the array when   it is no longer needed.
     */
    getPageRanges(): PageRange[]
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
     * @returns the set of pages to print
     */
    getPageSet(): PageSet
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT,
     * converted to `unit`.
     * @param unit the unit for the return value
     * @returns the paper height, in units of @unit
     */
    getPaperHeight(unit: Unit): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
     * converted to a `GtkPaperSize`.
     * @returns the paper size
     */
    getPaperSize(): PaperSize | null
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH,
     * converted to `unit`.
     * @param unit the unit for the return value
     * @returns the paper width, in units of @unit
     */
    getPaperWidth(unit: Unit): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
     * @returns which pages to print
     */
    getPrintPages(): PrintPages
    /**
     * Convenience function to obtain the value of
     * %GTK_PRINT_SETTINGS_PRINTER.
     * @returns the printer name
     */
    getPrinter(): string | null
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
     * @returns the resolution in lpi (lines per inch)
     */
    getPrinterLpi(): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_QUALITY.
     * @returns the print quality
     */
    getQuality(): PrintQuality
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
     * @returns the resolution in dpi
     */
    getResolution(): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_X.
     * @returns the horizontal resolution in dpi
     */
    getResolutionX(): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_Y.
     * @returns the vertical resolution in dpi
     */
    getResolutionY(): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_REVERSE.
     * @returns whether to reverse the order of the printed pages
     */
    getReverse(): boolean
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_SCALE.
     * @returns the scale in percent
     */
    getScale(): number
    /**
     * Gets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
     * @returns whether to use color
     */
    getUseColor(): boolean
    /**
     * Returns %TRUE, if a value is associated with `key`.
     * @param key a key
     * @returns %TRUE, if @key has a value
     */
    hasKey(key: string): boolean
    /**
     * Reads the print settings from `file_name`.
     *
     * If the file could not be loaded then error is set to either
     * a `GFileError` or `GKeyFileError`.
     *
     * See [method`Gtk`.PrintSettings.to_file].
     * @param fileName the filename to read the settings from
     * @returns %TRUE on success
     */
    loadFile(fileName: string): boolean
    /**
     * Reads the print settings from the group `group_name` in `key_file`.
     *
     * If the file could not be loaded then error is set to either a
     * `GFileError` or `GKeyFileError`.
     * @param keyFile the `GKeyFile` to retrieve the settings from
     * @param groupName the name of the group to use, or %NULL   to use the default “Print Settings”
     * @returns %TRUE on success
     */
    loadKeyFile(keyFile: GLib.KeyFile, groupName: string | null): boolean
    /**
     * Associates `value` with `key`.
     * @param key a key
     * @param value a string value
     */
    set(key: string, value: string | null): void
    /**
     * Sets `key` to a boolean value.
     * @param key a key
     * @param value a boolean
     */
    setBool(key: string, value: boolean): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_COLLATE.
     * @param collate whether to collate the output
     */
    setCollate(collate: boolean): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
     * @param defaultSource the default source
     */
    setDefaultSource(defaultSource: string): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_DITHER.
     * @param dither the dithering that is used
     */
    setDither(dither: string): void
    /**
     * Sets `key` to a double value.
     * @param key a key
     * @param value a double value
     */
    setDouble(key: string, value: number): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_DUPLEX.
     * @param duplex a `GtkPrintDuplex` value
     */
    setDuplex(duplex: PrintDuplex): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
     * @param finishings the finishings
     */
    setFinishings(finishings: string): void
    /**
     * Sets `key` to an integer value.
     * @param key a key
     * @param value an integer
     */
    setInt(key: string, value: number): void
    /**
     * Associates a length in units of `unit` with `key`.
     * @param key a key
     * @param value a length
     * @param unit the unit of `length`
     */
    setLength(key: string, value: number, unit: Unit): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
     *
     * The set of media types is defined in PWG 5101.1-2002 PWG.
     * @param mediaType the media type
     */
    setMediaType(mediaType: string): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_N_COPIES.
     * @param numCopies the number of copies
     */
    setNCopies(numCopies: number): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
     * @param numberUp the number of pages per sheet
     */
    setNumberUp(numberUp: number): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
     * @param numberUpLayout a `GtkNumberUpLayout` value
     */
    setNumberUpLayout(numberUpLayout: NumberUpLayout): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION.
     * @param orientation a page orientation
     */
    setOrientation(orientation: PageOrientation): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
     * @param outputBin the output bin
     */
    setOutputBin(outputBin: string): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
     * @param pageRanges an array of `GtkPageRange`s
     */
    setPageRanges(pageRanges: PageRange[]): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
     * @param pageSet a `GtkPageSet` value
     */
    setPageSet(pageSet: PageSet): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
     * @param height the paper height
     * @param unit the units of `height`
     */
    setPaperHeight(height: number, unit: Unit): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
     * %GTK_PRINT_SETTINGS_PAPER_WIDTH and
     * %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
     * @param paperSize a paper size
     */
    setPaperSize(paperSize: PaperSize): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH.
     * @param width the paper width
     * @param unit the units of `width`
     */
    setPaperWidth(width: number, unit: Unit): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
     * @param pages a `GtkPrintPages` value
     */
    setPrintPages(pages: PrintPages): void
    /**
     * Convenience function to set %GTK_PRINT_SETTINGS_PRINTER
     * to `printer`.
     * @param printer the printer name
     */
    setPrinter(printer: string): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
     * @param lpi the resolution in lpi (lines per inch)
     */
    setPrinterLpi(lpi: number): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_QUALITY.
     * @param quality a `GtkPrintQuality` value
     */
    setQuality(quality: PrintQuality): void
    /**
     * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
     * %GTK_PRINT_SETTINGS_RESOLUTION_X and
     * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
     * @param resolution the resolution in dpi
     */
    setResolution(resolution: number): void
    /**
     * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
     * %GTK_PRINT_SETTINGS_RESOLUTION_X and
     * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
     * @param resolutionX the horizontal resolution in dpi
     * @param resolutionY the vertical resolution in dpi
     */
    setResolutionXy(resolutionX: number, resolutionY: number): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_REVERSE.
     * @param reverse whether to reverse the output
     */
    setReverse(reverse: boolean): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_SCALE.
     * @param scale the scale in percent
     */
    setScale(scale: number): void
    /**
     * Sets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
     * @param useColor whether to use color
     */
    setUseColor(useColor: boolean): void
    /**
     * This function saves the print settings from `settings` to `file_name`.
     *
     * If the file could not be written then error is set to either a
     * `GFileError` or `GKeyFileError`.
     * @param fileName the file to save to
     * @returns %TRUE on success
     */
    toFile(fileName: string): boolean
    /**
     * Serialize print settings to an a{sv} variant.
     * @returns a new, floating, `GVariant`
     */
    toGvariant(): GLib.Variant
    /**
     * This function adds the print settings from `settings` to `key_file`.
     * @param keyFile the `GKeyFile` to save the print settings to
     * @param groupName the group to add the settings to in `key_file,` or   %NULL to use the default “Print Settings”
     */
    toKeyFile(keyFile: GLib.KeyFile, groupName: string | null): void
    /**
     * Removes any value associated with `key`.
     *
     * This has the same effect as setting the value to %NULL.
     * @param key a key
     */
    unset(key: string): void

    // Class property signals of Gtk-4.0.Gtk.PrintSettings

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkPrintSettings` object represents the settings of a print dialog in
   * a system-independent way.
   *
   * The main use for this object is that once you’ve printed you can get a
   * settings object that represents the settings the user chose, and the next
   * time you print you can pass that object in so that the user doesn’t have
   * to re-set all his settings.
   *
   * Its also possible to enumerate the settings so that you can easily save
   * the settings for the next time your app runs, or even store them in a
   * document. The predefined keys try to use shared values as much as possible
   * so that moving such a document between systems still works.
   * @class
   */
  class PrintSettings extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.PrintSettings

    static name: string

    // Constructors of Gtk-4.0.Gtk.PrintSettings

    constructor(config?: PrintSettings.ConstructorProperties)
    /**
     * Creates a new `GtkPrintSettings` object.
     * @constructor
     * @returns a new `GtkPrintSettings` object
     */
    constructor()
    /**
     * Creates a new `GtkPrintSettings` object.
     * @constructor
     * @returns a new `GtkPrintSettings` object
     */
    static new(): PrintSettings
    /**
     * Reads the print settings from `file_name`.
     *
     * Returns a new `GtkPrintSettings` object with the restored settings,
     * or %NULL if an error occurred. If the file could not be loaded then
     * error is set to either a `GFileError` or `GKeyFileError`.
     *
     * See [method`Gtk`.PrintSettings.to_file].
     * @constructor
     * @param fileName the filename to read the settings from
     * @returns the restored `GtkPrintSettings`
     */
    static newFromFile(fileName: string): PrintSettings
    /**
     * Deserialize print settings from an a{sv} variant.
     *
     * The variant must be in the format produced by
     * [method`Gtk`.PrintSettings.to_gvariant].
     * @constructor
     * @param variant an a{sv} `GVariant`
     * @returns a new `GtkPrintSettings` object
     */
    static newFromGvariant(variant: GLib.Variant): PrintSettings
    /**
     * Reads the print settings from the group `group_name` in `key_file`.
     *
     * Returns a new `GtkPrintSettings` object with the restored settings,
     * or %NULL if an error occurred. If the file could not be loaded then
     * error is set to either `GFileError` or `GKeyFileError`.
     * @constructor
     * @param keyFile the `GKeyFile` to retrieve the settings from
     * @param groupName the name of the group to use, or %NULL to use   the default “Print Settings”
     * @returns the restored `GtkPrintSettings`
     */
    static newFromKeyFile(
      keyFile: GLib.KeyFile,
      groupName: string | null
    ): PrintSettings
    _init(config?: PrintSettings.ConstructorProperties): void
  }

  module PrintUnixDialog {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Dialog.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.PrintUnixDialog

      /**
       * The current page in the document.
       */
      current_page?: number | null
      /**
       * %TRUE if the page setup controls are embedded.
       */
      embed_page_setup?: boolean | null
      /**
       * Whether the application has a selection.
       */
      has_selection?: boolean | null
      /**
       * Capabilities the application can handle.
       */
      manual_capabilities?: PrintCapabilities | null
      /**
       * The `GtkPageSetup` object to use.
       */
      page_setup?: PageSetup | null
      /**
       * The `GtkPrintSettings` object used for this dialog.
       */
      print_settings?: PrintSettings | null
      /**
       * Whether the dialog supports selection.
       */
      support_selection?: boolean | null
    }
  }

  interface PrintUnixDialog
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.PrintUnixDialog

    /**
     * The current page in the document.
     */
    currentPage: number
    /**
     * %TRUE if the page setup controls are embedded.
     */
    embedPageSetup: boolean
    /**
     * Whether the application has a selection.
     */
    hasSelection: boolean
    /**
     * Capabilities the application can handle.
     */
    manualCapabilities: PrintCapabilities
    /**
     * The `GtkPageSetup` object to use.
     */
    pageSetup: PageSetup
    /**
     * The `GtkPrintSettings` object used for this dialog.
     */
    printSettings: PrintSettings
    /**
     * The `GtkPrinter` which is selected.
     */
    readonly selectedPrinter: Printer
    /**
     * Whether the dialog supports selection.
     */
    supportSelection: boolean
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.PrintUnixDialog

    /**
     * Adds a custom tab to the print dialog.
     * @param child the widget to put in the custom tab
     * @param tabLabel the widget to use as tab label
     */
    addCustomTab(child: Widget, tabLabel: Widget): void
    /**
     * Gets the current page of the `GtkPrintUnixDialog`.
     * @returns the current page of @dialog
     */
    getCurrentPage(): number
    /**
     * Gets whether to embed the page setup.
     * @returns whether to embed the page setup
     */
    getEmbedPageSetup(): boolean
    /**
     * Gets whether there is a selection.
     * @returns whether there is a selection
     */
    getHasSelection(): boolean
    /**
     * Gets the capabilities that have been set on this `GtkPrintUnixDialog`.
     * @returns the printing capabilities
     */
    getManualCapabilities(): PrintCapabilities
    /**
     * Gets the page setup that is used by the `GtkPrintUnixDialog`.
     * @returns the page setup of @dialog.
     */
    getPageSetup(): PageSetup
    /**
     * Gets whether a page setup was set by the user.
     * @returns whether a page setup was set by user.
     */
    getPageSetupSet(): boolean
    /**
     * Gets the currently selected printer.
     * @returns the currently selected printer
     */
    getSelectedPrinter(): Printer | null
    /**
     * Gets a new `GtkPrintSettings` object that represents the
     * current values in the print dialog.
     *
     * Note that this creates a new object, and you need to unref
     * it if don’t want to keep it.
     * @returns a new `GtkPrintSettings` object with the values from @dialog
     */
    getSettings(): PrintSettings

    // Overloads of getSettings

    /**
     * Gets the settings object holding the settings used for this widget.
     *
     * Note that this function can only be called when the `GtkWidget`
     * is attached to a toplevel, since the settings object is specific
     * to a particular `GdkDisplay`. If you want to monitor the widget for
     * changes in its settings, connect to the `notify::display` signal.
     * @returns the relevant `GtkSettings` object
     */
    getSettings(): Settings
    /**
     * Gets whether the print dialog allows user to print a selection.
     * @returns whether the application supports print of selection
     */
    getSupportSelection(): boolean
    /**
     * Sets the current page number.
     *
     * If `current_page` is not -1, this enables the current page choice
     * for the range of pages to print.
     * @param currentPage the current page number.
     */
    setCurrentPage(currentPage: number): void
    /**
     * Embed page size combo box and orientation combo box into page setup page.
     * @param embed embed page setup selection
     */
    setEmbedPageSetup(embed: boolean): void
    /**
     * Sets whether a selection exists.
     * @param hasSelection %TRUE indicates that a selection exists
     */
    setHasSelection(hasSelection: boolean): void
    /**
     * This lets you specify the printing capabilities your application
     * supports.
     *
     * For instance, if you can handle scaling the output then you pass
     * %GTK_PRINT_CAPABILITY_SCALE. If you don’t pass that, then the dialog
     * will only let you select the scale if the printing system automatically
     * handles scaling.
     * @param capabilities the printing capabilities of your application
     */
    setManualCapabilities(capabilities: PrintCapabilities): void
    /**
     * Sets the page setup of the `GtkPrintUnixDialog`.
     * @param pageSetup a `GtkPageSetup`
     */
    setPageSetup(pageSetup: PageSetup): void
    /**
     * Sets the `GtkPrintSettings` for the `GtkPrintUnixDialog`.
     *
     * Typically, this is used to restore saved print settings
     * from a previous print operation before the print dialog
     * is shown.
     * @param settings a `GtkPrintSettings`
     */
    setSettings(settings: PrintSettings | null): void
    /**
     * Sets whether the print dialog allows user to print a selection.
     * @param supportSelection %TRUE to allow print selection
     */
    setSupportSelection(supportSelection: boolean): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void
    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @virtual
     */
    close(): void

    // Overloads of close

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void

    // Class property signals of Gtk-4.0.Gtk.PrintUnixDialog

    connect(
      sigName: "notify::current-page",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::current-page",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::current-page",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::current-page",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::current-page", ...args: any[]): void
    connect(
      sigName: "notify::embed-page-setup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::embed-page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::embed-page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::embed-page-setup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::embed-page-setup", ...args: any[]): void
    connect(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-selection", ...args: any[]): void
    connect(
      sigName: "notify::manual-capabilities",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::manual-capabilities",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::manual-capabilities",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::manual-capabilities",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::manual-capabilities", ...args: any[]): void
    connect(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::page-setup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::page-setup", ...args: any[]): void
    connect(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::print-settings",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::print-settings", ...args: any[]): void
    connect(
      sigName: "notify::selected-printer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected-printer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected-printer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected-printer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected-printer", ...args: any[]): void
    connect(
      sigName: "notify::support-selection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::support-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::support-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::support-selection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::support-selection", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-header-bar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-header-bar", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkPrintUnixDialog` implements a print dialog for platforms
   * which don’t provide a native print dialog, like Unix.
   *
   * ![An example GtkPrintUnixDialog](printdialog.png)
   *
   * It can be used very much like any other GTK dialog, at the cost of
   * the portability offered by the high-level printing API with
   * [class`Gtk`.PrintOperation].
   *
   * In order to print something with `GtkPrintUnixDialog`, you need to
   * use [method`Gtk`.PrintUnixDialog.get_selected_printer] to obtain a
   * [class`Gtk`.Printer] object and use it to construct a [class`Gtk`.PrintJob]
   * using [ctor`Gtk`.PrintJob.new].
   *
   * `GtkPrintUnixDialog` uses the following response values:
   *
   * - %GTK_RESPONSE_OK: for the “Print” button
   * - %GTK_RESPONSE_APPLY: for the “Preview” button
   * - %GTK_RESPONSE_CANCEL: for the “Cancel” button
   *
   * # GtkPrintUnixDialog as GtkBuildable
   *
   * The `GtkPrintUnixDialog` implementation of the `GtkBuildable` interface
   * exposes its `notebook` internal children with the name “notebook”.
   *
   * An example of a `GtkPrintUnixDialog` UI definition fragment:
   *
   * ```xml
   * <object class="GtkPrintUnixDialog" id="dialog1">
   *   <child internal-child="notebook">
   *     <object class="GtkNotebook" id="notebook">
   *       <child>
   *         <object type="GtkNotebookPage">
   *           <property name="tab_expand">False</property>
   *           <property name="tab_fill">False</property>
   *           <property name="tab">
   *             <object class="GtkLabel" id="tablabel">
   *               <property name="label">Tab label</property>
   *             </object>
   *           </property>
   *           <property name="child">
   *             <object class="GtkLabel" id="tabcontent">
   *               <property name="label">Content on notebook tab</property>
   *             </object>
   *           </property>
   *         </object>
   *       </child>
   *     </object>
   *   </child>
   * </object>
   * ```
   *
   * # CSS nodes
   *
   * `GtkPrintUnixDialog` has a single CSS node with name window. The style classes
   * dialog and print are added.
   * @class
   */
  class PrintUnixDialog extends Dialog {
    // Own properties of Gtk-4.0.Gtk.PrintUnixDialog

    static name: string

    // Constructors of Gtk-4.0.Gtk.PrintUnixDialog

    constructor(config?: PrintUnixDialog.ConstructorProperties)
    /**
     * Creates a new `GtkPrintUnixDialog`.
     * @constructor
     * @param title Title of the dialog
     * @param parent Transient parent of the dialog
     * @returns a new `GtkPrintUnixDialog`
     */
    constructor(title: string | null, parent: Window | null)
    /**
     * Creates a new `GtkPrintUnixDialog`.
     * @constructor
     * @param title Title of the dialog
     * @param parent Transient parent of the dialog
     * @returns a new `GtkPrintUnixDialog`
     */
    static new(title: string | null, parent: Window | null): PrintUnixDialog

    // Overloads of new

    /**
     * Creates a new dialog box.
     *
     * Widgets should not be packed into the `GtkWindow`
     * directly, but into the `content_area` and `action_area,`
     * as described above.
     * @constructor
     * @returns the new dialog as a `GtkWidget`
     */
    static new(): Dialog
    _init(config?: PrintUnixDialog.ConstructorProperties): void
  }

  module Printer {
    // Signal callback interfaces

    /**
     * Signal callback interface for `details-acquired`
     */
    interface DetailsAcquiredSignalCallback {
      (success: boolean): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Printer

      /**
       * %TRUE if this printer can accept PDF.
       */
      accepts_pdf?: boolean | null
      /**
       * %TRUE if this printer can accept PostScript.
       */
      accepts_ps?: boolean | null
      /**
       * %FALSE if this represents a real hardware device.
       */
      is_virtual?: boolean | null
      /**
       * The name of the printer.
       */
      name?: string | null
    }
  }

  interface Printer {
    // Own properties of Gtk-4.0.Gtk.Printer

    /**
     * %TRUE if the printer is accepting jobs.
     */
    readonly acceptingJobs: boolean
    /**
     * %TRUE if this printer can accept PDF.
     */
    readonly acceptsPdf: boolean
    /**
     * %TRUE if this printer can accept PostScript.
     */
    readonly acceptsPs: boolean
    /**
     * Icon name to use for the printer.
     */
    readonly iconName: string | null
    /**
     * %FALSE if this represents a real hardware device.
     */
    readonly isVirtual: boolean
    /**
     * Number of jobs queued in the printer.
     */
    readonly jobCount: number
    /**
     * Information about the location of the printer.
     */
    readonly location: string | null
    /**
     * The name of the printer.
     */
    readonly name: string | null
    /**
     * %TRUE if this printer is paused.
     *
     * A paused printer still accepts jobs, but it does
     * not print them.
     */
    readonly paused: boolean
    /**
     * String giving the current status of the printer.
     */
    readonly stateMessage: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Printer

    /**
     * Compares two printers.
     * @param b another `GtkPrinter`
     * @returns 0 if the printer match, a negative value if @a < @b,   or a positive value if @a > @b
     */
    compare(b: Printer): number
    /**
     * Returns the backend of the printer.
     * @returns the backend of @printer
     */
    getBackend(): PrintBackend
    /**
     * Returns the printer’s capabilities.
     *
     * This is useful when you’re using `GtkPrintUnixDialog`’s
     * manual-capabilities setting and need to know which settings
     * the printer can handle and which you must handle yourself.
     *
     * This will return 0 unless the printer’s details are
     * available, see [method`Gtk`.Printer.has_details] and
     * [method`Gtk`.Printer.request_details].
     * @returns the printer’s capabilities
     */
    getCapabilities(): PrintCapabilities
    /**
     * Returns default page size of `printer`.
     * @returns a newly allocated `GtkPageSetup` with default page size   of the printer.
     */
    getDefaultPageSize(): PageSetup
    /**
     * Gets the description of the printer.
     * @returns the description of @printer
     */
    getDescription(): string
    /**
     * Retrieve the hard margins of `printer`.
     *
     * These are the margins that define the area at the borders
     * of the paper that the printer cannot print to.
     *
     * Note: This will not succeed unless the printer’s details are
     * available, see [method`Gtk`.Printer.has_details] and
     * [method`Gtk`.Printer.request_details].
     * @returns %TRUE iff the hard margins were retrieved
     */
    getHardMargins(): [
      /* returnType */ boolean,
      /* top */ number,
      /* bottom */ number,
      /* left */ number,
      /* right */ number,
    ]
    /**
     * Retrieve the hard margins of `printer` for `paper_size`.
     *
     * These are the margins that define the area at the borders
     * of the paper that the printer cannot print to.
     *
     * Note: This will not succeed unless the printer’s details are
     * available, see [method`Gtk`.Printer.has_details] and
     * [method`Gtk`.Printer.request_details].
     * @param paperSize a `GtkPaperSize`
     * @returns %TRUE iff the hard margins were retrieved
     */
    getHardMarginsForPaperSize(
      paperSize: PaperSize
    ): [
      /* returnType */ boolean,
      /* top */ number,
      /* bottom */ number,
      /* left */ number,
      /* right */ number,
    ]
    /**
     * Gets the name of the icon to use for the printer.
     * @returns the icon name for @printer
     */
    getIconName(): string
    /**
     * Gets the number of jobs currently queued on the printer.
     * @returns the number of jobs on @printer
     */
    getJobCount(): number
    /**
     * Returns a description of the location of the printer.
     * @returns the location of @printer
     */
    getLocation(): string
    /**
     * Returns the name of the printer.
     * @returns the name of @printer
     */
    getName(): string
    /**
     * Returns the state message describing the current state
     * of the printer.
     * @returns the state message of @printer
     */
    getStateMessage(): string
    /**
     * Returns whether the printer details are available.
     * @returns %TRUE if @printer details are available
     */
    hasDetails(): boolean
    /**
     * Returns whether the printer is accepting jobs
     * @returns %TRUE if @printer is accepting jobs
     */
    isAcceptingJobs(): boolean
    /**
     * Returns whether the printer is currently active (i.e.
     * accepts new jobs).
     * @returns %TRUE if @printer is active
     */
    isActive(): boolean
    /**
     * Returns whether the printer is the default printer.
     * @returns %TRUE if @printer is the default
     */
    isDefault(): boolean
    /**
     * Returns whether the printer is currently paused.
     *
     * A paused printer still accepts jobs, but it is not
     * printing them.
     * @returns %TRUE if @printer is paused
     */
    isPaused(): boolean
    /**
     * Lists all the paper sizes `printer` supports.
     *
     * This will return and empty list unless the printer’s details
     * are available, see [method`Gtk`.Printer.has_details] and
     * [method`Gtk`.Printer.request_details].
     * @returns a newly   allocated list of newly allocated `GtkPageSetup`s.
     */
    listPapers(): PageSetup[]
    /**
     * Requests the printer details.
     *
     * When the details are available, the
     * [signal`Gtk`.Printer::details-acquired] signal
     * will be emitted on `printer`.
     */
    requestDetails(): void

    // Own signals of Gtk-4.0.Gtk.Printer

    connect(
      sigName: "details-acquired",
      callback: Printer.DetailsAcquiredSignalCallback
    ): number
    on(
      sigName: "details-acquired",
      callback: Printer.DetailsAcquiredSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "details-acquired",
      callback: Printer.DetailsAcquiredSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "details-acquired",
      callback: Printer.DetailsAcquiredSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "details-acquired", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Printer

    connect(
      sigName: "notify::accepting-jobs",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accepting-jobs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accepting-jobs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accepting-jobs",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accepting-jobs", ...args: any[]): void
    connect(
      sigName: "notify::accepts-pdf",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accepts-pdf",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accepts-pdf",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accepts-pdf",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accepts-pdf", ...args: any[]): void
    connect(
      sigName: "notify::accepts-ps",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accepts-ps",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accepts-ps",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accepts-ps",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accepts-ps", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-virtual",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-virtual",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-virtual",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-virtual",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-virtual", ...args: any[]): void
    connect(
      sigName: "notify::job-count",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::job-count",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::job-count",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::job-count",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::job-count", ...args: any[]): void
    connect(
      sigName: "notify::location",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::location",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::location",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::location",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::location", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::paused",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::paused",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::paused",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::paused",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::paused", ...args: any[]): void
    connect(
      sigName: "notify::state-message",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state-message",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state-message",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state-message",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state-message", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkPrinter` object represents a printer.
   *
   * You only need to deal directly with printers if you use the
   * non-portable [class`Gtk`.PrintUnixDialog] API.
   *
   * A `GtkPrinter` allows to get status information about the printer,
   * such as its description, its location, the number of queued jobs,
   * etc. Most importantly, a `GtkPrinter` object can be used to create
   * a [class`Gtk`.PrintJob] object, which lets you print to the printer.
   * @class
   */
  class Printer extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Printer

    static name: string

    // Constructors of Gtk-4.0.Gtk.Printer

    constructor(config?: Printer.ConstructorProperties)
    /**
     * Creates a new `GtkPrinter`.
     * @constructor
     * @param name the name of the printer
     * @param backend a `GtkPrintBackend`
     * @param virtual whether the printer is virtual
     * @returns a new `GtkPrinter`
     */
    constructor(name: string, backend: PrintBackend, virtual: boolean)
    /**
     * Creates a new `GtkPrinter`.
     * @constructor
     * @param name the name of the printer
     * @param backend a `GtkPrintBackend`
     * @param virtual whether the printer is virtual
     * @returns a new `GtkPrinter`
     */
    static new(name: string, backend: PrintBackend, virtual: boolean): Printer
    _init(config?: Printer.ConstructorProperties): void
  }

  module ProgressBar {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleRange.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ProgressBar

      /**
       * The preferred place to ellipsize the string.
       *
       * The text will be ellipsized if the progress bar does not have enough room
       * to display the entire string, specified as a `PangoEllipsizeMode`.
       *
       * Note that setting this property to a value other than
       * %PANGO_ELLIPSIZE_NONE has the side-effect that the progress bar requests
       * only enough space to display the ellipsis ("..."). Another means to set a
       * progress bar's width is [method`Gtk`.Widget.set_size_request].
       */
      ellipsize?: Pango.EllipsizeMode | null
      /**
       * The fraction of total work that has been completed.
       */
      fraction?: number | null
      /**
       * Invert the direction in which the progress bar grows.
       */
      inverted?: boolean | null
      /**
       * The fraction of total progress to move the bounding block when pulsed.
       */
      pulse_step?: number | null
      /**
       * Sets whether the progress bar will show a text in addition
       * to the bar itself.
       *
       * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
       * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction]
       * value, as a percentage.
       *
       * To make a progress bar that is styled and sized suitably for showing text
       * (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
       * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
       */
      show_text?: boolean | null
      /**
       * Text to be displayed in the progress bar.
       */
      text?: string | null
    }
  }

  interface ProgressBar
    extends Accessible,
      AccessibleRange,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.ProgressBar

    /**
     * The preferred place to ellipsize the string.
     *
     * The text will be ellipsized if the progress bar does not have enough room
     * to display the entire string, specified as a `PangoEllipsizeMode`.
     *
     * Note that setting this property to a value other than
     * %PANGO_ELLIPSIZE_NONE has the side-effect that the progress bar requests
     * only enough space to display the ellipsis ("..."). Another means to set a
     * progress bar's width is [method`Gtk`.Widget.set_size_request].
     */
    ellipsize: Pango.EllipsizeMode
    /**
     * The fraction of total work that has been completed.
     */
    fraction: number
    /**
     * Invert the direction in which the progress bar grows.
     */
    inverted: boolean
    /**
     * The fraction of total progress to move the bounding block when pulsed.
     */
    pulseStep: number
    /**
     * Sets whether the progress bar will show a text in addition
     * to the bar itself.
     *
     * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
     * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction]
     * value, as a percentage.
     *
     * To make a progress bar that is styled and sized suitably for showing text
     * (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
     * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
     */
    showText: boolean
    /**
     * Text to be displayed in the progress bar.
     */
    text: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ProgressBar

    /**
     * Returns the ellipsizing position of the progress bar.
     *
     * See [method`Gtk`.ProgressBar.set_ellipsize].
     * @returns `PangoEllipsizeMode`
     */
    getEllipsize(): Pango.EllipsizeMode
    /**
     * Returns the current fraction of the task that’s been completed.
     * @returns a fraction from 0.0 to 1.0
     */
    getFraction(): number
    /**
     * Returns whether the progress bar is inverted.
     * @returns %TRUE if the progress bar is inverted
     */
    getInverted(): boolean
    /**
     * Retrieves the pulse step.
     *
     * See [method`Gtk`.ProgressBar.set_pulse_step].
     * @returns a fraction from 0.0 to 1.0
     */
    getPulseStep(): number
    /**
     * Returns whether the `GtkProgressBar` shows text.
     *
     * See [method`Gtk`.ProgressBar.set_show_text].
     * @returns %TRUE if text is shown in the progress bar
     */
    getShowText(): boolean
    /**
     * Retrieves the text that is displayed with the progress bar.
     *
     * The return value is a reference to the text, not a copy of it,
     * so will become invalid if you change the text in the progress bar.
     * @returns the text
     */
    getText(): string | null
    /**
     * Indicates that some progress has been made, but you don’t know how much.
     *
     * Causes the progress bar to enter “activity mode,” where a block
     * bounces back and forth. Each call to [method`Gtk`.ProgressBar.pulse]
     * causes the block to move by a little bit (the amount of movement
     * per pulse is determined by [method`Gtk`.ProgressBar.set_pulse_step]).
     */
    pulse(): void
    /**
     * Sets the mode used to ellipsize the text.
     *
     * The text is ellipsized if there is not enough space
     * to render the entire string.
     * @param mode a `PangoEllipsizeMode`
     */
    setEllipsize(mode: Pango.EllipsizeMode): void
    /**
     * Causes the progress bar to “fill in” the given fraction
     * of the bar.
     *
     * The fraction should be between 0.0 and 1.0, inclusive.
     * @param fraction fraction of the task that’s been completed
     */
    setFraction(fraction: number): void
    /**
     * Sets whether the progress bar is inverted.
     *
     * Progress bars normally grow from top to bottom or left to right.
     * Inverted progress bars grow in the opposite direction.
     * @param inverted %TRUE to invert the progress bar
     */
    setInverted(inverted: boolean): void
    /**
     * Sets the fraction of total progress bar length to move the
     * bouncing block.
     *
     * The bouncing block is moved when [method`Gtk`.ProgressBar.pulse]
     * is called.
     * @param fraction fraction between 0.0 and 1.0
     */
    setPulseStep(fraction: number): void
    /**
     * Sets whether the progress bar will show text next to the bar.
     *
     * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
     * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction] value,
     * as a percentage.
     *
     * To make a progress bar that is styled and sized suitably for containing
     * text (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
     * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
     * @param showText whether to show text
     */
    setShowText(showText: boolean): void
    /**
     * Causes the given `text` to appear next to the progress bar.
     *
     * If `text` is %NULL and [property`Gtk`.ProgressBar:show-text] is %TRUE,
     * the current value of [property`Gtk`.ProgressBar:fraction] will be displayed
     * as a percentage.
     *
     * If `text` is non-%NULL and [property`Gtk`.ProgressBar:show-text] is %TRUE,
     * the text will be displayed. In this case, it will not display the progress
     * percentage. If `text` is the empty string, the progress bar will still
     * be styled and sized suitably for containing text, as long as
     * [property`Gtk`.ProgressBar:show-text] is %TRUE.
     * @param text a UTF-8 string
     */
    setText(text: string | null): void

    // Class property signals of Gtk-4.0.Gtk.ProgressBar

    connect(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ellipsize",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ellipsize", ...args: any[]): void
    connect(
      sigName: "notify::fraction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fraction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fraction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fraction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fraction", ...args: any[]): void
    connect(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inverted", ...args: any[]): void
    connect(
      sigName: "notify::pulse-step",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pulse-step",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pulse-step",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pulse-step",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pulse-step", ...args: any[]): void
    connect(
      sigName: "notify::show-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-text", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkProgressBar` is typically used to display the progress of a long
   * running operation.
   *
   * It provides a visual clue that processing is underway. `GtkProgressBar`
   * can be used in two different modes: percentage mode and activity mode.
   *
   * ![An example GtkProgressBar](progressbar.png)
   *
   * When an application can determine how much work needs to take place
   * (e.g. read a fixed number of bytes from a file) and can monitor its
   * progress, it can use the `GtkProgressBar` in percentage mode and the
   * user sees a growing bar indicating the percentage of the work that
   * has been completed. In this mode, the application is required to call
   * [method`Gtk`.ProgressBar.set_fraction] periodically to update the progress bar.
   *
   * When an application has no accurate way of knowing the amount of work
   * to do, it can use the `GtkProgressBar` in activity mode, which shows
   * activity by a block moving back and forth within the progress area. In
   * this mode, the application is required to call [method`Gtk`.ProgressBar.pulse]
   * periodically to update the progress bar.
   *
   * There is quite a bit of flexibility provided to control the appearance
   * of the `GtkProgressBar`. Functions are provided to control the orientation
   * of the bar, optional text can be displayed along with the bar, and the
   * step size used in activity mode can be set.
   *
   * # CSS nodes
   *
   * ```
   * progressbar[.osd]
   * ├── [text]
   * ╰── trough[.empty][.full]
   *     ╰── progress[.pulse]
   * ```
   *
   * `GtkProgressBar` has a main CSS node with name progressbar and subnodes with
   * names text and trough, of which the latter has a subnode named progress. The
   * text subnode is only present if text is shown. The progress subnode has the
   * style class .pulse when in activity mode. It gets the style classes .left,
   * .right, .top or .bottom added when the progress 'touches' the corresponding
   * end of the GtkProgressBar. The .osd class on the progressbar node is for use
   * in overlays like the one Epiphany has for page loading progress.
   *
   * # Accessibility
   *
   * `GtkProgressBar` uses the %GTK_ACCESSIBLE_ROLE_PROGRESS_BAR role.
   * @class
   */
  class ProgressBar extends Widget {
    // Own properties of Gtk-4.0.Gtk.ProgressBar

    static name: string

    // Constructors of Gtk-4.0.Gtk.ProgressBar

    constructor(config?: ProgressBar.ConstructorProperties)
    /**
     * Creates a new `GtkProgressBar`.
     * @constructor
     * @returns a `GtkProgressBar`.
     */
    constructor()
    /**
     * Creates a new `GtkProgressBar`.
     * @constructor
     * @returns a `GtkProgressBar`.
     */
    static new(): ProgressBar
    _init(config?: ProgressBar.ConstructorProperties): void
  }

  interface PropertyExpression {
    // Owm methods of Gtk-4.0.Gtk.PropertyExpression

    /**
     * Gets the expression specifying the object of
     * a property expression.
     * @returns the object expression
     */
    getExpression(): Expression | null
    /**
     * Gets the `GParamSpec` specifying the property of
     * a property expression.
     * @returns the `GParamSpec` for the property
     */
    getPspec(): GObject.ParamSpec
  }

  /**
   * A `GObject` property value in a `GtkExpression`.
   * @class
   */
  class PropertyExpression extends Expression {
    // Own properties of Gtk-4.0.Gtk.PropertyExpression

    static name: string

    // Constructors of Gtk-4.0.Gtk.PropertyExpression

    /**
     * Creates an expression that looks up a property.
     *
     * The object to use is found by evaluating the `expression`,
     * or using the `this` argument when `expression` is `NULL`.
     *
     * If the resulting object conforms to `this_type`, its property named
     * `property_name` will be queried. Otherwise, this expression's
     * evaluation will fail.
     *
     * The given `this_type` must have a property with `property_name`.
     * @constructor
     * @param thisType The type to expect for the this type
     * @param expression Expression to   evaluate to get the object to query or `NULL` to   query the `this` object
     * @param propertyName name of the property
     * @returns a new `GtkExpression`
     */
    constructor(
      thisType: GObject.GType,
      expression: Expression | null,
      propertyName: string
    )
    /**
     * Creates an expression that looks up a property.
     *
     * The object to use is found by evaluating the `expression`,
     * or using the `this` argument when `expression` is `NULL`.
     *
     * If the resulting object conforms to `this_type`, its property named
     * `property_name` will be queried. Otherwise, this expression's
     * evaluation will fail.
     *
     * The given `this_type` must have a property with `property_name`.
     * @constructor
     * @param thisType The type to expect for the this type
     * @param expression Expression to   evaluate to get the object to query or `NULL` to   query the `this` object
     * @param propertyName name of the property
     * @returns a new `GtkExpression`
     */
    static new(
      thisType: GObject.GType,
      expression: Expression | null,
      propertyName: string
    ): PropertyExpression
    /**
     * Creates an expression that looks up a property.
     *
     * The object to use is found by evaluating the `expression`,
     * or using the `this` argument when `expression` is `NULL`.
     *
     * If the resulting object conforms to `this_type`, its
     * property specified by `pspec` will be queried.
     * Otherwise, this expression's evaluation will fail.
     * @constructor
     * @param expression Expression to   evaluate to get the object to query or `NULL` to   query the `this` object
     * @param pspec the `GParamSpec` for the property to query
     * @returns a new `GtkExpression`
     */
    static newForPspec(
      expression: Expression | null,
      pspec: GObject.ParamSpec
    ): PropertyExpression
  }

  module Range {
    // Signal callback interfaces

    /**
     * Signal callback interface for `adjust-bounds`
     */
    interface AdjustBoundsSignalCallback {
      (value: number): void
    }

    /**
     * Signal callback interface for `change-value`
     */
    interface ChangeValueSignalCallback {
      (scroll: ScrollType, value: number): boolean
    }

    /**
     * Signal callback interface for `move-slider`
     */
    interface MoveSliderSignalCallback {
      (step: ScrollType): void
    }

    /**
     * Signal callback interface for `value-changed`
     */
    interface ValueChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleRange.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Range

      /**
       * The adjustment that is controlled by the range.
       */
      adjustment?: Adjustment | null
      /**
       * The fill level (e.g. prebuffering of a network stream).
       */
      fill_level?: number | null
      /**
       * If %TRUE, the direction in which the slider moves is inverted.
       */
      inverted?: boolean | null
      /**
       * Controls whether slider movement is restricted to an
       * upper boundary set by the fill level.
       */
      restrict_to_fill_level?: boolean | null
      /**
       * The number of digits to round the value to when
       * it changes.
       *
       * See [signal`Gtk`.Range::change-value].
       */
      round_digits?: number | null
      /**
       * Controls whether fill level indicator graphics are displayed
       * on the trough.
       */
      show_fill_level?: boolean | null
    }
  }

  interface Range
    extends Accessible,
      AccessibleRange,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.Range

    /**
     * The adjustment that is controlled by the range.
     */
    adjustment: Adjustment
    /**
     * The fill level (e.g. prebuffering of a network stream).
     */
    fillLevel: number
    /**
     * If %TRUE, the direction in which the slider moves is inverted.
     */
    inverted: boolean
    /**
     * Controls whether slider movement is restricted to an
     * upper boundary set by the fill level.
     */
    restrictToFillLevel: boolean
    /**
     * The number of digits to round the value to when
     * it changes.
     *
     * See [signal`Gtk`.Range::change-value].
     */
    roundDigits: number
    /**
     * Controls whether fill level indicator graphics are displayed
     * on the trough.
     */
    showFillLevel: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Range

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.Range

    /**
     * Get the adjustment which is the “model” object for `GtkRange`.
     * @returns a `GtkAdjustment`
     */
    getAdjustment(): Adjustment
    /**
     * Gets the current position of the fill level indicator.
     * @returns The current fill level
     */
    getFillLevel(): number
    /**
     * Gets whether the `GtkRange` respects text direction.
     *
     * See [method`Gtk`.Range.set_flippable].
     * @returns %TRUE if the range is flippable
     */
    getFlippable(): boolean
    /**
     * Gets whether the range is inverted.
     *
     * See [method`Gtk`.Range.set_inverted].
     * @returns %TRUE if the range is inverted
     */
    getInverted(): boolean
    /**
     * This function returns the area that contains the range’s trough,
     * in coordinates relative to `range'`s origin.
     *
     * This function is useful mainly for `GtkRange` subclasses.
     */
    getRangeRect(): /* rangeRect */ Gdk.Rectangle
    /**
     * Gets whether the range is restricted to the fill level.
     * @returns %TRUE if @range is restricted to the fill level.
     */
    getRestrictToFillLevel(): boolean
    /**
     * Gets the number of digits to round the value to when
     * it changes.
     *
     * See [signal`Gtk`.Range::change-value].
     * @returns the number of digits to round to
     */
    getRoundDigits(): number
    /**
     * Gets whether the range displays the fill level graphically.
     * @returns %TRUE if @range shows the fill level.
     */
    getShowFillLevel(): boolean
    /**
     * This function returns sliders range along the long dimension,
     * in widget->window coordinates.
     *
     * This function is useful mainly for `GtkRange` subclasses.
     */
    getSliderRange(): [/* sliderStart */ number, /* sliderEnd */ number]
    /**
     * This function is useful mainly for `GtkRange` subclasses.
     *
     * See [method`Gtk`.Range.set_slider_size_fixed].
     * @returns whether the range’s slider has a fixed size.
     */
    getSliderSizeFixed(): boolean
    /**
     * Gets the current value of the range.
     * @returns current value of the range.
     */
    getValue(): number
    /**
     * Sets the adjustment to be used as the “model” object for the `GtkRange`
     *
     * The adjustment indicates the current range value, the minimum and
     * maximum range values, the step/page increments used for keybindings
     * and scrolling, and the page size.
     *
     * The page size is normally 0 for `GtkScale` and nonzero for `GtkScrollbar`,
     * and indicates the size of the visible area of the widget being scrolled.
     * The page size affects the size of the scrollbar slider.
     * @param adjustment a `GtkAdjustment`
     */
    setAdjustment(adjustment: Adjustment): void
    /**
     * Set the new position of the fill level indicator.
     *
     * The “fill level” is probably best described by its most prominent
     * use case, which is an indicator for the amount of pre-buffering in
     * a streaming media player. In that use case, the value of the range
     * would indicate the current play position, and the fill level would
     * be the position up to which the file/stream has been downloaded.
     *
     * This amount of prebuffering can be displayed on the range’s trough
     * and is themeable separately from the trough. To enable fill level
     * display, use [method`Gtk`.Range.set_show_fill_level]. The range defaults
     * to not showing the fill level.
     *
     * Additionally, it’s possible to restrict the range’s slider position
     * to values which are smaller than the fill level. This is controlled
     * by [method`Gtk`.Range.set_restrict_to_fill_level] and is by default
     * enabled.
     * @param fillLevel the new position of the fill level indicator
     */
    setFillLevel(fillLevel: number): void
    /**
     * Sets whether the `GtkRange` respects text direction.
     *
     * If a range is flippable, it will switch its direction
     * if it is horizontal and its direction is %GTK_TEXT_DIR_RTL.
     *
     * See [method`Gtk`.Widget.get_direction].
     * @param flippable %TRUE to make the range flippable
     */
    setFlippable(flippable: boolean): void
    /**
     * Sets the step and page sizes for the range.
     *
     * The step size is used when the user clicks the `GtkScrollbar`
     * arrows or moves a `GtkScale` via arrow keys. The page size
     * is used for example when moving via Page Up or Page Down keys.
     * @param step step size
     * @param page page size
     */
    setIncrements(step: number, page: number): void
    /**
     * Sets whether to invert the range.
     *
     * Ranges normally move from lower to higher values as the
     * slider moves from top to bottom or left to right. Inverted
     * ranges have higher values at the top or on the right rather
     * than on the bottom or left.
     * @param setting %TRUE to invert the range
     */
    setInverted(setting: boolean): void
    /**
     * Sets the allowable values in the `GtkRange`.
     *
     * The range value is clamped to be between `min` and `max`.
     * (If the range has a non-zero page size, it is clamped
     * between `min` and `max` - page-size.)
     * @param min minimum range value
     * @param max maximum range value
     */
    setRange(min: number, max: number): void
    /**
     * Sets whether the slider is restricted to the fill level.
     *
     * See [method`Gtk`.Range.set_fill_level] for a general description
     * of the fill level concept.
     * @param restrictToFillLevel Whether the fill level restricts slider movement.
     */
    setRestrictToFillLevel(restrictToFillLevel: boolean): void
    /**
     * Sets the number of digits to round the value to when
     * it changes.
     *
     * See [signal`Gtk`.Range::change-value].
     * @param roundDigits the precision in digits, or -1
     */
    setRoundDigits(roundDigits: number): void
    /**
     * Sets whether a graphical fill level is show on the trough.
     *
     * See [method`Gtk`.Range.set_fill_level] for a general description
     * of the fill level concept.
     * @param showFillLevel Whether a fill level indicator graphics is shown.
     */
    setShowFillLevel(showFillLevel: boolean): void
    /**
     * Sets whether the range’s slider has a fixed size, or a size that
     * depends on its adjustment’s page size.
     *
     * This function is useful mainly for `GtkRange` subclasses.
     * @param sizeFixed %TRUE to make the slider size constant
     */
    setSliderSizeFixed(sizeFixed: boolean): void
    /**
     * Sets the current value of the range.
     *
     * If the value is outside the minimum or maximum range values,
     * it will be clamped to fit inside them. The range emits the
     * [signal`Gtk`.Range::value-changed] signal if the value changes.
     * @param value new value of the range
     */
    setValue(value: number): void

    // Own virtual methods of Gtk-4.0.Gtk.Range

    adjustBounds(newValue: number): void
    changeValue(scroll: ScrollType, newValue: number): boolean
    getRangeBorder(border: Border): void
    moveSlider(scroll: ScrollType): void
    valueChanged(): void

    // Own signals of Gtk-4.0.Gtk.Range

    connect(
      sigName: "adjust-bounds",
      callback: Range.AdjustBoundsSignalCallback
    ): number
    on(
      sigName: "adjust-bounds",
      callback: Range.AdjustBoundsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "adjust-bounds",
      callback: Range.AdjustBoundsSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "adjust-bounds",
      callback: Range.AdjustBoundsSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "adjust-bounds", ...args: any[]): void
    connect(
      sigName: "change-value",
      callback: Range.ChangeValueSignalCallback
    ): number
    on(
      sigName: "change-value",
      callback: Range.ChangeValueSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "change-value",
      callback: Range.ChangeValueSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "change-value",
      callback: Range.ChangeValueSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "change-value", value: number, ...args: any[]): void
    connect(
      sigName: "move-slider",
      callback: Range.MoveSliderSignalCallback
    ): number
    on(
      sigName: "move-slider",
      callback: Range.MoveSliderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-slider",
      callback: Range.MoveSliderSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-slider",
      callback: Range.MoveSliderSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "move-slider", ...args: any[]): void
    connect(
      sigName: "value-changed",
      callback: Range.ValueChangedSignalCallback
    ): number
    on(
      sigName: "value-changed",
      callback: Range.ValueChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "value-changed",
      callback: Range.ValueChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "value-changed",
      callback: Range.ValueChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "value-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Range

    connect(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::adjustment", ...args: any[]): void
    connect(
      sigName: "notify::fill-level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fill-level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fill-level", ...args: any[]): void
    connect(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inverted", ...args: any[]): void
    connect(
      sigName: "notify::restrict-to-fill-level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::restrict-to-fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::restrict-to-fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::restrict-to-fill-level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::restrict-to-fill-level", ...args: any[]): void
    connect(
      sigName: "notify::round-digits",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::round-digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::round-digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::round-digits",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::round-digits", ...args: any[]): void
    connect(
      sigName: "notify::show-fill-level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-fill-level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-fill-level", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkRange` is the common base class for widgets which visualize an
   * adjustment.
   *
   * Widgets that are derived from `GtkRange` include
   * [class`Gtk`.Scale] and [class`Gtk`.Scrollbar].
   *
   * Apart from signals for monitoring the parameters of the adjustment,
   * `GtkRange` provides properties and methods for setting a
   * “fill level” on range widgets. See [method`Gtk`.Range.set_fill_level].
   * @class
   */
  class Range extends Widget {
    // Own properties of Gtk-4.0.Gtk.Range

    static name: string

    // Constructors of Gtk-4.0.Gtk.Range

    constructor(config?: Range.ConstructorProperties)
    _init(config?: Range.ConstructorProperties): void
  }

  module RecentManager {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.RecentManager

      /**
       * The full path to the file to be used to store and read the
       * recently used resources list
       */
      filename?: string | null
    }
  }

  interface RecentManager {
    // Own properties of Gtk-4.0.Gtk.RecentManager

    /**
     * The full path to the file to be used to store and read the
     * recently used resources list
     */
    readonly filename: string | null
    /**
     * The size of the recently used resources list.
     */
    readonly size: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.RecentManager

    /**
     * Adds a new resource, pointed by `uri,` into the recently used
     * resources list, using the metadata specified inside the
     * `GtkRecentData` passed in `recent_data`.
     *
     * The passed URI will be used to identify this resource inside the
     * list.
     *
     * In order to register the new recently used resource, metadata about
     * the resource must be passed as well as the URI; the metadata is
     * stored in a `GtkRecentData`, which must contain the MIME
     * type of the resource pointed by the URI; the name of the application
     * that is registering the item, and a command line to be used when
     * launching the item.
     *
     * Optionally, a `GtkRecentData` might contain a UTF-8 string
     * to be used when viewing the item instead of the last component of
     * the URI; a short description of the item; whether the item should
     * be considered private - that is, should be displayed only by the
     * applications that have registered it.
     * @param uri a valid URI
     * @param recentData metadata of the resource
     * @returns %TRUE if the new item was successfully added to the   recently used resources list, %FALSE otherwise
     */
    addFull(uri: string, recentData: RecentData): boolean
    /**
     * Adds a new resource, pointed by `uri,` into the recently used
     * resources list.
     *
     * This function automatically retrieves some of the needed
     * metadata and setting other metadata to common default values;
     * it then feeds the data to [method`Gtk`.RecentManager.add_full].
     *
     * See [method`Gtk`.RecentManager.add_full] if you want to explicitly
     * define the metadata for the resource pointed by `uri`.
     * @param uri a valid URI
     * @returns %TRUE if the new item was successfully added   to the recently used resources list
     */
    addItem(uri: string): boolean
    /**
     * Gets the list of recently used resources.
     * @returns a list of   newly allocated `GtkRecentInfo objects`. Use   [method@Gtk.RecentInfo.unref] on each item inside the list, and then   free the list itself using g_list_free().
     */
    getItems(): RecentInfo[]
    /**
     * Checks whether there is a recently used resource registered
     * with `uri` inside the recent manager.
     * @param uri a URI
     * @returns %TRUE if the resource was found, %FALSE otherwise
     */
    hasItem(uri: string): boolean
    /**
     * Searches for a URI inside the recently used resources list, and
     * returns a `GtkRecentInfo` containing information about the resource
     * like its MIME type, or its display name.
     * @param uri a URI
     * @returns a `GtkRecentInfo` containing information   about the resource pointed by @uri, or %NULL if the URI was   not registered in the recently used resources list. Free with   [method@Gtk.RecentInfo.unref].
     */
    lookupItem(uri: string): RecentInfo | null
    /**
     * Changes the location of a recently used resource from `uri` to `new_uri`.
     *
     * Please note that this function will not affect the resource pointed
     * by the URIs, but only the URI used in the recently used resources list.
     * @param uri the URI of a recently used resource
     * @param newUri the new URI of the recently used resource, or    %NULL to remove the item pointed by `uri` in the list
     * @returns %TRUE on success
     */
    moveItem(uri: string, newUri: string | null): boolean
    /**
     * Purges every item from the recently used resources list.
     * @returns the number of items that have been removed from the   recently used resources list
     */
    purgeItems(): number
    /**
     * Removes a resource pointed by `uri` from the recently used resources
     * list handled by a recent manager.
     * @param uri the URI of the item you wish to remove
     * @returns %TRUE if the item pointed by @uri has been successfully   removed by the recently used resources list, and %FALSE otherwise
     */
    removeItem(uri: string): boolean

    // Own virtual methods of Gtk-4.0.Gtk.RecentManager

    changed(): void

    // Own signals of Gtk-4.0.Gtk.RecentManager

    connect(
      sigName: "changed",
      callback: RecentManager.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: RecentManager.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: RecentManager.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: RecentManager.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.RecentManager

    connect(
      sigName: "notify::filename",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::filename",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::filename",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::filename",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::filename", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkRecentManager` manages and looks up recently used files.
   *
   * Each recently used file is identified by its URI, and has meta-data
   * associated to it, like the names and command lines of the applications
   * that have registered it, the number of time each application has
   * registered the same file, the mime type of the file and whether
   * the file should be displayed only by the applications that have
   * registered it.
   *
   * The recently used files list is per user.
   *
   * `GtkRecentManager` acts like a database of all the recently
   * used files. You can create new `GtkRecentManager` objects, but
   * it is more efficient to use the default manager created by GTK.
   *
   * Adding a new recently used file is as simple as:
   *
   * ```c
   * GtkRecentManager *manager;
   *
   * manager = gtk_recent_manager_get_default ();
   * gtk_recent_manager_add_item (manager, file_uri);
   * ```
   *
   * The `GtkRecentManager` will try to gather all the needed information
   * from the file itself through GIO.
   *
   * Looking up the meta-data associated with a recently used file
   * given its URI requires calling [method`Gtk`.RecentManager.lookup_item]:
   *
   * ```c
   * GtkRecentManager *manager;
   * GtkRecentInfo *info;
   * GError *error = NULL;
   *
   * manager = gtk_recent_manager_get_default ();
   * info = gtk_recent_manager_lookup_item (manager, file_uri, &error);
   * if (error)
   *   {
   *     g_warning ("Could not find the file: %s", error->message);
   *     g_error_free (error);
   *   }
   * else
   *  {
   *    // Use the info object
   *    gtk_recent_info_unref (info);
   *  }
   * ```
   *
   * In order to retrieve the list of recently used files, you can use
   * [method`Gtk`.RecentManager.get_items], which returns a list of
   * [struct`Gtk`.RecentInfo].
   *
   * Note that the maximum age of the recently used files list is
   * controllable through the [property`Gtk`.Settings:gtk-recent-files-max-age]
   * property.
   * @class
   */
  class RecentManager extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.RecentManager

    static name: string

    // Constructors of Gtk-4.0.Gtk.RecentManager

    constructor(config?: RecentManager.ConstructorProperties)
    /**
     * Creates a new recent manager object.
     *
     * Recent manager objects are used to handle the list of recently used
     * resources. A `GtkRecentManager` object monitors the recently used
     * resources list, and emits the [signal`Gtk`.RecentManager::changed]
     * signal each time something inside the list changes.
     *
     * `GtkRecentManager` objects are expensive: be sure to create them
     * only when needed. You should use [func`Gtk`.RecentManager.get_default]
     * instead.
     * @constructor
     * @returns A newly created `GtkRecentManager` object
     */
    constructor()
    /**
     * Creates a new recent manager object.
     *
     * Recent manager objects are used to handle the list of recently used
     * resources. A `GtkRecentManager` object monitors the recently used
     * resources list, and emits the [signal`Gtk`.RecentManager::changed]
     * signal each time something inside the list changes.
     *
     * `GtkRecentManager` objects are expensive: be sure to create them
     * only when needed. You should use [func`Gtk`.RecentManager.get_default]
     * instead.
     * @constructor
     * @returns A newly created `GtkRecentManager` object
     */
    static new(): RecentManager
    _init(config?: RecentManager.ConstructorProperties): void
    /**
     * Gets a unique instance of `GtkRecentManager` that you can share
     * in your application without caring about memory management.
     * @returns A unique `GtkRecentManager`. Do not ref or   unref it.
     */
    static getDefault(): RecentManager
  }

  module Revealer {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Revealer

      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Whether the revealer should reveal the child.
       */
      reveal_child?: boolean | null
      /**
       * The animation duration, in milliseconds.
       */
      transition_duration?: number | null
      /**
       * The type of animation used to transition.
       */
      transition_type?: RevealerTransitionType | null
    }
  }

  interface Revealer extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Revealer

    /**
     * The child widget.
     */
    child: Widget
    /**
     * Whether the child is revealed and the animation target reached.
     */
    readonly childRevealed: boolean
    /**
     * Whether the revealer should reveal the child.
     */
    revealChild: boolean
    /**
     * The animation duration, in milliseconds.
     */
    transitionDuration: number
    /**
     * The type of animation used to transition.
     */
    transitionType: RevealerTransitionType
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Revealer

    /**
     * Gets the child widget of `revealer`.
     * @returns the child widget of @revealer
     */
    getChild(): Widget | null
    /**
     * Returns whether the child is fully revealed.
     *
     * In other words, this returns whether the transition
     * to the revealed state is completed.
     * @returns %TRUE if the child is fully revealed
     */
    getChildRevealed(): boolean
    /**
     * Returns whether the child is currently revealed.
     *
     * This function returns %TRUE as soon as the transition
     * is to the revealed state is started. To learn whether
     * the child is fully revealed (ie the transition is completed),
     * use [method`Gtk`.Revealer.get_child_revealed].
     * @returns %TRUE if the child is revealed.
     */
    getRevealChild(): boolean
    /**
     * Returns the amount of time (in milliseconds) that
     * transitions will take.
     * @returns the transition duration
     */
    getTransitionDuration(): number
    /**
     * Gets the type of animation that will be used
     * for transitions in `revealer`.
     * @returns the current transition type of @revealer
     */
    getTransitionType(): RevealerTransitionType
    /**
     * Sets the child widget of `revealer`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Tells the `GtkRevealer` to reveal or conceal its child.
     *
     * The transition will be animated with the current
     * transition type of `revealer`.
     * @param revealChild %TRUE to reveal the child
     */
    setRevealChild(revealChild: boolean): void
    /**
     * Sets the duration that transitions will take.
     * @param duration the new duration, in milliseconds
     */
    setTransitionDuration(duration: number): void
    /**
     * Sets the type of animation that will be used for
     * transitions in `revealer`.
     *
     * Available types include various kinds of fades and slides.
     * @param transition the new transition type
     */
    setTransitionType(transition: RevealerTransitionType): void

    // Class property signals of Gtk-4.0.Gtk.Revealer

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::child-revealed",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child-revealed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child-revealed",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child-revealed",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child-revealed", ...args: any[]): void
    connect(
      sigName: "notify::reveal-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::reveal-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::reveal-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::reveal-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::reveal-child", ...args: any[]): void
    connect(
      sigName: "notify::transition-duration",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transition-duration",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transition-duration",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transition-duration",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transition-duration", ...args: any[]): void
    connect(
      sigName: "notify::transition-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transition-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transition-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transition-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transition-type", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkRevealer` animates the transition of its child from invisible to visible.
   *
   * The style of transition can be controlled with
   * [method`Gtk`.Revealer.set_transition_type].
   *
   * These animations respect the [property`Gtk`.Settings:gtk-enable-animations]
   * setting.
   *
   * # CSS nodes
   *
   * `GtkRevealer` has a single CSS node with name revealer.
   * When styling `GtkRevealer` using CSS, remember that it only hides its contents,
   * not itself. That means applied margin, padding and borders will be visible even
   * when the [property`Gtk`.Revealer:reveal-child] property is set to %FALSE.
   *
   * # Accessibility
   *
   * `GtkRevealer` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
   *
   * The child of `GtkRevealer`, if set, is always available in the accessibility
   * tree, regardless of the state of the revealer widget.
   * @class
   */
  class Revealer extends Widget {
    // Own properties of Gtk-4.0.Gtk.Revealer

    static name: string

    // Constructors of Gtk-4.0.Gtk.Revealer

    constructor(config?: Revealer.ConstructorProperties)
    /**
     * Creates a new `GtkRevealer`.
     * @constructor
     * @returns a newly created `GtkRevealer`
     */
    constructor()
    /**
     * Creates a new `GtkRevealer`.
     * @constructor
     * @returns a newly created `GtkRevealer`
     */
    static new(): Revealer
    _init(config?: Revealer.ConstructorProperties): void
  }

  module Scale {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleRange.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Range.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Scale

      /**
       * The number of decimal places that are displayed in the value.
       */
      digits?: number | null
      /**
       * Whether the current value is displayed as a string next to the slider.
       */
      draw_value?: boolean | null
      /**
       * Whether the scale has an origin.
       */
      has_origin?: boolean | null
      /**
       * The position in which the current value is displayed.
       */
      value_pos?: PositionType | null
    }
  }

  interface Scale
    extends Accessible,
      AccessibleRange,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.Scale

    /**
     * The number of decimal places that are displayed in the value.
     */
    digits: number
    /**
     * Whether the current value is displayed as a string next to the slider.
     */
    drawValue: boolean
    /**
     * Whether the scale has an origin.
     */
    hasOrigin: boolean
    /**
     * The position in which the current value is displayed.
     */
    valuePos: PositionType
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Scale

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.Scale

    /**
     * Adds a mark at `value`.
     *
     * A mark is indicated visually by drawing a tick mark next to the scale,
     * and GTK makes it easy for the user to position the scale exactly at the
     * marks value.
     *
     * If `markup` is not %NULL, text is shown next to the tick mark.
     *
     * To remove marks from a scale, use [method`Gtk`.Scale.clear_marks].
     * @param value the value at which the mark is placed, must be between   the lower and upper limits of the scales’ adjustment
     * @param position where to draw the mark. For a horizontal scale, %GTK_POS_TOP   and %GTK_POS_LEFT are drawn above the scale, anything else below.   For a vertical scale, %GTK_POS_LEFT and %GTK_POS_TOP are drawn to   the left of the scale, anything else to the right.
     * @param markup Text to be shown at the mark, using Pango markup
     */
    addMark(value: number, position: PositionType, markup: string | null): void
    /**
     * Removes any marks that have been added.
     */
    clearMarks(): void
    /**
     * Gets the number of decimal places that are displayed in the value.
     * @returns the number of decimal places that are displayed
     */
    getDigits(): number
    /**
     * Returns whether the current value is displayed as a string
     * next to the slider.
     * @returns whether the current value is displayed as a string
     */
    getDrawValue(): boolean
    /**
     * Returns whether the scale has an origin.
     * @returns %TRUE if the scale has an origin.
     */
    getHasOrigin(): boolean
    /**
     * Gets the `PangoLayout` used to display the scale.
     *
     * The returned object is owned by the scale so does not need
     * to be freed by the caller.
     * @returns the [class@Pango.Layout]   for this scale, or %NULL if the [property@Gtk.Scale:draw-value]   property is %FALSE.
     */
    getLayout(): Pango.Layout | null
    // Has conflict: getLayoutOffsets(): [ /* x */ number, /* y */ number ]
    /**
     * Gets the position in which the current value is displayed.
     * @returns the position in which the current value is displayed
     */
    getValuePos(): PositionType
    /**
     * Sets the number of decimal places that are displayed in the value.
     *
     * Also causes the value of the adjustment to be rounded to this number
     * of digits, so the retrieved value matches the displayed one, if
     * [property`Gtk`.Scale:draw-value] is %TRUE when the value changes. If
     * you want to enforce rounding the value when [property`Gtk`.Scale:draw-value]
     * is %FALSE, you can set [property`Gtk`.Range:round-digits] instead.
     *
     * Note that rounding to a small number of digits can interfere with
     * the smooth autoscrolling that is built into `GtkScale`. As an alternative,
     * you can use [method`Gtk`.Scale.set_format_value_func] to format the displayed
     * value yourself.
     * @param digits the number of decimal places to display,   e.g. use 1 to display 1.0, 2 to display 1.00, etc
     */
    setDigits(digits: number): void
    /**
     * Specifies whether the current value is displayed as a string next
     * to the slider.
     * @param drawValue %TRUE to draw the value
     */
    setDrawValue(drawValue: boolean): void
    /**
     * `func` allows you to change how the scale value is displayed.
     *
     * The given function will return an allocated string representing
     * `value`. That string will then be used to display the scale's value.
     *
     * If #NULL is passed as `func,` the value will be displayed on
     * its own, rounded according to the value of the
     * [property`Gtk`.Scale:digits] property.
     * @param func function that formats the value
     */
    setFormatValueFunc(func: ScaleFormatValueFunc | null): void
    /**
     * Sets whether the scale has an origin.
     *
     * If [property`Gtk`.Scale:has-origin] is set to %TRUE (the default),
     * the scale will highlight the part of the trough between the origin
     * (bottom or left side) and the current value.
     * @param hasOrigin %TRUE if the scale has an origin
     */
    setHasOrigin(hasOrigin: boolean): void
    /**
     * Sets the position in which the current value is displayed.
     * @param pos the position in which the current value is displayed
     */
    setValuePos(pos: PositionType): void

    // Own virtual methods of Gtk-4.0.Gtk.Scale

    /**
     * Obtains the coordinates where the scale will draw the
     * `PangoLayout` representing the text in the scale.
     *
     * Remember when using the `PangoLayout` function you need to
     * convert to and from pixels using `PANGO_PIXELS()` or `PANGO_SCALE`.
     *
     * If the [property`Gtk`.Scale:draw-value] property is %FALSE, the return
     * values are undefined.
     * @virtual
     */
    getLayoutOffsets(): [/* x */ number, /* y */ number]

    // Class property signals of Gtk-4.0.Gtk.Scale

    connect(
      sigName: "notify::digits",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::digits",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::digits", ...args: any[]): void
    connect(
      sigName: "notify::draw-value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::draw-value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::draw-value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::draw-value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::draw-value", ...args: any[]): void
    connect(
      sigName: "notify::has-origin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-origin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-origin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-origin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-origin", ...args: any[]): void
    connect(
      sigName: "notify::value-pos",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::value-pos",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::value-pos",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::value-pos",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::value-pos", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::adjustment", ...args: any[]): void
    connect(
      sigName: "notify::fill-level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fill-level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fill-level", ...args: any[]): void
    connect(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::inverted",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::inverted", ...args: any[]): void
    connect(
      sigName: "notify::restrict-to-fill-level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::restrict-to-fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::restrict-to-fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::restrict-to-fill-level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::restrict-to-fill-level", ...args: any[]): void
    connect(
      sigName: "notify::round-digits",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::round-digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::round-digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::round-digits",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::round-digits", ...args: any[]): void
    connect(
      sigName: "notify::show-fill-level",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-fill-level",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-fill-level",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-fill-level", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkScale` is a slider control used to select a numeric value.
   *
   * ![An example GtkScale](scales.png)
   *
   * To use it, you’ll probably want to investigate the methods on its base
   * class, [class`Gtk`.Range], in addition to the methods for `GtkScale` itself.
   * To set the value of a scale, you would normally use [method`Gtk`.Range.set_value].
   * To detect changes to the value, you would normally use the
   * [signal`Gtk`.Range::value-changed] signal.
   *
   * Note that using the same upper and lower bounds for the `GtkScale` (through
   * the `GtkRange` methods) will hide the slider itself. This is useful for
   * applications that want to show an undeterminate value on the scale, without
   * changing the layout of the application (such as movie or music players).
   *
   * # GtkScale as GtkBuildable
   *
   * `GtkScale` supports a custom `<marks>` element, which can contain multiple
   * `<mark\>` elements. The “value” and “position” attributes have the same
   * meaning as [method`Gtk`.Scale.add_mark] parameters of the same name. If
   * the element is not empty, its content is taken as the markup to show at
   * the mark. It can be translated with the usual ”translatable” and
   * “context” attributes.
   *
   * # CSS nodes
   *
   * ```
   * scale[.fine-tune][.marks-before][.marks-after]
   * ├── [value][.top][.right][.bottom][.left]
   * ├── marks.top
   * │   ├── mark
   * │   ┊    ├── [label]
   * │   ┊    ╰── indicator
   * ┊   ┊
   * │   ╰── mark
   * ├── marks.bottom
   * │   ├── mark
   * │   ┊    ├── indicator
   * │   ┊    ╰── [label]
   * ┊   ┊
   * │   ╰── mark
   * ╰── trough
   *     ├── [fill]
   *     ├── [highlight]
   *     ╰── slider
   * ```
   *
   * `GtkScale` has a main CSS node with name scale and a subnode for its contents,
   * with subnodes named trough and slider.
   *
   * The main node gets the style class .fine-tune added when the scale is in
   * 'fine-tuning' mode.
   *
   * If the scale has an origin (see [method`Gtk`.Scale.set_has_origin]), there is
   * a subnode with name highlight below the trough node that is used for rendering
   * the highlighted part of the trough.
   *
   * If the scale is showing a fill level (see [method`Gtk`.Range.set_show_fill_level]),
   * there is a subnode with name fill below the trough node that is used for
   * rendering the filled in part of the trough.
   *
   * If marks are present, there is a marks subnode before or after the trough
   * node, below which each mark gets a node with name mark. The marks nodes get
   * either the .top or .bottom style class.
   *
   * The mark node has a subnode named indicator. If the mark has text, it also
   * has a subnode named label. When the mark is either above or left of the
   * scale, the label subnode is the first when present. Otherwise, the indicator
   * subnode is the first.
   *
   * The main CSS node gets the 'marks-before' and/or 'marks-after' style classes
   * added depending on what marks are present.
   *
   * If the scale is displaying the value (see [property`Gtk`.Scale:draw-value]),
   * there is subnode with name value. This node will get the .top or .bottom style
   * classes similar to the marks node.
   *
   * # Accessibility
   *
   * `GtkScale` uses the %GTK_ACCESSIBLE_ROLE_SLIDER role.
   * @class
   */
  class Scale extends Range {
    // Own properties of Gtk-4.0.Gtk.Scale

    static name: string

    // Constructors of Gtk-4.0.Gtk.Scale

    constructor(config?: Scale.ConstructorProperties)
    /**
     * Creates a new `GtkScale`.
     * @constructor
     * @param orientation the scale’s orientation.
     * @param adjustment the [class`Gtk`.Adjustment] which sets   the range of the scale, or %NULL to create a new adjustment.
     * @returns a new `GtkScale`
     */
    constructor(orientation: Orientation, adjustment: Adjustment | null)
    /**
     * Creates a new `GtkScale`.
     * @constructor
     * @param orientation the scale’s orientation.
     * @param adjustment the [class`Gtk`.Adjustment] which sets   the range of the scale, or %NULL to create a new adjustment.
     * @returns a new `GtkScale`
     */
    static new(orientation: Orientation, adjustment: Adjustment | null): Scale
    /**
     * Creates a new scale widget with a range from `min` to `max`.
     *
     * The returns scale will have the given orientation and will let the
     * user input a number between `min` and `max` (including `min` and `max)`
     * with the increment `step`. `step` must be nonzero; it’s the distance
     * the slider moves when using the arrow keys to adjust the scale
     * value.
     *
     * Note that the way in which the precision is derived works best if
     * `step` is a power of ten. If the resulting precision is not suitable
     * for your needs, use [method`Gtk`.Scale.set_digits] to correct it.
     * @constructor
     * @param orientation the scale’s orientation.
     * @param min minimum value
     * @param max maximum value
     * @param step step increment (tick size) used with keyboard shortcuts
     * @returns a new `GtkScale`
     */
    static newWithRange(
      orientation: Orientation,
      min: number,
      max: number,
      step: number
    ): Scale
    _init(config?: Scale.ConstructorProperties): void
  }

  module ScaleButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `popdown`
     */
    interface PopdownSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `popup`
     */
    interface PopupSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `value-changed`
     */
    interface ValueChangedSignalCallback {
      (value: number): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleRange.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ScaleButton

      /**
       * The `GtkAdjustment` that is used as the model.
       */
      adjustment?: Adjustment | null
      /**
       * If the scale button has a frame.
       */
      has_frame?: boolean | null
      /**
       * The names of the icons to be used by the scale button.
       *
       * The first item in the array will be used in the button
       * when the current value is the lowest value, the second
       * item for the highest value. All the subsequent icons will
       * be used for all the other values, spread evenly over the
       * range of values.
       *
       * If there's only one icon name in the `icons` array, it will
       * be used for all the values. If only two icon names are in
       * the `icons` array, the first one will be used for the bottom
       * 50% of the scale, and the second one for the top 50%.
       *
       * It is recommended to use at least 3 icons so that the
       * `GtkScaleButton` reflects the current value of the scale
       * better for the users.
       */
      icons?: string[] | null
      /**
       * The value of the scale.
       */
      value?: number | null
    }
  }

  interface ScaleButton
    extends Accessible,
      AccessibleRange,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.ScaleButton

    /**
     * If the scale button should be pressed in.
     */
    readonly active: boolean
    /**
     * The `GtkAdjustment` that is used as the model.
     */
    adjustment: Adjustment
    /**
     * If the scale button has a frame.
     */
    hasFrame: boolean
    /**
     * The names of the icons to be used by the scale button.
     *
     * The first item in the array will be used in the button
     * when the current value is the lowest value, the second
     * item for the highest value. All the subsequent icons will
     * be used for all the other values, spread evenly over the
     * range of values.
     *
     * If there's only one icon name in the `icons` array, it will
     * be used for all the values. If only two icon names are in
     * the `icons` array, the first one will be used for the bottom
     * 50% of the scale, and the second one for the top 50%.
     *
     * It is recommended to use at least 3 icons so that the
     * `GtkScaleButton` reflects the current value of the scale
     * better for the users.
     */
    icons: string[]
    /**
     * The value of the scale.
     */
    value: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.ScaleButton

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.ScaleButton

    /**
     * Queries a `GtkScaleButton` and returns its current state.
     *
     * Returns %TRUE if the scale button is pressed in and %FALSE
     * if it is raised.
     * @returns whether the button is pressed
     */
    getActive(): boolean
    /**
     * Gets the `GtkAdjustment` associated with the `GtkScaleButton`’s scale.
     *
     * See [method`Gtk`.Range.get_adjustment] for details.
     * @returns the adjustment associated with the scale
     */
    getAdjustment(): Adjustment
    /**
     * Returns whether the button has a frame.
     * @returns %TRUE if the button has a frame
     */
    getHasFrame(): boolean
    /**
     * Retrieves the minus button of the `GtkScaleButton`.
     * @returns the minus button   of the `GtkScaleButton`
     */
    getMinusButton(): Button
    /**
     * Retrieves the plus button of the `GtkScaleButton.`
     * @returns the plus button   of the `GtkScaleButton`
     */
    getPlusButton(): Button
    /**
     * Retrieves the popup of the `GtkScaleButton`.
     * @returns the popup of the `GtkScaleButton`
     */
    getPopup(): Widget
    /**
     * Gets the current value of the scale button.
     * @returns current value of the scale button
     */
    getValue(): number
    /**
     * Sets the `GtkAdjustment` to be used as a model
     * for the `GtkScaleButton`’s scale.
     *
     * See [method`Gtk`.Range.set_adjustment] for details.
     * @param adjustment a `GtkAdjustment`
     */
    setAdjustment(adjustment: Adjustment): void
    /**
     * Sets the style of the button.
     * @param hasFrame whether the button should have a visible frame
     */
    setHasFrame(hasFrame: boolean): void
    /**
     * Sets the icons to be used by the scale button.
     * @param icons a %NULL-terminated array of icon names
     */
    setIcons(icons: string[]): void
    /**
     * Sets the current value of the scale.
     *
     * If the value is outside the minimum or maximum range values,
     * it will be clamped to fit inside them.
     *
     * The scale button emits the [signal`Gtk`.ScaleButton::value-changed]
     * signal if the value changes.
     * @param value new value of the scale button
     */
    setValue(value: number): void

    // Own virtual methods of Gtk-4.0.Gtk.ScaleButton

    valueChanged(value: number): void

    // Own signals of Gtk-4.0.Gtk.ScaleButton

    connect(
      sigName: "popdown",
      callback: ScaleButton.PopdownSignalCallback
    ): number
    on(
      sigName: "popdown",
      callback: ScaleButton.PopdownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "popdown",
      callback: ScaleButton.PopdownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "popdown",
      callback: ScaleButton.PopdownSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "popdown", ...args: any[]): void
    connect(sigName: "popup", callback: ScaleButton.PopupSignalCallback): number
    on(
      sigName: "popup",
      callback: ScaleButton.PopupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "popup",
      callback: ScaleButton.PopupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "popup",
      callback: ScaleButton.PopupSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "popup", ...args: any[]): void
    connect(
      sigName: "value-changed",
      callback: ScaleButton.ValueChangedSignalCallback
    ): number
    on(
      sigName: "value-changed",
      callback: ScaleButton.ValueChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "value-changed",
      callback: ScaleButton.ValueChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "value-changed",
      callback: ScaleButton.ValueChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "value-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ScaleButton

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::adjustment", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::icons",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icons",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icons", ...args: any[]): void
    connect(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::value", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkScaleButton` provides a button which pops up a scale widget.
   *
   * This kind of widget is commonly used for volume controls in multimedia
   * applications, and GTK provides a [class`Gtk`.VolumeButton] subclass that
   * is tailored for this use case.
   *
   * # CSS nodes
   *
   * ```
   * scalebutton.scale
   * ╰── button.toggle
   *     ╰── <icon>
   * ```
   *
   * `GtkScaleButton` has a single CSS node with name scalebutton and `.scale`
   * style class, and contains a `button` node with a `.toggle` style class.
   * @class
   */
  class ScaleButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.ScaleButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.ScaleButton

    constructor(config?: ScaleButton.ConstructorProperties)
    /**
     * Creates a `GtkScaleButton`.
     *
     * The new scale button has a range between `min` and `max,`
     * with a stepping of `step`.
     * @constructor
     * @param min the minimum value of the scale (usually 0)
     * @param max the maximum value of the scale (usually 100)
     * @param step the stepping of value when a scroll-wheel event,   or up/down arrow event occurs (usually 2)
     * @param icons a %NULL-terminated   array of icon names, or %NULL if you want to set the list   later with gtk_scale_button_set_icons()
     * @returns a new `GtkScaleButton`
     */
    constructor(min: number, max: number, step: number, icons: string[] | null)
    /**
     * Creates a `GtkScaleButton`.
     *
     * The new scale button has a range between `min` and `max,`
     * with a stepping of `step`.
     * @constructor
     * @param min the minimum value of the scale (usually 0)
     * @param max the maximum value of the scale (usually 100)
     * @param step the stepping of value when a scroll-wheel event,   or up/down arrow event occurs (usually 2)
     * @param icons a %NULL-terminated   array of icon names, or %NULL if you want to set the list   later with gtk_scale_button_set_icons()
     * @returns a new `GtkScaleButton`
     */
    static new(
      min: number,
      max: number,
      step: number,
      icons: string[] | null
    ): ScaleButton
    _init(config?: ScaleButton.ConstructorProperties): void
  }

  module Scrollbar {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Scrollbar

      /**
       * The `GtkAdjustment` controlled by this scrollbar.
       */
      adjustment?: Adjustment | null
    }
  }

  interface Scrollbar
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.Scrollbar

    /**
     * The `GtkAdjustment` controlled by this scrollbar.
     */
    adjustment: Adjustment
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Scrollbar

    /**
     * Returns the scrollbar's adjustment.
     * @returns the scrollbar's adjustment
     */
    getAdjustment(): Adjustment
    /**
     * Makes the scrollbar use the given adjustment.
     * @param adjustment the adjustment to set
     */
    setAdjustment(adjustment: Adjustment | null): void

    // Class property signals of Gtk-4.0.Gtk.Scrollbar

    connect(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::adjustment", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkScrollbar` widget is a horizontal or vertical scrollbar.
   *
   * ![An example GtkScrollbar](scrollbar.png)
   *
   * Its position and movement are controlled by the adjustment that is passed to
   * or created by [ctor`Gtk`.Scrollbar.new]. See [class`Gtk`.Adjustment] for more
   * details. The [property`Gtk`.Adjustment:value] field sets the position of the
   * thumb and must be between [property`Gtk`.Adjustment:lower] and
   * [property`Gtk`.Adjustment:upper] - [property`Gtk`.Adjustment:page-size].
   * The [property`Gtk`.Adjustment:page-size] represents the size of the visible
   * scrollable area.
   *
   * The fields [property`Gtk`.Adjustment:step-increment] and
   * [property`Gtk`.Adjustment:page-increment] fields are added to or subtracted
   * from the [property`Gtk`.Adjustment:value] when the user asks to move by a step
   * (using e.g. the cursor arrow keys) or by a page (using e.g. the Page Down/Up
   * keys).
   *
   * # CSS nodes
   *
   * ```
   * scrollbar
   * ╰── range[.fine-tune]
   *     ╰── trough
   *         ╰── slider
   * ```
   *
   * `GtkScrollbar` has a main CSS node with name scrollbar and a subnode for its
   * contents. The main node gets the .horizontal or .vertical style classes applied,
   * depending on the scrollbar's orientation.
   *
   * The range node gets the style class .fine-tune added when the scrollbar is
   * in 'fine-tuning' mode.
   *
   * Other style classes that may be added to scrollbars inside
   * [class`Gtk`.ScrolledWindow] include the positional classes (.left, .right,
   * .top, .bottom) and style classes related to overlay scrolling (.overlay-indicator,
   * .dragging, .hovering).
   *
   * # Accessibility
   *
   * `GtkScrollbar` uses the %GTK_ACCESSIBLE_ROLE_SCROLLBAR role.
   * @class
   */
  class Scrollbar extends Widget {
    // Own properties of Gtk-4.0.Gtk.Scrollbar

    static name: string

    // Constructors of Gtk-4.0.Gtk.Scrollbar

    constructor(config?: Scrollbar.ConstructorProperties)
    /**
     * Creates a new scrollbar with the given orientation.
     * @constructor
     * @param orientation the scrollbar’s orientation.
     * @param adjustment the [class`Gtk`.Adjustment] to use, or %NULL   to create a new adjustment.
     * @returns the new `GtkScrollbar`.
     */
    constructor(orientation: Orientation, adjustment: Adjustment | null)
    /**
     * Creates a new scrollbar with the given orientation.
     * @constructor
     * @param orientation the scrollbar’s orientation.
     * @param adjustment the [class`Gtk`.Adjustment] to use, or %NULL   to create a new adjustment.
     * @returns the new `GtkScrollbar`.
     */
    static new(
      orientation: Orientation,
      adjustment: Adjustment | null
    ): Scrollbar
    _init(config?: Scrollbar.ConstructorProperties): void
  }

  module ScrolledWindow {
    // Signal callback interfaces

    /**
     * Signal callback interface for `edge-overshot`
     */
    interface EdgeOvershotSignalCallback {
      (pos: PositionType): void
    }

    /**
     * Signal callback interface for `edge-reached`
     */
    interface EdgeReachedSignalCallback {
      (pos: PositionType): void
    }

    /**
     * Signal callback interface for `move-focus-out`
     */
    interface MoveFocusOutSignalCallback {
      (directionType: DirectionType): void
    }

    /**
     * Signal callback interface for `scroll-child`
     */
    interface ScrollChildSignalCallback {
      (scroll: ScrollType, horizontal: boolean): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ScrolledWindow

      /**
       * The child widget.
       *
       * When setting this property, if the child widget does not implement
       * [iface`Gtk`.Scrollable], the scrolled window will add the child to
       * a [class`Gtk`.Viewport] and then set the viewport as the child.
       */
      child?: Widget | null
      hadjustment?: Adjustment | null
      /**
       * Whether to draw a frame around the contents.
       */
      has_frame?: boolean | null
      /**
       * When the horizontal scrollbar is displayed.
       *
       * Use [method`Gtk`.ScrolledWindow.set_policy] to set
       * this property.
       */
      hscrollbar_policy?: PolicyType | null
      /**
       * Whether kinetic scrolling is enabled or not.
       *
       * Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
       */
      kinetic_scrolling?: boolean | null
      /**
       * The maximum content height of `scrolled_window`.
       */
      max_content_height?: number | null
      /**
       * The maximum content width of `scrolled_window`.
       */
      max_content_width?: number | null
      /**
       * The minimum content height of `scrolled_window`.
       */
      min_content_height?: number | null
      /**
       * The minimum content width of `scrolled_window`.
       */
      min_content_width?: number | null
      /**
       * Whether overlay scrolling is enabled or not.
       *
       * If it is, the scrollbars are only added as traditional widgets
       * when a mouse is present. Otherwise, they are overlaid on top of
       * the content, as narrow indicators.
       *
       * Note that overlay scrolling can also be globally disabled, with
       * the [property`Gtk`.Settings:gtk-overlay-scrolling] setting.
       */
      overlay_scrolling?: boolean | null
      /**
       * Whether the natural height of the child should be calculated and propagated
       * through the scrolled window’s requested natural height.
       *
       * This is useful in cases where an attempt should be made to allocate exactly
       * enough space for the natural size of the child.
       */
      propagate_natural_height?: boolean | null
      /**
       * Whether the natural width of the child should be calculated and propagated
       * through the scrolled window’s requested natural width.
       *
       * This is useful in cases where an attempt should be made to allocate exactly
       * enough space for the natural size of the child.
       */
      propagate_natural_width?: boolean | null
      vadjustment?: Adjustment | null
      /**
       * When the vertical scrollbar is displayed.
       *
       * Use [method`Gtk`.ScrolledWindow.set_policy] to set
       * this property.
       */
      vscrollbar_policy?: PolicyType | null
      /**
       * Where the contents are located with respect to the scrollbars.
       */
      window_placement?: CornerType | null
    }
  }

  interface ScrolledWindow extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ScrolledWindow

    /**
     * The child widget.
     *
     * When setting this property, if the child widget does not implement
     * [iface`Gtk`.Scrollable], the scrolled window will add the child to
     * a [class`Gtk`.Viewport] and then set the viewport as the child.
     */
    child: Widget
    hadjustment: Adjustment
    /**
     * Whether to draw a frame around the contents.
     */
    hasFrame: boolean
    /**
     * When the horizontal scrollbar is displayed.
     *
     * Use [method`Gtk`.ScrolledWindow.set_policy] to set
     * this property.
     */
    hscrollbarPolicy: PolicyType
    /**
     * Whether kinetic scrolling is enabled or not.
     *
     * Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
     */
    kineticScrolling: boolean
    /**
     * The maximum content height of `scrolled_window`.
     */
    maxContentHeight: number
    /**
     * The maximum content width of `scrolled_window`.
     */
    maxContentWidth: number
    /**
     * The minimum content height of `scrolled_window`.
     */
    minContentHeight: number
    /**
     * The minimum content width of `scrolled_window`.
     */
    minContentWidth: number
    /**
     * Whether overlay scrolling is enabled or not.
     *
     * If it is, the scrollbars are only added as traditional widgets
     * when a mouse is present. Otherwise, they are overlaid on top of
     * the content, as narrow indicators.
     *
     * Note that overlay scrolling can also be globally disabled, with
     * the [property`Gtk`.Settings:gtk-overlay-scrolling] setting.
     */
    overlayScrolling: boolean
    /**
     * Whether the natural height of the child should be calculated and propagated
     * through the scrolled window’s requested natural height.
     *
     * This is useful in cases where an attempt should be made to allocate exactly
     * enough space for the natural size of the child.
     */
    propagateNaturalHeight: boolean
    /**
     * Whether the natural width of the child should be calculated and propagated
     * through the scrolled window’s requested natural width.
     *
     * This is useful in cases where an attempt should be made to allocate exactly
     * enough space for the natural size of the child.
     */
    propagateNaturalWidth: boolean
    vadjustment: Adjustment
    /**
     * When the vertical scrollbar is displayed.
     *
     * Use [method`Gtk`.ScrolledWindow.set_policy] to set
     * this property.
     */
    vscrollbarPolicy: PolicyType
    /**
     * Where the contents are located with respect to the scrollbars.
     */
    windowPlacement: CornerType
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ScrolledWindow

    /**
     * Gets the child widget of `scrolled_window`.
     *
     * If the scrolled window automatically added a [class`Gtk`.Viewport], this
     * function will return the viewport widget, and you can retrieve its child
     * using [method`Gtk`.Viewport.get_child].
     * @returns the child widget of @scrolled_window
     */
    getChild(): Widget | null
    /**
     * Returns the horizontal scrollbar’s adjustment.
     *
     * This is the adjustment used to connect the horizontal scrollbar
     * to the child widget’s horizontal scroll functionality.
     * @returns the horizontal `GtkAdjustment`
     */
    getHadjustment(): Adjustment
    /**
     * Gets whether the scrolled window draws a frame.
     * @returns %TRUE if the @scrolled_window has a frame
     */
    getHasFrame(): boolean
    /**
     * Returns the horizontal scrollbar of `scrolled_window`.
     * @returns the horizontal scrollbar of the scrolled window.
     */
    getHscrollbar(): Widget
    /**
     * Returns the specified kinetic scrolling behavior.
     * @returns the scrolling behavior flags.
     */
    getKineticScrolling(): boolean
    /**
     * Returns the maximum content height set.
     * @returns the maximum content height, or -1
     */
    getMaxContentHeight(): number
    /**
     * Returns the maximum content width set.
     * @returns the maximum content width, or -1
     */
    getMaxContentWidth(): number
    /**
     * Gets the minimal content height of `scrolled_window`.
     * @returns the minimal content height
     */
    getMinContentHeight(): number
    /**
     * Gets the minimum content width of `scrolled_window`.
     * @returns the minimum content width
     */
    getMinContentWidth(): number
    /**
     * Returns whether overlay scrolling is enabled for this scrolled window.
     * @returns %TRUE if overlay scrolling is enabled
     */
    getOverlayScrolling(): boolean
    /**
     * Gets the placement of the contents with respect to the scrollbars.
     * @returns the current placement value.
     */
    getPlacement(): CornerType
    /**
     * Retrieves the current policy values for the horizontal and vertical
     * scrollbars.
     *
     * See [method`Gtk`.ScrolledWindow.set_policy].
     */
    getPolicy(): [
      /* hscrollbarPolicy */ PolicyType,
      /* vscrollbarPolicy */ PolicyType,
    ]
    /**
     * Reports whether the natural height of the child will be calculated
     * and propagated through the scrolled window’s requested natural height.
     * @returns whether natural height propagation is enabled.
     */
    getPropagateNaturalHeight(): boolean
    /**
     * Reports whether the natural width of the child will be calculated
     * and propagated through the scrolled window’s requested natural width.
     * @returns whether natural width propagation is enabled.
     */
    getPropagateNaturalWidth(): boolean
    /**
     * Returns the vertical scrollbar’s adjustment.
     *
     * This is the adjustment used to connect the vertical
     * scrollbar to the child widget’s vertical scroll functionality.
     * @returns the vertical `GtkAdjustment`
     */
    getVadjustment(): Adjustment
    /**
     * Returns the vertical scrollbar of `scrolled_window`.
     * @returns the vertical scrollbar of the scrolled window.
     */
    getVscrollbar(): Widget
    /**
     * Sets the child widget of `scrolled_window`.
     *
     * If `child` does not implement the [iface`Gtk`.Scrollable] interface,
     * the scrolled window will add `child` to a [class`Gtk`.Viewport] instance
     * and then add the viewport as its child widget.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets the `GtkAdjustment` for the horizontal scrollbar.
     * @param hadjustment the `GtkAdjustment` to use, or %NULL to create a new one
     */
    setHadjustment(hadjustment: Adjustment | null): void
    /**
     * Changes the frame drawn around the contents of `scrolled_window`.
     * @param hasFrame whether to draw a frame around scrolled window contents
     */
    setHasFrame(hasFrame: boolean): void
    /**
     * Turns kinetic scrolling on or off.
     *
     * Kinetic scrolling only applies to devices with source
     * %GDK_SOURCE_TOUCHSCREEN.
     * @param kineticScrolling %TRUE to enable kinetic scrolling
     */
    setKineticScrolling(kineticScrolling: boolean): void
    /**
     * Sets the maximum height that `scrolled_window` should keep visible.
     *
     * The `scrolled_window` will grow up to this height before it starts
     * scrolling the content.
     *
     * It is a programming error to set the maximum content height to a value
     * smaller than [property`Gtk`.ScrolledWindow:min-content-height].
     * @param height the maximum content height
     */
    setMaxContentHeight(height: number): void
    /**
     * Sets the maximum width that `scrolled_window` should keep visible.
     *
     * The `scrolled_window` will grow up to this width before it starts
     * scrolling the content.
     *
     * It is a programming error to set the maximum content width to a
     * value smaller than [property`Gtk`.ScrolledWindow:min-content-width].
     * @param width the maximum content width
     */
    setMaxContentWidth(width: number): void
    /**
     * Sets the minimum height that `scrolled_window` should keep visible.
     *
     * Note that this can and (usually will) be smaller than the minimum
     * size of the content.
     *
     * It is a programming error to set the minimum content height to a
     * value greater than [property`Gtk`.ScrolledWindow:max-content-height].
     * @param height the minimal content height
     */
    setMinContentHeight(height: number): void
    /**
     * Sets the minimum width that `scrolled_window` should keep visible.
     *
     * Note that this can and (usually will) be smaller than the minimum
     * size of the content.
     *
     * It is a programming error to set the minimum content width to a
     * value greater than [property`Gtk`.ScrolledWindow:max-content-width].
     * @param width the minimal content width
     */
    setMinContentWidth(width: number): void
    /**
     * Enables or disables overlay scrolling for this scrolled window.
     * @param overlayScrolling whether to enable overlay scrolling
     */
    setOverlayScrolling(overlayScrolling: boolean): void
    /**
     * Sets the placement of the contents with respect to the scrollbars
     * for the scrolled window.
     *
     * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
     * in the top left, with the scrollbars underneath and to the right.
     * Other values in [enum`Gtk`.CornerType] are %GTK_CORNER_TOP_RIGHT,
     * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
     *
     * See also [method`Gtk`.ScrolledWindow.get_placement] and
     * [method`Gtk`.ScrolledWindow.unset_placement].
     * @param windowPlacement position of the child window
     */
    setPlacement(windowPlacement: CornerType): void
    /**
     * Sets the scrollbar policy for the horizontal and vertical scrollbars.
     *
     * The policy determines when the scrollbar should appear; it is a value
     * from the [enum`Gtk`.PolicyType] enumeration. If %GTK_POLICY_ALWAYS, the
     * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
     * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
     * if needed (that is, if the slider part of the bar would be smaller
     * than the trough — the display is larger than the page size).
     * @param hscrollbarPolicy policy for horizontal bar
     * @param vscrollbarPolicy policy for vertical bar
     */
    setPolicy(hscrollbarPolicy: PolicyType, vscrollbarPolicy: PolicyType): void
    /**
     * Sets whether the natural height of the child should be calculated
     * and propagated through the scrolled window’s requested natural height.
     * @param propagate whether to propagate natural height
     */
    setPropagateNaturalHeight(propagate: boolean): void
    /**
     * Sets whether the natural width of the child should be calculated
     * and propagated through the scrolled window’s requested natural width.
     * @param propagate whether to propagate natural width
     */
    setPropagateNaturalWidth(propagate: boolean): void
    /**
     * Sets the `GtkAdjustment` for the vertical scrollbar.
     * @param vadjustment the `GtkAdjustment` to use, or %NULL to create a new one
     */
    setVadjustment(vadjustment: Adjustment | null): void
    /**
     * Unsets the placement of the contents with respect to the scrollbars.
     *
     * If no window placement is set for a scrolled window,
     * it defaults to %GTK_CORNER_TOP_LEFT.
     */
    unsetPlacement(): void
    scrollTo(value: number, vertical?: boolean): number

    // Own signals of Gtk-4.0.Gtk.ScrolledWindow

    connect(
      sigName: "edge-overshot",
      callback: ScrolledWindow.EdgeOvershotSignalCallback
    ): number
    on(
      sigName: "edge-overshot",
      callback: ScrolledWindow.EdgeOvershotSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "edge-overshot",
      callback: ScrolledWindow.EdgeOvershotSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "edge-overshot",
      callback: ScrolledWindow.EdgeOvershotSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "edge-overshot", ...args: any[]): void
    connect(
      sigName: "edge-reached",
      callback: ScrolledWindow.EdgeReachedSignalCallback
    ): number
    on(
      sigName: "edge-reached",
      callback: ScrolledWindow.EdgeReachedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "edge-reached",
      callback: ScrolledWindow.EdgeReachedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "edge-reached",
      callback: ScrolledWindow.EdgeReachedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "edge-reached", ...args: any[]): void
    connect(
      sigName: "move-focus-out",
      callback: ScrolledWindow.MoveFocusOutSignalCallback
    ): number
    on(
      sigName: "move-focus-out",
      callback: ScrolledWindow.MoveFocusOutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-focus-out",
      callback: ScrolledWindow.MoveFocusOutSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-focus-out",
      callback: ScrolledWindow.MoveFocusOutSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "move-focus-out", ...args: any[]): void
    connect(
      sigName: "scroll-child",
      callback: ScrolledWindow.ScrollChildSignalCallback
    ): number
    on(
      sigName: "scroll-child",
      callback: ScrolledWindow.ScrollChildSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "scroll-child",
      callback: ScrolledWindow.ScrollChildSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "scroll-child",
      callback: ScrolledWindow.ScrollChildSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "scroll-child", horizontal: boolean, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ScrolledWindow

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::hscrollbar-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscrollbar-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscrollbar-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscrollbar-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscrollbar-policy", ...args: any[]): void
    connect(
      sigName: "notify::kinetic-scrolling",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::kinetic-scrolling",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::kinetic-scrolling",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::kinetic-scrolling",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::kinetic-scrolling", ...args: any[]): void
    connect(
      sigName: "notify::max-content-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-content-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-content-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-content-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-content-height", ...args: any[]): void
    connect(
      sigName: "notify::max-content-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-content-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-content-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-content-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-content-width", ...args: any[]): void
    connect(
      sigName: "notify::min-content-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-content-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-content-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-content-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-content-height", ...args: any[]): void
    connect(
      sigName: "notify::min-content-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-content-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-content-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-content-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-content-width", ...args: any[]): void
    connect(
      sigName: "notify::overlay-scrolling",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overlay-scrolling",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overlay-scrolling",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overlay-scrolling",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overlay-scrolling", ...args: any[]): void
    connect(
      sigName: "notify::propagate-natural-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagate-natural-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagate-natural-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagate-natural-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagate-natural-height", ...args: any[]): void
    connect(
      sigName: "notify::propagate-natural-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagate-natural-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagate-natural-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagate-natural-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagate-natural-width", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscrollbar-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscrollbar-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscrollbar-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscrollbar-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscrollbar-policy", ...args: any[]): void
    connect(
      sigName: "notify::window-placement",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::window-placement",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::window-placement",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::window-placement",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::window-placement", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkScrolledWindow` is a container that makes its child scrollable.
   *
   * It does so using either internally added scrollbars or externally
   * associated adjustments, and optionally draws a frame around the child.
   *
   * Widgets with native scrolling support, i.e. those whose classes implement
   * the [iface`Gtk`.Scrollable] interface, are added directly. For other types
   * of widget, the class [class`Gtk`.Viewport] acts as an adaptor, giving
   * scrollability to other widgets. [method`Gtk`.ScrolledWindow.set_child]
   * intelligently accounts for whether or not the added child is a `GtkScrollable`.
   * If it isn’t, then it wraps the child in a `GtkViewport`. Therefore, you can
   * just add any child widget and not worry about the details.
   *
   * If [method`Gtk`.ScrolledWindow.set_child] has added a `GtkViewport` for you,
   * it will be automatically removed when you unset the child.
   * Unless [property`Gtk`.ScrolledWindow:hscrollbar-policy] and
   * [property`Gtk`.ScrolledWindow:vscrollbar-policy] are %GTK_POLICY_NEVER or
   * %GTK_POLICY_EXTERNAL, `GtkScrolledWindow` adds internal `GtkScrollbar` widgets
   * around its child. The scroll position of the child, and if applicable the
   * scrollbars, is controlled by the [property`Gtk`.ScrolledWindow:hadjustment]
   * and [property`Gtk`.ScrolledWindow:vadjustment] that are associated with the
   * `GtkScrolledWindow`. See the docs on [class`Gtk`.Scrollbar] for the details,
   * but note that the “step_increment” and “page_increment” fields are only
   * effective if the policy causes scrollbars to be present.
   *
   * If a `GtkScrolledWindow` doesn’t behave quite as you would like, or
   * doesn’t have exactly the right layout, it’s very possible to set up
   * your own scrolling with `GtkScrollbar` and for example a `GtkGrid`.
   *
   * # Touch support
   *
   * `GtkScrolledWindow` has built-in support for touch devices. When a
   * touchscreen is used, swiping will move the scrolled window, and will
   * expose 'kinetic' behavior. This can be turned off with the
   * [property`Gtk`.ScrolledWindow:kinetic-scrolling] property if it is undesired.
   *
   * `GtkScrolledWindow` also displays visual 'overshoot' indication when
   * the content is pulled beyond the end, and this situation can be
   * captured with the [signal`Gtk`.ScrolledWindow::edge-overshot] signal.
   *
   * If no mouse device is present, the scrollbars will overlaid as
   * narrow, auto-hiding indicators over the content. If traditional
   * scrollbars are desired although no mouse is present, this behaviour
   * can be turned off with the [property`Gtk`.ScrolledWindow:overlay-scrolling]
   * property.
   *
   * # CSS nodes
   *
   * `GtkScrolledWindow` has a main CSS node with name scrolledwindow.
   * It gets a .frame style class added when [property`Gtk`.ScrolledWindow:has-frame]
   * is %TRUE.
   *
   * It uses subnodes with names overshoot and undershoot to draw the overflow
   * and underflow indications. These nodes get the .left, .right, .top or .bottom
   * style class added depending on where the indication is drawn.
   *
   * `GtkScrolledWindow` also sets the positional style classes (.left, .right,
   * .top, .bottom) and style classes related to overlay scrolling
   * (.overlay-indicator, .dragging, .hovering) on its scrollbars.
   *
   * If both scrollbars are visible, the area where they meet is drawn
   * with a subnode named junction.
   *
   * # Accessibility
   *
   * Until GTK 4.10, `GtkScrolledWindow` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   *
   * Starting from GTK 4.12, `GtkScrolledWindow` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
   * @class
   */
  class ScrolledWindow extends Widget {
    // Own properties of Gtk-4.0.Gtk.ScrolledWindow

    static name: string

    // Constructors of Gtk-4.0.Gtk.ScrolledWindow

    constructor(config?: ScrolledWindow.ConstructorProperties)
    /**
     * Creates a new scrolled window.
     * @constructor
     * @returns a new scrolled window
     */
    constructor()
    /**
     * Creates a new scrolled window.
     * @constructor
     * @returns a new scrolled window
     */
    static new(): ScrolledWindow
    _init(config?: ScrolledWindow.ConstructorProperties): void
  }

  module SearchBar {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SearchBar

      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * The key capture widget.
       */
      key_capture_widget?: Widget | null
      /**
       * Whether the search mode is on and the search bar shown.
       */
      search_mode_enabled?: boolean | null
      /**
       * Whether to show the close button in the search bar.
       */
      show_close_button?: boolean | null
    }
  }

  interface SearchBar extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.SearchBar

    /**
     * The child widget.
     */
    child: Widget
    /**
     * The key capture widget.
     */
    keyCaptureWidget: Widget
    /**
     * Whether the search mode is on and the search bar shown.
     */
    searchModeEnabled: boolean
    /**
     * Whether to show the close button in the search bar.
     */
    showCloseButton: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SearchBar

    /**
     * Connects the `GtkEditable` widget passed as the one to be used in
     * this search bar.
     *
     * The entry should be a descendant of the search bar. Calling this
     * function manually is only required if the entry isn’t the direct
     * child of the search bar (as in our main example).
     * @param entry a `GtkEditable`
     */
    connectEntry(entry: Editable): void
    /**
     * Gets the child widget of `bar`.
     * @returns the child widget of @bar
     */
    getChild(): Widget | null
    /**
     * Gets the widget that `bar` is capturing key events from.
     * @returns The key capture widget.
     */
    getKeyCaptureWidget(): Widget | null
    /**
     * Returns whether the search mode is on or off.
     * @returns whether search mode is toggled on
     */
    getSearchMode(): boolean
    /**
     * Returns whether the close button is shown.
     * @returns whether the close button is shown
     */
    getShowCloseButton(): boolean
    /**
     * Sets the child widget of `bar`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets `widget` as the widget that `bar` will capture key events
     * from.
     *
     * If key events are handled by the search bar, the bar will
     * be shown, and the entry populated with the entered text.
     *
     * Note that despite the name of this function, the events
     * are only 'captured' in the bubble phase, which means that
     * editable child widgets of `widget` will receive text input
     * before it gets captured. If that is not desired, you can
     * capture and forward the events yourself with
     * [method`Gtk`.EventControllerKey.forward].
     * @param widget a `GtkWidget`
     */
    setKeyCaptureWidget(widget: Widget | null): void
    /**
     * Switches the search mode on or off.
     * @param searchMode the new state of the search mode
     */
    setSearchMode(searchMode: boolean): void
    /**
     * Shows or hides the close button.
     *
     * Applications that already have a “search” toggle button should not
     * show a close button in their search bar, as it duplicates the role
     * of the toggle button.
     * @param visible whether the close button will be shown or not
     */
    setShowCloseButton(visible: boolean): void

    // Class property signals of Gtk-4.0.Gtk.SearchBar

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::key-capture-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::key-capture-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::key-capture-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::key-capture-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::key-capture-widget", ...args: any[]): void
    connect(
      sigName: "notify::search-mode-enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::search-mode-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::search-mode-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::search-mode-enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::search-mode-enabled", ...args: any[]): void
    connect(
      sigName: "notify::show-close-button",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-close-button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-close-button",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-close-button",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-close-button", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSearchBar` is a container made to have a search entry.
   *
   * ![An example GtkSearchBar](search-bar.png)
   *
   * It can also contain additional widgets, such as drop-down menus,
   * or buttons.  The search bar would appear when a search is started
   * through typing on the keyboard, or the application’s search mode
   * is toggled on.
   *
   * For keyboard presses to start a search, the search bar must be told
   * of a widget to capture key events from through
   * [method`Gtk`.SearchBar.set_key_capture_widget]. This widget will
   * typically be the top-level window, or a parent container of the
   * search bar. Common shortcuts such as Ctrl+F should be handled as an
   * application action, or through the menu items.
   *
   * You will also need to tell the search bar about which entry you
   * are using as your search entry using [method`Gtk`.SearchBar.connect_entry].
   *
   * ## Creating a search bar
   *
   * The following example shows you how to create a more complex search
   * entry.
   *
   * [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/search-bar.c)
   *
   * # CSS nodes
   *
   * ```
   * searchbar
   * ╰── revealer
   *     ╰── box
   *          ├── [child]
   *          ╰── [button.close]
   * ```
   *
   * `GtkSearchBar` has a main CSS node with name searchbar. It has a child
   * node with name revealer that contains a node with name box. The box node
   * contains both the CSS node of the child widget as well as an optional button
   * node which gets the .close style class applied.
   *
   * # Accessibility
   *
   * `GtkSearchBar` uses the %GTK_ACCESSIBLE_ROLE_SEARCH role.
   * @class
   */
  class SearchBar extends Widget {
    // Own properties of Gtk-4.0.Gtk.SearchBar

    static name: string

    // Constructors of Gtk-4.0.Gtk.SearchBar

    constructor(config?: SearchBar.ConstructorProperties)
    /**
     * Creates a `GtkSearchBar`.
     *
     * You will need to tell it about which widget is going to be your text
     * entry using [method`Gtk`.SearchBar.connect_entry].
     * @constructor
     * @returns a new `GtkSearchBar`
     */
    constructor()
    /**
     * Creates a `GtkSearchBar`.
     *
     * You will need to tell it about which widget is going to be your text
     * entry using [method`Gtk`.SearchBar.connect_entry].
     * @constructor
     * @returns a new `GtkSearchBar`
     */
    static new(): SearchBar
    _init(config?: SearchBar.ConstructorProperties): void
  }

  module SearchEntry {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `next-match`
     */
    interface NextMatchSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `previous-match`
     */
    interface PreviousMatchSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `search-changed`
     */
    interface SearchChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `search-started`
     */
    interface SearchStartedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `stop-search`
     */
    interface StopSearchSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Editable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SearchEntry

      /**
       * Whether to activate the default widget when Enter is pressed.
       */
      activates_default?: boolean | null
      /**
       * The hints about input for the `GtkSearchEntry` used to alter the
       * behaviour of input methods.
       */
      input_hints?: InputHints | null
      /**
       * The purpose for the `GtkSearchEntry` input used to alter the
       * behaviour of input methods.
       */
      input_purpose?: InputPurpose | null
      /**
       * The text that will be displayed in the `GtkSearchEntry`
       * when it is empty and unfocused.
       */
      placeholder_text?: string | null
      /**
       * The delay in milliseconds from last keypress to the search
       * changed signal.
       */
      search_delay?: number | null
    }
  }

  interface SearchEntry
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Editable {
    // Own properties of Gtk-4.0.Gtk.SearchEntry

    /**
     * Whether to activate the default widget when Enter is pressed.
     */
    activatesDefault: boolean
    /**
     * The hints about input for the `GtkSearchEntry` used to alter the
     * behaviour of input methods.
     */
    inputHints: InputHints
    /**
     * The purpose for the `GtkSearchEntry` input used to alter the
     * behaviour of input methods.
     */
    inputPurpose: InputPurpose
    /**
     * The text that will be displayed in the `GtkSearchEntry`
     * when it is empty and unfocused.
     */
    placeholderText: string | null
    /**
     * The delay in milliseconds from last keypress to the search
     * changed signal.
     */
    searchDelay: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SearchEntry

    /**
     * Gets the input purpose for `entry`.
     * @returns The input hints
     */
    getInputHints(): InputHints
    /**
     * Gets the input purpose of `entry`.
     * @returns The input hints
     */
    getInputPurpose(): InputPurpose
    /**
     * Gets the widget that `entry` is capturing key events from.
     * @returns The key capture widget.
     */
    getKeyCaptureWidget(): Widget | null
    /**
     * Gets the placeholder text associated with `entry`.
     * @returns The placeholder text.
     */
    getPlaceholderText(): string | null
    /**
     * Get the delay to be used between the last keypress and the
     * [signal`Gtk`.SearchEntry::search-changed] signal being emitted.
     * @returns a delay in milliseconds.
     */
    getSearchDelay(): number
    /**
     * Sets the input hints for `entry`.
     * @param hints the new input hints
     */
    setInputHints(hints: InputHints): void
    /**
     * Sets the input purpose of `entry`.
     * @param purpose the new input purpose
     */
    setInputPurpose(purpose: InputPurpose): void
    /**
     * Sets `widget` as the widget that `entry` will capture key
     * events from.
     *
     * Key events are consumed by the search entry to start or
     * continue a search.
     *
     * If the entry is part of a `GtkSearchBar`, it is preferable
     * to call [method`Gtk`.SearchBar.set_key_capture_widget] instead,
     * which will reveal the entry in addition to triggering the
     * search entry.
     *
     * Note that despite the name of this function, the events
     * are only 'captured' in the bubble phase, which means that
     * editable child widgets of `widget` will receive text input
     * before it gets captured. If that is not desired, you can
     * capture and forward the events yourself with
     * [method`Gtk`.EventControllerKey.forward].
     * @param widget a `GtkWidget`
     */
    setKeyCaptureWidget(widget: Widget | null): void
    /**
     * Sets the placeholder text associated with `entry`.
     * @param text the text to set as a placeholder
     */
    setPlaceholderText(text: string | null): void
    /**
     * Set the delay to be used between the last keypress and the
     * [signal`Gtk`.SearchEntry::search-changed] signal being emitted.
     * @param delay a delay in milliseconds
     */
    setSearchDelay(delay: number): void

    // Own signals of Gtk-4.0.Gtk.SearchEntry

    connect(
      sigName: "activate",
      callback: SearchEntry.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: SearchEntry.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: SearchEntry.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: SearchEntry.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "next-match",
      callback: SearchEntry.NextMatchSignalCallback
    ): number
    on(
      sigName: "next-match",
      callback: SearchEntry.NextMatchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "next-match",
      callback: SearchEntry.NextMatchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "next-match",
      callback: SearchEntry.NextMatchSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "next-match", ...args: any[]): void
    connect(
      sigName: "previous-match",
      callback: SearchEntry.PreviousMatchSignalCallback
    ): number
    on(
      sigName: "previous-match",
      callback: SearchEntry.PreviousMatchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "previous-match",
      callback: SearchEntry.PreviousMatchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "previous-match",
      callback: SearchEntry.PreviousMatchSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "previous-match", ...args: any[]): void
    connect(
      sigName: "search-changed",
      callback: SearchEntry.SearchChangedSignalCallback
    ): number
    on(
      sigName: "search-changed",
      callback: SearchEntry.SearchChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "search-changed",
      callback: SearchEntry.SearchChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "search-changed",
      callback: SearchEntry.SearchChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "search-changed", ...args: any[]): void
    connect(
      sigName: "search-started",
      callback: SearchEntry.SearchStartedSignalCallback
    ): number
    on(
      sigName: "search-started",
      callback: SearchEntry.SearchStartedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "search-started",
      callback: SearchEntry.SearchStartedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "search-started",
      callback: SearchEntry.SearchStartedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "search-started", ...args: any[]): void
    connect(
      sigName: "stop-search",
      callback: SearchEntry.StopSearchSignalCallback
    ): number
    on(
      sigName: "stop-search",
      callback: SearchEntry.StopSearchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "stop-search",
      callback: SearchEntry.StopSearchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "stop-search",
      callback: SearchEntry.StopSearchSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "stop-search", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.SearchEntry

    connect(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activates-default", ...args: any[]): void
    connect(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-hints", ...args: any[]): void
    connect(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-purpose", ...args: any[]): void
    connect(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::placeholder-text", ...args: any[]): void
    connect(
      sigName: "notify::search-delay",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::search-delay",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::search-delay",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::search-delay",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::search-delay", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-position", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-undo", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-bound", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSearchEntry` is an entry widget that has been tailored for use
   * as a search entry.
   *
   * The main API for interacting with a `GtkSearchEntry` as entry
   * is the `GtkEditable` interface.
   *
   * ![An example GtkSearchEntry](search-entry.png)
   *
   * It will show an inactive symbolic “find” icon when the search
   * entry is empty, and a symbolic “clear” icon when there is text.
   * Clicking on the “clear” icon will empty the search entry.
   *
   * To make filtering appear more reactive, it is a good idea to
   * not react to every change in the entry text immediately, but
   * only after a short delay. To support this, `GtkSearchEntry`
   * emits the [signal`Gtk`.SearchEntry::search-changed] signal which
   * can be used instead of the [signal`Gtk`.Editable::changed] signal.
   *
   * The [signal`Gtk`.SearchEntry::previous-match],
   * [signal`Gtk`.SearchEntry::next-match] and
   * [signal`Gtk`.SearchEntry::stop-search] signals can be used to
   * implement moving between search results and ending the search.
   *
   * Often, `GtkSearchEntry` will be fed events by means of being
   * placed inside a [class`Gtk`.SearchBar]. If that is not the case,
   * you can use [method`Gtk`.SearchEntry.set_key_capture_widget] to
   * let it capture key input from another widget.
   *
   * `GtkSearchEntry` provides only minimal API and should be used with
   * the [iface`Gtk`.Editable] API.
   *
   * ## CSS Nodes
   *
   * ```
   * entry.search
   * ╰── text
   * ```
   *
   * `GtkSearchEntry` has a single CSS node with name entry that carries
   * a `.search` style class, and the text node is a child of that.
   *
   * ## Accessibility
   *
   * `GtkSearchEntry` uses the %GTK_ACCESSIBLE_ROLE_SEARCH_BOX role.
   * @class
   */
  class SearchEntry extends Widget {
    // Own properties of Gtk-4.0.Gtk.SearchEntry

    static name: string

    // Constructors of Gtk-4.0.Gtk.SearchEntry

    constructor(config?: SearchEntry.ConstructorProperties)
    /**
     * Creates a `GtkSearchEntry`.
     * @constructor
     * @returns a new `GtkSearchEntry`
     */
    constructor()
    /**
     * Creates a `GtkSearchEntry`.
     * @constructor
     * @returns a new `GtkSearchEntry`
     */
    static new(): SearchEntry
    _init(config?: SearchEntry.ConstructorProperties): void
  }

  module SelectionFilterModel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SelectionFilterModel

      /**
       * The model being filtered.
       */
      model?: SelectionModel | null
    }
  }

  interface SelectionFilterModel extends Gio.ListModel {
    // Own properties of Gtk-4.0.Gtk.SelectionFilterModel

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The model being filtered.
     */
    model: SelectionModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SelectionFilterModel

    /**
     * Gets the model currently filtered or %NULL if none.
     * @returns The model that gets filtered
     */
    getModel(): SelectionModel | null
    /**
     * Sets the model to be filtered.
     *
     * Note that GTK makes no effort to ensure that `model` conforms to
     * the item type of `self`. It assumes that the caller knows what they
     * are doing and have set up an appropriate filter to ensure that item
     * types match.
     * @param model The model to be filtered
     */
    setModel(model: SelectionModel | null): void

    // Class property signals of Gtk-4.0.Gtk.SelectionFilterModel

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSelectionFilterModel` is a list model that presents the selection from
   * a `GtkSelectionModel`.
   * @class
   */
  class SelectionFilterModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.SelectionFilterModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.SelectionFilterModel

    constructor(config?: SelectionFilterModel.ConstructorProperties)
    /**
     * Creates a new `GtkSelectionFilterModel` that will include the
     * selected items from the underlying selection model.
     * @constructor
     * @param model the selection model to filter
     * @returns a new `GtkSelectionFilterModel`
     */
    constructor(model: SelectionModel | null)
    /**
     * Creates a new `GtkSelectionFilterModel` that will include the
     * selected items from the underlying selection model.
     * @constructor
     * @param model the selection model to filter
     * @returns a new `GtkSelectionFilterModel`
     */
    static new(model: SelectionModel | null): SelectionFilterModel
    _init(config?: SelectionFilterModel.ConstructorProperties): void
  }

  module Separator {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {}
  }

  interface Separator
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.Separator

    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.Separator

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSeparator` is a horizontal or vertical separator widget.
   *
   * ![An example GtkSeparator](separator.png)
   *
   * A `GtkSeparator` can be used to group the widgets within a window.
   * It displays a line with a shadow to make it appear sunken into the
   * interface.
   *
   * # CSS nodes
   *
   * `GtkSeparator` has a single CSS node with name separator. The node
   * gets one of the .horizontal or .vertical style classes.
   *
   * # Accessibility
   *
   * `GtkSeparator` uses the %GTK_ACCESSIBLE_ROLE_SEPARATOR role.
   * @class
   */
  class Separator extends Widget {
    // Own properties of Gtk-4.0.Gtk.Separator

    static name: string

    // Constructors of Gtk-4.0.Gtk.Separator

    constructor(config?: Separator.ConstructorProperties)
    /**
     * Creates a new `GtkSeparator` with the given orientation.
     * @constructor
     * @param orientation the separator’s orientation.
     * @returns a new `GtkSeparator`.
     */
    constructor(orientation: Orientation)
    /**
     * Creates a new `GtkSeparator` with the given orientation.
     * @constructor
     * @param orientation the separator’s orientation.
     * @returns a new `GtkSeparator`.
     */
    static new(orientation: Orientation): Separator
    _init(config?: Separator.ConstructorProperties): void
  }

  module Settings {
    // Constructor properties interface

    interface ConstructorProperties
      extends StyleProvider.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Settings

      /**
       * Whether buttons in dialogs should use the alternative button order.
       */
      gtk_alternative_button_order?: boolean | null
      /**
       * Controls the direction of the sort indicators in sorted list and tree
       * views.
       *
       * By default an arrow pointing down means the column is sorted
       * in ascending order. When set to %TRUE, this order will be inverted.
       */
      gtk_alternative_sort_arrows?: boolean | null
      /**
       * Whether the application prefers to use a dark theme.
       *
       * If a GTK theme includes a dark variant, it will be used
       * instead of the configured theme.
       *
       * Some applications benefit from minimizing the amount of light
       * pollution that interferes with the content. Good candidates for
       * dark themes are photo and video editors that make the actual
       * content get all the attention and minimize the distraction of
       * the chrome.
       *
       * Dark themes should not be used for documents, where large spaces
       * are white/light and the dark chrome creates too much contrast
       * (web browser, text editor...).
       */
      gtk_application_prefer_dark_theme?: boolean | null
      /**
       * The aspect ratio of the text caret.
       */
      gtk_cursor_aspect_ratio?: number | null
      /**
       * Whether the cursor should blink.
       *
       * Also see the [property`Gtk`.Settings:gtk-cursor-blink-timeout] setting,
       * which allows more flexible control over cursor blinking.
       */
      gtk_cursor_blink?: boolean | null
      /**
       * Length of the cursor blink cycle, in milliseconds.
       */
      gtk_cursor_blink_time?: number | null
      /**
       * Time after which the cursor stops blinking, in seconds.
       *
       * The timer is reset after each user interaction.
       *
       * Setting this to zero has the same effect as setting
       * [property`Gtk`.Settings:gtk-cursor-blink] to %FALSE.
       */
      gtk_cursor_blink_timeout?: number | null
      /**
       * Name of the cursor theme to use.
       *
       * Use %NULL to use the default theme.
       */
      gtk_cursor_theme_name?: string | null
      /**
       * The size to use for cursors.
       *
       * 0 means to use the default size.
       */
      gtk_cursor_theme_size?: number | null
      /**
       * Determines which buttons should be put in the
       * titlebar of client-side decorated windows, and whether they
       * should be placed on the left or right.
       *
       * The format of the string is button names, separated by commas.
       * A colon separates the buttons that should appear on the left
       * from those on the right. Recognized button names are minimize,
       * maximize, close, icon (the window icon) and menu (a menu button
       * for the fallback app menu).
       *
       * For example, "menu:minimize,maximize,close" specifies a menu
       * on the left, and minimize, maximize and close buttons on the right.
       *
       * Note that buttons will only be shown when they are meaningful.
       * E.g. a menu button only appears when the desktop shell does not
       * show the app menu, and a close button only appears on a window
       * that can be closed.
       *
       * Also note that the setting can be overridden with the
       * [property`Gtk`.HeaderBar:decoration-layout] property.
       */
      gtk_decoration_layout?: string | null
      /**
       * Whether builtin GTK dialogs such as the file chooser, the
       * color chooser or the font chooser will use a header bar at
       * the top to show action widgets, or an action area at the bottom.
       *
       * This setting does not affect custom dialogs using `GtkDialog`
       * directly, or message dialogs.
       */
      gtk_dialogs_use_header?: boolean | null
      /**
       * The number of pixels the cursor can move before dragging.
       */
      gtk_dnd_drag_threshold?: number | null
      /**
       * The maximum distance allowed between two clicks for them to be considered
       * a double click, in pixels.
       */
      gtk_double_click_distance?: number | null
      /**
       * The maximum time to allow between two clicks for them to be considered
       * a double click, in milliseconds.
       */
      gtk_double_click_time?: number | null
      /**
       * Whether menu items should have visible accelerators which can be
       * activated.
       */
      gtk_enable_accels?: boolean | null
      /**
       * Whether to enable toolkit-wide animations.
       */
      gtk_enable_animations?: boolean | null
      /**
       * Whether to play any event sounds at all.
       *
       * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
       * for more information on event sounds and sound themes.
       *
       * GTK itself does not support event sounds, you have to use a loadable
       * module like the one that comes with libcanberra.
       */
      gtk_enable_event_sounds?: boolean | null
      /**
       * Whether to play event sounds as feedback to user input.
       *
       * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
       * for more information on event sounds and sound themes.
       *
       * GTK itself does not support event sounds, you have to use a loadable
       * module like the one that comes with libcanberra.
       */
      gtk_enable_input_feedback_sounds?: boolean | null
      /**
       * Whether a middle click on a mouse should paste the
       * 'PRIMARY' clipboard content at the cursor location.
       */
      gtk_enable_primary_paste?: boolean | null
      /**
       * How long to show the last input character in hidden
       * entries.
       *
       * This value is in milliseconds. 0 disables showing the
       * last char. 600 is a good value for enabling it.
       */
      gtk_entry_password_hint_timeout?: number | null
      /**
       * Whether to select the contents of an entry when it is focused.
       */
      gtk_entry_select_on_focus?: boolean | null
      /**
       * When %TRUE, keyboard navigation and other input-related errors
       * will cause a beep.
       *
       * Since the error bell is implemented using gdk_surface_beep(), the
       * windowing system may offer ways to configure the error bell in many
       * ways, such as flashing the window or similar visual effects.
       */
      gtk_error_bell?: boolean | null
      /**
       * The default font to use.
       *
       * GTK uses the family name and size from this string.
       */
      gtk_font_name?: string | null
      /**
       * Timestamp of the current fontconfig configuration.
       */
      gtk_fontconfig_timestamp?: number | null
      /**
       * Whether hinting should be applied to font metrics.
       *
       * Note that this also turns off subpixel positioning of glyphs,
       * since it conflicts with metrics hinting.
       */
      gtk_hint_font_metrics?: boolean | null
      /**
       * Name of the icon theme to use.
       *
       * See [class`Gtk`.IconTheme] for details about how
       * GTK handles icon themes.
       */
      gtk_icon_theme_name?: string | null
      /**
       * Which IM (input method) module should be used by default.
       *
       * This is the input method that will be used if the user has not
       * explicitly chosen another input method from the IM context menu.
       * This also can be a colon-separated list of input methods, which GTK
       * will try in turn until it finds one available on the system.
       *
       * See [class`Gtk`.IMContext].
       */
      gtk_im_module?: string | null
      /**
       * Whether GTK should make sure that text can be navigated with
       * a caret, even if it is not editable.
       *
       * This is useful when using a screen reader.
       */
      gtk_keynav_use_caret?: boolean | null
      /**
       * Whether to select the contents of a selectable
       * label when it is focused.
       */
      gtk_label_select_on_focus?: boolean | null
      /**
       * The time for a button or touch press to be considered a “long press”.
       *
       * See [class`Gtk`.GestureLongPress].
       */
      gtk_long_press_time?: number | null
      /**
       * Whether scrolled windows may use overlaid scrolling indicators.
       *
       * If this is set to %FALSE, scrolled windows will have permanent
       * scrollbars.
       */
      gtk_overlay_scrolling?: boolean | null
      /**
       * If the value of this setting is %TRUE, clicking the primary button in a
       * `GtkRange` trough will move the slider, and hence set the range’s value, to
       * the point that you clicked.
       *
       * If it is %FALSE, a primary click will cause the slider/value to move
       * by the range’s page-size towards the point clicked.
       *
       * Whichever action you choose for the primary button, the other action will
       * be available by holding Shift and primary-clicking, or clicking the middle
       * mouse button.
       */
      gtk_primary_button_warps_slider?: boolean | null
      /**
       * A comma-separated list of print backends to use in the print
       * dialog.
       *
       * Available print backends depend on the GTK installation,
       * and may include "file", "cups", "lpr" or "papi".
       */
      gtk_print_backends?: string | null
      /**
       * A command to run for displaying the print preview.
       *
       * The command should contain a `%f` placeholder, which will get
       * replaced by the path to the pdf file. The command may also
       * contain a `%s` placeholder, which will get replaced by the
       * path to a file containing the print settings in the format
       * produced by [method`Gtk`.PrintSettings.to_file].
       *
       * The preview application is responsible for removing the pdf
       * file and the print settings file when it is done.
       */
      gtk_print_preview_command?: string | null
      /**
       * Whether GTK should keep track of items inside the recently used
       * resources list.
       *
       * If set to %FALSE, the list will always be empty.
       */
      gtk_recent_files_enabled?: boolean | null
      /**
       * The maximum age, in days, of the items inside the recently used
       * resources list.
       *
       * Items older than this setting will be excised from the list.
       * If set to 0, the list will always be empty; if set to -1, no
       * item will be removed.
       */
      gtk_recent_files_max_age?: number | null
      /**
       * Set to %TRUE if the desktop environment is displaying
       * the app menu, %FALSE if the app should display it itself.
       */
      gtk_shell_shows_app_menu?: boolean | null
      /**
       * Set to %TRUE if the desktop environment is displaying
       * the desktop folder, %FALSE if not.
       */
      gtk_shell_shows_desktop?: boolean | null
      /**
       * Set to %TRUE if the desktop environment is displaying
       * the menubar, %FALSE if the app should display it itself.
       */
      gtk_shell_shows_menubar?: boolean | null
      /**
       * When %TRUE, widgets like switches include shapes to indicate their on/off state.
       */
      gtk_show_status_shapes?: boolean | null
      /**
       * The XDG sound theme to use for event sounds.
       *
       * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
       * for more information on event sounds and sound themes.
       *
       * GTK itself does not support event sounds, you have to use
       * a loadable module like the one that comes with libcanberra.
       */
      gtk_sound_theme_name?: string | null
      /**
       * Whether two cursors should be displayed for mixed left-to-right and
       * right-to-left text.
       */
      gtk_split_cursor?: boolean | null
      /**
       * Name of the theme to load.
       *
       * See [class`Gtk`.CssProvider] for details about how
       * GTK finds the CSS stylesheet for a theme.
       */
      gtk_theme_name?: string | null
      /**
       * Determines the action to take when a double-click
       * occurs on the titlebar of client-side decorated windows.
       *
       * Recognized actions are minimize, toggle-maximize, menu, lower
       * or none.
       */
      gtk_titlebar_double_click?: string | null
      /**
       * Determines the action to take when a middle-click
       * occurs on the titlebar of client-side decorated windows.
       *
       * Recognized actions are minimize, toggle-maximize, menu, lower
       * or none.
       */
      gtk_titlebar_middle_click?: string | null
      /**
       * Determines the action to take when a right-click
       * occurs on the titlebar of client-side decorated windows.
       *
       * Recognized actions are minimize, toggle-maximize, menu, lower
       * or none.
       */
      gtk_titlebar_right_click?: string | null
      /**
       * Whether to antialias fonts.
       *
       * The values are 0 for no, 1 for yes, or -1 for the system default.
       */
      gtk_xft_antialias?: number | null
      /**
       * The font resolution, in 1024 * dots/inch.
       *
       * -1 to use the default value.
       */
      gtk_xft_dpi?: number | null
      /**
       * Whether to enable font hinting.
       *
       * The values are 0 for no, 1 for yes, or -1 for the system default.
       */
      gtk_xft_hinting?: number | null
      /**
       * What degree of font hinting to use.
       *
       * The possible vaues are hintnone, hintslight,
       * hintmedium, hintfull.
       */
      gtk_xft_hintstyle?: string | null
      /**
       * The type of subpixel antialiasing to use.
       *
       * The possible values are none, rgb, bgr, vrgb, vbgr.
       *
       * Note that GSK does not support subpixel antialiasing, and this
       * setting has no effect on font rendering in GTK.
       */
      gtk_xft_rgba?: string | null
    }
  }

  interface Settings extends StyleProvider {
    // Own properties of Gtk-4.0.Gtk.Settings

    /**
     * Whether buttons in dialogs should use the alternative button order.
     */
    gtkAlternativeButtonOrder: boolean
    /**
     * Controls the direction of the sort indicators in sorted list and tree
     * views.
     *
     * By default an arrow pointing down means the column is sorted
     * in ascending order. When set to %TRUE, this order will be inverted.
     */
    gtkAlternativeSortArrows: boolean
    /**
     * Whether the application prefers to use a dark theme.
     *
     * If a GTK theme includes a dark variant, it will be used
     * instead of the configured theme.
     *
     * Some applications benefit from minimizing the amount of light
     * pollution that interferes with the content. Good candidates for
     * dark themes are photo and video editors that make the actual
     * content get all the attention and minimize the distraction of
     * the chrome.
     *
     * Dark themes should not be used for documents, where large spaces
     * are white/light and the dark chrome creates too much contrast
     * (web browser, text editor...).
     */
    gtkApplicationPreferDarkTheme: boolean
    /**
     * The aspect ratio of the text caret.
     */
    gtkCursorAspectRatio: number
    /**
     * Whether the cursor should blink.
     *
     * Also see the [property`Gtk`.Settings:gtk-cursor-blink-timeout] setting,
     * which allows more flexible control over cursor blinking.
     */
    gtkCursorBlink: boolean
    /**
     * Length of the cursor blink cycle, in milliseconds.
     */
    gtkCursorBlinkTime: number
    /**
     * Time after which the cursor stops blinking, in seconds.
     *
     * The timer is reset after each user interaction.
     *
     * Setting this to zero has the same effect as setting
     * [property`Gtk`.Settings:gtk-cursor-blink] to %FALSE.
     */
    gtkCursorBlinkTimeout: number
    /**
     * Name of the cursor theme to use.
     *
     * Use %NULL to use the default theme.
     */
    gtkCursorThemeName: string | null
    /**
     * The size to use for cursors.
     *
     * 0 means to use the default size.
     */
    gtkCursorThemeSize: number
    /**
     * Determines which buttons should be put in the
     * titlebar of client-side decorated windows, and whether they
     * should be placed on the left or right.
     *
     * The format of the string is button names, separated by commas.
     * A colon separates the buttons that should appear on the left
     * from those on the right. Recognized button names are minimize,
     * maximize, close, icon (the window icon) and menu (a menu button
     * for the fallback app menu).
     *
     * For example, "menu:minimize,maximize,close" specifies a menu
     * on the left, and minimize, maximize and close buttons on the right.
     *
     * Note that buttons will only be shown when they are meaningful.
     * E.g. a menu button only appears when the desktop shell does not
     * show the app menu, and a close button only appears on a window
     * that can be closed.
     *
     * Also note that the setting can be overridden with the
     * [property`Gtk`.HeaderBar:decoration-layout] property.
     */
    gtkDecorationLayout: string | null
    /**
     * Whether builtin GTK dialogs such as the file chooser, the
     * color chooser or the font chooser will use a header bar at
     * the top to show action widgets, or an action area at the bottom.
     *
     * This setting does not affect custom dialogs using `GtkDialog`
     * directly, or message dialogs.
     */
    gtkDialogsUseHeader: boolean
    /**
     * The number of pixels the cursor can move before dragging.
     */
    gtkDndDragThreshold: number
    /**
     * The maximum distance allowed between two clicks for them to be considered
     * a double click, in pixels.
     */
    gtkDoubleClickDistance: number
    /**
     * The maximum time to allow between two clicks for them to be considered
     * a double click, in milliseconds.
     */
    gtkDoubleClickTime: number
    /**
     * Whether menu items should have visible accelerators which can be
     * activated.
     */
    gtkEnableAccels: boolean
    /**
     * Whether to enable toolkit-wide animations.
     */
    gtkEnableAnimations: boolean
    /**
     * Whether to play any event sounds at all.
     *
     * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
     * for more information on event sounds and sound themes.
     *
     * GTK itself does not support event sounds, you have to use a loadable
     * module like the one that comes with libcanberra.
     */
    gtkEnableEventSounds: boolean
    /**
     * Whether to play event sounds as feedback to user input.
     *
     * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
     * for more information on event sounds and sound themes.
     *
     * GTK itself does not support event sounds, you have to use a loadable
     * module like the one that comes with libcanberra.
     */
    gtkEnableInputFeedbackSounds: boolean
    /**
     * Whether a middle click on a mouse should paste the
     * 'PRIMARY' clipboard content at the cursor location.
     */
    gtkEnablePrimaryPaste: boolean
    /**
     * How long to show the last input character in hidden
     * entries.
     *
     * This value is in milliseconds. 0 disables showing the
     * last char. 600 is a good value for enabling it.
     */
    gtkEntryPasswordHintTimeout: number
    /**
     * Whether to select the contents of an entry when it is focused.
     */
    gtkEntrySelectOnFocus: boolean
    /**
     * When %TRUE, keyboard navigation and other input-related errors
     * will cause a beep.
     *
     * Since the error bell is implemented using gdk_surface_beep(), the
     * windowing system may offer ways to configure the error bell in many
     * ways, such as flashing the window or similar visual effects.
     */
    gtkErrorBell: boolean
    /**
     * The default font to use.
     *
     * GTK uses the family name and size from this string.
     */
    gtkFontName: string | null
    /**
     * Timestamp of the current fontconfig configuration.
     */
    gtkFontconfigTimestamp: number
    /**
     * Whether hinting should be applied to font metrics.
     *
     * Note that this also turns off subpixel positioning of glyphs,
     * since it conflicts with metrics hinting.
     */
    gtkHintFontMetrics: boolean
    /**
     * Name of the icon theme to use.
     *
     * See [class`Gtk`.IconTheme] for details about how
     * GTK handles icon themes.
     */
    gtkIconThemeName: string | null
    /**
     * Which IM (input method) module should be used by default.
     *
     * This is the input method that will be used if the user has not
     * explicitly chosen another input method from the IM context menu.
     * This also can be a colon-separated list of input methods, which GTK
     * will try in turn until it finds one available on the system.
     *
     * See [class`Gtk`.IMContext].
     */
    gtkImModule: string | null
    /**
     * Whether GTK should make sure that text can be navigated with
     * a caret, even if it is not editable.
     *
     * This is useful when using a screen reader.
     */
    gtkKeynavUseCaret: boolean
    /**
     * Whether to select the contents of a selectable
     * label when it is focused.
     */
    gtkLabelSelectOnFocus: boolean
    /**
     * The time for a button or touch press to be considered a “long press”.
     *
     * See [class`Gtk`.GestureLongPress].
     */
    gtkLongPressTime: number
    /**
     * Whether scrolled windows may use overlaid scrolling indicators.
     *
     * If this is set to %FALSE, scrolled windows will have permanent
     * scrollbars.
     */
    gtkOverlayScrolling: boolean
    /**
     * If the value of this setting is %TRUE, clicking the primary button in a
     * `GtkRange` trough will move the slider, and hence set the range’s value, to
     * the point that you clicked.
     *
     * If it is %FALSE, a primary click will cause the slider/value to move
     * by the range’s page-size towards the point clicked.
     *
     * Whichever action you choose for the primary button, the other action will
     * be available by holding Shift and primary-clicking, or clicking the middle
     * mouse button.
     */
    gtkPrimaryButtonWarpsSlider: boolean
    /**
     * A comma-separated list of print backends to use in the print
     * dialog.
     *
     * Available print backends depend on the GTK installation,
     * and may include "file", "cups", "lpr" or "papi".
     */
    gtkPrintBackends: string | null
    /**
     * A command to run for displaying the print preview.
     *
     * The command should contain a `%f` placeholder, which will get
     * replaced by the path to the pdf file. The command may also
     * contain a `%s` placeholder, which will get replaced by the
     * path to a file containing the print settings in the format
     * produced by [method`Gtk`.PrintSettings.to_file].
     *
     * The preview application is responsible for removing the pdf
     * file and the print settings file when it is done.
     */
    gtkPrintPreviewCommand: string | null
    /**
     * Whether GTK should keep track of items inside the recently used
     * resources list.
     *
     * If set to %FALSE, the list will always be empty.
     */
    gtkRecentFilesEnabled: boolean
    /**
     * The maximum age, in days, of the items inside the recently used
     * resources list.
     *
     * Items older than this setting will be excised from the list.
     * If set to 0, the list will always be empty; if set to -1, no
     * item will be removed.
     */
    gtkRecentFilesMaxAge: number
    /**
     * Set to %TRUE if the desktop environment is displaying
     * the app menu, %FALSE if the app should display it itself.
     */
    gtkShellShowsAppMenu: boolean
    /**
     * Set to %TRUE if the desktop environment is displaying
     * the desktop folder, %FALSE if not.
     */
    gtkShellShowsDesktop: boolean
    /**
     * Set to %TRUE if the desktop environment is displaying
     * the menubar, %FALSE if the app should display it itself.
     */
    gtkShellShowsMenubar: boolean
    /**
     * When %TRUE, widgets like switches include shapes to indicate their on/off state.
     */
    gtkShowStatusShapes: boolean
    /**
     * The XDG sound theme to use for event sounds.
     *
     * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
     * for more information on event sounds and sound themes.
     *
     * GTK itself does not support event sounds, you have to use
     * a loadable module like the one that comes with libcanberra.
     */
    gtkSoundThemeName: string | null
    /**
     * Whether two cursors should be displayed for mixed left-to-right and
     * right-to-left text.
     */
    gtkSplitCursor: boolean
    /**
     * Name of the theme to load.
     *
     * See [class`Gtk`.CssProvider] for details about how
     * GTK finds the CSS stylesheet for a theme.
     */
    gtkThemeName: string | null
    /**
     * Determines the action to take when a double-click
     * occurs on the titlebar of client-side decorated windows.
     *
     * Recognized actions are minimize, toggle-maximize, menu, lower
     * or none.
     */
    gtkTitlebarDoubleClick: string | null
    /**
     * Determines the action to take when a middle-click
     * occurs on the titlebar of client-side decorated windows.
     *
     * Recognized actions are minimize, toggle-maximize, menu, lower
     * or none.
     */
    gtkTitlebarMiddleClick: string | null
    /**
     * Determines the action to take when a right-click
     * occurs on the titlebar of client-side decorated windows.
     *
     * Recognized actions are minimize, toggle-maximize, menu, lower
     * or none.
     */
    gtkTitlebarRightClick: string | null
    /**
     * Whether to antialias fonts.
     *
     * The values are 0 for no, 1 for yes, or -1 for the system default.
     */
    gtkXftAntialias: number
    /**
     * The font resolution, in 1024 * dots/inch.
     *
     * -1 to use the default value.
     */
    gtkXftDpi: number
    /**
     * Whether to enable font hinting.
     *
     * The values are 0 for no, 1 for yes, or -1 for the system default.
     */
    gtkXftHinting: number
    /**
     * What degree of font hinting to use.
     *
     * The possible vaues are hintnone, hintslight,
     * hintmedium, hintfull.
     */
    gtkXftHintstyle: string | null
    /**
     * The type of subpixel antialiasing to use.
     *
     * The possible values are none, rgb, bgr, vrgb, vbgr.
     *
     * Note that GSK does not support subpixel antialiasing, and this
     * setting has no effect on font rendering in GTK.
     */
    gtkXftRgba: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Settings

    /**
     * Undoes the effect of calling g_object_set() to install an
     * application-specific value for a setting.
     *
     * After this call, the setting will again follow the session-wide
     * value for this setting.
     * @param name the name of the setting to reset
     */
    resetProperty(name: string): void

    // Class property signals of Gtk-4.0.Gtk.Settings

    connect(
      sigName: "notify::gtk-alternative-button-order",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-alternative-button-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-alternative-button-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-alternative-button-order",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-alternative-button-order", ...args: any[]): void
    connect(
      sigName: "notify::gtk-alternative-sort-arrows",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-alternative-sort-arrows",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-alternative-sort-arrows",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-alternative-sort-arrows",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-alternative-sort-arrows", ...args: any[]): void
    connect(
      sigName: "notify::gtk-application-prefer-dark-theme",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-application-prefer-dark-theme",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-application-prefer-dark-theme",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-application-prefer-dark-theme",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(
      sigName: "notify::gtk-application-prefer-dark-theme",
      ...args: any[]
    ): void
    connect(
      sigName: "notify::gtk-cursor-aspect-ratio",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-cursor-aspect-ratio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-cursor-aspect-ratio",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-cursor-aspect-ratio",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-cursor-aspect-ratio", ...args: any[]): void
    connect(
      sigName: "notify::gtk-cursor-blink",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-cursor-blink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-cursor-blink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-cursor-blink",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-cursor-blink", ...args: any[]): void
    connect(
      sigName: "notify::gtk-cursor-blink-time",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-cursor-blink-time",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-cursor-blink-time",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-cursor-blink-time",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-cursor-blink-time", ...args: any[]): void
    connect(
      sigName: "notify::gtk-cursor-blink-timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-cursor-blink-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-cursor-blink-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-cursor-blink-timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-cursor-blink-timeout", ...args: any[]): void
    connect(
      sigName: "notify::gtk-cursor-theme-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-cursor-theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-cursor-theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-cursor-theme-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-cursor-theme-name", ...args: any[]): void
    connect(
      sigName: "notify::gtk-cursor-theme-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-cursor-theme-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-cursor-theme-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-cursor-theme-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-cursor-theme-size", ...args: any[]): void
    connect(
      sigName: "notify::gtk-decoration-layout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-decoration-layout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-decoration-layout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-decoration-layout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-decoration-layout", ...args: any[]): void
    connect(
      sigName: "notify::gtk-dialogs-use-header",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-dialogs-use-header",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-dialogs-use-header",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-dialogs-use-header",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-dialogs-use-header", ...args: any[]): void
    connect(
      sigName: "notify::gtk-dnd-drag-threshold",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-dnd-drag-threshold",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-dnd-drag-threshold",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-dnd-drag-threshold",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-dnd-drag-threshold", ...args: any[]): void
    connect(
      sigName: "notify::gtk-double-click-distance",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-double-click-distance",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-double-click-distance",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-double-click-distance",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-double-click-distance", ...args: any[]): void
    connect(
      sigName: "notify::gtk-double-click-time",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-double-click-time",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-double-click-time",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-double-click-time",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-double-click-time", ...args: any[]): void
    connect(
      sigName: "notify::gtk-enable-accels",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-enable-accels",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-enable-accels",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-enable-accels",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-enable-accels", ...args: any[]): void
    connect(
      sigName: "notify::gtk-enable-animations",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-enable-animations",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-enable-animations",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-enable-animations",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-enable-animations", ...args: any[]): void
    connect(
      sigName: "notify::gtk-enable-event-sounds",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-enable-event-sounds",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-enable-event-sounds",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-enable-event-sounds",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-enable-event-sounds", ...args: any[]): void
    connect(
      sigName: "notify::gtk-enable-input-feedback-sounds",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-enable-input-feedback-sounds",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-enable-input-feedback-sounds",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-enable-input-feedback-sounds",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(
      sigName: "notify::gtk-enable-input-feedback-sounds",
      ...args: any[]
    ): void
    connect(
      sigName: "notify::gtk-enable-primary-paste",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-enable-primary-paste",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-enable-primary-paste",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-enable-primary-paste",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-enable-primary-paste", ...args: any[]): void
    connect(
      sigName: "notify::gtk-entry-password-hint-timeout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-entry-password-hint-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-entry-password-hint-timeout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-entry-password-hint-timeout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(
      sigName: "notify::gtk-entry-password-hint-timeout",
      ...args: any[]
    ): void
    connect(
      sigName: "notify::gtk-entry-select-on-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-entry-select-on-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-entry-select-on-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-entry-select-on-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-entry-select-on-focus", ...args: any[]): void
    connect(
      sigName: "notify::gtk-error-bell",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-error-bell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-error-bell",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-error-bell",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-error-bell", ...args: any[]): void
    connect(
      sigName: "notify::gtk-font-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-font-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-font-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-font-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-font-name", ...args: any[]): void
    connect(
      sigName: "notify::gtk-fontconfig-timestamp",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-fontconfig-timestamp",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-fontconfig-timestamp",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-fontconfig-timestamp",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-fontconfig-timestamp", ...args: any[]): void
    connect(
      sigName: "notify::gtk-hint-font-metrics",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-hint-font-metrics",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-hint-font-metrics",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-hint-font-metrics",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-hint-font-metrics", ...args: any[]): void
    connect(
      sigName: "notify::gtk-icon-theme-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-icon-theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-icon-theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-icon-theme-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-icon-theme-name", ...args: any[]): void
    connect(
      sigName: "notify::gtk-im-module",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-im-module",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-im-module",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-im-module",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-im-module", ...args: any[]): void
    connect(
      sigName: "notify::gtk-keynav-use-caret",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-keynav-use-caret",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-keynav-use-caret",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-keynav-use-caret",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-keynav-use-caret", ...args: any[]): void
    connect(
      sigName: "notify::gtk-label-select-on-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-label-select-on-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-label-select-on-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-label-select-on-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-label-select-on-focus", ...args: any[]): void
    connect(
      sigName: "notify::gtk-long-press-time",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-long-press-time",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-long-press-time",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-long-press-time",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-long-press-time", ...args: any[]): void
    connect(
      sigName: "notify::gtk-overlay-scrolling",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-overlay-scrolling",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-overlay-scrolling",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-overlay-scrolling",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-overlay-scrolling", ...args: any[]): void
    connect(
      sigName: "notify::gtk-primary-button-warps-slider",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-primary-button-warps-slider",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-primary-button-warps-slider",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-primary-button-warps-slider",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(
      sigName: "notify::gtk-primary-button-warps-slider",
      ...args: any[]
    ): void
    connect(
      sigName: "notify::gtk-print-backends",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-print-backends",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-print-backends",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-print-backends",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-print-backends", ...args: any[]): void
    connect(
      sigName: "notify::gtk-print-preview-command",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-print-preview-command",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-print-preview-command",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-print-preview-command",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-print-preview-command", ...args: any[]): void
    connect(
      sigName: "notify::gtk-recent-files-enabled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-recent-files-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-recent-files-enabled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-recent-files-enabled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-recent-files-enabled", ...args: any[]): void
    connect(
      sigName: "notify::gtk-recent-files-max-age",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-recent-files-max-age",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-recent-files-max-age",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-recent-files-max-age",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-recent-files-max-age", ...args: any[]): void
    connect(
      sigName: "notify::gtk-shell-shows-app-menu",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-shell-shows-app-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-shell-shows-app-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-shell-shows-app-menu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-shell-shows-app-menu", ...args: any[]): void
    connect(
      sigName: "notify::gtk-shell-shows-desktop",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-shell-shows-desktop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-shell-shows-desktop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-shell-shows-desktop",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-shell-shows-desktop", ...args: any[]): void
    connect(
      sigName: "notify::gtk-shell-shows-menubar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-shell-shows-menubar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-shell-shows-menubar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-shell-shows-menubar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-shell-shows-menubar", ...args: any[]): void
    connect(
      sigName: "notify::gtk-show-status-shapes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-show-status-shapes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-show-status-shapes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-show-status-shapes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-show-status-shapes", ...args: any[]): void
    connect(
      sigName: "notify::gtk-sound-theme-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-sound-theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-sound-theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-sound-theme-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-sound-theme-name", ...args: any[]): void
    connect(
      sigName: "notify::gtk-split-cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-split-cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-split-cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-split-cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-split-cursor", ...args: any[]): void
    connect(
      sigName: "notify::gtk-theme-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-theme-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-theme-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-theme-name", ...args: any[]): void
    connect(
      sigName: "notify::gtk-titlebar-double-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-titlebar-double-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-titlebar-double-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-titlebar-double-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-titlebar-double-click", ...args: any[]): void
    connect(
      sigName: "notify::gtk-titlebar-middle-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-titlebar-middle-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-titlebar-middle-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-titlebar-middle-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-titlebar-middle-click", ...args: any[]): void
    connect(
      sigName: "notify::gtk-titlebar-right-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-titlebar-right-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-titlebar-right-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-titlebar-right-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-titlebar-right-click", ...args: any[]): void
    connect(
      sigName: "notify::gtk-xft-antialias",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-xft-antialias",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-xft-antialias",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-xft-antialias",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-xft-antialias", ...args: any[]): void
    connect(
      sigName: "notify::gtk-xft-dpi",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-xft-dpi",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-xft-dpi",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-xft-dpi",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-xft-dpi", ...args: any[]): void
    connect(
      sigName: "notify::gtk-xft-hinting",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-xft-hinting",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-xft-hinting",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-xft-hinting",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-xft-hinting", ...args: any[]): void
    connect(
      sigName: "notify::gtk-xft-hintstyle",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-xft-hintstyle",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-xft-hintstyle",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-xft-hintstyle",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-xft-hintstyle", ...args: any[]): void
    connect(
      sigName: "notify::gtk-xft-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::gtk-xft-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::gtk-xft-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::gtk-xft-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::gtk-xft-rgba", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSettings` provides a mechanism to share global settings between
   * applications.
   *
   * On the X window system, this sharing is realized by an
   * [XSettings](http://www.freedesktop.org/wiki/Specifications/xsettings-spec)
   * manager that is usually part of the desktop environment, along with
   * utilities that let the user change these settings.
   *
   * On Wayland, the settings are obtained either via a settings portal,
   * or by reading desktop settings from DConf.
   *
   * On macOS, the settings are obtained from `NSUserDefaults`.
   *
   * In the absence of these sharing mechanisms, GTK reads default values for
   * settings from `settings.ini` files in `/etc/gtk-4.0`, `$XDG_CONFIG_DIRS/gtk-4.0`
   * and `$XDG_CONFIG_HOME/gtk-4.0`. These files must be valid key files (see
   * `GKeyFile`), and have a section called Settings. Themes can also provide
   * default values for settings by installing a `settings.ini` file
   * next to their `gtk.css` file.
   *
   * Applications can override system-wide settings by setting the property
   * of the `GtkSettings` object with g_object_set(). This should be restricted
   * to special cases though; `GtkSettings` are not meant as an application
   * configuration facility.
   *
   * There is one `GtkSettings` instance per display. It can be obtained with
   * [func`Gtk`.Settings.get_for_display], but in many cases, it is more
   * convenient to use [method`Gtk`.Widget.get_settings].
   * @class
   */
  class Settings extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Settings

    static name: string

    // Constructors of Gtk-4.0.Gtk.Settings

    constructor(config?: Settings.ConstructorProperties)
    _init(config?: Settings.ConstructorProperties): void
    /**
     * Gets the `GtkSettings` object for the default display, creating
     * it if necessary.
     *
     * See [func`Gtk`.Settings.get_for_display].
     * @returns a `GtkSettings` object. If there is   no default display, then returns %NULL.
     */
    static getDefault(): Settings | null
    /**
     * Gets the `GtkSettings` object for `display,` creating it if necessary.
     * @param display a `GdkDisplay`
     * @returns a `GtkSettings` object
     */
    static getForDisplay(display: Gdk.Display): Settings
  }

  module Shortcut {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Shortcut

      /**
       * The action that gets activated by this shortcut.
       */
      action?: ShortcutAction | null
      /**
       * Arguments passed to activation.
       */
      arguments?: GLib.Variant | null
      /**
       * The trigger that triggers this shortcut.
       */
      trigger?: ShortcutTrigger | null
    }
  }

  interface Shortcut {
    // Own properties of Gtk-4.0.Gtk.Shortcut

    /**
     * The action that gets activated by this shortcut.
     */
    action: ShortcutAction
    /**
     * Arguments passed to activation.
     */
    arguments: GLib.Variant
    /**
     * The trigger that triggers this shortcut.
     */
    trigger: ShortcutTrigger
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Shortcut

    /**
     * Gets the action that is activated by this shortcut.
     * @returns the action
     */
    getAction(): ShortcutAction | null
    /**
     * Gets the arguments that are passed when activating the shortcut.
     * @returns the arguments
     */
    getArguments(): GLib.Variant | null
    /**
     * Gets the trigger used to trigger `self`.
     * @returns the trigger used
     */
    getTrigger(): ShortcutTrigger | null
    /**
     * Sets the new action for `self` to be `action`.
     * @param action The new action.   If the `action` is %NULL, the nothing action will be used.
     */
    setAction(action: ShortcutAction | null): void
    /**
     * Sets the arguments to pass when activating the shortcut.
     * @param args arguments to pass when activating `self`
     */
    setArguments(args: GLib.Variant | null): void
    /**
     * Sets the new trigger for `self` to be `trigger`.
     * @param trigger The new trigger.   If the `trigger` is %NULL, the never trigger will be used.
     */
    setTrigger(trigger: ShortcutTrigger | null): void

    // Class property signals of Gtk-4.0.Gtk.Shortcut

    connect(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action", ...args: any[]): void
    connect(
      sigName: "notify::arguments",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::arguments",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::arguments",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::arguments",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::arguments", ...args: any[]): void
    connect(
      sigName: "notify::trigger",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::trigger",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::trigger",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::trigger",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::trigger", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcut` describes a keyboard shortcut.
   *
   * It contains a description of how to trigger the shortcut via a
   * [class`Gtk`.ShortcutTrigger] and a way to activate the shortcut
   * on a widget via a [class`Gtk`.ShortcutAction].
   *
   * The actual work is usually done via [class`Gtk`.ShortcutController],
   * which decides if and when to activate a shortcut. Using that controller
   * directly however is rarely necessary as various higher level
   * convenience APIs exist on `GtkWidget`s that make it easier to use
   * shortcuts in GTK.
   *
   * `GtkShortcut` does provide functionality to make it easy for users
   * to work with shortcuts, either by providing informational strings
   * for display purposes or by allowing shortcuts to be configured.
   * @class
   */
  class Shortcut extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Shortcut

    static name: string

    // Constructors of Gtk-4.0.Gtk.Shortcut

    constructor(config?: Shortcut.ConstructorProperties)
    /**
     * Creates a new `GtkShortcut` that is triggered by
     * `trigger` and then activates `action`.
     * @constructor
     * @param trigger The trigger that will trigger the shortcut
     * @param action The action that will be activated upon    triggering
     * @returns a new `GtkShortcut`
     */
    constructor(trigger: ShortcutTrigger | null, action: ShortcutAction | null)
    /**
     * Creates a new `GtkShortcut` that is triggered by
     * `trigger` and then activates `action`.
     * @constructor
     * @param trigger The trigger that will trigger the shortcut
     * @param action The action that will be activated upon    triggering
     * @returns a new `GtkShortcut`
     */
    static new(
      trigger: ShortcutTrigger | null,
      action: ShortcutAction | null
    ): Shortcut
    _init(config?: Shortcut.ConstructorProperties): void
  }

  module ShortcutAction {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ShortcutAction {
    // Own properties of Gtk-4.0.Gtk.ShortcutAction

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ShortcutAction

    /**
     * Activates the action on the `widget` with the given `args`.
     *
     * Note that some actions ignore the passed in `flags,` `widget` or `args`.
     *
     * Activation of an action can fail for various reasons. If the action
     * is not supported by the `widget,` if the `args` don't match the action
     * or if the activation otherwise had no effect, %FALSE will be returned.
     * @param flags flags to activate with
     * @param widget Target of the activation
     * @param args arguments to pass
     * @returns %TRUE if this action was activated successfully
     */
    activate(
      flags: ShortcutActionFlags,
      widget: Widget,
      args: GLib.Variant | null
    ): boolean
    /**
     * Prints the given action into a string for the developer.
     *
     * This is meant for debugging and logging.
     *
     * The form of the representation may change at any time and is
     * not guaranteed to stay identical.
     * @param string a `GString` to print into
     */
    print(string: GLib.String): void
    /**
     * Prints the given action into a human-readable string.
     *
     * This is a small wrapper around [method`Gtk`.ShortcutAction.print]
     * to help when debugging.
     * @returns a new string
     */
    toString(): string | null

    // Class property signals of Gtk-4.0.Gtk.ShortcutAction

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkShortcutAction` encodes an action that can be triggered by a
   * keyboard shortcut.
   *
   * `GtkShortcutActions` contain functions that allow easy presentation
   * to end users as well as being printed for debugging.
   *
   * All `GtkShortcutActions` are immutable, you can only specify their
   * properties during construction. If you want to change a action, you
   * have to replace it with a new one. If you need to pass arguments to
   * an action, these are specified by the higher-level `GtkShortcut` object.
   *
   * To activate a `GtkShortcutAction` manually, [method`Gtk`.ShortcutAction.activate]
   * can be called.
   *
   * GTK provides various actions:
   *
   *  - [class`Gtk`.MnemonicAction]: a shortcut action that calls
   *    gtk_widget_mnemonic_activate()
   *  - [class`Gtk`.CallbackAction]: a shortcut action that invokes
   *    a given callback
   *  - [class`Gtk`.SignalAction]: a shortcut action that emits a
   *    given signal
   *  - [class`Gtk`.ActivateAction]: a shortcut action that calls
   *    gtk_widget_activate()
   *  - [class`Gtk`.NamedAction]: a shortcut action that calls
   *    gtk_widget_activate_action()
   *  - [class`Gtk`.NothingAction]: a shortcut action that does nothing
   * @class
   */
  class ShortcutAction extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ShortcutAction

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutAction

    constructor(config?: ShortcutAction.ConstructorProperties)
    /**
     * Tries to parse the given string into an action.
     *
     * On success, the parsed action is returned. When parsing
     * failed, %NULL is returned.
     *
     * The accepted strings are:
     *
     * - `nothing`, for `GtkNothingAction`
     * - `activate`, for `GtkActivateAction`
     * - `mnemonic-activate`, for `GtkMnemonicAction`
     * - `action(NAME)`, for a `GtkNamedAction` for the action named `NAME`
     * - `signal(NAME)`, for a `GtkSignalAction` for the signal `NAME`
     * @constructor
     * @param string the string to parse
     * @returns a new `GtkShortcutAction`
     */
    static parseString(string: string): ShortcutAction
    _init(config?: ShortcutAction.ConstructorProperties): void
  }

  module ShortcutController {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        Buildable.ConstructorProperties,
        EventController.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ShortcutController

      /**
       * The modifiers that need to be pressed to allow mnemonics activation.
       */
      mnemonic_modifiers?: Gdk.ModifierType | null
      /**
       * A list model to take shortcuts from.
       */
      model?: Gio.ListModel | null
      /**
       * What scope the shortcuts will be handled in.
       */
      scope?: ShortcutScope | null
    }
  }

  interface ShortcutController extends Gio.ListModel, Buildable {
    // Own properties of Gtk-4.0.Gtk.ShortcutController

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The modifiers that need to be pressed to allow mnemonics activation.
     */
    mnemonicModifiers: Gdk.ModifierType
    /**
     * A list model to take shortcuts from.
     */
    readonly model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    /**
     * What scope the shortcuts will be handled in.
     */
    scope: ShortcutScope
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ShortcutController

    /**
     * Adds `shortcut` to the list of shortcuts handled by `self`.
     *
     * If this controller uses an external shortcut list, this
     * function does nothing.
     * @param shortcut a `GtkShortcut`
     */
    addShortcut(shortcut: Shortcut): void
    /**
     * Gets the mnemonics modifiers for when this controller activates its shortcuts.
     * @returns the controller's mnemonics modifiers
     */
    getMnemonicsModifiers(): Gdk.ModifierType
    /**
     * Gets the scope for when this controller activates its shortcuts.
     *
     * See [method`Gtk`.ShortcutController.set_scope] for details.
     * @returns the controller's scope
     */
    getScope(): ShortcutScope
    /**
     * Removes `shortcut` from the list of shortcuts handled by `self`.
     *
     * If `shortcut` had not been added to `controller` or this controller
     * uses an external shortcut list, this function does nothing.
     * @param shortcut a `GtkShortcut`
     */
    removeShortcut(shortcut: Shortcut): void
    /**
     * Sets the controller to use the given modifier for mnemonics.
     *
     * The mnemonics modifiers determines which modifiers need to be pressed to allow
     * activation of shortcuts with mnemonics triggers.
     *
     * GTK normally uses the Alt modifier for mnemonics, except in `GtkPopoverMenu`s,
     * where mnemonics can be triggered without any modifiers. It should be very
     * rarely necessary to change this, and doing so is likely to interfere with
     * other shortcuts.
     *
     * This value is only relevant for local shortcut controllers. Global and managed
     * shortcut controllers will have their shortcuts activated from other places which
     * have their own modifiers for activating mnemonics.
     * @param modifiers the new mnemonics_modifiers to use
     */
    setMnemonicsModifiers(modifiers: Gdk.ModifierType): void
    /**
     * Sets the controller to have the given `scope`.
     *
     * The scope allows shortcuts to be activated outside of the normal
     * event propagation. In particular, it allows installing global
     * keyboard shortcuts that can be activated even when a widget does
     * not have focus.
     *
     * With %GTK_SHORTCUT_SCOPE_LOCAL, shortcuts will only be activated
     * when the widget has focus.
     * @param scope the new scope to use
     */
    setScope(scope: ShortcutScope): void

    // Class property signals of Gtk-4.0.Gtk.ShortcutController

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::mnemonic-modifiers",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonic-modifiers",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonic-modifiers",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonic-modifiers",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonic-modifiers", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::scope",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scope",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scope",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scope",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scope", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-limit",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-limit", ...args: any[]): void
    connect(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagation-phase",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagation-phase", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkShortcutController` is an event controller that manages shortcuts.
   *
   * Most common shortcuts are using this controller implicitly, e.g. by
   * adding a mnemonic underline to a [class`Gtk`.Label], or by installing a key
   * binding using [method`Gtk`.WidgetClass.add_binding], or by adding accelerators
   * to global actions using [method`Gtk`.Application.set_accels_for_action].
   *
   * But it is possible to create your own shortcut controller, and add
   * shortcuts to it.
   *
   * `GtkShortcutController` implements [iface`Gio`.ListModel] for querying the
   * shortcuts that have been added to it.
   *
   * # GtkShortcutController as GtkBuildable
   *
   * `GtkShortcutController`s can be created in [class`Gtk`.Builder] ui files, to set up
   * shortcuts in the same place as the widgets.
   *
   * An example of a UI definition fragment with `GtkShortcutController`:
   * ```xml
   *   <object class='GtkButton'>
   *     <child>
   *       <object class='GtkShortcutController'>
   *         <property name='scope'>managed</property>
   *         <child>
   *           <object class='GtkShortcut'>
   *             <property name='trigger'>&lt;Control&gt;k</property>
   *             <property name='action'>activate</property>
   *           </object>
   *         </child>
   *       </object>
   *     </child>
   *   </object>
   * ```
   *
   * This example creates a [class`Gtk`.ActivateAction] for triggering the
   * `activate` signal of the [class`Gtk`.Button]. See [ctor`Gtk`.ShortcutAction.parse_string]
   * for the syntax for other kinds of [class`Gtk`.ShortcutAction]. See
   * [ctor`Gtk`.ShortcutTrigger.parse_string] to learn more about the syntax
   * for triggers.
   * @class
   */
  class ShortcutController extends EventController {
    // Own properties of Gtk-4.0.Gtk.ShortcutController

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutController

    constructor(config?: ShortcutController.ConstructorProperties)
    /**
     * Creates a new shortcut controller.
     * @constructor
     * @returns a newly created shortcut controller
     */
    constructor()
    /**
     * Creates a new shortcut controller.
     * @constructor
     * @returns a newly created shortcut controller
     */
    static new(): ShortcutController
    /**
     * Creates a new shortcut controller that takes its shortcuts from
     * the given list model.
     *
     * A controller created by this function does not let you add or
     * remove individual shortcuts using the shortcut controller api,
     * but you can change the contents of the model.
     * @constructor
     * @param model a `GListModel` containing shortcuts
     * @returns a newly created shortcut controller
     */
    static newForModel(model: Gio.ListModel): ShortcutController
    _init(config?: ShortcutController.ConstructorProperties): void
  }

  module ShortcutLabel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ShortcutLabel

      /**
       * The accelerator that `self` displays.
       *
       * See [property`Gtk`.ShortcutsShortcut:accelerator]
       * for the accepted syntax.
       */
      accelerator?: string | null
      /**
       * The text that is displayed when no accelerator is set.
       */
      disabled_text?: string | null
    }
  }

  interface ShortcutLabel extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ShortcutLabel

    /**
     * The accelerator that `self` displays.
     *
     * See [property`Gtk`.ShortcutsShortcut:accelerator]
     * for the accepted syntax.
     */
    accelerator: string | null
    /**
     * The text that is displayed when no accelerator is set.
     */
    disabledText: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ShortcutLabel

    /**
     * Retrieves the current accelerator of `self`.
     * @returns the current accelerator.
     */
    getAccelerator(): string | null
    /**
     * Retrieves the text that is displayed when no accelerator is set.
     * @returns the current text displayed when no accelerator is set.
     */
    getDisabledText(): string | null
    /**
     * Sets the accelerator to be displayed by `self`.
     * @param accelerator the new accelerator
     */
    setAccelerator(accelerator: string): void
    /**
     * Sets the text to be displayed by `self` when no accelerator is set.
     * @param disabledText the text to be displayed when no accelerator is set
     */
    setDisabledText(disabledText: string): void

    // Class property signals of Gtk-4.0.Gtk.ShortcutLabel

    connect(
      sigName: "notify::accelerator",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accelerator",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accelerator",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accelerator",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accelerator", ...args: any[]): void
    connect(
      sigName: "notify::disabled-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::disabled-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::disabled-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::disabled-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::disabled-text", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkShortcutLabel` displays a single keyboard shortcut or gesture.
   *
   * The main use case for `GtkShortcutLabel` is inside a [class`Gtk`.ShortcutsWindow].
   * @class
   */
  class ShortcutLabel extends Widget {
    // Own properties of Gtk-4.0.Gtk.ShortcutLabel

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutLabel

    constructor(config?: ShortcutLabel.ConstructorProperties)
    /**
     * Creates a new `GtkShortcutLabel` with `accelerator` set.
     * @constructor
     * @param accelerator the initial accelerator
     * @returns a newly-allocated `GtkShortcutLabel`
     */
    constructor(accelerator: string)
    /**
     * Creates a new `GtkShortcutLabel` with `accelerator` set.
     * @constructor
     * @param accelerator the initial accelerator
     * @returns a newly-allocated `GtkShortcutLabel`
     */
    static new(accelerator: string): ShortcutLabel
    _init(config?: ShortcutLabel.ConstructorProperties): void
  }

  module ShortcutTrigger {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface ShortcutTrigger {
    // Own properties of Gtk-4.0.Gtk.ShortcutTrigger

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ShortcutTrigger

    /**
     * The types of `trigger1` and `trigger2` are `gconstpointer` only to allow
     * use of this function as a `GCompareFunc`.
     *
     * They must each be a `GtkShortcutTrigger`.
     * @param trigger2 a `GtkShortcutTrigger`
     * @returns An integer less than, equal to, or greater than zero if   @trigger1 is found, respectively, to be less than, to match,   or be greater than @trigger2.
     */
    compare(trigger2: ShortcutTrigger): number
    /**
     * Checks if `trigger1` and `trigger2` trigger under the same conditions.
     *
     * The types of `one` and `two` are `gconstpointer` only to allow use of this
     * function with `GHashTable`. They must each be a `GtkShortcutTrigger`.
     * @param trigger2 a `GtkShortcutTrigger`
     * @returns %TRUE if @trigger1 and @trigger2 are equal
     */
    equal(trigger2: ShortcutTrigger): boolean
    /**
     * Generates a hash value for a `GtkShortcutTrigger`.
     *
     * The output of this function is guaranteed to be the same for a given
     * value only per-process. It may change between different processor
     * architectures or even different versions of GTK. Do not use this
     * function as a basis for building protocols or file formats.
     *
     * The types of `trigger` is `gconstpointer` only to allow use of this
     * function with `GHashTable`. They must each be a `GtkShortcutTrigger`.
     * @returns a hash value corresponding to @trigger
     */
    hash(): number
    /**
     * Prints the given trigger into a string for the developer.
     * This is meant for debugging and logging.
     *
     * The form of the representation may change at any time
     * and is not guaranteed to stay identical.
     * @param string a `GString` to print into
     */
    print(string: GLib.String): void
    /**
     * Prints the given trigger into a string.
     *
     * This function is returning a translated string for presentation
     * to end users for example in menu items or in help texts.
     *
     * The `display` in use may influence the resulting string in
     * various forms, such as resolving hardware keycodes or by
     * causing display-specific modifier names.
     *
     * The form of the representation may change at any time and is
     * not guaranteed to stay identical.
     * @param display `GdkDisplay` to print for
     * @param string a `GString` to print into
     * @returns %TRUE if something was printed or %FALSE if the   trigger did not have a textual representation suitable   for end users.
     */
    printLabel(display: Gdk.Display, string: GLib.String): boolean
    /**
     * Gets textual representation for the given trigger.
     *
     * This function is returning a translated string for
     * presentation to end users for example in menu items
     * or in help texts.
     *
     * The `display` in use may influence the resulting string in
     * various forms, such as resolving hardware keycodes or by
     * causing display-specific modifier names.
     *
     * The form of the representation may change at any time and is
     * not guaranteed to stay identical.
     * @param display `GdkDisplay` to print for
     * @returns a new string
     */
    toLabel(display: Gdk.Display): string | null
    /**
     * Prints the given trigger into a human-readable string.
     *
     * This is a small wrapper around [method`Gtk`.ShortcutTrigger.print]
     * to help when debugging.
     * @returns a new string
     */
    toString(): string | null
    /**
     * Checks if the given `event` triggers `self`.
     * @param event the event to check
     * @param enableMnemonics %TRUE if mnemonics should trigger. Usually the   value of this property is determined by checking that the passed   in `event` is a Key event and has the right modifiers set.
     * @returns Whether the event triggered the shortcut
     */
    trigger(event: Gdk.Event, enableMnemonics: boolean): Gdk.KeyMatch

    // Class property signals of Gtk-4.0.Gtk.ShortcutTrigger

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkShortcutTrigger` tracks how a `GtkShortcut` should be activated.
   *
   * To find out if a `GtkShortcutTrigger` triggers, you can call
   * [method`Gtk`.ShortcutTrigger.trigger] on a `GdkEvent`.
   *
   * `GtkShortcutTriggers` contain functions that allow easy presentation
   * to end users as well as being printed for debugging.
   *
   * All `GtkShortcutTriggers` are immutable, you can only specify their
   * properties during construction. If you want to change a trigger, you
   * have to replace it with a new one.
   * @class
   */
  class ShortcutTrigger extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.ShortcutTrigger

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutTrigger

    constructor(config?: ShortcutTrigger.ConstructorProperties)
    /**
     * Tries to parse the given string into a trigger.
     *
     * On success, the parsed trigger is returned.
     * When parsing failed, %NULL is returned.
     *
     * The accepted strings are:
     *
     *   - `never`, for `GtkNeverTrigger`
     *   - a string parsed by gtk_accelerator_parse(), for a `GtkKeyvalTrigger`, e.g. `<Control>C`
     *   - underscore, followed by a single character, for `GtkMnemonicTrigger`, e.g. `_l`
     *   - two valid trigger strings, separated by a `|` character, for a
     *     `GtkAlternativeTrigger`: `<Control>q|<Control>w`
     *
     * Note that you will have to escape the `<` and `>` characters when specifying
     * triggers in XML files, such as GtkBuilder ui files. Use `&lt;` instead of
     * `<` and `&gt;` instead of `>`.
     * @constructor
     * @param string the string to parse
     * @returns a new `GtkShortcutTrigger`
     */
    static parseString(string: string): ShortcutTrigger
    _init(config?: ShortcutTrigger.ConstructorProperties): void
  }

  module ShortcutsGroup {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Box.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ShortcutsGroup

      /**
       * The size group for the accelerator portion of shortcuts in this group.
       *
       * This is used internally by GTK, and must not be modified by applications.
       */
      accel_size_group?: SizeGroup | null
      /**
       * The title for this group of shortcuts.
       */
      title?: string | null
      /**
       * The size group for the textual portion of shortcuts in this group.
       *
       * This is used internally by GTK, and must not be modified by applications.
       */
      title_size_group?: SizeGroup | null
      /**
       * An optional view that the shortcuts in this group are relevant for.
       *
       * The group will be hidden if the [property`Gtk`.ShortcutsWindow:view-name]
       * property does not match the view of this group.
       *
       * Set this to %NULL to make the group always visible.
       */
      view?: string | null
    }
  }

  interface ShortcutsGroup
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.ShortcutsGroup

    /**
     * The size group for the accelerator portion of shortcuts in this group.
     *
     * This is used internally by GTK, and must not be modified by applications.
     */
    accelSizeGroup: SizeGroup
    /**
     * A rough measure for the number of lines in this group.
     *
     * This is used internally by GTK, and is not useful for applications.
     */
    readonly height: number
    /**
     * The title for this group of shortcuts.
     */
    title: string | null
    /**
     * The size group for the textual portion of shortcuts in this group.
     *
     * This is used internally by GTK, and must not be modified by applications.
     */
    titleSizeGroup: SizeGroup
    /**
     * An optional view that the shortcuts in this group are relevant for.
     *
     * The group will be hidden if the [property`Gtk`.ShortcutsWindow:view-name]
     * property does not match the view of this group.
     *
     * Set this to %NULL to make the group always visible.
     */
    view: string | null
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.ShortcutsGroup

    /**
     * Adds a shortcut to the shortcuts group.
     *
     * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
     * `<child>` tag to add the child. Adding children with other API is not
     * appropriate as `GtkShortcutsGroup` manages its children internally.
     * @param shortcut the `GtkShortcutsShortcut` to add
     */
    addShortcut(shortcut: ShortcutsShortcut): void

    // Class property signals of Gtk-4.0.Gtk.ShortcutsGroup

    connect(
      sigName: "notify::accel-size-group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accel-size-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accel-size-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accel-size-group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accel-size-group", ...args: any[]): void
    connect(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::title-size-group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title-size-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title-size-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title-size-group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title-size-group", ...args: any[]): void
    connect(sigName: "notify::view", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::view",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::view",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::view",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::view", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-child", ...args: any[]): void
    connect(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-position", ...args: any[]): void
    connect(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::spacing", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutsGroup` represents a group of related keyboard shortcuts
   * or gestures.
   *
   * The group has a title. It may optionally be associated with a view
   * of the application, which can be used to show only relevant shortcuts
   * depending on the application context.
   *
   * This widget is only meant to be used with [class`Gtk`.ShortcutsWindow].
   *
   * The recommended way to construct a `GtkShortcutsGroup` is with
   * [class`Gtk`.Builder], by using the `<child>` tag to populate a
   * `GtkShortcutsGroup` with one or more [class`Gtk`.ShortcutsShortcut]
   * instances.
   *
   * If you need to add a shortcut programmatically, use
   * [method`Gtk`.ShortcutsGroup.add_shortcut].
   * @class
   */
  class ShortcutsGroup extends Box {
    // Own properties of Gtk-4.0.Gtk.ShortcutsGroup

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutsGroup

    constructor(config?: ShortcutsGroup.ConstructorProperties)
    _init(config?: ShortcutsGroup.ConstructorProperties): void
  }

  module ShortcutsSection {
    // Signal callback interfaces

    /**
     * Signal callback interface for `change-current-page`
     */
    interface ChangeCurrentPageSignalCallback {
      (object: number): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Box.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ShortcutsSection

      /**
       * The maximum number of lines to allow per column.
       *
       * This property can be used to influence how the groups in this
       * section are distributed across pages and columns. The default
       * value of 15 should work in most cases.
       */
      max_height?: number | null
      /**
       * A unique name to identify this section among the sections
       * added to the `GtkShortcutsWindow`.
       *
       * Setting the [property`Gtk`.ShortcutsWindow:section-name] property
       * to this string will make this section shown in the `GtkShortcutsWindow`.
       */
      section_name?: string | null
      /**
       * The string to show in the section selector of the `GtkShortcutsWindow`
       * for this section.
       *
       * If there is only one section, you don't need to set a title,
       * since the section selector will not be shown in this case.
       */
      title?: string | null
      /**
       * A view name to filter the groups in this section by.
       *
       * See [property`Gtk`.ShortcutsGroup:view].
       *
       * Applications are expected to use the
       * [property`Gtk`.ShortcutsWindow:view-name] property
       * for this purpose.
       */
      view_name?: string | null
    }
  }

  interface ShortcutsSection
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.ShortcutsSection

    /**
     * The maximum number of lines to allow per column.
     *
     * This property can be used to influence how the groups in this
     * section are distributed across pages and columns. The default
     * value of 15 should work in most cases.
     */
    maxHeight: number
    /**
     * A unique name to identify this section among the sections
     * added to the `GtkShortcutsWindow`.
     *
     * Setting the [property`Gtk`.ShortcutsWindow:section-name] property
     * to this string will make this section shown in the `GtkShortcutsWindow`.
     */
    sectionName: string | null
    /**
     * The string to show in the section selector of the `GtkShortcutsWindow`
     * for this section.
     *
     * If there is only one section, you don't need to set a title,
     * since the section selector will not be shown in this case.
     */
    title: string | null
    /**
     * A view name to filter the groups in this section by.
     *
     * See [property`Gtk`.ShortcutsGroup:view].
     *
     * Applications are expected to use the
     * [property`Gtk`.ShortcutsWindow:view-name] property
     * for this purpose.
     */
    viewName: string | null
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.ShortcutsSection

    /**
     * Adds a group to the shortcuts section.
     *
     * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
     * `<child>` tag to add the child.
     *
     * Adding children with the `GtkBox` API is not appropriate, as
     * `GtkShortcutsSection` manages its children internally.
     * @param group the `GtkShortcutsGroup` to add
     */
    addGroup(group: ShortcutsGroup): void

    // Own signals of Gtk-4.0.Gtk.ShortcutsSection

    connect(
      sigName: "change-current-page",
      callback: ShortcutsSection.ChangeCurrentPageSignalCallback
    ): number
    on(
      sigName: "change-current-page",
      callback: ShortcutsSection.ChangeCurrentPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "change-current-page",
      callback: ShortcutsSection.ChangeCurrentPageSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "change-current-page",
      callback: ShortcutsSection.ChangeCurrentPageSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "change-current-page", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ShortcutsSection

    connect(
      sigName: "notify::max-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-height", ...args: any[]): void
    connect(
      sigName: "notify::section-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::section-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::section-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::section-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::section-name", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::view-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::view-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::view-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::view-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::view-name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-child", ...args: any[]): void
    connect(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::baseline-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::baseline-position", ...args: any[]): void
    connect(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::homogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::homogeneous", ...args: any[]): void
    connect(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::spacing", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutsSection` collects all the keyboard shortcuts and gestures
   * for a major application mode.
   *
   * If your application needs multiple sections, you should give each
   * section a unique [property`Gtk`.ShortcutsSection:section-name] and
   * a [property`Gtk`.ShortcutsSection:title] that can be shown in the
   * section selector of the [class`Gtk`.ShortcutsWindow].
   *
   * The [property`Gtk`.ShortcutsSection:max-height] property can be used
   * to influence how the groups in the section are distributed over pages
   * and columns.
   *
   * This widget is only meant to be used with [class`Gtk`.ShortcutsWindow].
   *
   * The recommended way to construct a `GtkShortcutsSection` is with
   * [class`Gtk`.Builder], by using the `<child>` tag to populate a
   * `GtkShortcutsSection` with one or more [class`Gtk`.ShortcutsGroup]
   * instances, which in turn contain one or more [class`Gtk`.ShortcutsShortcut]
   * objects.
   *
   * If you need to add a group programmatically, use
   * [method`Gtk`.ShortcutsSection.add_group].
   * @class
   */
  class ShortcutsSection extends Box {
    // Own properties of Gtk-4.0.Gtk.ShortcutsSection

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutsSection

    constructor(config?: ShortcutsSection.ConstructorProperties)
    _init(config?: ShortcutsSection.ConstructorProperties): void
  }

  module ShortcutsShortcut {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ShortcutsShortcut

      /**
       * The size group for the accelerator portion of this shortcut.
       *
       * This is used internally by GTK, and must not be modified by applications.
       */
      accel_size_group?: SizeGroup | null
      /**
       * The accelerator(s) represented by this object.
       *
       * This property is used if [property`Gtk`.ShortcutsShortcut:shortcut-type]
       * is set to %GTK_SHORTCUT_ACCELERATOR.
       *
       * The syntax of this property is (an extension of) the syntax understood
       * by [func`Gtk`.accelerator_parse]. Multiple accelerators can be specified
       * by separating them with a space, but keep in mind that the available width
       * is limited.
       *
       * It is also possible to specify ranges of shortcuts, using `...` between
       * the keys. Sequences of keys can be specified using a `+` or `&` between
       * the keys.
       *
       * Examples:
       *
       * - A single shortcut: `<ctl><alt>delete`
       * - Two alternative shortcuts: `<shift>a Home`
       * - A range of shortcuts: `<alt>1...<alt>9`
       * - Several keys pressed together: `Control_L&Control_R`
       * - A sequence of shortcuts or keys: `<ctl>c+<ctl>x`
       *
       * Use "+" instead of "&" when the keys may (or have to be) pressed
       * sequentially (e.g use "t+t" for 'press the t key twice').
       *
       * Note that `<`, `>` and `&` need to be escaped as `&lt;`, `&gt`; and `&amp`; when used
       * in .ui files.
       */
      accelerator?: string | null
      /**
       * A detailed action name.
       *
       * If this is set for a shortcut of type %GTK_SHORTCUT_ACCELERATOR,
       * then GTK will use the accelerators that are associated with the
       * action via [method`Gtk`.Application.set_accels_for_action], and
       * setting [property`Gtk`.ShortcutsShortcut:accelerator] is not necessary.
       */
      action_name?: string | null
      /**
       * The text direction for which this shortcut is active.
       *
       * If the shortcut is used regardless of the text direction,
       * set this property to %GTK_TEXT_DIR_NONE.
       */
      direction?: TextDirection | null
      /**
       * An icon to represent the shortcut or gesture.
       *
       * This property is used if [property`Gtk`.ShortcutsShortcut:shortcut-type]
       * is set to %GTK_SHORTCUT_GESTURE.
       *
       * For the other predefined gesture types, GTK provides an icon on its own.
       */
      icon?: Gio.Icon | null
      /**
       * %TRUE if an icon has been set.
       */
      icon_set?: boolean | null
      /**
       * The type of shortcut that is represented.
       */
      shortcut_type?: ShortcutType | null
      /**
       * The subtitle for the shortcut or gesture.
       *
       * This is typically used for gestures and should be a short, one-line
       * text that describes the gesture itself. For the predefined gesture
       * types, GTK provides a subtitle on its own.
       */
      subtitle?: string | null
      /**
       * %TRUE if a subtitle has been set.
       */
      subtitle_set?: boolean | null
      /**
       * The textual description for the shortcut or gesture represented by
       * this object.
       *
       * This should be a short string that can fit in a single line.
       */
      title?: string | null
      /**
       * The size group for the textual portion of this shortcut.
       *
       * This is used internally by GTK, and must not be modified by applications.
       */
      title_size_group?: SizeGroup | null
    }
  }

  interface ShortcutsShortcut extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ShortcutsShortcut

    /**
     * The size group for the accelerator portion of this shortcut.
     *
     * This is used internally by GTK, and must not be modified by applications.
     */
    accelSizeGroup: SizeGroup
    /**
     * The accelerator(s) represented by this object.
     *
     * This property is used if [property`Gtk`.ShortcutsShortcut:shortcut-type]
     * is set to %GTK_SHORTCUT_ACCELERATOR.
     *
     * The syntax of this property is (an extension of) the syntax understood
     * by [func`Gtk`.accelerator_parse]. Multiple accelerators can be specified
     * by separating them with a space, but keep in mind that the available width
     * is limited.
     *
     * It is also possible to specify ranges of shortcuts, using `...` between
     * the keys. Sequences of keys can be specified using a `+` or `&` between
     * the keys.
     *
     * Examples:
     *
     * - A single shortcut: `<ctl><alt>delete`
     * - Two alternative shortcuts: `<shift>a Home`
     * - A range of shortcuts: `<alt>1...<alt>9`
     * - Several keys pressed together: `Control_L&Control_R`
     * - A sequence of shortcuts or keys: `<ctl>c+<ctl>x`
     *
     * Use "+" instead of "&" when the keys may (or have to be) pressed
     * sequentially (e.g use "t+t" for 'press the t key twice').
     *
     * Note that `<`, `>` and `&` need to be escaped as `&lt;`, `&gt`; and `&amp`; when used
     * in .ui files.
     */
    accelerator: string | null
    /**
     * A detailed action name.
     *
     * If this is set for a shortcut of type %GTK_SHORTCUT_ACCELERATOR,
     * then GTK will use the accelerators that are associated with the
     * action via [method`Gtk`.Application.set_accels_for_action], and
     * setting [property`Gtk`.ShortcutsShortcut:accelerator] is not necessary.
     */
    actionName: string | null
    /**
     * The text direction for which this shortcut is active.
     *
     * If the shortcut is used regardless of the text direction,
     * set this property to %GTK_TEXT_DIR_NONE.
     */
    direction: TextDirection
    /**
     * An icon to represent the shortcut or gesture.
     *
     * This property is used if [property`Gtk`.ShortcutsShortcut:shortcut-type]
     * is set to %GTK_SHORTCUT_GESTURE.
     *
     * For the other predefined gesture types, GTK provides an icon on its own.
     */
    icon: Gio.Icon
    /**
     * %TRUE if an icon has been set.
     */
    iconSet: boolean
    /**
     * The type of shortcut that is represented.
     */
    shortcutType: ShortcutType
    /**
     * The subtitle for the shortcut or gesture.
     *
     * This is typically used for gestures and should be a short, one-line
     * text that describes the gesture itself. For the predefined gesture
     * types, GTK provides a subtitle on its own.
     */
    subtitle: string | null
    /**
     * %TRUE if a subtitle has been set.
     */
    subtitleSet: boolean
    /**
     * The textual description for the shortcut or gesture represented by
     * this object.
     *
     * This should be a short string that can fit in a single line.
     */
    title: string | null
    /**
     * The size group for the textual portion of this shortcut.
     *
     * This is used internally by GTK, and must not be modified by applications.
     */
    titleSizeGroup: SizeGroup
    __gtype__: number

    // Class property signals of Gtk-4.0.Gtk.ShortcutsShortcut

    connect(
      sigName: "notify::accel-size-group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accel-size-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accel-size-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accel-size-group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accel-size-group", ...args: any[]): void
    connect(
      sigName: "notify::accelerator",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accelerator",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accelerator",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accelerator",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accelerator", ...args: any[]): void
    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::direction", ...args: any[]): void
    connect(sigName: "notify::icon", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon", ...args: any[]): void
    connect(
      sigName: "notify::icon-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-set", ...args: any[]): void
    connect(
      sigName: "notify::shortcut-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::shortcut-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::shortcut-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::shortcut-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::shortcut-type", ...args: any[]): void
    connect(
      sigName: "notify::subtitle",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::subtitle",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::subtitle",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::subtitle",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::subtitle", ...args: any[]): void
    connect(
      sigName: "notify::subtitle-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::subtitle-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::subtitle-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::subtitle-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::subtitle-set", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::title-size-group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title-size-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title-size-group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title-size-group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title-size-group", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutsShortcut` represents a single keyboard shortcut or gesture
   * with a short text.
   *
   * This widget is only meant to be used with `GtkShortcutsWindow`.
   * @class
   */
  class ShortcutsShortcut extends Widget {
    // Own properties of Gtk-4.0.Gtk.ShortcutsShortcut

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutsShortcut

    constructor(config?: ShortcutsShortcut.ConstructorProperties)
    _init(config?: ShortcutsShortcut.ConstructorProperties): void
  }

  module ShortcutsWindow {
    // Signal callback interfaces

    /**
     * Signal callback interface for `close`
     */
    interface CloseSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `search`
     */
    interface SearchSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Window.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ShortcutsWindow

      /**
       * The name of the section to show.
       *
       * This should be the section-name of one of the `GtkShortcutsSection`
       * objects that are in this shortcuts window.
       */
      section_name?: string | null
      /**
       * The view name by which to filter the contents.
       *
       * This should correspond to the [property`Gtk`.ShortcutsGroup:view]
       * property of some of the [class`Gtk`.ShortcutsGroup] objects that
       * are inside this shortcuts window.
       *
       * Set this to %NULL to show all groups.
       */
      view_name?: string | null
    }
  }

  interface ShortcutsWindow
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.ShortcutsWindow

    /**
     * The name of the section to show.
     *
     * This should be the section-name of one of the `GtkShortcutsSection`
     * objects that are in this shortcuts window.
     */
    sectionName: string | null
    /**
     * The view name by which to filter the contents.
     *
     * This should correspond to the [property`Gtk`.ShortcutsGroup:view]
     * property of some of the [class`Gtk`.ShortcutsGroup] objects that
     * are inside this shortcuts window.
     *
     * Set this to %NULL to show all groups.
     */
    viewName: string | null
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.ShortcutsWindow

    /**
     * Adds a section to the shortcuts window.
     *
     * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
     * `<child>` tag to add the child.
     *
     * Using [method`Gtk`.Window.set_child] is not appropriate as the shortcuts
     * window manages its children internally.
     * @param section the `GtkShortcutsSection` to add
     */
    addSection(section: ShortcutsSection): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Own signals of Gtk-4.0.Gtk.ShortcutsWindow

    connect(
      sigName: "close",
      callback: ShortcutsWindow.CloseSignalCallback
    ): number
    on(
      sigName: "close",
      callback: ShortcutsWindow.CloseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "close",
      callback: ShortcutsWindow.CloseSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "close",
      callback: ShortcutsWindow.CloseSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "close", ...args: any[]): void
    connect(
      sigName: "search",
      callback: ShortcutsWindow.SearchSignalCallback
    ): number
    on(
      sigName: "search",
      callback: ShortcutsWindow.SearchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "search",
      callback: ShortcutsWindow.SearchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "search",
      callback: ShortcutsWindow.SearchSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "search", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ShortcutsWindow

    connect(
      sigName: "notify::section-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::section-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::section-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::section-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::section-name", ...args: any[]): void
    connect(
      sigName: "notify::view-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::view-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::view-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::view-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::view-name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcutsWindow` shows information about the keyboard shortcuts
   * and gestures of an application.
   *
   * The shortcuts can be grouped, and you can have multiple sections in this
   * window, corresponding to the major modes of your application.
   *
   * Additionally, the shortcuts can be filtered by the current view, to avoid
   * showing information that is not relevant in the current application context.
   *
   * The recommended way to construct a `GtkShortcutsWindow` is with
   * [class`Gtk`.Builder], by using the `<child>` tag to populate a
   * `GtkShortcutsWindow` with one or more [class`Gtk`.ShortcutsSection] objects,
   * which contain one or more [class`Gtk`.ShortcutsGroup] instances, which, in turn,
   * contain [class`Gtk`.ShortcutsShortcut] instances.
   *
   * If you need to add a section programmatically, use [method`Gtk`.ShortcutsWindow.add_section]
   * instead of [method`Gtk`.Window.set_child], as the shortcuts window manages
   * its children directly.
   *
   * # A simple example:
   *
   * ![](gedit-shortcuts.png)
   *
   * This example has as single section. As you can see, the shortcut groups
   * are arranged in columns, and spread across several pages if there are too
   * many to find on a single page.
   *
   * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-gedit.ui).
   *
   * # An example with multiple views:
   *
   * ![](clocks-shortcuts.png)
   *
   * This example shows a `GtkShortcutsWindow` that has been configured to show only
   * the shortcuts relevant to the "stopwatch" view.
   *
   * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-clocks.ui).
   *
   * # An example with multiple sections:
   *
   * ![](builder-shortcuts.png)
   *
   * This example shows a `GtkShortcutsWindow` with two sections, "Editor Shortcuts"
   * and "Terminal Shortcuts".
   *
   * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-builder.ui).
   *
   * ## CSS nodes
   *
   * `GtkShortcutsWindow` has a single CSS node with the name `window` and style
   * class `.shortcuts`.
   * @class
   */
  class ShortcutsWindow extends Window {
    // Own properties of Gtk-4.0.Gtk.ShortcutsWindow

    static name: string

    // Constructors of Gtk-4.0.Gtk.ShortcutsWindow

    constructor(config?: ShortcutsWindow.ConstructorProperties)
    _init(config?: ShortcutsWindow.ConstructorProperties): void
  }

  module SignalAction {
    // Constructor properties interface

    interface ConstructorProperties
      extends ShortcutAction.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SignalAction

      /**
       * The name of the signal to emit.
       */
      signal_name?: string | null
    }
  }

  interface SignalAction {
    // Own properties of Gtk-4.0.Gtk.SignalAction

    /**
     * The name of the signal to emit.
     */
    readonly signalName: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SignalAction

    /**
     * Returns the name of the signal that will be emitted.
     * @returns the name of the signal to emit
     */
    getSignalName(): string

    // Class property signals of Gtk-4.0.Gtk.SignalAction

    connect(
      sigName: "notify::signal-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::signal-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::signal-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::signal-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::signal-name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkShortcut`Action that emits a signal.
   *
   * Signals that are used in this way are referred to as keybinding signals,
   * and they are expected to be defined with the %G_SIGNAL_ACTION flag.
   * @class
   */
  class SignalAction extends ShortcutAction {
    // Own properties of Gtk-4.0.Gtk.SignalAction

    static name: string

    // Constructors of Gtk-4.0.Gtk.SignalAction

    constructor(config?: SignalAction.ConstructorProperties)
    /**
     * Creates an action that when activated, emits the given action signal
     * on the provided widget.
     *
     * It will also unpack the args into arguments passed to the signal.
     * @constructor
     * @param signalName name of the signal to emit
     * @returns a new `GtkShortcutAction`
     */
    constructor(signalName: string)
    /**
     * Creates an action that when activated, emits the given action signal
     * on the provided widget.
     *
     * It will also unpack the args into arguments passed to the signal.
     * @constructor
     * @param signalName name of the signal to emit
     * @returns a new `GtkShortcutAction`
     */
    static new(signalName: string): SignalAction
    _init(config?: SignalAction.ConstructorProperties): void
  }

  module SignalListItemFactory {
    // Signal callback interfaces

    /**
     * Signal callback interface for `bind`
     */
    interface BindSignalCallback {
      (object: GObject.Object): void
    }

    /**
     * Signal callback interface for `setup`
     */
    interface SetupSignalCallback {
      (object: GObject.Object): void
    }

    /**
     * Signal callback interface for `teardown`
     */
    interface TeardownSignalCallback {
      (object: GObject.Object): void
    }

    /**
     * Signal callback interface for `unbind`
     */
    interface UnbindSignalCallback {
      (object: GObject.Object): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends ListItemFactory.ConstructorProperties {}
  }

  interface SignalListItemFactory {
    // Own properties of Gtk-4.0.Gtk.SignalListItemFactory

    __gtype__: number

    // Own signals of Gtk-4.0.Gtk.SignalListItemFactory

    connect(
      sigName: "bind",
      callback: SignalListItemFactory.BindSignalCallback
    ): number
    on(
      sigName: "bind",
      callback: SignalListItemFactory.BindSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "bind",
      callback: SignalListItemFactory.BindSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "bind",
      callback: SignalListItemFactory.BindSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "bind", ...args: any[]): void
    connect(
      sigName: "setup",
      callback: SignalListItemFactory.SetupSignalCallback
    ): number
    on(
      sigName: "setup",
      callback: SignalListItemFactory.SetupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "setup",
      callback: SignalListItemFactory.SetupSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "setup",
      callback: SignalListItemFactory.SetupSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "setup", ...args: any[]): void
    connect(
      sigName: "teardown",
      callback: SignalListItemFactory.TeardownSignalCallback
    ): number
    on(
      sigName: "teardown",
      callback: SignalListItemFactory.TeardownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "teardown",
      callback: SignalListItemFactory.TeardownSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "teardown",
      callback: SignalListItemFactory.TeardownSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "teardown", ...args: any[]): void
    connect(
      sigName: "unbind",
      callback: SignalListItemFactory.UnbindSignalCallback
    ): number
    on(
      sigName: "unbind",
      callback: SignalListItemFactory.UnbindSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unbind",
      callback: SignalListItemFactory.UnbindSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unbind",
      callback: SignalListItemFactory.UnbindSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unbind", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.SignalListItemFactory

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSignalListItemFactory` is a `GtkListItemFactory` that emits signals
   * to manage listitems.
   *
   * Signals are emitted for every listitem in the same order:
   *
   *  1. [signal`Gtk`.SignalListItemFactory::setup] is emitted to set up permanent
   *  things on the listitem. This usually means constructing the widgets used in
   *  the row and adding them to the listitem.
   *
   *  2. [signal`Gtk`.SignalListItemFactory::bind] is emitted to bind the item passed
   *  via [property`Gtk`.ListItem:item] to the widgets that have been created in
   *  step 1 or to add item-specific widgets. Signals are connected to listen to
   *  changes - both to changes in the item to update the widgets or to changes
   *  in the widgets to update the item. After this signal has been called, the
   *  listitem may be shown in a list widget.
   *
   *  3. [signal`Gtk`.SignalListItemFactory::unbind] is emitted to undo everything
   *  done in step 2. Usually this means disconnecting signal handlers. Once this
   *  signal has been called, the listitem will no longer be used in a list
   *  widget.
   *
   *  4. [signal`Gtk`.SignalListItemFactory::bind] and
   *  [signal`Gtk`.SignalListItemFactory::unbind] may be emitted multiple times
   *  again to bind the listitem for use with new items. By reusing listitems,
   *  potentially costly setup can be avoided. However, it means code needs to
   *  make sure to properly clean up the listitem in step 3 so that no information
   *  from the previous use leaks into the next use.
   *
   * 5. [signal`Gtk`.SignalListItemFactory::teardown] is emitted to allow undoing
   * the effects of [signal`Gtk`.SignalListItemFactory::setup]. After this signal
   * was emitted on a listitem, the listitem will be destroyed and not be used again.
   *
   * Note that during the signal emissions, changing properties on the
   * listitems passed will not trigger notify signals as the listitem's
   * notifications are frozen. See g_object_freeze_notify() for details.
   *
   * For tracking changes in other properties in the listitem, the
   * ::notify signal is recommended. The signal can be connected in the
   * [signal`Gtk`.SignalListItemFactory::setup] signal and removed again during
   * [signal`Gtk`.SignalListItemFactory::teardown].
   * @class
   */
  class SignalListItemFactory extends ListItemFactory {
    // Own properties of Gtk-4.0.Gtk.SignalListItemFactory

    static name: string

    // Constructors of Gtk-4.0.Gtk.SignalListItemFactory

    constructor(config?: SignalListItemFactory.ConstructorProperties)
    /**
     * Creates a new `GtkSignalListItemFactory`.
     *
     * You need to connect signal handlers before you use it.
     * @constructor
     * @returns a new `GtkSignalListItemFactory`
     */
    constructor()
    /**
     * Creates a new `GtkSignalListItemFactory`.
     *
     * You need to connect signal handlers before you use it.
     * @constructor
     * @returns a new `GtkSignalListItemFactory`
     */
    static new(): SignalListItemFactory
    _init(config?: SignalListItemFactory.ConstructorProperties): void
  }

  module SingleSelection {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        SectionModel.ConstructorProperties,
        SelectionModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SingleSelection

      /**
       * If the selection will always select an item.
       */
      autoselect?: boolean | null
      /**
       * If unselecting the selected item is allowed.
       */
      can_unselect?: boolean | null
      /**
       * The model being managed.
       */
      model?: Gio.ListModel | null
      /**
       * Position of the selected item.
       */
      selected?: number | null
    }
  }

  interface SingleSelection
    extends Gio.ListModel,
      SectionModel,
      SelectionModel {
    // Own properties of Gtk-4.0.Gtk.SingleSelection

    /**
     * If the selection will always select an item.
     */
    autoselect: boolean
    /**
     * If unselecting the selected item is allowed.
     */
    canUnselect: boolean
    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The model being managed.
     */
    model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    /**
     * Position of the selected item.
     */
    selected: number
    /**
     * The selected item.
     */
    readonly selectedItem: GObject.Object
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SingleSelection

    /**
     * Checks if autoselect has been enabled or disabled via
     * gtk_single_selection_set_autoselect().
     * @returns %TRUE if autoselect is enabled
     */
    getAutoselect(): boolean
    /**
     * If %TRUE, gtk_selection_model_unselect_item() is supported and allows
     * unselecting the selected item.
     * @returns %TRUE to support unselecting
     */
    getCanUnselect(): boolean
    /**
     * Gets the model that `self` is wrapping.
     * @returns The model being wrapped
     */
    getModel(): Gio.ListModel | null
    /**
     * Gets the position of the selected item.
     *
     * If no item is selected, %GTK_INVALID_LIST_POSITION is returned.
     * @returns The position of the selected item
     */
    getSelected(): number
    /**
     * Gets the selected item.
     *
     * If no item is selected, %NULL is returned.
     * @returns The selected item
     */
    getSelectedItem(): GObject.Object | null
    /**
     * Enables or disables autoselect.
     *
     * If `autoselect` is %TRUE, `self` will enforce that an item is always
     * selected. It will select a new item when the currently selected
     * item is deleted and it will disallow unselecting the current item.
     * @param autoselect %TRUE to always select an item
     */
    setAutoselect(autoselect: boolean): void
    /**
     * If %TRUE, unselecting the current item via
     * gtk_selection_model_unselect_item() is supported.
     *
     * Note that setting [property`Gtk`.SingleSelection:autoselect] will
     * cause unselecting to not work, so it practically makes no sense
     * to set both at the same time the same time.
     * @param canUnselect %TRUE to allow unselecting
     */
    setCanUnselect(canUnselect: boolean): void
    /**
     * Sets the model that `self` should wrap.
     *
     * If `model` is %NULL, `self` will be empty.
     * @param model A `GListModel` to wrap
     */
    setModel(model: Gio.ListModel | null): void
    /**
     * Selects the item at the given position.
     *
     * If the list does not have an item at `position` or
     * %GTK_INVALID_LIST_POSITION is given, the behavior depends on the
     * value of the [property`Gtk`.SingleSelection:autoselect] property:
     * If it is set, no change will occur and the old item will stay
     * selected. If it is unset, the selection will be unset and no item
     * will be selected.
     * @param position the item to select or %GTK_INVALID_LIST_POSITION
     */
    setSelected(position: number): void

    // Class property signals of Gtk-4.0.Gtk.SingleSelection

    connect(
      sigName: "notify::autoselect",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::autoselect",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::autoselect",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::autoselect",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::autoselect", ...args: any[]): void
    connect(
      sigName: "notify::can-unselect",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-unselect",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-unselect",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-unselect",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-unselect", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected", ...args: any[]): void
    connect(
      sigName: "notify::selected-item",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selected-item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selected-item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selected-item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selected-item", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSingleSelection` is a `GtkSelectionModel` that allows selecting a single
   * item.
   *
   * Note that the selection is *persistent* -- if the selected item is removed
   * and re-added in the same [signal`Gio`.ListModel::items-changed] emission, it
   * stays selected. In particular, this means that changing the sort order of an
   * underlying sort model will preserve the selection.
   * @class
   */
  class SingleSelection extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.SingleSelection

    static name: string

    // Constructors of Gtk-4.0.Gtk.SingleSelection

    constructor(config?: SingleSelection.ConstructorProperties)
    /**
     * Creates a new selection to handle `model`.
     * @constructor
     * @param model the `GListModel` to manage
     * @returns a new `GtkSingleSelection`
     */
    constructor(model: Gio.ListModel | null)
    /**
     * Creates a new selection to handle `model`.
     * @constructor
     * @param model the `GListModel` to manage
     * @returns a new `GtkSingleSelection`
     */
    static new(model: Gio.ListModel | null): SingleSelection
    _init(config?: SingleSelection.ConstructorProperties): void
  }

  module SizeGroup {
    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SizeGroup

      /**
       * The direction in which the size group affects requested sizes.
       */
      mode?: SizeGroupMode | null
    }
  }

  interface SizeGroup extends Buildable {
    // Own properties of Gtk-4.0.Gtk.SizeGroup

    /**
     * The direction in which the size group affects requested sizes.
     */
    mode: SizeGroupMode
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.SizeGroup

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.SizeGroup

    /**
     * Adds a widget to a `GtkSizeGroup`.
     *
     * In the future, the requisition
     * of the widget will be determined as the maximum of its requisition
     * and the requisition of the other widgets in the size group.
     * Whether this applies horizontally, vertically, or in both directions
     * depends on the mode of the size group.
     * See [method`Gtk`.SizeGroup.set_mode].
     *
     * When the widget is destroyed or no longer referenced elsewhere, it
     * will be removed from the size group.
     * @param widget the `GtkWidget` to add
     */
    addWidget(widget: Widget): void
    /**
     * Gets the current mode of the size group.
     * @returns the current mode of the size group.
     */
    getMode(): SizeGroupMode
    /**
     * Returns the list of widgets associated with `size_group`.
     * @returns a `GSList` of   widgets. The list is owned by GTK and should not be modified.
     */
    getWidgets(): Widget[]
    /**
     * Removes a widget from a `GtkSizeGroup`.
     * @param widget the `GtkWidget` to remove
     */
    removeWidget(widget: Widget): void
    /**
     * Sets the `GtkSizeGroupMode` of the size group.
     *
     * The mode of the size group determines whether the widgets in the
     * size group should all have the same horizontal requisition
     * (%GTK_SIZE_GROUP_HORIZONTAL) all have the same vertical requisition
     * (%GTK_SIZE_GROUP_VERTICAL), or should all have the same requisition
     * in both directions (%GTK_SIZE_GROUP_BOTH).
     * @param mode the mode to set for the size group.
     */
    setMode(mode: SizeGroupMode): void

    // Class property signals of Gtk-4.0.Gtk.SizeGroup

    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSizeGroup` groups widgets together so they all request the same size.
   *
   * This is typically useful when you want a column of widgets to have the
   * same size, but you can’t use a `GtkGrid`.
   *
   * In detail, the size requested for each widget in a `GtkSizeGroup` is
   * the maximum of the sizes that would have been requested for each
   * widget in the size group if they were not in the size group. The mode
   * of the size group (see [method`Gtk`.SizeGroup.set_mode]) determines whether
   * this applies to the horizontal size, the vertical size, or both sizes.
   *
   * Note that size groups only affect the amount of space requested, not
   * the size that the widgets finally receive. If you want the widgets in
   * a `GtkSizeGroup` to actually be the same size, you need to pack them in
   * such a way that they get the size they request and not more.
   *
   * `GtkSizeGroup` objects are referenced by each widget in the size group,
   * so once you have added all widgets to a `GtkSizeGroup`, you can drop
   * the initial reference to the size group with g_object_unref(). If the
   * widgets in the size group are subsequently destroyed, then they will
   * be removed from the size group and drop their references on the size
   * group; when all widgets have been removed, the size group will be
   * freed.
   *
   * Widgets can be part of multiple size groups; GTK will compute the
   * horizontal size of a widget from the horizontal requisition of all
   * widgets that can be reached from the widget by a chain of size groups
   * of type %GTK_SIZE_GROUP_HORIZONTAL or %GTK_SIZE_GROUP_BOTH, and the
   * vertical size from the vertical requisition of all widgets that can be
   * reached from the widget by a chain of size groups of type
   * %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH.
   *
   * Note that only non-contextual sizes of every widget are ever consulted
   * by size groups (since size groups have no knowledge of what size a widget
   * will be allocated in one dimension, it cannot derive how much height
   * a widget will receive for a given width). When grouping widgets that
   * trade height for width in mode %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH:
   * the height for the minimum width will be the requested height for all
   * widgets in the group. The same is of course true when horizontally grouping
   * width for height widgets.
   *
   * Widgets that trade height-for-width should set a reasonably large minimum
   * width by way of [property`Gtk`.Label:width-chars] for instance. Widgets with
   * static sizes as well as widgets that grow (such as ellipsizing text) need no
   * such considerations.
   *
   * # GtkSizeGroup as GtkBuildable
   *
   * Size groups can be specified in a UI definition by placing an `<object>`
   * element with `class="GtkSizeGroup"` somewhere in the UI definition. The
   * widgets that belong to the size group are specified by a `<widgets>` element
   * that may contain multiple `<widget>` elements, one for each member of the
   * size group. The ”name” attribute gives the id of the widget.
   *
   * An example of a UI definition fragment with `GtkSizeGroup`:
   * ```xml
   * <object class="GtkSizeGroup">
   *   <property name="mode">horizontal</property>
   *   <widgets>
   *     <widget name="radio1"/>
   *     <widget name="radio2"/>
   *   </widgets>
   * </object>
   * ```
   * @class
   */
  class SizeGroup extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.SizeGroup

    static name: string

    // Constructors of Gtk-4.0.Gtk.SizeGroup

    constructor(config?: SizeGroup.ConstructorProperties)
    /**
     * Create a new `GtkSizeGroup`.
     * @constructor
     * @param mode the mode for the new size group.
     * @returns a newly created `GtkSizeGroup`
     */
    constructor(mode: SizeGroupMode)
    /**
     * Create a new `GtkSizeGroup`.
     * @constructor
     * @param mode the mode for the new size group.
     * @returns a newly created `GtkSizeGroup`
     */
    static new(mode: SizeGroupMode): SizeGroup
    _init(config?: SizeGroup.ConstructorProperties): void
  }

  module SliceListModel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        SectionModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SliceListModel

      /**
       * Child model to take slice from.
       */
      model?: Gio.ListModel | null
      /**
       * Offset of slice.
       */
      offset?: number | null
      /**
       * Maximum size of slice.
       */
      size?: number | null
    }
  }

  interface SliceListModel extends Gio.ListModel, SectionModel {
    // Own properties of Gtk-4.0.Gtk.SliceListModel

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * Child model to take slice from.
     */
    model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    /**
     * Offset of slice.
     */
    offset: number
    /**
     * Maximum size of slice.
     */
    size: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SliceListModel

    /**
     * Gets the model that is currently being used or %NULL if none.
     * @returns The model in use
     */
    getModel(): Gio.ListModel | null
    /**
     * Gets the offset set via gtk_slice_list_model_set_offset().
     * @returns The offset
     */
    getOffset(): number
    /**
     * Gets the size set via gtk_slice_list_model_set_size().
     * @returns The size
     */
    getSize(): number
    /**
     * Sets the model to show a slice of.
     *
     * The model's item type must conform to `self'`s item type.
     * @param model The model to be sliced
     */
    setModel(model: Gio.ListModel | null): void
    /**
     * Sets the offset into the original model for this slice.
     *
     * If the offset is too large for the sliced model,
     * `self` will end up empty.
     * @param offset the new offset to use
     */
    setOffset(offset: number): void
    /**
     * Sets the maximum size. `self` will never have more items
     * than `size`.
     *
     * It can however have fewer items if the offset is too large
     * or the model sliced from doesn't have enough items.
     * @param size the maximum size
     */
    setSize(size: number): void

    // Class property signals of Gtk-4.0.Gtk.SliceListModel

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::offset",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::offset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::offset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::offset",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::offset", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSliceListModel` is a list model that presents a slice of another model.
   *
   * This is useful when implementing paging by setting the size to the number
   * of elements per page and updating the offset whenever a different page is
   * opened.
   *
   * `GtkSliceListModel` passes through sections from the underlying model.
   * @class
   */
  class SliceListModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.SliceListModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.SliceListModel

    constructor(config?: SliceListModel.ConstructorProperties)
    /**
     * Creates a new slice model.
     *
     * It presents the slice from `offset` to offset + `size`
     * of the given `model`.
     * @constructor
     * @param model The model to use
     * @param offset the offset of the slice
     * @param size maximum size of the slice
     * @returns A new `GtkSliceListModel`
     */
    constructor(model: Gio.ListModel | null, offset: number, size: number)
    /**
     * Creates a new slice model.
     *
     * It presents the slice from `offset` to offset + `size`
     * of the given `model`.
     * @constructor
     * @param model The model to use
     * @param offset the offset of the slice
     * @param size maximum size of the slice
     * @returns A new `GtkSliceListModel`
     */
    static new(
      model: Gio.ListModel | null,
      offset: number,
      size: number
    ): SliceListModel
    _init(config?: SliceListModel.ConstructorProperties): void
  }

  module Snapshot {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gdk.Snapshot.ConstructorProperties {}
  }

  interface Snapshot {
    // Own properties of Gtk-4.0.Gtk.Snapshot

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Snapshot

    /**
     * Appends a stroked border rectangle inside the given `outline`.
     *
     * The four sides of the border can have different widths and colors.
     * @param outline the outline of the border
     * @param borderWidth the stroke width of the border on   the top, right, bottom and left side respectively.
     * @param borderColor the color used on the top, right,   bottom and left side.
     */
    appendBorder(
      outline: Gsk.RoundedRect,
      borderWidth: number[],
      borderColor: Gdk.RGBA[]
    ): void
    /**
     * Creates a new [class`Gsk`.CairoNode] and appends it to the current
     * render node of `snapshot,` without changing the current node.
     * @param bounds the bounds for the new node
     * @returns a `cairo_t` suitable for drawing the contents of   the newly created render node
     */
    appendCairo(bounds: Graphene.Rect): cairo.Context
    /**
     * Creates a new render node drawing the `color` into the
     * given `bounds` and appends it to the current render node
     * of `snapshot`.
     *
     * You should try to avoid calling this function if
     * `color` is transparent.
     * @param color the color to draw
     * @param bounds the bounds for the new node
     */
    appendColor(color: Gdk.RGBA, bounds: Graphene.Rect): void
    /**
     * Appends a conic gradient node with the given stops to `snapshot`.
     * @param bounds the rectangle to render the gradient into
     * @param center the center point of the conic gradient
     * @param rotation the clockwise rotation in degrees of the starting angle.   0 means the starting angle is the top.
     * @param stops the color stops defining the gradient
     */
    appendConicGradient(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      rotation: number,
      stops: Gsk.ColorStop[]
    ): void
    /**
     * A convenience method to fill a path with a color.
     *
     * See [method`Gtk`.Snapshot.push_fill] if you need
     * to fill a path with more complex content than
     * a color.
     * @param path The path describing the area to fill
     * @param fillRule The fill rule to use
     * @param color the color to fill the path with
     */
    appendFill(path: Gsk.Path, fillRule: Gsk.FillRule, color: Gdk.RGBA): void
    /**
     * Appends an inset shadow into the box given by `outline`.
     * @param outline outline of the region surrounded by shadow
     * @param color color of the shadow
     * @param dx horizontal offset of shadow
     * @param dy vertical offset of shadow
     * @param spread how far the shadow spreads towards the inside
     * @param blurRadius how much blur to apply to the shadow
     */
    appendInsetShadow(
      outline: Gsk.RoundedRect,
      color: Gdk.RGBA,
      dx: number,
      dy: number,
      spread: number,
      blurRadius: number
    ): void
    appendLayout(layout: Pango.Layout, color: Gdk.RGBA): void
    /**
     * Appends a linear gradient node with the given stops to `snapshot`.
     * @param bounds the rectangle to render the linear gradient into
     * @param startPoint the point at which the linear gradient will begin
     * @param endPoint the point at which the linear gradient will finish
     * @param stops the color stops defining the gradient
     */
    appendLinearGradient(
      bounds: Graphene.Rect,
      startPoint: Graphene.Point,
      endPoint: Graphene.Point,
      stops: Gsk.ColorStop[]
    ): void
    /**
     * Appends `node` to the current render node of `snapshot,`
     * without changing the current node.
     *
     * If `snapshot` does not have a current node yet, `node`
     * will become the initial node.
     * @param node a `GskRenderNode`
     */
    appendNode(node: Gsk.RenderNode): void
    /**
     * Appends an outset shadow node around the box given by `outline`.
     * @param outline outline of the region surrounded by shadow
     * @param color color of the shadow
     * @param dx horizontal offset of shadow
     * @param dy vertical offset of shadow
     * @param spread how far the shadow spreads towards the outside
     * @param blurRadius how much blur to apply to the shadow
     */
    appendOutsetShadow(
      outline: Gsk.RoundedRect,
      color: Gdk.RGBA,
      dx: number,
      dy: number,
      spread: number,
      blurRadius: number
    ): void
    /**
     * Appends a radial gradient node with the given stops to `snapshot`.
     * @param bounds the rectangle to render the readial gradient into
     * @param center the center point for the radial gradient
     * @param hradius the horizontal radius
     * @param vradius the vertical radius
     * @param start the start position (on the horizontal axis)
     * @param end the end position (on the horizontal axis)
     * @param stops the color stops defining the gradient
     */
    appendRadialGradient(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      hradius: number,
      vradius: number,
      start: number,
      end: number,
      stops: Gsk.ColorStop[]
    ): void
    /**
     * Appends a repeating linear gradient node with the given stops to `snapshot`.
     * @param bounds the rectangle to render the linear gradient into
     * @param startPoint the point at which the linear gradient will begin
     * @param endPoint the point at which the linear gradient will finish
     * @param stops the color stops defining the gradient
     */
    appendRepeatingLinearGradient(
      bounds: Graphene.Rect,
      startPoint: Graphene.Point,
      endPoint: Graphene.Point,
      stops: Gsk.ColorStop[]
    ): void
    /**
     * Appends a repeating radial gradient node with the given stops to `snapshot`.
     * @param bounds the rectangle to render the readial gradient into
     * @param center the center point for the radial gradient
     * @param hradius the horizontal radius
     * @param vradius the vertical radius
     * @param start the start position (on the horizontal axis)
     * @param end the end position (on the horizontal axis)
     * @param stops the color stops defining the gradient
     */
    appendRepeatingRadialGradient(
      bounds: Graphene.Rect,
      center: Graphene.Point,
      hradius: number,
      vradius: number,
      start: number,
      end: number,
      stops: Gsk.ColorStop[]
    ): void
    /**
     * Creates a new render node drawing the `texture`
     * into the given `bounds` and appends it to the
     * current render node of `snapshot`.
     *
     * In contrast to [method`Gtk`.Snapshot.append_texture],
     * this function provides control about how the filter
     * that is used when scaling.
     * @param texture the texture to render
     * @param filter the filter to use
     * @param bounds the bounds for the new node
     */
    appendScaledTexture(
      texture: Gdk.Texture,
      filter: Gsk.ScalingFilter,
      bounds: Graphene.Rect
    ): void
    /**
     * A convenience method to stroke a path with a color.
     *
     * See [method`Gtk`.Snapshot.push_stroke] if you need
     * to stroke a path with more complex content than
     * a color.
     * @param path The path describing the area to fill
     * @param stroke The stroke attributes
     * @param color the color to fill the path with
     */
    appendStroke(path: Gsk.Path, stroke: Gsk.Stroke, color: Gdk.RGBA): void
    /**
     * Creates a new render node drawing the `texture`
     * into the given `bounds` and appends it to the
     * current render node of `snapshot`.
     *
     * If the texture needs to be scaled to fill `bounds,`
     * linear filtering is used. See [method`Gtk`.Snapshot.append_scaled_texture]
     * if you need other filtering, such as nearest-neighbour.
     * @param texture the texture to render
     * @param bounds the bounds for the new node
     */
    appendTexture(texture: Gdk.Texture, bounds: Graphene.Rect): void
    /**
     * Removes the top element from the stack of render nodes and
     * adds it to the nearest [class`Gsk`.GLShaderNode] below it.
     *
     * This must be called the same number of times as the number
     * of textures is needed for the shader in
     * [method`Gtk`.Snapshot.push_gl_shader].
     */
    glShaderPopTexture(): void
    /**
     * Applies a perspective projection transform.
     *
     * See [method`Gsk`.Transform.perspective] for a discussion on the details.
     * @param depth distance of the z=0 plane
     */
    perspective(depth: number): void
    /**
     * Removes the top element from the stack of render nodes,
     * and appends it to the node underneath it.
     */
    pop(): void
    /**
     * Blends together two images with the given blend mode.
     *
     * Until the first call to [method`Gtk`.Snapshot.pop], the
     * bottom image for the blend operation will be recorded.
     * After that call, the top image to be blended will be
     * recorded until the second call to [method`Gtk`.Snapshot.pop].
     *
     * Calling this function requires two subsequent calls
     * to [method`Gtk`.Snapshot.pop].
     * @param blendMode blend mode to use
     */
    pushBlend(blendMode: Gsk.BlendMode): void
    /**
     * Blurs an image.
     *
     * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
     * @param radius the blur radius to use. Must be positive
     */
    pushBlur(radius: number): void
    /**
     * Clips an image to a rectangle.
     *
     * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
     * @param bounds the rectangle to clip to
     */
    pushClip(bounds: Graphene.Rect): void
    /**
     * Modifies the colors of an image by applying an affine transformation
     * in RGB space.
     *
     * In particular, the colors will be transformed by applying
     *
     *     pixel = transpose(color_matrix) * pixel + color_offset
     *
     * for every pixel. The transformation operates on unpremultiplied
     * colors, with color components ordered R, G, B, A.
     *
     * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
     * @param colorMatrix the color matrix to use
     * @param colorOffset the color offset to use
     */
    pushColorMatrix(
      colorMatrix: Graphene.Matrix,
      colorOffset: Graphene.Vec4
    ): void
    /**
     * Snapshots a cross-fade operation between two images with the
     * given `progress`.
     *
     * Until the first call to [method`Gtk`.Snapshot.pop], the start image
     * will be snapshot. After that call, the end image will be recorded
     * until the second call to [method`Gtk`.Snapshot.pop].
     *
     * Calling this function requires two subsequent calls
     * to [method`Gtk`.Snapshot.pop].
     * @param progress progress between 0.0 and 1.0
     */
    pushCrossFade(progress: number): void
    /**
     * Fills the area given by `path` and `fill_rule` with an image and discards everything
     * outside of it.
     *
     * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
     *
     * If you want to fill the path with a color, [method`Gtk`.Snapshot.append_fill]
     * may be more convenient.
     * @param path The path describing the area to fill
     * @param fillRule The fill rule to use
     */
    pushFill(path: Gsk.Path, fillRule: Gsk.FillRule): void
    /**
     * Push a [class`Gsk`.GLShaderNode].
     *
     * The node uses the given [class`Gsk`.GLShader] and uniform values
     * Additionally this takes a list of `n_children` other nodes
     * which will be passed to the [class`Gsk`.GLShaderNode].
     *
     * The `take_args` argument is a block of data to use for uniform
     * arguments, as per types and offsets defined by the `shader`.
     * Normally this is generated by [method`Gsk`.GLShader.format_args]
     * or [struct`Gsk`.ShaderArgsBuilder].
     *
     * The snapshotter takes ownership of `take_args,` so the caller should
     * not free it after this.
     *
     * If the renderer doesn't support GL shaders, or if there is any
     * problem when compiling the shader, then the node will draw pink.
     * You should use [method`Gsk`.GLShader.compile] to ensure the `shader`
     * will work for the renderer before using it.
     *
     * If the shader requires textures (see [method`Gsk`.GLShader.get_n_textures]),
     * then it is expected that you call [method`Gtk`.Snapshot.gl_shader_pop_texture]
     * the number of times that are required. Each of these calls will generate
     * a node that is added as a child to the `GskGLShaderNode`, which in turn
     * will render these offscreen and pass as a texture to the shader.
     *
     * Once all textures (if any) are pop:ed, you must call the regular
     * [method`Gtk`.Snapshot.pop].
     *
     * If you want to use pre-existing textures as input to the shader rather
     * than rendering new ones, use [method`Gtk`.Snapshot.append_texture] to
     * push a texture node. These will be used directly rather than being
     * re-rendered.
     *
     * For details on how to write shaders, see [class`Gsk`.GLShader].
     * @param shader The code to run
     * @param bounds the rectangle to render into
     * @param takeArgs Data block with arguments for the shader.
     */
    pushGlShader(
      shader: Gsk.GLShader,
      bounds: Graphene.Rect,
      takeArgs: any
    ): void
    /**
     * Until the first call to [method`Gtk`.Snapshot.pop], the
     * mask image for the mask operation will be recorded.
     *
     * After that call, the source image will be recorded until
     * the second call to [method`Gtk`.Snapshot.pop].
     *
     * Calling this function requires 2 subsequent calls to gtk_snapshot_pop().
     * @param maskMode mask mode to use
     */
    pushMask(maskMode: Gsk.MaskMode): void
    /**
     * Modifies the opacity of an image.
     *
     * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
     * @param opacity the opacity to use
     */
    pushOpacity(opacity: number): void
    /**
     * Creates a node that repeats the child node.
     *
     * The child is recorded until the next call to [method`Gtk`.Snapshot.pop].
     * @param bounds the bounds within which to repeat
     * @param childBounds the bounds of the child or %NULL   to use the full size of the collected child node
     */
    pushRepeat(bounds: Graphene.Rect, childBounds: Graphene.Rect | null): void
    /**
     * Clips an image to a rounded rectangle.
     *
     * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
     * @param bounds the rounded rectangle to clip to
     */
    pushRoundedClip(bounds: Gsk.RoundedRect): void
    /**
     * Applies a shadow to an image.
     *
     * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
     * @param shadow the first shadow specification
     */
    pushShadow(shadow: Gsk.Shadow[]): void
    /**
     * Strokes the given `path` with the attributes given by `stroke` and
     * an image.
     *
     * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
     *
     * Note that the strokes are subject to the same transformation as
     * everything else, so uneven scaling will cause horizontal and vertical
     * strokes to have different widths.
     *
     * If you want to stroke the path with a color, [method`Gtk`.Snapshot.append_stroke]
     * may be more convenient.
     * @param path The path to stroke
     * @param stroke The stroke attributes
     */
    pushStroke(path: Gsk.Path, stroke: Gsk.Stroke): void
    /**
     * Creates a render node for the CSS background according to `context,`
     * and appends it to the current node of `snapshot,` without changing
     * the current node.
     * @param context the style context that defines the background
     * @param x X origin of the rectangle
     * @param y Y origin of the rectangle
     * @param width rectangle width
     * @param height rectangle height
     */
    renderBackground(
      context: StyleContext,
      x: number,
      y: number,
      width: number,
      height: number
    ): void
    /**
     * Creates a render node for the focus outline according to `context,`
     * and appends it to the current node of `snapshot,` without changing
     * the current node.
     * @param context the style context that defines the focus ring
     * @param x X origin of the rectangle
     * @param y Y origin of the rectangle
     * @param width rectangle width
     * @param height rectangle height
     */
    renderFocus(
      context: StyleContext,
      x: number,
      y: number,
      width: number,
      height: number
    ): void
    /**
     * Creates a render node for the CSS border according to `context,`
     * and appends it to the current node of `snapshot,` without changing
     * the current node.
     * @param context the style context that defines the frame
     * @param x X origin of the rectangle
     * @param y Y origin of the rectangle
     * @param width rectangle width
     * @param height rectangle height
     */
    renderFrame(
      context: StyleContext,
      x: number,
      y: number,
      width: number,
      height: number
    ): void
    /**
     * Draws a text caret using `snapshot` at the specified index of `layout`.
     * @param context a `GtkStyleContext`
     * @param x X origin
     * @param y Y origin
     * @param layout the `PangoLayout` of the text
     * @param index the index in the `PangoLayout`
     * @param direction the `PangoDirection` of the text
     */
    renderInsertionCursor(
      context: StyleContext,
      x: number,
      y: number,
      layout: Pango.Layout,
      index: number,
      direction: Pango.Direction
    ): void
    /**
     * Creates a render node for rendering `layout` according to the style
     * information in `context,` and appends it to the current node of `snapshot,`
     * without changing the current node.
     * @param context the style context that defines the text
     * @param x X origin of the rectangle
     * @param y Y origin of the rectangle
     * @param layout the `PangoLayout` to render
     */
    renderLayout(
      context: StyleContext,
      x: number,
      y: number,
      layout: Pango.Layout
    ): void
    /**
     * Restores `snapshot` to the state saved by a preceding call to
     * [method`Snapshot`.save] and removes that state from the stack of
     * saved states.
     */
    restore(): void
    /**
     * Rotates `@`snapshot's coordinate system by `angle` degrees in 2D space -
     * or in 3D speak, rotates around the Z axis. The rotation happens around
     * the origin point of (0, 0) in the `snapshot'`s current coordinate system.
     *
     * To rotate around axes other than the Z axis, use [method`Gsk`.Transform.rotate_3d].
     * @param angle the rotation angle, in degrees (clockwise)
     */
    rotate(angle: number): void
    /**
     * Rotates `snapshot'`s coordinate system by `angle` degrees around `axis`.
     *
     * For a rotation in 2D space, use [method`Gsk`.Transform.rotate].
     * @param angle the rotation angle, in degrees (clockwise)
     * @param axis The rotation axis
     */
    rotate3d(angle: number, axis: Graphene.Vec3): void
    /**
     * Makes a copy of the current state of `snapshot` and saves it
     * on an internal stack.
     *
     * When [method`Gtk`.Snapshot.restore] is called, `snapshot` will
     * be restored to the saved state.
     *
     * Multiple calls to [method`Gtk`.Snapshot.save] and [method`Gtk`.Snapshot.restore]
     * can be nested; each call to `gtk_snapshot_restore()` restores the state from
     * the matching paired `gtk_snapshot_save()`.
     *
     * It is necessary to clear all saved states with corresponding
     * calls to `gtk_snapshot_restore()`.
     */
    save(): void
    /**
     * Scales `snapshot'`s coordinate system in 2-dimensional space by
     * the given factors.
     *
     * Use [method`Gtk`.Snapshot.scale_3d] to scale in all 3 dimensions.
     * @param factorX scaling factor on the X axis
     * @param factorY scaling factor on the Y axis
     */
    scale(factorX: number, factorY: number): void
    /**
     * Scales `snapshot'`s coordinate system by the given factors.
     * @param factorX scaling factor on the X axis
     * @param factorY scaling factor on the Y axis
     * @param factorZ scaling factor on the Z axis
     */
    scale3d(factorX: number, factorY: number, factorZ: number): void
    /**
     * Returns the render node that was constructed
     * by `snapshot`.
     *
     * Note that this function may return %NULL if nothing has been
     * added to the snapshot or if its content does not produce pixels
     * to be rendered.
     *
     * After calling this function, it is no longer possible to
     * add more nodes to `snapshot`. The only function that should
     * be called after this is [method`GObject`.Object.unref].
     * @returns the constructed `GskRenderNode` or   %NULL if there are no nodes to render.
     */
    toNode(): Gsk.RenderNode | null
    /**
     * Returns a paintable encapsulating the render node
     * that was constructed by `snapshot`.
     *
     * After calling this function, it is no longer possible to
     * add more nodes to `snapshot`. The only function that should
     * be called after this is [method`GObject`.Object.unref].
     * @param size The size of the resulting paintable   or %NULL to use the bounds of the snapshot
     * @returns a new `GdkPaintable`
     */
    toPaintable(size: Graphene.Size | null): Gdk.Paintable | null
    /**
     * Transforms `snapshot'`s coordinate system with the given `transform`.
     * @param transform the transform to apply
     */
    transform(transform: Gsk.Transform | null): void
    /**
     * Transforms `snapshot'`s coordinate system with the given `matrix`.
     * @param matrix the matrix to multiply the transform with
     */
    transformMatrix(matrix: Graphene.Matrix): void
    /**
     * Translates `snapshot'`s coordinate system by `point` in 2-dimensional space.
     * @param point the point to translate the snapshot by
     */
    translate(point: Graphene.Point): void
    /**
     * Translates `snapshot'`s coordinate system by `point`.
     * @param point the point to translate the snapshot by
     */
    translate3d(point: Graphene.Point3D): void

    // Class property signals of Gtk-4.0.Gtk.Snapshot

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSnapshot` assists in creating [class`Gsk`.RenderNode]s for widgets.
   *
   * It functions in a similar way to a cairo context, and maintains a stack
   * of render nodes and their associated transformations.
   *
   * The node at the top of the stack is the one that `gtk_snapshot_append_…()`
   * functions operate on. Use the `gtk_snapshot_push_…()` functions and
   * [method`Snapshot`.pop] to change the current node.
   *
   * The typical way to obtain a `GtkSnapshot` object is as an argument to
   * the [vfunc`Gtk`.Widget.snapshot] vfunc. If you need to create your own
   * `GtkSnapshot`, use [ctor`Gtk`.Snapshot.new].
   * @class
   */
  class Snapshot extends Gdk.Snapshot {
    // Own properties of Gtk-4.0.Gtk.Snapshot

    static name: string

    // Constructors of Gtk-4.0.Gtk.Snapshot

    constructor(config?: Snapshot.ConstructorProperties)
    /**
     * Creates a new `GtkSnapshot`.
     * @constructor
     * @returns a newly-allocated `GtkSnapshot`
     */
    constructor()
    /**
     * Creates a new `GtkSnapshot`.
     * @constructor
     * @returns a newly-allocated `GtkSnapshot`
     */
    static new(): Snapshot
    _init(config?: Snapshot.ConstructorProperties): void
  }

  module SortListModel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        SectionModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SortListModel

      /**
       * If the model should sort items incrementally.
       */
      incremental?: boolean | null
      /**
       * The model being sorted.
       */
      model?: Gio.ListModel | null
      /**
       * The section sorter for this model, if one is set.
       */
      section_sorter?: Sorter | null
      /**
       * The sorter for this model.
       */
      sorter?: Sorter | null
    }
  }

  interface SortListModel extends Gio.ListModel, SectionModel {
    // Own properties of Gtk-4.0.Gtk.SortListModel

    /**
     * If the model should sort items incrementally.
     */
    incremental: boolean
    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The model being sorted.
     */
    model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    /**
     * Estimate of unsorted items remaining.
     */
    readonly pending: number
    /**
     * The section sorter for this model, if one is set.
     */
    sectionSorter: Sorter
    /**
     * The sorter for this model.
     */
    sorter: Sorter
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SortListModel

    /**
     * Returns whether incremental sorting is enabled.
     *
     * See [method`Gtk`.SortListModel.set_incremental].
     * @returns %TRUE if incremental sorting is enabled
     */
    getIncremental(): boolean
    /**
     * Gets the model currently sorted or %NULL if none.
     * @returns The model that gets sorted
     */
    getModel(): Gio.ListModel | null
    /**
     * Estimates progress of an ongoing sorting operation.
     *
     * The estimate is the number of items that would still need to be
     * sorted to finish the sorting operation if this was a linear
     * algorithm. So this number is not related to how many items are
     * already correctly sorted.
     *
     * If you want to estimate the progress, you can use code like this:
     * ```c
     * pending = gtk_sort_list_model_get_pending (self);
     * model = gtk_sort_list_model_get_model (self);
     * progress = 1.0 - pending / (double) MAX (1, g_list_model_get_n_items (model));
     * ```
     *
     * If no sort operation is ongoing - in particular when
     * [property`Gtk`.SortListModel:incremental] is %FALSE - this
     * function returns 0.
     * @returns a progress estimate of remaining items to sort
     */
    getPending(): number
    /**
     * Gets the section sorter that is used to sort items of `self` into
     * sections.
     * @returns the sorter of #self
     */
    getSectionSorter(): Sorter | null
    /**
     * Gets the sorter that is used to sort `self`.
     * @returns the sorter of #self
     */
    getSorter(): Sorter | null
    /**
     * Sets the sort model to do an incremental sort.
     *
     * When incremental sorting is enabled, the `GtkSortListModel` will not do
     * a complete sort immediately, but will instead queue an idle handler that
     * incrementally sorts the items towards their correct position. This of
     * course means that items do not instantly appear in the right place. It
     * also means that the total sorting time is a lot slower.
     *
     * When your filter blocks the UI while sorting, you might consider
     * turning this on. Depending on your model and sorters, this may become
     * interesting around 10,000 to 100,000 items.
     *
     * By default, incremental sorting is disabled.
     *
     * See [method`Gtk`.SortListModel.get_pending] for progress information
     * about an ongoing incremental sorting operation.
     * @param incremental %TRUE to sort incrementally
     */
    setIncremental(incremental: boolean): void
    /**
     * Sets the model to be sorted.
     *
     * The `model'`s item type must conform to the item type of `self`.
     * @param model The model to be sorted
     */
    setModel(model: Gio.ListModel | null): void
    /**
     * Sets a new section sorter on `self`.
     * @param sorter the `GtkSorter` to sort `model` with
     */
    setSectionSorter(sorter: Sorter | null): void
    /**
     * Sets a new sorter on `self`.
     * @param sorter the `GtkSorter` to sort `model` with
     */
    setSorter(sorter: Sorter | null): void

    // Class property signals of Gtk-4.0.Gtk.SortListModel

    connect(
      sigName: "notify::incremental",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::incremental",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::incremental",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::incremental",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::incremental", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::pending",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pending",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pending",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pending",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pending", ...args: any[]): void
    connect(
      sigName: "notify::section-sorter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::section-sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::section-sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::section-sorter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::section-sorter", ...args: any[]): void
    connect(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sorter", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GListModel` that sorts the elements of an underlying model
   * according to a `GtkSorter`.
   *
   * The model is a stable sort. If two items compare equal according
   * to the sorter, the one that appears first in the original model will
   * also appear first after sorting.
   * Note that if you change the sorter, the previous order will have no
   * influence on the new order. If you want that, consider using a
   * `GtkMultiSorter` and appending the previous sorter to it.
   *
   * The model can be set up to do incremental sorting, so that
   * sorting long lists doesn't block the UI. See
   * [method`Gtk`.SortListModel.set_incremental] for details.
   *
   * `GtkSortListModel` is a generic model and because of that it
   * cannot take advantage of any external knowledge when sorting.
   * If you run into performance issues with `GtkSortListModel`,
   * it is strongly recommended that you write your own sorting list
   * model.
   *
   * `GtkSortListModel` allows sorting the items into sections. It
   * implements `GtkSectionModel` and when [property`Gtk`.SortListModel:section-sorter]
   * is set, it will sort all items with that sorter and items comparing
   * equal with it will be put into the same section.
   * The [property`Gtk`.SortListModel:sorter] will then be used to sort items
   * inside their sections.
   * @class
   */
  class SortListModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.SortListModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.SortListModel

    constructor(config?: SortListModel.ConstructorProperties)
    /**
     * Creates a new sort list model that uses the `sorter` to sort `model`.
     * @constructor
     * @param model the model to sort
     * @param sorter the `GtkSorter` to sort `model` with,
     * @returns a new `GtkSortListModel`
     */
    constructor(model: Gio.ListModel | null, sorter: Sorter | null)
    /**
     * Creates a new sort list model that uses the `sorter` to sort `model`.
     * @constructor
     * @param model the model to sort
     * @param sorter the `GtkSorter` to sort `model` with,
     * @returns a new `GtkSortListModel`
     */
    static new(
      model: Gio.ListModel | null,
      sorter: Sorter | null
    ): SortListModel
    _init(config?: SortListModel.ConstructorProperties): void
  }

  module Sorter {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (change: SorterChange): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Sorter {
    // Own properties of Gtk-4.0.Gtk.Sorter

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Sorter

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.Sorter

    /**
     * Notifies all users of the sorter that it has changed.
     *
     * This emits the [signal`Gtk`.Sorter::changed] signal. Users
     * of the sorter should then update the sort order via
     * [method`Gtk`.Sorter.compare].
     *
     * Depending on the `change` parameter, it may be possible to
     * update the sort order without a full resorting. Refer to
     * the [enum`Gtk`.SorterChange] documentation for details.
     *
     * This function is intended for implementers of `GtkSorter`
     * subclasses and should not be called from other functions.
     * @param change How the sorter changed
     */
    changed(change: SorterChange): void
    // Has conflict: compare(item1: GObject.Object, item2: GObject.Object): Ordering
    // Has conflict: getOrder(): SorterOrder

    // Own virtual methods of Gtk-4.0.Gtk.Sorter

    /**
     * Compares two given items according to the sort order implemented
     * by the sorter.
     *
     * Sorters implement a partial order:
     *
     * * It is reflexive, ie a = a
     * * It is antisymmetric, ie if a < b and b < a, then a = b
     * * It is transitive, ie given any 3 items with a ≤ b and b ≤ c,
     *   then a ≤ c
     *
     * The sorter may signal it conforms to additional constraints
     * via the return value of [method`Gtk`.Sorter.get_order].
     * @virtual
     * @param item1 first item to compare
     * @param item2 second item to compare
     * @returns %GTK_ORDERING_EQUAL if @item1 == @item2,   %GTK_ORDERING_SMALLER if @item1 < @item2,   %GTK_ORDERING_LARGER if @item1 > @item2
     */
    compare(
      item1: GObject.Object | null,
      item2: GObject.Object | null
    ): Ordering
    /**
     * Gets the order that `self` conforms to.
     *
     * See [enum`Gtk`.SorterOrder] for details
     * of the possible return values.
     *
     * This function is intended to allow optimizations.
     * @virtual
     * @returns The order
     */
    getOrder(): SorterOrder

    // Own signals of Gtk-4.0.Gtk.Sorter

    connect(sigName: "changed", callback: Sorter.ChangedSignalCallback): number
    on(
      sigName: "changed",
      callback: Sorter.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: Sorter.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: Sorter.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Sorter

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSorter` is an object to describe sorting criteria.
   *
   * Its primary user is [class`Gtk`.SortListModel]
   *
   * The model will use a sorter to determine the order in which
   * its items should appear by calling [method`Gtk`.Sorter.compare]
   * for pairs of items.
   *
   * Sorters may change their sorting behavior through their lifetime.
   * In that case, they will emit the [signal`Gtk`.Sorter::changed] signal
   * to notify that the sort order is no longer valid and should be updated
   * by calling gtk_sorter_compare() again.
   *
   * GTK provides various pre-made sorter implementations for common sorting
   * operations. [class`Gtk`.ColumnView] has built-in support for sorting lists
   * via the [property`Gtk`.ColumnViewColumn:sorter] property, where the user can
   * change the sorting by clicking on list headers.
   *
   * Of course, in particular for large lists, it is also possible to subclass
   * `GtkSorter` and provide one's own sorter.
   * @class
   */
  class Sorter extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Sorter

    static name: string

    // Constructors of Gtk-4.0.Gtk.Sorter

    constructor(config?: Sorter.ConstructorProperties)
    _init(config?: Sorter.ConstructorProperties): void
  }

  module SpinButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `change-value`
     */
    interface ChangeValueSignalCallback {
      (scroll: ScrollType): void
    }

    /**
     * Signal callback interface for `input`
     */
    interface InputSignalCallback {
      (): number
    }

    /**
     * Signal callback interface for `output`
     */
    interface OutputSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `value-changed`
     */
    interface ValueChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `wrapped`
     */
    interface WrappedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleRange.ConstructorProperties,
        Buildable.ConstructorProperties,
        CellEditable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Editable.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.SpinButton

      /**
       * Whether to activate the default widget when the spin button is activated.
       *
       * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
       */
      activates_default?: boolean | null
      /**
       * The adjustment that holds the value of the spin button.
       */
      adjustment?: Adjustment | null
      /**
       * The acceleration rate when you hold down a button or key.
       */
      climb_rate?: number | null
      /**
       * The number of decimal places to display.
       */
      digits?: number | null
      /**
       * Whether non-numeric characters should be ignored.
       */
      numeric?: boolean | null
      /**
       * Whether erroneous values are automatically changed to the spin buttons
       * nearest step increment.
       */
      snap_to_ticks?: boolean | null
      /**
       * Whether the spin button should update always, or only when the value
       * is acceptable.
       */
      update_policy?: SpinButtonUpdatePolicy | null
      /**
       * The current value.
       */
      value?: number | null
      /**
       * Whether a spin button should wrap upon reaching its limits.
       */
      wrap?: boolean | null
    }
  }

  interface SpinButton
    extends Accessible,
      AccessibleRange,
      Buildable,
      CellEditable,
      ConstraintTarget,
      Editable,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.SpinButton

    /**
     * Whether to activate the default widget when the spin button is activated.
     *
     * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
     */
    activatesDefault: boolean
    /**
     * The adjustment that holds the value of the spin button.
     */
    adjustment: Adjustment
    /**
     * The acceleration rate when you hold down a button or key.
     */
    climbRate: number
    /**
     * The number of decimal places to display.
     */
    digits: number
    /**
     * Whether non-numeric characters should be ignored.
     */
    numeric: boolean
    /**
     * Whether erroneous values are automatically changed to the spin buttons
     * nearest step increment.
     */
    snapToTicks: boolean
    /**
     * Whether the spin button should update always, or only when the value
     * is acceptable.
     */
    updatePolicy: SpinButtonUpdatePolicy
    /**
     * The current value.
     */
    value: number
    /**
     * Whether a spin button should wrap upon reaching its limits.
     */
    wrap: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.SpinButton

    /**
     * Changes the properties of an existing spin button.
     *
     * The adjustment, climb rate, and number of decimal places
     * are updated accordingly.
     * @param adjustment a `GtkAdjustment` to replace the spin button’s   existing adjustment, or %NULL to leave its current adjustment unchanged
     * @param climbRate the new climb rate
     * @param digits the number of decimal places to display in the spin button
     */
    configure(
      adjustment: Adjustment | null,
      climbRate: number,
      digits: number
    ): void
    /**
     * Retrieves the value set by [method`Gtk`.SpinButton.set_activates_default].
     * @returns %TRUE if the spin button will activate the default widget
     */
    getActivatesDefault(): boolean
    /**
     * Get the adjustment associated with a `GtkSpinButton`.
     * @returns the `GtkAdjustment` of @spin_button
     */
    getAdjustment(): Adjustment
    /**
     * Returns the acceleration rate for repeated changes.
     * @returns the acceleration rate
     */
    getClimbRate(): number
    /**
     * Fetches the precision of `spin_button`.
     * @returns the current precision
     */
    getDigits(): number
    /**
     * Gets the current step and page the increments
     * used by `spin_button`.
     *
     * See [method`Gtk`.SpinButton.set_increments].
     */
    getIncrements(): [/* step */ number, /* page */ number]
    /**
     * Returns whether non-numeric text can be typed into the spin button.
     * @returns %TRUE if only numeric text can be entered
     */
    getNumeric(): boolean
    /**
     * Gets the range allowed for `spin_button`.
     *
     * See [method`Gtk`.SpinButton.set_range].
     */
    getRange(): [/* min */ number, /* max */ number]
    /**
     * Returns whether the values are corrected to the nearest step.
     * @returns %TRUE if values are snapped to the nearest step
     */
    getSnapToTicks(): boolean
    /**
     * Gets the update behavior of a spin button.
     *
     * See [method`Gtk`.SpinButton.set_update_policy].
     * @returns the current update policy
     */
    getUpdatePolicy(): SpinButtonUpdatePolicy
    /**
     * Get the value in the `spin_button`.
     * @returns the value of @spin_button
     */
    getValue(): number
    /**
     * Get the value `spin_button` represented as an integer.
     * @returns the value of @spin_button
     */
    getValueAsInt(): number
    /**
     * Returns whether the spin button’s value wraps around to the
     * opposite limit when the upper or lower limit of the range is
     * exceeded.
     * @returns %TRUE if the spin button wraps around
     */
    getWrap(): boolean
    /**
     * Sets whether activating the spin button will activate the default
     * widget for the window containing the spin button.
     *
     * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
     * @param activatesDefault %TRUE to activate window’s default widget on activation
     */
    setActivatesDefault(activatesDefault: boolean): void
    /**
     * Replaces the `GtkAdjustment` associated with `spin_button`.
     * @param adjustment a `GtkAdjustment` to replace the existing adjustment
     */
    setAdjustment(adjustment: Adjustment): void
    /**
     * Sets the acceleration rate for repeated changes when you
     * hold down a button or key.
     * @param climbRate the rate of acceleration, must be >= 0
     */
    setClimbRate(climbRate: number): void
    /**
     * Set the precision to be displayed by `spin_button`.
     *
     * Up to 20 digit precision is allowed.
     * @param digits the number of digits after the decimal point to be   displayed for the spin button’s value
     */
    setDigits(digits: number): void
    /**
     * Sets the step and page increments for spin_button.
     *
     * This affects how quickly the value changes when
     * the spin button’s arrows are activated.
     * @param step increment applied for a button 1 press.
     * @param page increment applied for a button 2 press.
     */
    setIncrements(step: number, page: number): void
    /**
     * Sets the flag that determines if non-numeric text can be typed
     * into the spin button.
     * @param numeric flag indicating if only numeric entry is allowed
     */
    setNumeric(numeric: boolean): void
    /**
     * Sets the minimum and maximum allowable values for `spin_button`.
     *
     * If the current value is outside this range, it will be adjusted
     * to fit within the range, otherwise it will remain unchanged.
     * @param min minimum allowable value
     * @param max maximum allowable value
     */
    setRange(min: number, max: number): void
    /**
     * Sets the policy as to whether values are corrected to the
     * nearest step increment when a spin button is activated after
     * providing an invalid value.
     * @param snapToTicks a flag indicating if invalid values should be corrected
     */
    setSnapToTicks(snapToTicks: boolean): void
    /**
     * Sets the update behavior of a spin button.
     *
     * This determines whether the spin button is always
     * updated or only when a valid value is set.
     * @param policy a `GtkSpinButtonUpdatePolicy` value
     */
    setUpdatePolicy(policy: SpinButtonUpdatePolicy): void
    /**
     * Sets the value of `spin_button`.
     * @param value the new value
     */
    setValue(value: number): void
    /**
     * Sets the flag that determines if a spin button value wraps
     * around to the opposite limit when the upper or lower limit
     * of the range is exceeded.
     * @param wrap a flag indicating if wrapping behavior is performed
     */
    setWrap(wrap: boolean): void
    /**
     * Increment or decrement a spin button’s value in a specified
     * direction by a specified amount.
     * @param direction a `GtkSpinType` indicating the direction to spin
     * @param increment step increment to apply in the specified direction
     */
    spin(direction: SpinType, increment: number): void
    /**
     * Manually force an update of the spin button.
     */
    update(): void

    // Own signals of Gtk-4.0.Gtk.SpinButton

    connect(
      sigName: "activate",
      callback: SpinButton.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: SpinButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: SpinButton.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: SpinButton.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "change-value",
      callback: SpinButton.ChangeValueSignalCallback
    ): number
    on(
      sigName: "change-value",
      callback: SpinButton.ChangeValueSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "change-value",
      callback: SpinButton.ChangeValueSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "change-value",
      callback: SpinButton.ChangeValueSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "change-value", ...args: any[]): void
    connect(sigName: "input", callback: SpinButton.InputSignalCallback): number
    on(
      sigName: "input",
      callback: SpinButton.InputSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "input",
      callback: SpinButton.InputSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "input",
      callback: SpinButton.InputSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "input", ...args: any[]): void
    connect(
      sigName: "output",
      callback: SpinButton.OutputSignalCallback
    ): number
    on(
      sigName: "output",
      callback: SpinButton.OutputSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "output",
      callback: SpinButton.OutputSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "output",
      callback: SpinButton.OutputSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "output", ...args: any[]): void
    connect(
      sigName: "value-changed",
      callback: SpinButton.ValueChangedSignalCallback
    ): number
    on(
      sigName: "value-changed",
      callback: SpinButton.ValueChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "value-changed",
      callback: SpinButton.ValueChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "value-changed",
      callback: SpinButton.ValueChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "value-changed", ...args: any[]): void
    connect(
      sigName: "wrapped",
      callback: SpinButton.WrappedSignalCallback
    ): number
    on(
      sigName: "wrapped",
      callback: SpinButton.WrappedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "wrapped",
      callback: SpinButton.WrappedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "wrapped",
      callback: SpinButton.WrappedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "wrapped", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.SpinButton

    connect(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activates-default", ...args: any[]): void
    connect(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::adjustment", ...args: any[]): void
    connect(
      sigName: "notify::climb-rate",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::climb-rate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::climb-rate",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::climb-rate",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::climb-rate", ...args: any[]): void
    connect(
      sigName: "notify::digits",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::digits",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::digits",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::digits", ...args: any[]): void
    connect(
      sigName: "notify::numeric",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::numeric",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::numeric",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::numeric",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::numeric", ...args: any[]): void
    connect(
      sigName: "notify::snap-to-ticks",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::snap-to-ticks",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::snap-to-ticks",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::snap-to-ticks",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::snap-to-ticks", ...args: any[]): void
    connect(
      sigName: "notify::update-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::update-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::update-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::update-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::update-policy", ...args: any[]): void
    connect(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::value", ...args: any[]): void
    connect(sigName: "notify::wrap", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::wrap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editing-canceled",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editing-canceled", ...args: any[]): void
    connect(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-position", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-undo", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-bound", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkSpinButton` is an ideal way to allow the user to set the
   * value of some attribute.
   *
   * ![An example GtkSpinButton](spinbutton.png)
   *
   * Rather than having to directly type a number into a `GtkEntry`,
   * `GtkSpinButton` allows the user to click on one of two arrows
   * to increment or decrement the displayed value. A value can still be
   * typed in, with the bonus that it can be checked to ensure it is in a
   * given range.
   *
   * The main properties of a `GtkSpinButton` are through an adjustment.
   * See the [class`Gtk`.Adjustment] documentation for more details about
   * an adjustment's properties.
   *
   * Note that `GtkSpinButton` will by default make its entry large enough
   * to accommodate the lower and upper bounds of the adjustment. If this
   * is not desired, the automatic sizing can be turned off by explicitly
   * setting [property`Gtk`.Editable:width-chars] to a value != -1.
   *
   * ## Using a GtkSpinButton to get an integer
   *
   * ```c
   * // Provides a function to retrieve an integer value from a GtkSpinButton
   * // and creates a spin button to model percentage values.
   *
   * int
   * grab_int_value (GtkSpinButton *button,
   *                 gpointer       user_data)
   * {
   *   return gtk_spin_button_get_value_as_int (button);
   * }
   *
   * void
   * create_integer_spin_button (void)
   * {
   *
   *   GtkWidget *window, *button;
   *   GtkAdjustment *adjustment;
   *
   *   adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0);
   *
   *   window = gtk_window_new ();
   *
   *   // creates the spinbutton, with no decimal places
   *   button = gtk_spin_button_new (adjustment, 1.0, 0);
   *   gtk_window_set_child (GTK_WINDOW (window), button);
   *
   *   gtk_window_present (GTK_WINDOW (window));
   * }
   * ```
   *
   * ## Using a GtkSpinButton to get a floating point value
   *
   * ```c
   * // Provides a function to retrieve a floating point value from a
   * // GtkSpinButton, and creates a high precision spin button.
   *
   * float
   * grab_float_value (GtkSpinButton *button,
   *                   gpointer       user_data)
   * {
   *   return gtk_spin_button_get_value (button);
   * }
   *
   * void
   * create_floating_spin_button (void)
   * {
   *   GtkWidget *window, *button;
   *   GtkAdjustment *adjustment;
   *
   *   adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0);
   *
   *   window = gtk_window_new ();
   *
   *   // creates the spinbutton, with three decimal places
   *   button = gtk_spin_button_new (adjustment, 0.001, 3);
   *   gtk_window_set_child (GTK_WINDOW (window), button);
   *
   *   gtk_window_present (GTK_WINDOW (window));
   * }
   * ```
   *
   * # CSS nodes
   *
   * ```
   * spinbutton.horizontal
   * ├── text
   * │    ├── undershoot.left
   * │    ╰── undershoot.right
   * ├── button.down
   * ╰── button.up
   * ```
   *
   * ```
   * spinbutton.vertical
   * ├── button.up
   * ├── text
   * │    ├── undershoot.left
   * │    ╰── undershoot.right
   * ╰── button.down
   * ```
   *
   * `GtkSpinButton`s main CSS node has the name spinbutton. It creates subnodes
   * for the entry and the two buttons, with these names. The button nodes have
   * the style classes .up and .down. The `GtkText` subnodes (if present) are put
   * below the text node. The orientation of the spin button is reflected in
   * the .vertical or .horizontal style class on the main node.
   *
   * # Accessibility
   *
   * `GtkSpinButton` uses the %GTK_ACCESSIBLE_ROLE_SPIN_BUTTON role.
   * @class
   */
  class SpinButton extends Widget {
    // Own properties of Gtk-4.0.Gtk.SpinButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.SpinButton

    constructor(config?: SpinButton.ConstructorProperties)
    /**
     * Creates a new `GtkSpinButton`.
     * @constructor
     * @param adjustment the `GtkAdjustment` that this spin button should use
     * @param climbRate specifies by how much the rate of change in the value will   accelerate if you continue to hold down an up/down button or arrow key
     * @param digits the number of decimal places to display
     * @returns The new `GtkSpinButton`
     */
    constructor(
      adjustment: Adjustment | null,
      climbRate: number,
      digits: number
    )
    /**
     * Creates a new `GtkSpinButton`.
     * @constructor
     * @param adjustment the `GtkAdjustment` that this spin button should use
     * @param climbRate specifies by how much the rate of change in the value will   accelerate if you continue to hold down an up/down button or arrow key
     * @param digits the number of decimal places to display
     * @returns The new `GtkSpinButton`
     */
    static new(
      adjustment: Adjustment | null,
      climbRate: number,
      digits: number
    ): SpinButton
    /**
     * Creates a new `GtkSpinButton` with the given properties.
     *
     * This is a convenience constructor that allows creation
     * of a numeric `GtkSpinButton` without manually creating
     * an adjustment. The value is initially set to the minimum
     * value and a page increment of 10 * `step` is the default.
     * The precision of the spin button is equivalent to the
     * precision of `step`.
     *
     * Note that the way in which the precision is derived works
     * best if `step` is a power of ten. If the resulting precision
     * is not suitable for your needs, use
     * [method`Gtk`.SpinButton.set_digits] to correct it.
     * @constructor
     * @param min Minimum allowable value
     * @param max Maximum allowable value
     * @param step Increment added or subtracted by spinning the widget
     * @returns The new `GtkSpinButton`
     */
    static newWithRange(min: number, max: number, step: number): SpinButton
    _init(config?: SpinButton.ConstructorProperties): void
  }

  module Spinner {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Spinner

      /**
       * Whether the spinner is spinning
       */
      spinning?: boolean | null
    }
  }

  interface Spinner extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Spinner

    /**
     * Whether the spinner is spinning
     */
    spinning: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Spinner

    /**
     * Returns whether the spinner is spinning.
     * @returns %TRUE if the spinner is active
     */
    getSpinning(): boolean
    /**
     * Sets the activity of the spinner.
     * @param spinning whether the spinner should be spinning
     */
    setSpinning(spinning: boolean): void
    /**
     * Starts the animation of the spinner.
     */
    start(): void
    /**
     * Stops the animation of the spinner.
     */
    stop(): void

    // Class property signals of Gtk-4.0.Gtk.Spinner

    connect(
      sigName: "notify::spinning",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::spinning",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::spinning",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::spinning",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::spinning", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkSpinner` widget displays an icon-size spinning animation.
   *
   * It is often used as an alternative to a [class`Gtk`.ProgressBar]
   * for displaying indefinite activity, instead of actual progress.
   *
   * ![An example GtkSpinner](spinner.png)
   *
   * To start the animation, use [method`Gtk`.Spinner.start], to stop it
   * use [method`Gtk`.Spinner.stop].
   *
   * # CSS nodes
   *
   * `GtkSpinner` has a single CSS node with the name spinner.
   * When the animation is active, the :checked pseudoclass is
   * added to this node.
   * @class
   */
  class Spinner extends Widget {
    // Own properties of Gtk-4.0.Gtk.Spinner

    static name: string

    // Constructors of Gtk-4.0.Gtk.Spinner

    constructor(config?: Spinner.ConstructorProperties)
    /**
     * Returns a new spinner widget. Not yet started.
     * @constructor
     * @returns a new `GtkSpinner`
     */
    constructor()
    /**
     * Returns a new spinner widget. Not yet started.
     * @constructor
     * @returns a new `GtkSpinner`
     */
    static new(): Spinner
    _init(config?: Spinner.ConstructorProperties): void
  }

  module Stack {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Stack

      /**
       * %TRUE if the stack allocates the same width for all children.
       */
      hhomogeneous?: boolean | null
      /**
       * Whether or not the size should smoothly change during the transition.
       */
      interpolate_size?: boolean | null
      /**
       * The animation duration, in milliseconds.
       */
      transition_duration?: number | null
      /**
       * The type of animation used to transition.
       */
      transition_type?: StackTransitionType | null
      /**
       * %TRUE if the stack allocates the same height for all children.
       */
      vhomogeneous?: boolean | null
      /**
       * The widget currently visible in the stack.
       */
      visible_child?: Widget | null
      /**
       * The name of the widget currently visible in the stack.
       */
      visible_child_name?: string | null
    }
  }

  interface Stack extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Stack

    /**
     * %TRUE if the stack allocates the same width for all children.
     */
    hhomogeneous: boolean
    /**
     * Whether or not the size should smoothly change during the transition.
     */
    interpolateSize: boolean
    /**
     * A selection model with the stack pages.
     */
    readonly pages: SelectionModel
    /**
     * The animation duration, in milliseconds.
     */
    transitionDuration: number
    /**
     * Whether or not the transition is currently running.
     */
    readonly transitionRunning: boolean
    /**
     * The type of animation used to transition.
     */
    transitionType: StackTransitionType
    /**
     * %TRUE if the stack allocates the same height for all children.
     */
    vhomogeneous: boolean
    /**
     * The widget currently visible in the stack.
     */
    visibleChild: Widget
    /**
     * The name of the widget currently visible in the stack.
     */
    visibleChildName: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Stack

    /**
     * Adds a child to `stack`.
     * @param child the widget to add
     * @returns the `GtkStackPage` for @child
     */
    addChild(child: Widget): StackPage

    // Overloads of addChild

    /**
     * Adds a child to `buildable`. `type` is an optional string
     * describing how the child should be added.
     * @virtual
     * @param builder a `GtkBuilder`
     * @param child child to add
     * @param type kind of child or %NULL
     */
    addChild(builder: Builder, child: GObject.Object, type: string | null): void
    /**
     * Adds a child to `stack`.
     *
     * The child is identified by the `name`.
     * @param child the widget to add
     * @param name the name for `child`
     * @returns the `GtkStackPage` for @child
     */
    addNamed(child: Widget, name: string | null): StackPage
    /**
     * Adds a child to `stack`.
     *
     * The child is identified by the `name`. The `title`
     * will be used by `GtkStackSwitcher` to represent
     * `child` in a tab bar, so it should be short.
     * @param child the widget to add
     * @param name the name for `child`
     * @param title a human-readable title for `child`
     * @returns the `GtkStackPage` for @child
     */
    addTitled(child: Widget, name: string | null, title: string): StackPage
    /**
     * Finds the child with the name given as the argument.
     *
     * Returns %NULL if there is no child with this name.
     * @param name the name of the child to find
     * @returns the requested child   of the `GtkStack`
     */
    getChildByName(name: string): Widget | null
    /**
     * Gets whether `stack` is horizontally homogeneous.
     * @returns whether @stack is horizontally homogeneous.
     */
    getHhomogeneous(): boolean
    /**
     * Returns whether the `GtkStack` is set up to interpolate between
     * the sizes of children on page switch.
     * @returns %TRUE if child sizes are interpolated
     */
    getInterpolateSize(): boolean
    /**
     * Returns the `GtkStackPage` object for `child`.
     * @param child a child of `stack`
     * @returns the `GtkStackPage` for @child
     */
    getPage(child: Widget): StackPage
    /**
     * Returns a `GListModel` that contains the pages of the stack.
     *
     * This can be used to keep an up-to-date view. The model also
     * implements [iface`Gtk`.SelectionModel] and can be used to track
     * and modify the visible page.
     * @returns a `GtkSelectionModel` for the stack's children
     */
    getPages(): SelectionModel
    /**
     * Returns the amount of time (in milliseconds) that
     * transitions between pages in `stack` will take.
     * @returns the transition duration
     */
    getTransitionDuration(): number
    /**
     * Returns whether the `stack` is currently in a transition from one page to
     * another.
     * @returns %TRUE if the transition is currently running, %FALSE otherwise.
     */
    getTransitionRunning(): boolean
    /**
     * Gets the type of animation that will be used
     * for transitions between pages in `stack`.
     * @returns the current transition type of @stack
     */
    getTransitionType(): StackTransitionType
    /**
     * Gets whether `stack` is vertically homogeneous.
     * @returns whether @stack is vertically homogeneous.
     */
    getVhomogeneous(): boolean
    /**
     * Gets the currently visible child of `stack`.
     *
     * Returns %NULL if there are no visible children.
     * @returns the visible child of the `GtkStack`
     */
    getVisibleChild(): Widget | null
    /**
     * Returns the name of the currently visible child of `stack`.
     *
     * Returns %NULL if there is no visible child.
     * @returns the name of the visible child   of the `GtkStack`
     */
    getVisibleChildName(): string | null
    /**
     * Removes a child widget from `stack`.
     * @param child the child to remove
     */
    remove(child: Widget): void
    /**
     * Sets the `GtkStack` to be horizontally homogeneous or not.
     *
     * If it is homogeneous, the `GtkStack` will request the same
     * width for all its children. If it isn't, the stack
     * may change width when a different child becomes visible.
     * @param hhomogeneous %TRUE to make `stack` horizontally homogeneous
     */
    setHhomogeneous(hhomogeneous: boolean): void
    /**
     * Sets whether or not `stack` will interpolate its size when
     * changing the visible child.
     *
     * If the [property`Gtk`.Stack:interpolate-size] property is set
     * to %TRUE, `stack` will interpolate its size between the current
     * one and the one it'll take after changing the visible child,
     * according to the set transition duration.
     * @param interpolateSize the new value
     */
    setInterpolateSize(interpolateSize: boolean): void
    /**
     * Sets the duration that transitions between pages in `stack`
     * will take.
     * @param duration the new duration, in milliseconds
     */
    setTransitionDuration(duration: number): void
    /**
     * Sets the type of animation that will be used for
     * transitions between pages in `stack`.
     *
     * Available types include various kinds of fades and slides.
     *
     * The transition type can be changed without problems
     * at runtime, so it is possible to change the animation
     * based on the page that is about to become current.
     * @param transition the new transition type
     */
    setTransitionType(transition: StackTransitionType): void
    /**
     * Sets the `GtkStack` to be vertically homogeneous or not.
     *
     * If it is homogeneous, the `GtkStack` will request the same
     * height for all its children. If it isn't, the stack
     * may change height when a different child becomes visible.
     * @param vhomogeneous %TRUE to make `stack` vertically homogeneous
     */
    setVhomogeneous(vhomogeneous: boolean): void
    /**
     * Makes `child` the visible child of `stack`.
     *
     * If `child` is different from the currently visible child,
     * the transition between the two will be animated with the
     * current transition type of `stack`.
     *
     * Note that the `child` widget has to be visible itself
     * (see [method`Gtk`.Widget.show]) in order to become the visible
     * child of `stack`.
     * @param child a child of `stack`
     */
    setVisibleChild(child: Widget): void
    /**
     * Makes the child with the given name visible.
     *
     * Note that the child widget has to be visible itself
     * (see [method`Gtk`.Widget.show]) in order to become the visible
     * child of `stack`.
     * @param name the name of the child to make visible
     * @param transition the transition type to use
     */
    setVisibleChildFull(name: string, transition: StackTransitionType): void
    /**
     * Makes the child with the given name visible.
     *
     * If `child` is different from the currently visible child,
     * the transition between the two will be animated with the
     * current transition type of `stack`.
     *
     * Note that the child widget has to be visible itself
     * (see [method`Gtk`.Widget.show]) in order to become the visible
     * child of `stack`.
     * @param name the name of the child to make visible
     */
    setVisibleChildName(name: string): void

    // Class property signals of Gtk-4.0.Gtk.Stack

    connect(
      sigName: "notify::hhomogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hhomogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hhomogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hhomogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hhomogeneous", ...args: any[]): void
    connect(
      sigName: "notify::interpolate-size",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::interpolate-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::interpolate-size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::interpolate-size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::interpolate-size", ...args: any[]): void
    connect(
      sigName: "notify::pages",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pages",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pages",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pages",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pages", ...args: any[]): void
    connect(
      sigName: "notify::transition-duration",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transition-duration",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transition-duration",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transition-duration",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transition-duration", ...args: any[]): void
    connect(
      sigName: "notify::transition-running",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transition-running",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transition-running",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transition-running",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transition-running", ...args: any[]): void
    connect(
      sigName: "notify::transition-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transition-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transition-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transition-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transition-type", ...args: any[]): void
    connect(
      sigName: "notify::vhomogeneous",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vhomogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vhomogeneous",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vhomogeneous",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vhomogeneous", ...args: any[]): void
    connect(
      sigName: "notify::visible-child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible-child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible-child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible-child", ...args: any[]): void
    connect(
      sigName: "notify::visible-child-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible-child-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible-child-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible-child-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible-child-name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkStack` is a container which only shows one of its children
   * at a time.
   *
   * In contrast to `GtkNotebook`, `GtkStack` does not provide a means
   * for users to change the visible child. Instead, a separate widget
   * such as [class`Gtk`.StackSwitcher] or [class`Gtk`.StackSidebar] can
   * be used with `GtkStack` to provide this functionality.
   *
   * Transitions between pages can be animated as slides or fades. This
   * can be controlled with [method`Gtk`.Stack.set_transition_type].
   * These animations respect the [property`Gtk`.Settings:gtk-enable-animations]
   * setting.
   *
   * `GtkStack` maintains a [class`Gtk`.StackPage] object for each added
   * child, which holds additional per-child properties. You
   * obtain the `GtkStackPage` for a child with [method`Gtk`.Stack.get_page]
   * and you can obtain a `GtkSelectionModel` containing all the pages
   * with [method`Gtk`.Stack.get_pages].
   *
   * # GtkStack as GtkBuildable
   *
   * To set child-specific properties in a .ui file, create `GtkStackPage`
   * objects explicitly, and set the child widget as a property on it:
   *
   * ```xml
   *   <object class="GtkStack" id="stack">
   *     <child>
   *       <object class="GtkStackPage">
   *         <property name="name">page1</property>
   *         <property name="title">In the beginning…</property>
   *         <property name="child">
   *           <object class="GtkLabel">
   *             <property name="label">It was dark</property>
   *           </object>
   *         </property>
   *       </object>
   *     </child>
   * ```
   *
   * # CSS nodes
   *
   * `GtkStack` has a single CSS node named stack.
   *
   * # Accessibility
   *
   * `GtkStack` uses the %GTK_ACCESSIBLE_ROLE_TAB_PANEL for the stack
   * pages, which are the accessible parent objects of the child widgets.
   * @class
   */
  class Stack extends Widget {
    // Own properties of Gtk-4.0.Gtk.Stack

    static name: string

    // Constructors of Gtk-4.0.Gtk.Stack

    constructor(config?: Stack.ConstructorProperties)
    /**
     * Creates a new `GtkStack`.
     * @constructor
     * @returns a new `GtkStack`
     */
    constructor()
    /**
     * Creates a new `GtkStack`.
     * @constructor
     * @returns a new `GtkStack`
     */
    static new(): Stack
    _init(config?: Stack.ConstructorProperties): void
  }

  module StackPage {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.StackPage

      /**
       * The child that this page is for.
       */
      child?: Widget | null
      /**
       * The icon name of the child page.
       */
      icon_name?: string | null
      /**
       * The name of the child page.
       */
      name?: string | null
      /**
       * Whether the page requires the user attention.
       *
       * This is used by the [class`Gtk`.StackSwitcher] to change the
       * appearance of the corresponding button when a page needs
       * attention and it is not the current one.
       */
      needs_attention?: boolean | null
      /**
       * The title of the child page.
       */
      title?: string | null
      /**
       * If set, an underline in the title indicates a mnemonic.
       */
      use_underline?: boolean | null
      /**
       * Whether this page is visible.
       */
      visible?: boolean | null
    }
  }

  interface StackPage extends Accessible {
    // Own properties of Gtk-4.0.Gtk.StackPage

    /**
     * The child that this page is for.
     */
    readonly child: Widget
    /**
     * The icon name of the child page.
     */
    iconName: string | null
    /**
     * The name of the child page.
     */
    name: string | null
    /**
     * Whether the page requires the user attention.
     *
     * This is used by the [class`Gtk`.StackSwitcher] to change the
     * appearance of the corresponding button when a page needs
     * attention and it is not the current one.
     */
    needsAttention: boolean
    /**
     * The title of the child page.
     */
    title: string | null
    /**
     * If set, an underline in the title indicates a mnemonic.
     */
    useUnderline: boolean
    /**
     * Whether this page is visible.
     */
    visible: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.StackPage

    /**
     * Returns the stack child to which `self` belongs.
     * @returns the child to which @self belongs
     */
    getChild(): Widget
    /**
     * Returns the icon name of the page.
     * @returns The value of the [property@Gtk.StackPage:icon-name] property
     */
    getIconName(): string | null
    /**
     * Returns the name of the page.
     * @returns The value of the [property@Gtk.StackPage:name] property
     */
    getName(): string | null
    /**
     * Returns whether the page is marked as “needs attention”.
     * @returns The value of the [property@Gtk.StackPage:needs-attention]   property.
     */
    getNeedsAttention(): boolean
    /**
     * Gets the page title.
     * @returns The value of the [property@Gtk.StackPage:title] property
     */
    getTitle(): string | null
    /**
     * Gets whether underlines in the page title indicate mnemonics.
     * @returns The value of the [property@Gtk.StackPage:use-underline] property
     */
    getUseUnderline(): boolean
    /**
     * Returns whether `page` is visible in its `GtkStack`.
     *
     * This is independent from the [property`Gtk`.Widget:visible]
     * property of its widget.
     * @returns %TRUE if @page is visible
     */
    getVisible(): boolean
    /**
     * Sets the icon name of the page.
     * @param setting the new value to set
     */
    setIconName(setting: string): void
    /**
     * Sets the name of the page.
     * @param setting the new value to set
     */
    setName(setting: string): void
    /**
     * Sets whether the page is marked as “needs attention”.
     * @param setting the new value to set
     */
    setNeedsAttention(setting: boolean): void
    /**
     * Sets the page title.
     * @param setting the new value to set
     */
    setTitle(setting: string): void
    /**
     * Sets whether underlines in the page title indicate mnemonics.
     * @param setting the new value to set
     */
    setUseUnderline(setting: boolean): void
    /**
     * Sets whether `page` is visible in its `GtkStack`.
     * @param visible The new property value
     */
    setVisible(visible: boolean): void

    // Class property signals of Gtk-4.0.Gtk.StackPage

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::needs-attention",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::needs-attention",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::needs-attention",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::needs-attention",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::needs-attention", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkStackPage` is an auxiliary class used by `GtkStack`.
   * @class
   */
  class StackPage extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.StackPage

    static name: string

    // Constructors of Gtk-4.0.Gtk.StackPage

    constructor(config?: StackPage.ConstructorProperties)
    _init(config?: StackPage.ConstructorProperties): void
  }

  module StackSidebar {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.StackSidebar

      /**
       * The stack.
       */
      stack?: Stack | null
    }
  }

  interface StackSidebar extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.StackSidebar

    /**
     * The stack.
     */
    stack: Stack
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.StackSidebar

    /**
     * Retrieves the stack.
     * @returns the associated `GtkStack` or   %NULL if none has been set explicitly
     */
    getStack(): Stack | null
    /**
     * Set the `GtkStack` associated with this `GtkStackSidebar`.
     *
     * The sidebar widget will automatically update according to
     * the order and items within the given `GtkStack`.
     * @param stack a `GtkStack`
     */
    setStack(stack: Stack): void

    // Class property signals of Gtk-4.0.Gtk.StackSidebar

    connect(
      sigName: "notify::stack",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stack",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stack",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stack",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stack", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkStackSidebar` uses a sidebar to switch between `GtkStack` pages.
   *
   * In order to use a `GtkStackSidebar`, you simply use a `GtkStack` to
   * organize your UI flow, and add the sidebar to your sidebar area. You
   * can use [method`Gtk`.StackSidebar.set_stack] to connect the `GtkStackSidebar`
   * to the `GtkStack`.
   *
   * # CSS nodes
   *
   * `GtkStackSidebar` has a single CSS node with name stacksidebar and
   * style class .sidebar.
   *
   * When circumstances require it, `GtkStackSidebar` adds the
   * .needs-attention style class to the widgets representing the stack
   * pages.
   * @class
   */
  class StackSidebar extends Widget {
    // Own properties of Gtk-4.0.Gtk.StackSidebar

    static name: string

    // Constructors of Gtk-4.0.Gtk.StackSidebar

    constructor(config?: StackSidebar.ConstructorProperties)
    /**
     * Creates a new `GtkStackSidebar`.
     * @constructor
     * @returns the new `GtkStackSidebar`
     */
    constructor()
    /**
     * Creates a new `GtkStackSidebar`.
     * @constructor
     * @returns the new `GtkStackSidebar`
     */
    static new(): StackSidebar
    _init(config?: StackSidebar.ConstructorProperties): void
  }

  module StackSwitcher {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.StackSwitcher

      /**
       * The stack.
       */
      stack?: Stack | null
    }
  }

  interface StackSwitcher
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.StackSwitcher

    /**
     * The stack.
     */
    stack: Stack
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.StackSwitcher

    /**
     * Retrieves the stack.
     * @returns the stack
     */
    getStack(): Stack | null
    /**
     * Sets the stack to control.
     * @param stack a `GtkStack`
     */
    setStack(stack: Stack | null): void

    // Class property signals of Gtk-4.0.Gtk.StackSwitcher

    connect(
      sigName: "notify::stack",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stack",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stack",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stack",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stack", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkStackSwitcher` shows a row of buttons to switch between `GtkStack`
   * pages.
   *
   * ![An example GtkStackSwitcher](stackswitcher.png)
   *
   * It acts as a controller for the associated `GtkStack`.
   *
   * All the content for the buttons comes from the properties of the stacks
   * [class`Gtk`.StackPage] objects; the button visibility in a `GtkStackSwitcher`
   * widget is controlled by the visibility of the child in the `GtkStack`.
   *
   * It is possible to associate multiple `GtkStackSwitcher` widgets
   * with the same `GtkStack` widget.
   *
   * # CSS nodes
   *
   * `GtkStackSwitcher` has a single CSS node named stackswitcher and
   * style class .stack-switcher.
   *
   * When circumstances require it, `GtkStackSwitcher` adds the
   * .needs-attention style class to the widgets representing the
   * stack pages.
   *
   * # Accessibility
   *
   * `GtkStackSwitcher` uses the %GTK_ACCESSIBLE_ROLE_TAB_LIST role
   * and uses the %GTK_ACCESSIBLE_ROLE_TAB for its buttons.
   *
   * # Orientable
   *
   * Since GTK 4.4, `GtkStackSwitcher` implements `GtkOrientable` allowing
   * the stack switcher to be made vertical with
   * `gtk_orientable_set_orientation()`.
   * @class
   */
  class StackSwitcher extends Widget {
    // Own properties of Gtk-4.0.Gtk.StackSwitcher

    static name: string

    // Constructors of Gtk-4.0.Gtk.StackSwitcher

    constructor(config?: StackSwitcher.ConstructorProperties)
    /**
     * Create a new `GtkStackSwitcher`.
     * @constructor
     * @returns a new `GtkStackSwitcher`.
     */
    constructor()
    /**
     * Create a new `GtkStackSwitcher`.
     * @constructor
     * @returns a new `GtkStackSwitcher`.
     */
    static new(): StackSwitcher
    _init(config?: StackSwitcher.ConstructorProperties): void
  }

  module Statusbar {
    // Signal callback interfaces

    /**
     * Signal callback interface for `text-popped`
     */
    interface TextPoppedSignalCallback {
      (contextId: number, text: string | null): void
    }

    /**
     * Signal callback interface for `text-pushed`
     */
    interface TextPushedSignalCallback {
      (contextId: number, text: string | null): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {}
  }

  interface Statusbar extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Statusbar

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Statusbar

    /**
     * Returns a new context identifier, given a description
     * of the actual context.
     *
     * Note that the description is not shown in the UI.
     * @param contextDescription textual description of what context   the new message is being used in
     * @returns an integer id
     */
    getContextId(contextDescription: string): number
    /**
     * Removes the first message in the `GtkStatusbar`’s stack
     * with the given context id.
     *
     * Note that this may not change the displayed message,
     * if the message at the top of the stack has a different
     * context id.
     * @param contextId a context identifier
     */
    pop(contextId: number): void
    /**
     * Pushes a new message onto a statusbar’s stack.
     * @param contextId the message’s context id, as returned by    gtk_statusbar_get_context_id()
     * @param text the message to add to the statusbar
     * @returns a message id that can be used with   [method@Gtk.Statusbar.remove].
     */
    push(contextId: number, text: string): number
    /**
     * Forces the removal of a message from a statusbar’s stack.
     * The exact `context_id` and `message_id` must be specified.
     * @param contextId a context identifier
     * @param messageId a message identifier, as returned by [method`Gtk`.Statusbar.push]
     */
    remove(contextId: number, messageId: number): void
    /**
     * Forces the removal of all messages from a statusbar's
     * stack with the exact `context_id`.
     * @param contextId a context identifier
     */
    removeAll(contextId: number): void

    // Own signals of Gtk-4.0.Gtk.Statusbar

    connect(
      sigName: "text-popped",
      callback: Statusbar.TextPoppedSignalCallback
    ): number
    on(
      sigName: "text-popped",
      callback: Statusbar.TextPoppedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "text-popped",
      callback: Statusbar.TextPoppedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "text-popped",
      callback: Statusbar.TextPoppedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "text-popped", text: string | null, ...args: any[]): void
    connect(
      sigName: "text-pushed",
      callback: Statusbar.TextPushedSignalCallback
    ): number
    on(
      sigName: "text-pushed",
      callback: Statusbar.TextPushedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "text-pushed",
      callback: Statusbar.TextPushedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "text-pushed",
      callback: Statusbar.TextPushedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "text-pushed", text: string | null, ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Statusbar

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkStatusbar` widget is usually placed along the bottom of an application's
   * main [class`Gtk`.Window].
   *
   * ![An example GtkStatusbar](statusbar.png)
   *
   * A `GtkStatusBar` may provide a regular commentary of the application's
   * status (as is usually the case in a web browser, for example), or may be
   * used to simply output a message when the status changes, (when an upload
   * is complete in an FTP client, for example).
   *
   * Status bars in GTK maintain a stack of messages. The message at
   * the top of the each bar’s stack is the one that will currently be displayed.
   *
   * Any messages added to a statusbar’s stack must specify a context id that
   * is used to uniquely identify the source of a message. This context id can
   * be generated by [method`Gtk`.Statusbar.get_context_id], given a message and
   * the statusbar that it will be added to. Note that messages are stored in a
   * stack, and when choosing which message to display, the stack structure is
   * adhered to, regardless of the context identifier of a message.
   *
   * One could say that a statusbar maintains one stack of messages for
   * display purposes, but allows multiple message producers to maintain
   * sub-stacks of the messages they produced (via context ids).
   *
   * Status bars are created using [ctor`Gtk`.Statusbar.new].
   *
   * Messages are added to the bar’s stack with [method`Gtk`.Statusbar.push].
   *
   * The message at the top of the stack can be removed using
   * [method`Gtk`.Statusbar.pop]. A message can be removed from anywhere in the
   * stack if its message id was recorded at the time it was added. This is done
   * using [method`Gtk`.Statusbar.remove].
   *
   * ## CSS node
   *
   * `GtkStatusbar` has a single CSS node with name `statusbar`.
   * @class
   */
  class Statusbar extends Widget {
    // Own properties of Gtk-4.0.Gtk.Statusbar

    static name: string

    // Constructors of Gtk-4.0.Gtk.Statusbar

    constructor(config?: Statusbar.ConstructorProperties)
    /**
     * Creates a new `GtkStatusbar` ready for messages.
     * @constructor
     * @returns the new `GtkStatusbar`
     */
    constructor()
    /**
     * Creates a new `GtkStatusbar` ready for messages.
     * @constructor
     * @returns the new `GtkStatusbar`
     */
    static new(): Statusbar
    _init(config?: Statusbar.ConstructorProperties): void
  }

  module StringFilter {
    // Constructor properties interface

    interface ConstructorProperties extends Filter.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.StringFilter

      /**
       * The expression to evaluate on item to get a string to compare with.
       */
      expression?: Expression | null
      /**
       * If matching is case sensitive.
       */
      ignore_case?: boolean | null
      /**
       * If exact matches are necessary or if substrings are allowed.
       */
      match_mode?: StringFilterMatchMode | null
      /**
       * The search term.
       */
      search?: string | null
    }
  }

  interface StringFilter {
    // Own properties of Gtk-4.0.Gtk.StringFilter

    /**
     * The expression to evaluate on item to get a string to compare with.
     */
    expression: Expression
    /**
     * If matching is case sensitive.
     */
    ignoreCase: boolean
    /**
     * If exact matches are necessary or if substrings are allowed.
     */
    matchMode: StringFilterMatchMode
    /**
     * The search term.
     */
    search: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.StringFilter

    /**
     * Gets the expression that the string filter uses to
     * obtain strings from items.
     * @returns a `GtkExpression`
     */
    getExpression(): Expression | null
    /**
     * Returns whether the filter ignores case differences.
     * @returns %TRUE if the filter ignores case
     */
    getIgnoreCase(): boolean
    /**
     * Returns the match mode that the filter is using.
     * @returns the match mode of the filter
     */
    getMatchMode(): StringFilterMatchMode
    /**
     * Gets the search term.
     * @returns The search term
     */
    getSearch(): string | null
    /**
     * Sets the expression that the string filter uses to
     * obtain strings from items.
     *
     * The expression must have a value type of %G_TYPE_STRING.
     * @param expression a `GtkExpression`
     */
    setExpression(expression: Expression | null): void
    /**
     * Sets whether the filter ignores case differences.
     * @param ignoreCase %TRUE to ignore case
     */
    setIgnoreCase(ignoreCase: boolean): void
    /**
     * Sets the match mode for the filter.
     * @param mode the new match mode
     */
    setMatchMode(mode: StringFilterMatchMode): void
    /**
     * Sets the string to search for.
     * @param search The string to search for   or %NULL to clear the search
     */
    setSearch(search: string | null): void

    // Class property signals of Gtk-4.0.Gtk.StringFilter

    connect(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expression", ...args: any[]): void
    connect(
      sigName: "notify::ignore-case",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ignore-case",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ignore-case",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ignore-case",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ignore-case", ...args: any[]): void
    connect(
      sigName: "notify::match-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::match-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::match-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::match-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::match-mode", ...args: any[]): void
    connect(
      sigName: "notify::search",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::search",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::search",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::search",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::search", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkStringFilter` determines whether to include items by comparing
   * strings to a fixed search term.
   *
   * The strings are obtained from the items by evaluating a `GtkExpression`
   * set with [method`Gtk`.StringFilter.set_expression], and they are
   * compared against a search term set with [method`Gtk`.StringFilter.set_search].
   *
   * `GtkStringFilter` has several different modes of comparison - it
   * can match the whole string, just a prefix, or any substring. Use
   * [method`Gtk`.StringFilter.set_match_mode] choose a mode.
   *
   * It is also possible to make case-insensitive comparisons, with
   * [method`Gtk`.StringFilter.set_ignore_case].
   * @class
   */
  class StringFilter extends Filter {
    // Own properties of Gtk-4.0.Gtk.StringFilter

    static name: string

    // Constructors of Gtk-4.0.Gtk.StringFilter

    constructor(config?: StringFilter.ConstructorProperties)
    /**
     * Creates a new string filter.
     *
     * You will want to set up the filter by providing a string to search for
     * and by providing a property to look up on the item.
     * @constructor
     * @param expression The expression to evaluate
     * @returns a new `GtkStringFilter`
     */
    constructor(expression: Expression | null)
    /**
     * Creates a new string filter.
     *
     * You will want to set up the filter by providing a string to search for
     * and by providing a property to look up on the item.
     * @constructor
     * @param expression The expression to evaluate
     * @returns a new `GtkStringFilter`
     */
    static new(expression: Expression | null): StringFilter
    _init(config?: StringFilter.ConstructorProperties): void
  }

  module StringList {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        Buildable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.StringList

      strings?: string[] | null
    }
  }

  interface StringList extends Gio.ListModel, Buildable {
    // Own properties of Gtk-4.0.Gtk.StringList

    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    readonly strings: string[]
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.StringList

    /**
     * Appends `string` to `self`.
     *
     * The `string` will be copied. See
     * [method`Gtk`.StringList.take] for a way to avoid that.
     * @param string the string to insert
     */
    append(string: string): void
    /**
     * Gets the string that is at `position` in `self`.
     *
     * If `self` does not contain `position` items, %NULL is returned.
     *
     * This function returns the const char *. To get the
     * object wrapping it, use g_list_model_get_item().
     * @param position the position to get the string for
     * @returns the string at the given position
     */
    getString(position: number): string | null
    /**
     * Removes the string at `position` from `self`.
     *
     * `position` must be smaller than the current
     * length of the list.
     * @param position the position of the string that is to be removed
     */
    remove(position: number): void
    /**
     * Changes `self` by removing `n_removals` strings and adding `additions`
     * to it.
     *
     * This function is more efficient than [method`Gtk`.StringList.append]
     * and [method`Gtk`.StringList.remove], because it only emits the
     * ::items-changed signal once for the change.
     *
     * This function copies the strings in `additions`.
     *
     * The parameters `position` and `n_removals` must be correct (ie:
     * `position` + `n_removals` must be less than or equal to the length
     * of the list at the time this function is called).
     * @param position the position at which to make the change
     * @param nRemovals the number of strings to remove
     * @param additions The strings to add
     */
    splice(
      position: number,
      nRemovals: number,
      additions: string[] | null
    ): void
    /**
     * Adds `string` to self at the end, and takes
     * ownership of it.
     *
     * This variant of [method`Gtk`.StringList.append]
     * is convenient for formatting strings:
     *
     * ```c
     * gtk_string_list_take (self, g_strdup_print ("%d dollars", lots));
     * ```
     * @param string the string to insert
     */
    take(string: string | null): void

    // Class property signals of Gtk-4.0.Gtk.StringList

    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::strings",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strings",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strings",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strings", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkStringList` is a list model that wraps an array of strings.
   *
   * The objects in the model are of type [class`Gtk`.StringObject] and have
   * a "string" property that can be used inside expressions.
   *
   * `GtkStringList` is well-suited for any place where you would
   * typically use a `char*[]`, but need a list model.
   *
   * ## GtkStringList as GtkBuildable
   *
   * The `GtkStringList` implementation of the `GtkBuildable` interface
   * supports adding items directly using the `<items>` element and
   * specifying `<item>` elements for each item. Each `<item>` element
   * supports the regular translation attributes “translatable”,
   * “context” and “comments”.
   *
   * Here is a UI definition fragment specifying a `GtkStringList`
   *
   * ```xml
   * <object class="GtkStringList">
   *   <items>
   *     <item translatable="yes">Factory</item>
   *     <item translatable="yes">Home</item>
   *     <item translatable="yes">Subway</item>
   *   </items>
   * </object>
   * ```
   * @class
   */
  class StringList extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.StringList

    static name: string

    // Constructors of Gtk-4.0.Gtk.StringList

    constructor(config?: StringList.ConstructorProperties)
    /**
     * Creates a new `GtkStringList` with the given `strings`.
     * @constructor
     * @param strings The strings to put in the model
     * @returns a new `GtkStringList`
     */
    constructor(strings: string[] | null)
    /**
     * Creates a new `GtkStringList` with the given `strings`.
     * @constructor
     * @param strings The strings to put in the model
     * @returns a new `GtkStringList`
     */
    static new(strings: string[] | null): StringList
    _init(config?: StringList.ConstructorProperties): void
  }

  module StringObject {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface StringObject {
    // Own properties of Gtk-4.0.Gtk.StringObject

    /**
     * The string.
     */
    readonly string: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.StringObject

    /**
     * Returns the string contained in a `GtkStringObject`.
     * @returns the string of @self
     */
    getString(): string

    // Class property signals of Gtk-4.0.Gtk.StringObject

    connect(
      sigName: "notify::string",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::string",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::string",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::string",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::string", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkStringObject` is the type of items in a `GtkStringList`.
   *
   * A `GtkStringObject` is a wrapper around a `const char*`; it has
   * a [property`Gtk`.StringObject:string] property that can be used
   * for property bindings and expressions.
   * @class
   */
  class StringObject extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.StringObject

    static name: string

    // Constructors of Gtk-4.0.Gtk.StringObject

    constructor(config?: StringObject.ConstructorProperties)
    /**
     * Wraps a string in an object for use with `GListModel`.
     * @constructor
     * @param string The string to wrap
     * @returns a new `GtkStringObject`
     */
    constructor(string: string)
    /**
     * Wraps a string in an object for use with `GListModel`.
     * @constructor
     * @param string The string to wrap
     * @returns a new `GtkStringObject`
     */
    static new(string: string): StringObject
    _init(config?: StringObject.ConstructorProperties): void
  }

  module StringSorter {
    // Constructor properties interface

    interface ConstructorProperties extends Sorter.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.StringSorter

      /**
       * The collation method to use for sorting.
       *
       * The `GTK_COLLATION_NONE` value is useful when the expression already
       * returns collation keys, or strings that need to be compared byte-by-byte.
       *
       * The default value, `GTK_COLLATION_UNICODE`, compares strings according
       * to the [Unicode collation algorithm](https://www.unicode.org/reports/tr10/).
       */
      collation?: Collation | null
      /**
       * The expression to evaluate on item to get a string to compare with.
       */
      expression?: Expression | null
      /**
       * If sorting is case sensitive.
       */
      ignore_case?: boolean | null
    }
  }

  interface StringSorter {
    // Own properties of Gtk-4.0.Gtk.StringSorter

    /**
     * The collation method to use for sorting.
     *
     * The `GTK_COLLATION_NONE` value is useful when the expression already
     * returns collation keys, or strings that need to be compared byte-by-byte.
     *
     * The default value, `GTK_COLLATION_UNICODE`, compares strings according
     * to the [Unicode collation algorithm](https://www.unicode.org/reports/tr10/).
     */
    collation: Collation
    /**
     * The expression to evaluate on item to get a string to compare with.
     */
    expression: Expression
    /**
     * If sorting is case sensitive.
     */
    ignoreCase: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.StringSorter

    /**
     * Gets which collation method the sorter uses.
     * @returns The collation method
     */
    getCollation(): Collation
    /**
     * Gets the expression that is evaluated to obtain strings from items.
     * @returns a `GtkExpression`
     */
    getExpression(): Expression | null
    /**
     * Gets whether the sorter ignores case differences.
     * @returns %TRUE if @self is ignoring case differences
     */
    getIgnoreCase(): boolean
    /**
     * Sets the collation method to use for sorting.
     * @param collation the collation method
     */
    setCollation(collation: Collation): void
    /**
     * Sets the expression that is evaluated to obtain strings from items.
     *
     * The expression must have the type %G_TYPE_STRING.
     * @param expression a `GtkExpression`
     */
    setExpression(expression: Expression | null): void
    /**
     * Sets whether the sorter will ignore case differences.
     * @param ignoreCase %TRUE to ignore case differences
     */
    setIgnoreCase(ignoreCase: boolean): void

    // Class property signals of Gtk-4.0.Gtk.StringSorter

    connect(
      sigName: "notify::collation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::collation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::collation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::collation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::collation", ...args: any[]): void
    connect(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expression",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expression",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expression", ...args: any[]): void
    connect(
      sigName: "notify::ignore-case",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::ignore-case",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::ignore-case",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::ignore-case",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::ignore-case", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkStringSorter` is a `GtkSorter` that compares strings.
   *
   * It does the comparison in a linguistically correct way using the
   * current locale by normalizing Unicode strings and possibly case-folding
   * them before performing the comparison.
   *
   * To obtain the strings to compare, this sorter evaluates a
   * [class`Gtk`.Expression].
   * @class
   */
  class StringSorter extends Sorter {
    // Own properties of Gtk-4.0.Gtk.StringSorter

    static name: string

    // Constructors of Gtk-4.0.Gtk.StringSorter

    constructor(config?: StringSorter.ConstructorProperties)
    /**
     * Creates a new string sorter that compares items using the given
     * `expression`.
     *
     * Unless an expression is set on it, this sorter will always
     * compare items as invalid.
     * @constructor
     * @param expression The expression to evaluate
     * @returns a new `GtkStringSorter`
     */
    constructor(expression: Expression | null)
    /**
     * Creates a new string sorter that compares items using the given
     * `expression`.
     *
     * Unless an expression is set on it, this sorter will always
     * compare items as invalid.
     * @constructor
     * @param expression The expression to evaluate
     * @returns a new `GtkStringSorter`
     */
    static new(expression: Expression | null): StringSorter
    _init(config?: StringSorter.ConstructorProperties): void
  }

  module StyleContext {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.StyleContext

      display?: Gdk.Display | null
    }
  }

  interface StyleContext {
    // Own properties of Gtk-4.0.Gtk.StyleContext

    display: Gdk.Display
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.StyleContext

    parentObject: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.StyleContext

    /**
     * Adds a style class to `context,` so later uses of the
     * style context will make use of this new class for styling.
     *
     * In the CSS file format, a `GtkEntry` defining a “search”
     * class, would be matched by:
     *
     * ```css
     * entry.search { ... }
     * ```
     *
     * While any widget defining a “search” class would be
     * matched by:
     * ```css
     * .search { ... }
     * ```
     * @param className class name to use in styling
     */
    addClass(className: string): void
    /**
     * Adds a style provider to `context,` to be used in style construction.
     *
     * Note that a style provider added by this function only affects
     * the style of the widget to which `context` belongs. If you want
     * to affect the style of all widgets, use
     * [func`Gtk`.StyleContext.add_provider_for_display].
     *
     * Note: If both priorities are the same, a `GtkStyleProvider`
     * added through this function takes precedence over another added
     * through [func`Gtk`.StyleContext.add_provider_for_display].
     * @param provider a `GtkStyleProvider`
     * @param priority the priority of the style provider. The lower   it is, the earlier it will be used in the style construction.   Typically this will be in the range between   %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and   %GTK_STYLE_PROVIDER_PRIORITY_USER
     */
    addProvider(provider: StyleProvider, priority: number): void
    /**
     * Gets the border for a given state as a `GtkBorder`.
     */
    getBorder(): /* border */ Border
    /**
     * Gets the foreground color for a given state.
     */
    getColor(): /* color */ Gdk.RGBA
    /**
     * Returns the `GdkDisplay` to which `context` is attached.
     * @returns a `GdkDisplay`.
     */
    getDisplay(): Gdk.Display
    /**
     * Gets the margin for a given state as a `GtkBorder`.
     */
    getMargin(): /* margin */ Border
    /**
     * Gets the padding for a given state as a `GtkBorder`.
     */
    getPadding(): /* padding */ Border
    /**
     * Returns the scale used for assets.
     * @returns the scale
     */
    getScale(): number
    /**
     * Returns the state used for style matching.
     *
     * This method should only be used to retrieve the `GtkStateFlags`
     * to pass to `GtkStyleContext` methods, like
     * [method`Gtk`.StyleContext.get_padding].
     * If you need to retrieve the current state of a `GtkWidget`, use
     * [method`Gtk`.Widget.get_state_flags].
     * @returns the state flags
     */
    getState(): StateFlags
    /**
     * Returns %TRUE if `context` currently has defined the
     * given class name.
     * @param className a class name
     * @returns %TRUE if @context has @class_name defined
     */
    hasClass(className: string): boolean
    /**
     * Looks up and resolves a color name in the `context` color map.
     * @param colorName color name to lookup
     * @returns %TRUE if @color_name was found and resolved, %FALSE otherwise
     */
    lookupColor(
      colorName: string
    ): [/* returnType */ boolean, /* color */ Gdk.RGBA]
    /**
     * Removes `class_name` from `context`.
     * @param className class name to remove
     */
    removeClass(className: string): void
    /**
     * Removes `provider` from the style providers list in `context`.
     * @param provider a `GtkStyleProvider`
     */
    removeProvider(provider: StyleProvider): void
    /**
     * Restores `context` state to a previous stage.
     *
     * See [method`Gtk`.StyleContext.save].
     */
    restore(): void
    /**
     * Saves the `context` state.
     *
     * This allows temporary modifications done through
     * [method`Gtk`.StyleContext.add_class],
     * [method`Gtk`.StyleContext.remove_class],
     * [method`Gtk`.StyleContext.set_state] to be quickly
     * reverted in one go through [method`Gtk`.StyleContext.restore].
     *
     * The matching call to [method`Gtk`.StyleContext.restore]
     * must be done before GTK returns to the main loop.
     */
    save(): void
    /**
     * Attaches `context` to the given display.
     *
     * The display is used to add style information from “global”
     * style providers, such as the display's `GtkSettings` instance.
     *
     * If you are using a `GtkStyleContext` returned from
     * [method`Gtk`.Widget.get_style_context], you do not need to
     * call this yourself.
     * @param display a `GdkDisplay`
     */
    setDisplay(display: Gdk.Display): void
    /**
     * Sets the scale to use when getting image assets for the style.
     * @param scale scale
     */
    setScale(scale: number): void
    /**
     * Sets the state to be used for style matching.
     * @param flags state to represent
     */
    setState(flags: StateFlags): void
    /**
     * Converts the style context into a string representation.
     *
     * The string representation always includes information about
     * the name, state, id, visibility and style classes of the CSS
     * node that is backing `context`. Depending on the flags, more
     * information may be included.
     *
     * This function is intended for testing and debugging of the
     * CSS implementation in GTK. There are no guarantees about
     * the format of the returned string, it may change.
     * @param flags Flags that determine what to print
     * @returns a newly allocated string representing @context
     */
    toString(flags: StyleContextPrintFlags): string | null

    // Own virtual methods of Gtk-4.0.Gtk.StyleContext

    changed(): void

    // Class property signals of Gtk-4.0.Gtk.StyleContext

    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkStyleContext` stores styling information affecting a widget.
   *
   * In order to construct the final style information, `GtkStyleContext`
   * queries information from all attached `GtkStyleProviders`. Style
   * providers can be either attached explicitly to the context through
   * [method`Gtk`.StyleContext.add_provider], or to the display through
   * [func`Gtk`.StyleContext.add_provider_for_display]. The resulting
   * style is a combination of all providers’ information in priority order.
   *
   * For GTK widgets, any `GtkStyleContext` returned by
   * [method`Gtk`.Widget.get_style_context] will already have a `GdkDisplay`
   * and RTL/LTR information set. The style context will also be updated
   * automatically if any of these settings change on the widget.
   *
   * ## Style Classes
   *
   * Widgets can add style classes to their context, which can be used to associate
   * different styles by class. The documentation for individual widgets lists
   * which style classes it uses itself, and which style classes may be added by
   * applications to affect their appearance.
   *
   * # Custom styling in UI libraries and applications
   *
   * If you are developing a library with custom widgets that render differently
   * than standard components, you may need to add a `GtkStyleProvider` yourself
   * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority, either a
   * `GtkCssProvider` or a custom object implementing the `GtkStyleProvider`
   * interface. This way themes may still attempt to style your UI elements in
   * a different way if needed so.
   *
   * If you are using custom styling on an applications, you probably want then
   * to make your style information prevail to the theme’s, so you must use
   * a `GtkStyleProvider` with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
   * priority, keep in mind that the user settings in
   * `XDG_CONFIG_HOME/gtk-4.0/gtk.css` will
   * still take precedence over your changes, as it uses the
   * %GTK_STYLE_PROVIDER_PRIORITY_USER priority.
   * @class
   */
  class StyleContext extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.StyleContext

    static name: string

    // Constructors of Gtk-4.0.Gtk.StyleContext

    constructor(config?: StyleContext.ConstructorProperties)
    _init(config?: StyleContext.ConstructorProperties): void
    /**
     * Adds a global style provider to `display,` which will be used
     * in style construction for all `GtkStyleContexts` under `display`.
     *
     * GTK uses this to make styling information from `GtkSettings`
     * available.
     *
     * Note: If both priorities are the same, A `GtkStyleProvider`
     * added through [method`Gtk`.StyleContext.add_provider] takes
     * precedence over another added through this function.
     * @param display a `GdkDisplay`
     * @param provider a `GtkStyleProvider`
     * @param priority the priority of the style provider. The lower   it is, the earlier it will be used in the style construction.   Typically this will be in the range between   %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and   %GTK_STYLE_PROVIDER_PRIORITY_USER
     */
    static addProviderForDisplay(
      display: Gdk.Display,
      provider: StyleProvider,
      priority: number
    ): void
    /**
     * Removes `provider` from the global style providers list in `display`.
     * @param display a `GdkDisplay`
     * @param provider a `GtkStyleProvider`
     */
    static removeProviderForDisplay(
      display: Gdk.Display,
      provider: StyleProvider
    ): void
  }

  module Switch {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `state-set`
     */
    interface StateSetSignalCallback {
      (state: boolean): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Actionable.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Switch

      /**
       * Whether the `GtkSwitch` widget is in its on or off state.
       */
      active?: boolean | null
      /**
       * The backend state that is controlled by the switch.
       *
       * See [signal`Gtk`.Switch::state-set] for details.
       */
      state?: boolean | null
    }
  }

  interface Switch extends Accessible, Actionable, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Switch

    /**
     * Whether the `GtkSwitch` widget is in its on or off state.
     */
    active: boolean
    /**
     * The backend state that is controlled by the switch.
     *
     * See [signal`Gtk`.Switch::state-set] for details.
     */
    state: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Switch

    /**
     * Gets whether the `GtkSwitch` is in its “on” or “off” state.
     * @returns %TRUE if the `GtkSwitch` is active, and %FALSE otherwise
     */
    getActive(): boolean
    /**
     * Gets the underlying state of the `GtkSwitch`.
     * @returns the underlying state
     */
    getState(): boolean
    /**
     * Changes the state of `self` to the desired one.
     * @param isActive %TRUE if `self` should be active, and %FALSE otherwise
     */
    setActive(isActive: boolean): void
    /**
     * Sets the underlying state of the `GtkSwitch`.
     *
     * This function is typically called from a [signal`Gtk`.Switch::state-set]
     * signal handler in order to set up delayed state changes.
     *
     * See [signal`Gtk`.Switch::state-set] for details.
     * @param state the new state
     */
    setState(state: boolean): void

    // Own signals of Gtk-4.0.Gtk.Switch

    connect(
      sigName: "activate",
      callback: Switch.ActivateSignalCallback
    ): number
    on(
      sigName: "activate",
      callback: Switch.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: Switch.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: Switch.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "state-set",
      callback: Switch.StateSetSignalCallback
    ): number
    on(
      sigName: "state-set",
      callback: Switch.StateSetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "state-set",
      callback: Switch.StateSetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "state-set",
      callback: Switch.StateSetSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "state-set", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Switch

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::state",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::state",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::state", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-target", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkSwitch` is a "light switch" that has two states: on or off.
   *
   * ![An example GtkSwitch](switch.png)
   *
   * The user can control which state should be active by clicking the
   * empty area, or by dragging the handle.
   *
   * `GtkSwitch` can also handle situations where the underlying state
   * changes with a delay. In this case, the slider position indicates
   * the user's recent change (as indicated by the [property`Gtk`.Switch:active]
   * property), and the color indicates whether the underlying state (represented
   * by the [property`Gtk`.Switch:state] property) has been updated yet.
   *
   * ![GtkSwitch with delayed state change](switch-state.png)
   *
   * See [signal`Gtk`.Switch::state-set] for details.
   *
   * # CSS nodes
   *
   * ```
   * switch
   * ├── image
   * ├── image
   * ╰── slider
   * ```
   *
   * `GtkSwitch` has four css nodes, the main node with the name switch and
   * subnodes for the slider and the on and off images. Neither of them is
   * using any style classes.
   *
   * # Accessibility
   *
   * `GtkSwitch` uses the %GTK_ACCESSIBLE_ROLE_SWITCH role.
   * @class
   */
  class Switch extends Widget {
    // Own properties of Gtk-4.0.Gtk.Switch

    static name: string

    // Constructors of Gtk-4.0.Gtk.Switch

    constructor(config?: Switch.ConstructorProperties)
    /**
     * Creates a new `GtkSwitch` widget.
     * @constructor
     * @returns the newly created `GtkSwitch` instance
     */
    constructor()
    /**
     * Creates a new `GtkSwitch` widget.
     * @constructor
     * @returns the newly created `GtkSwitch` instance
     */
    static new(): Switch
    _init(config?: Switch.ConstructorProperties): void
  }

  module Text {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate`
     */
    interface ActivateSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `backspace`
     */
    interface BackspaceSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `copy-clipboard`
     */
    interface CopyClipboardSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `cut-clipboard`
     */
    interface CutClipboardSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `delete-from-cursor`
     */
    interface DeleteFromCursorSignalCallback {
      (type: DeleteType, count: number): void
    }

    /**
     * Signal callback interface for `insert-at-cursor`
     */
    interface InsertAtCursorSignalCallback {
      (string: string | null): void
    }

    /**
     * Signal callback interface for `insert-emoji`
     */
    interface InsertEmojiSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `move-cursor`
     */
    interface MoveCursorSignalCallback {
      (step: MovementStep, count: number, extend: boolean): void
    }

    /**
     * Signal callback interface for `paste-clipboard`
     */
    interface PasteClipboardSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `preedit-changed`
     */
    interface PreeditChangedSignalCallback {
      (preedit: string | null): void
    }

    /**
     * Signal callback interface for `toggle-overwrite`
     */
    interface ToggleOverwriteSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleText.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Editable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Text

      /**
       * Whether to activate the default widget when Enter is pressed.
       */
      activates_default?: boolean | null
      /**
       * A list of Pango attributes to apply to the text of the `GtkText`.
       *
       * This is mainly useful to change the size or weight of the text.
       *
       * The `PangoAttribute`'s `start_index` and `end_index` must refer to the
       * `GtkEntryBuffer` text, i.e. without the preedit string.
       */
      attributes?: Pango.AttrList | null
      /**
       * The `GtkEntryBuffer` object which stores the text.
       */
      buffer?: EntryBuffer | null
      /**
       * Whether to suggest Emoji replacements.
       */
      enable_emoji_completion?: boolean | null
      /**
       * A menu model whose contents will be appended to
       * the context menu.
       */
      extra_menu?: Gio.MenuModel | null
      /**
       * Which IM (input method) module should be used for this self.
       *
       * See [class`Gtk`.IMMulticontext].
       *
       * Setting this to a non-%NULL value overrides the system-wide
       * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
       * property.
       */
      im_module?: string | null
      /**
       * Additional hints that allow input methods to fine-tune
       * their behaviour.
       */
      input_hints?: InputHints | null
      /**
       * The purpose of this text field.
       *
       * This property can be used by on-screen keyboards and other input
       * methods to adjust their behaviour.
       *
       * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
       * %GTK_INPUT_PURPOSE_PIN is independent from setting
       * [property`Gtk`.Text:visibility].
       */
      input_purpose?: InputPurpose | null
      /**
       * The character to used when masking contents (in “password mode”).
       */
      invisible_char?: number | null
      /**
       * Whether the invisible char has been set for the `GtkText`.
       */
      invisible_char_set?: boolean | null
      /**
       * Maximum number of characters that are allowed.
       *
       * Zero indicates no limit.
       */
      max_length?: number | null
      /**
       * If text is overwritten when typing in the `GtkText`.
       */
      overwrite_mode?: boolean | null
      /**
       * The text that will be displayed in the `GtkText` when it is empty
       * and unfocused.
       */
      placeholder_text?: string | null
      /**
       * Whether the widget should grow and shrink with the content.
       */
      propagate_text_width?: boolean | null
      /**
       * A list of tabstops to apply to the text of the `GtkText`.
       */
      tabs?: Pango.TabArray | null
      /**
       * When %TRUE, pasted multi-line text is truncated to the first line.
       */
      truncate_multiline?: boolean | null
      /**
       * If %FALSE, the text is masked with the “invisible char”.
       */
      visibility?: boolean | null
    }
  }

  interface Text
    extends Accessible,
      AccessibleText,
      Buildable,
      ConstraintTarget,
      Editable {
    // Own properties of Gtk-4.0.Gtk.Text

    /**
     * Whether to activate the default widget when Enter is pressed.
     */
    activatesDefault: boolean
    /**
     * A list of Pango attributes to apply to the text of the `GtkText`.
     *
     * This is mainly useful to change the size or weight of the text.
     *
     * The `PangoAttribute`'s `start_index` and `end_index` must refer to the
     * `GtkEntryBuffer` text, i.e. without the preedit string.
     */
    attributes: Pango.AttrList
    /**
     * The `GtkEntryBuffer` object which stores the text.
     */
    buffer: EntryBuffer
    /**
     * Whether to suggest Emoji replacements.
     */
    enableEmojiCompletion: boolean
    /**
     * A menu model whose contents will be appended to
     * the context menu.
     */
    extraMenu: Gio.MenuModel
    /**
     * Which IM (input method) module should be used for this self.
     *
     * See [class`Gtk`.IMMulticontext].
     *
     * Setting this to a non-%NULL value overrides the system-wide
     * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
     * property.
     */
    imModule: string | null
    /**
     * Additional hints that allow input methods to fine-tune
     * their behaviour.
     */
    inputHints: InputHints
    /**
     * The purpose of this text field.
     *
     * This property can be used by on-screen keyboards and other input
     * methods to adjust their behaviour.
     *
     * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
     * %GTK_INPUT_PURPOSE_PIN is independent from setting
     * [property`Gtk`.Text:visibility].
     */
    inputPurpose: InputPurpose
    /**
     * The character to used when masking contents (in “password mode”).
     */
    invisibleChar: number
    /**
     * Whether the invisible char has been set for the `GtkText`.
     */
    invisibleCharSet: boolean
    /**
     * Maximum number of characters that are allowed.
     *
     * Zero indicates no limit.
     */
    maxLength: number
    /**
     * If text is overwritten when typing in the `GtkText`.
     */
    overwriteMode: boolean
    /**
     * The text that will be displayed in the `GtkText` when it is empty
     * and unfocused.
     */
    placeholderText: string | null
    /**
     * Whether the widget should grow and shrink with the content.
     */
    propagateTextWidth: boolean
    /**
     * Number of pixels scrolled of the screen to the left.
     */
    readonly scrollOffset: number
    /**
     * A list of tabstops to apply to the text of the `GtkText`.
     */
    tabs: Pango.TabArray
    /**
     * When %TRUE, pasted multi-line text is truncated to the first line.
     */
    truncateMultiline: boolean
    /**
     * If %FALSE, the text is masked with the “invisible char”.
     */
    visibility: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Text

    /**
     * Determine the positions of the strong and weak cursors if the
     * insertion point in the layout is at `position`.
     *
     * The position of each cursor is stored as a zero-width rectangle.
     * The strong cursor location is the location where characters of
     * the directionality equal to the base direction are inserted.
     * The weak cursor location is the location where characters of
     * the directionality opposite to the base direction are inserted.
     *
     * The rectangle positions are in widget coordinates.
     * @param position the character position
     */
    computeCursorExtents(
      position: number
    ): [/* strong */ Graphene.Rect, /* weak */ Graphene.Rect]
    /**
     * Returns whether pressing Enter will activate
     * the default widget for the window containing `self`.
     *
     * See [method`Gtk`.Text.set_activates_default].
     * @returns %TRUE if the `GtkText` will activate the default widget
     */
    getActivatesDefault(): boolean
    /**
     * Gets the attribute list that was set on the `GtkText`.
     *
     * See [method`Gtk`.Text.set_attributes].
     * @returns the attribute list
     */
    getAttributes(): Pango.AttrList | null

    // Overloads of getAttributes

    /**
     * Retrieves the text attributes inside the accessible object.
     *
     * Each attribute is composed by:
     *
     * - a range
     * - a name
     * - a value
     *
     * It is left to the implementation to determine the serialization format
     * of the value to a string.
     *
     * GTK provides support for various text attribute names and values, but
     * implementations of this interface are free to add their own attributes.
     *
     * If this function returns true, `n_ranges` will be set to a value
     * greater than or equal to one, `ranges` will be set to a newly
     * allocated array of [struct#Gtk.AccessibleTextRange].
     * @virtual
     * @param offset the offset, in characters
     * @returns true if the accessible object has at least an attribute,   and false otherwise
     */
    getAttributes(
      offset: number
    ): [
      /* returnType */ boolean,
      /* ranges */ AccessibleTextRange[],
      /* attributeNames */ string[],
      /* attributeValues */ string[],
    ]
    /**
     * Get the `GtkEntryBuffer` object which holds the text for
     * this widget.
     * @returns A `GtkEntryBuffer` object.
     */
    getBuffer(): EntryBuffer
    /**
     * Returns whether Emoji completion is enabled for this
     * `GtkText` widget.
     * @returns %TRUE if Emoji completion is enabled
     */
    getEnableEmojiCompletion(): boolean
    /**
     * Gets the menu model for extra items in the context menu.
     *
     * See [method`Gtk`.Text.set_extra_menu].
     * @returns the menu model
     */
    getExtraMenu(): Gio.MenuModel | null
    /**
     * Gets the input hints of the `GtkText`.
     */
    getInputHints(): InputHints
    /**
     * Gets the input purpose of the `GtkText`.
     */
    getInputPurpose(): InputPurpose
    /**
     * Retrieves the character displayed when visibility is set to false.
     *
     * Note that GTK does not compute this value unless it needs it,
     * so the value returned by this function is not very useful unless
     * it has been explicitly set with [method`Gtk`.Text.set_invisible_char].
     * @returns the current invisible char, or 0, if @text does not   show invisible text at all.
     */
    getInvisibleChar(): string
    /**
     * Retrieves the maximum allowed length of the text in `self`.
     *
     * See [method`Gtk`.Text.set_max_length].
     *
     * This is equivalent to getting `self'`s `GtkEntryBuffer` and
     * calling [method`Gtk`.EntryBuffer.get_max_length] on it.
     * @returns the maximum allowed number of characters   in `GtkText`, or 0 if there is no maximum.
     */
    getMaxLength(): number
    /**
     * Gets whether text is overwritten when typing in the `GtkText`.
     *
     * See [method`Gtk`.Text.set_overwrite_mode].
     * @returns whether the text is overwritten when typing
     */
    getOverwriteMode(): boolean
    /**
     * Retrieves the text that will be displayed when
     * `self` is empty and unfocused
     *
     * If no placeholder text has been set, %NULL will be returned.
     * @returns the placeholder text
     */
    getPlaceholderText(): string | null
    /**
     * Returns whether the `GtkText` will grow and shrink
     * with the content.
     * @returns %TRUE if @self will propagate the text width
     */
    getPropagateTextWidth(): boolean
    /**
     * Gets the tabstops that were set on the `GtkText`.
     *
     * See [method`Gtk`.Text.set_tabs].
     * @returns the tabstops
     */
    getTabs(): Pango.TabArray | null
    /**
     * Retrieves the current length of the text in `self`.
     *
     * This is equivalent to getting `self'`s `GtkEntryBuffer`
     * and calling [method`Gtk`.EntryBuffer.get_length] on it.
     * @returns the current number of characters   in `GtkText`, or 0 if there are none.
     */
    getTextLength(): number
    /**
     * Returns whether the `GtkText` will truncate multi-line text
     * that is pasted into the widget
     * @returns %TRUE if @self will truncate multi-line text
     */
    getTruncateMultiline(): boolean
    /**
     * Retrieves whether the text in `self` is visible.
     * @returns %TRUE if the text is currently visible
     */
    getVisibility(): boolean
    /**
     * Causes `self` to have keyboard focus.
     *
     * It behaves like [method`Gtk`.Widget.grab_focus],
     * except that it doesn't select the contents of `self`.
     * You only want to call this on some special entries
     * which the user usually doesn't want to replace all text in,
     * such as search-as-you-type entries.
     * @returns %TRUE if focus is now inside @self
     */
    grabFocusWithoutSelecting(): boolean
    /**
     * If `activates` is %TRUE, pressing Enter will activate
     * the default widget for the window containing `self`.
     *
     * This usually means that the dialog containing the `GtkText`
     * will be closed, since the default widget is usually one of
     * the dialog buttons.
     * @param activates %TRUE to activate window’s default widget on Enter keypress
     */
    setActivatesDefault(activates: boolean): void
    /**
     * Sets attributes that are applied to the text.
     * @param attrs a `PangoAttrList`
     */
    setAttributes(attrs: Pango.AttrList | null): void
    /**
     * Set the `GtkEntryBuffer` object which holds the text for
     * this widget.
     * @param buffer a `GtkEntryBuffer`
     */
    setBuffer(buffer: EntryBuffer): void
    /**
     * Sets whether Emoji completion is enabled.
     *
     * If it is, typing ':', followed by a recognized keyword,
     * will pop up a window with suggested Emojis matching the
     * keyword.
     * @param enableEmojiCompletion %TRUE to enable Emoji completion
     */
    setEnableEmojiCompletion(enableEmojiCompletion: boolean): void
    /**
     * Sets a menu model to add when constructing
     * the context menu for `self`.
     * @param model a `GMenuModel`
     */
    setExtraMenu(model: Gio.MenuModel | null): void
    /**
     * Sets input hints that allow input methods
     * to fine-tune their behaviour.
     * @param hints the hints
     */
    setInputHints(hints: InputHints): void
    /**
     * Sets the input purpose of the `GtkText`.
     *
     * This can be used by on-screen keyboards and other
     * input methods to adjust their behaviour.
     * @param purpose the purpose
     */
    setInputPurpose(purpose: InputPurpose): void
    /**
     * Sets the character to use when in “password mode”.
     *
     * By default, GTK picks the best invisible char available in the
     * current font. If you set the invisible char to 0, then the user
     * will get no feedback at all; there will be no text on the screen
     * as they type.
     * @param ch a Unicode character
     */
    setInvisibleChar(ch: string): void
    /**
     * Sets the maximum allowed length of the contents of the widget.
     *
     * If the current contents are longer than the given length, then
     * they will be truncated to fit.
     *
     * This is equivalent to getting `self'`s `GtkEntryBuffer` and
     * calling [method`Gtk`.EntryBuffer.set_max_length] on it.
     * @param length the maximum length of the `GtkText`, or 0 for no maximum.   (other than the maximum length of entries.) The value passed   in will be clamped to the range 0-65536.
     */
    setMaxLength(length: number): void
    /**
     * Sets whether the text is overwritten when typing
     * in the `GtkText`.
     * @param overwrite new value
     */
    setOverwriteMode(overwrite: boolean): void
    /**
     * Sets text to be displayed in `self` when it is empty.
     *
     * This can be used to give a visual hint of the expected
     * contents of the `GtkText`.
     * @param text a string to be displayed when `self`   is empty and unfocused
     */
    setPlaceholderText(text: string | null): void
    /**
     * Sets whether the `GtkText` should grow and shrink with the content.
     * @param propagateTextWidth %TRUE to propagate the text width
     */
    setPropagateTextWidth(propagateTextWidth: boolean): void
    /**
     * Sets tabstops that are applied to the text.
     * @param tabs a `PangoTabArray`
     */
    setTabs(tabs: Pango.TabArray | null): void
    /**
     * Sets whether the `GtkText` should truncate multi-line text
     * that is pasted into the widget.
     * @param truncateMultiline %TRUE to truncate multi-line text
     */
    setTruncateMultiline(truncateMultiline: boolean): void
    /**
     * Sets whether the contents of the `GtkText` are visible or not.
     *
     * When visibility is set to %FALSE, characters are displayed
     * as the invisible char, and will also appear that way when
     * the text in the widget is copied to the clipboard.
     *
     * By default, GTK picks the best invisible character available
     * in the current font, but it can be changed with
     * [method`Gtk`.Text.set_invisible_char].
     *
     * Note that you probably want to set [property`Gtk`.Text:input-purpose]
     * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
     * inform input methods about the purpose of this self,
     * in addition to setting visibility to %FALSE.
     * @param visible %TRUE if the contents of the `GtkText` are displayed   as plaintext
     */
    setVisibility(visible: boolean): void
    /**
     * Unsets the invisible char.
     *
     * After calling this, the default invisible
     * char is used again.
     */
    unsetInvisibleChar(): void

    // Own signals of Gtk-4.0.Gtk.Text

    connect(sigName: "activate", callback: Text.ActivateSignalCallback): number
    on(
      sigName: "activate",
      callback: Text.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate",
      callback: Text.ActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate",
      callback: Text.ActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate", ...args: any[]): void
    connect(
      sigName: "backspace",
      callback: Text.BackspaceSignalCallback
    ): number
    on(
      sigName: "backspace",
      callback: Text.BackspaceSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "backspace",
      callback: Text.BackspaceSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "backspace",
      callback: Text.BackspaceSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "backspace", ...args: any[]): void
    connect(
      sigName: "copy-clipboard",
      callback: Text.CopyClipboardSignalCallback
    ): number
    on(
      sigName: "copy-clipboard",
      callback: Text.CopyClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "copy-clipboard",
      callback: Text.CopyClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "copy-clipboard",
      callback: Text.CopyClipboardSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "copy-clipboard", ...args: any[]): void
    connect(
      sigName: "cut-clipboard",
      callback: Text.CutClipboardSignalCallback
    ): number
    on(
      sigName: "cut-clipboard",
      callback: Text.CutClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cut-clipboard",
      callback: Text.CutClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cut-clipboard",
      callback: Text.CutClipboardSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cut-clipboard", ...args: any[]): void
    connect(
      sigName: "delete-from-cursor",
      callback: Text.DeleteFromCursorSignalCallback
    ): number
    on(
      sigName: "delete-from-cursor",
      callback: Text.DeleteFromCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "delete-from-cursor",
      callback: Text.DeleteFromCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "delete-from-cursor",
      callback: Text.DeleteFromCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "delete-from-cursor", count: number, ...args: any[]): void
    connect(
      sigName: "insert-at-cursor",
      callback: Text.InsertAtCursorSignalCallback
    ): number
    on(
      sigName: "insert-at-cursor",
      callback: Text.InsertAtCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-at-cursor",
      callback: Text.InsertAtCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-at-cursor",
      callback: Text.InsertAtCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "insert-at-cursor", ...args: any[]): void
    connect(
      sigName: "insert-emoji",
      callback: Text.InsertEmojiSignalCallback
    ): number
    on(
      sigName: "insert-emoji",
      callback: Text.InsertEmojiSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-emoji",
      callback: Text.InsertEmojiSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-emoji",
      callback: Text.InsertEmojiSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "insert-emoji", ...args: any[]): void
    connect(
      sigName: "move-cursor",
      callback: Text.MoveCursorSignalCallback
    ): number
    on(
      sigName: "move-cursor",
      callback: Text.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-cursor",
      callback: Text.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-cursor",
      callback: Text.MoveCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "move-cursor",
      count: number,
      extend: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "paste-clipboard",
      callback: Text.PasteClipboardSignalCallback
    ): number
    on(
      sigName: "paste-clipboard",
      callback: Text.PasteClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "paste-clipboard",
      callback: Text.PasteClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "paste-clipboard",
      callback: Text.PasteClipboardSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "paste-clipboard", ...args: any[]): void
    connect(
      sigName: "preedit-changed",
      callback: Text.PreeditChangedSignalCallback
    ): number
    on(
      sigName: "preedit-changed",
      callback: Text.PreeditChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "preedit-changed",
      callback: Text.PreeditChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "preedit-changed",
      callback: Text.PreeditChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "preedit-changed", ...args: any[]): void
    connect(
      sigName: "toggle-overwrite",
      callback: Text.ToggleOverwriteSignalCallback
    ): number
    on(
      sigName: "toggle-overwrite",
      callback: Text.ToggleOverwriteSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggle-overwrite",
      callback: Text.ToggleOverwriteSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggle-overwrite",
      callback: Text.ToggleOverwriteSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggle-overwrite", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Text

    connect(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activates-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activates-default", ...args: any[]): void
    connect(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::attributes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::attributes", ...args: any[]): void
    connect(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::buffer", ...args: any[]): void
    connect(
      sigName: "notify::enable-emoji-completion",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-emoji-completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-emoji-completion",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-emoji-completion",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-emoji-completion", ...args: any[]): void
    connect(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::extra-menu", ...args: any[]): void
    connect(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::im-module", ...args: any[]): void
    connect(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-hints", ...args: any[]): void
    connect(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-purpose", ...args: any[]): void
    connect(
      sigName: "notify::invisible-char",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::invisible-char",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::invisible-char",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::invisible-char",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::invisible-char", ...args: any[]): void
    connect(
      sigName: "notify::invisible-char-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::invisible-char-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::invisible-char-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::invisible-char-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::invisible-char-set", ...args: any[]): void
    connect(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-length",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-length", ...args: any[]): void
    connect(
      sigName: "notify::overwrite-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overwrite-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overwrite-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overwrite-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overwrite-mode", ...args: any[]): void
    connect(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::placeholder-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::placeholder-text", ...args: any[]): void
    connect(
      sigName: "notify::propagate-text-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::propagate-text-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::propagate-text-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::propagate-text-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::propagate-text-width", ...args: any[]): void
    connect(
      sigName: "notify::scroll-offset",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scroll-offset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scroll-offset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scroll-offset",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scroll-offset", ...args: any[]): void
    connect(sigName: "notify::tabs", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tabs", ...args: any[]): void
    connect(
      sigName: "notify::truncate-multiline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::truncate-multiline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::truncate-multiline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::truncate-multiline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::truncate-multiline", ...args: any[]): void
    connect(
      sigName: "notify::visibility",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visibility",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visibility",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visibility",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visibility", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-position", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-undo", ...args: any[]): void
    connect(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width-chars", ...args: any[]): void
    connect(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::selection-bound",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::selection-bound", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-chars",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-chars", ...args: any[]): void
    connect(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::xalign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::xalign", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The `GtkText` widget is a single-line text entry widget.
   *
   * `GtkText` is the common implementation of single-line text editing
   * that is shared between [class`Gtk`.Entry], [class`Gtk`.PasswordEntry],
   * [class`Gtk`.SpinButton], and other widgets. In all of these, `GtkText` is
   * used as the delegate for the [iface`Gtk`.Editable] implementation.
   *
   * A fairly large set of key bindings are supported by default. If the
   * entered text is longer than the allocation of the widget, the widget
   * will scroll so that the cursor position is visible.
   *
   * When using an entry for passwords and other sensitive information,
   * it can be put into “password mode” using [method`Gtk`.Text.set_visibility].
   * In this mode, entered text is displayed using a “invisible” character.
   * By default, GTK picks the best invisible character that is available
   * in the current font, but it can be changed with
   * [method`Gtk`.Text.set_invisible_char].
   *
   * If you are looking to add icons or progress display in an entry, look
   * at [class`Gtk`.Entry]. There other alternatives for more specialized use
   * cases, such as [class`Gtk`.SearchEntry].
   *
   * If you need multi-line editable text, look at [class`Gtk`.TextView].
   *
   * # CSS nodes
   *
   * ```
   * text[.read-only]
   * ├── placeholder
   * ├── undershoot.left
   * ├── undershoot.right
   * ├── [selection]
   * ├── [block-cursor]
   * ╰── [window.popup]
   * ```
   *
   * `GtkText` has a main node with the name `text`. Depending on the properties
   * of the widget, the `.read-only` style class may appear.
   *
   * When the entry has a selection, it adds a subnode with the name `selection`.
   *
   * When the entry is in overwrite mode, it adds a subnode with the name
   * `block-cursor` that determines how the block cursor is drawn.
   *
   * The CSS node for a context menu is added as a subnode with the name `popup`.
   *
   * The `undershoot` nodes are used to draw the underflow indication when content
   * is scrolled out of view. These nodes get the `.left` or `.right` style class
   * added depending on where the indication is drawn.
   *
   * When touch is used and touch selection handles are shown, they are using
   * CSS nodes with name `cursor-handle`. They get the `.top` or `.bottom` style
   * class depending on where they are shown in relation to the selection. If
   * there is just a single handle for the text cursor, it gets the style class
   * `.insertion-cursor`.
   *
   * # Accessibility
   *
   * `GtkText` uses the %GTK_ACCESSIBLE_ROLE_NONE role, which causes it to be
   * skipped for accessibility. This is because `GtkText` is expected to be used
   * as a delegate for a `GtkEditable` implementation that will be represented
   * to accessibility.
   * @class
   */
  class Text extends Widget {
    // Own properties of Gtk-4.0.Gtk.Text

    static name: string

    // Constructors of Gtk-4.0.Gtk.Text

    constructor(config?: Text.ConstructorProperties)
    /**
     * Creates a new `GtkText`.
     * @constructor
     * @returns a new `GtkText`.
     */
    constructor()
    /**
     * Creates a new `GtkText`.
     * @constructor
     * @returns a new `GtkText`.
     */
    static new(): Text
    /**
     * Creates a new `GtkText` with the specified text buffer.
     * @constructor
     * @param buffer The buffer to use for the new `GtkText`.
     * @returns a new `GtkText`
     */
    static newWithBuffer(buffer: EntryBuffer): Text
    _init(config?: Text.ConstructorProperties): void
  }

  module TextBuffer {
    // Signal callback interfaces

    /**
     * Signal callback interface for `apply-tag`
     */
    interface ApplyTagSignalCallback {
      (tag: TextTag, start: TextIter, end: TextIter): void
    }

    /**
     * Signal callback interface for `begin-user-action`
     */
    interface BeginUserActionSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `delete-range`
     */
    interface DeleteRangeSignalCallback {
      (start: TextIter, end: TextIter): void
    }

    /**
     * Signal callback interface for `end-user-action`
     */
    interface EndUserActionSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `insert-child-anchor`
     */
    interface InsertChildAnchorSignalCallback {
      (location: TextIter, anchor: TextChildAnchor): void
    }

    /**
     * Signal callback interface for `insert-paintable`
     */
    interface InsertPaintableSignalCallback {
      (location: TextIter, paintable: Gdk.Paintable): void
    }

    /**
     * Signal callback interface for `insert-text`
     */
    interface InsertTextSignalCallback {
      (location: TextIter, text: string | null, len: number): void
    }

    /**
     * Signal callback interface for `mark-deleted`
     */
    interface MarkDeletedSignalCallback {
      (mark: TextMark): void
    }

    /**
     * Signal callback interface for `mark-set`
     */
    interface MarkSetSignalCallback {
      (location: TextIter, mark: TextMark): void
    }

    /**
     * Signal callback interface for `modified-changed`
     */
    interface ModifiedChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `paste-done`
     */
    interface PasteDoneSignalCallback {
      (clipboard: Gdk.Clipboard): void
    }

    /**
     * Signal callback interface for `redo`
     */
    interface RedoSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `remove-tag`
     */
    interface RemoveTagSignalCallback {
      (tag: TextTag, start: TextIter, end: TextIter): void
    }

    /**
     * Signal callback interface for `undo`
     */
    interface UndoSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TextBuffer

      /**
       * Denotes if support for undoing and redoing changes to the buffer is allowed.
       */
      enable_undo?: boolean | null
      /**
       * The GtkTextTagTable for the buffer.
       */
      tag_table?: TextTagTable | null
      /**
       * The text content of the buffer.
       *
       * Without child widgets and images,
       * see [method`Gtk`.TextBuffer.get_text] for more information.
       */
      text?: string | null
    }
  }

  interface TextBuffer {
    // Own properties of Gtk-4.0.Gtk.TextBuffer

    /**
     * Denotes that the buffer can reapply the last undone action.
     */
    readonly canRedo: boolean
    /**
     * Denotes that the buffer can undo the last applied action.
     */
    readonly canUndo: boolean
    /**
     * The position of the insert mark.
     *
     * This is an offset from the beginning of the buffer.
     * It is useful for getting notified when the cursor moves.
     */
    readonly cursorPosition: number
    /**
     * Denotes if support for undoing and redoing changes to the buffer is allowed.
     */
    enableUndo: boolean
    /**
     * Whether the buffer has some text currently selected.
     */
    readonly hasSelection: boolean
    /**
     * The GtkTextTagTable for the buffer.
     */
    readonly tagTable: TextTagTable
    /**
     * The text content of the buffer.
     *
     * Without child widgets and images,
     * see [method`Gtk`.TextBuffer.get_text] for more information.
     */
    text: string | null
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TextBuffer

    parentInstance: GObject.Object
    priv: TextBufferPrivate

    // Owm methods of Gtk-4.0.Gtk.TextBuffer

    /**
     * Adds the mark at position `where`.
     *
     * The mark must not be added to another buffer, and if its name
     * is not %NULL then there must not be another mark in the buffer
     * with the same name.
     *
     * Emits the [signal`Gtk`.TextBuffer::mark-set] signal as notification
     * of the mark's initial placement.
     * @param mark the mark to add
     * @param where location to place mark
     */
    addMark(mark: TextMark, where: TextIter): void
    /**
     * Adds `clipboard` to the list of clipboards in which the selection
     * contents of `buffer` are available.
     *
     * In most cases, `clipboard` will be the `GdkClipboard` returned by
     * [method`Gtk`.Widget.get_primary_clipboard] for a view of `buffer`.
     * @param clipboard a `GdkClipboard`
     */
    addSelectionClipboard(clipboard: Gdk.Clipboard): void
    // Has conflict: applyTag(tag: TextTag, start: TextIter, end: TextIter): void
    /**
     * Emits the “apply-tag” signal on `buffer`.
     *
     * Calls [method`Gtk`.TextTagTable.lookup] on the buffer’s
     * tag table to get a `GtkTextTag`, then calls
     * [method`Gtk`.TextBuffer.apply_tag].
     * @param name name of a named `GtkTextTag`
     * @param start one bound of range to be tagged
     * @param end other bound of range to be tagged
     */
    applyTagByName(name: string, start: TextIter, end: TextIter): void
    /**
     * Performs the appropriate action as if the user hit the delete
     * key with the cursor at the position specified by `iter`.
     *
     * In the normal case a single character will be deleted, but when
     * combining accents are involved, more than one character can
     * be deleted, and when precomposed character and accent combinations
     * are involved, less than one character will be deleted.
     *
     * Because the buffer is modified, all outstanding iterators become
     * invalid after calling this function; however, the `iter` will be
     * re-initialized to point to the location where text was deleted.
     * @param iter a position in `buffer`
     * @param interactive whether the deletion is caused by user interaction
     * @param defaultEditable whether the buffer is editable by default
     * @returns %TRUE if the buffer was modified
     */
    backspace(
      iter: TextIter,
      interactive: boolean,
      defaultEditable: boolean
    ): boolean
    /**
     * Denotes the beginning of an action that may not be undone.
     *
     * This will cause any previous operations in the undo/redo queue
     * to be cleared.
     *
     * This should be paired with a call to
     * [method`Gtk`.TextBuffer.end_irreversible_action] after the irreversible
     * action has completed.
     *
     * You may nest calls to gtk_text_buffer_begin_irreversible_action()
     * and gtk_text_buffer_end_irreversible_action() pairs.
     */
    beginIrreversibleAction(): void
    // Has conflict: beginUserAction(): void
    /**
     * Copies the currently-selected text to a clipboard.
     * @param clipboard the `GdkClipboard` object to copy to
     */
    copyClipboard(clipboard: Gdk.Clipboard): void
    /**
     * Creates and inserts a child anchor.
     *
     * This is a convenience function which simply creates a child anchor
     * with [ctor`Gtk`.TextChildAnchor.new] and inserts it into the buffer
     * with [method`Gtk`.TextBuffer.insert_child_anchor].
     *
     * The new anchor is owned by the buffer; no reference count is
     * returned to the caller of this function.
     * @param iter location in the buffer
     * @returns the created child anchor
     */
    createChildAnchor(iter: TextIter): TextChildAnchor
    /**
     * Creates a mark at position `where`.
     *
     * If `mark_name` is %NULL, the mark is anonymous; otherwise, the mark
     * can be retrieved by name using [method`Gtk`.TextBuffer.get_mark].
     * If a mark has left gravity, and text is inserted at the mark’s
     * current location, the mark will be moved to the left of the
     * newly-inserted text. If the mark has right gravity
     * (`left_gravity` = %FALSE), the mark will end up on the right of
     * newly-inserted text. The standard left-to-right cursor is a mark
     * with right gravity (when you type, the cursor stays on the right
     * side of the text you’re typing).
     *
     * The caller of this function does not own a
     * reference to the returned `GtkTextMark`, so you can ignore the
     * return value if you like. Marks are owned by the buffer and go
     * away when the buffer does.
     *
     * Emits the [signal`Gtk`.TextBuffer::mark-set] signal as notification
     * of the mark's initial placement.
     * @param markName name for mark
     * @param where location to place mark
     * @param leftGravity whether the mark has left gravity
     * @returns the new `GtkTextMark` object
     */
    createMark(
      markName: string | null,
      where: TextIter,
      leftGravity: boolean
    ): TextMark
    /**
     * Copies the currently-selected text to a clipboard,
     * then deletes said text if it’s editable.
     * @param clipboard the `GdkClipboard` object to cut to
     * @param defaultEditable default editability of the buffer
     */
    cutClipboard(clipboard: Gdk.Clipboard, defaultEditable: boolean): void
    /**
     * Deletes text between `start` and `end`.
     *
     * The order of `start` and `end` is not actually relevant;
     * gtk_text_buffer_delete() will reorder them.
     *
     * This function actually emits the “delete-range” signal, and
     * the default handler of that signal deletes the text. Because the
     * buffer is modified, all outstanding iterators become invalid after
     * calling this function; however, the `start` and `end` will be
     * re-initialized to point to the location where text was deleted.
     * @param start a position in `buffer`
     * @param end another position in `buffer`
     */
    delete(start: TextIter, end: TextIter): void
    /**
     * Deletes all editable text in the given range.
     *
     * Calls [method`Gtk`.TextBuffer.delete] for each editable
     * sub-range of [`start,``end)`. `start` and `end` are revalidated
     * to point to the location of the last deleted range, or left
     * untouched if no text was deleted.
     * @param startIter start of range to delete
     * @param endIter end of range
     * @param defaultEditable whether the buffer is editable by default
     * @returns whether some text was actually deleted
     */
    deleteInteractive(
      startIter: TextIter,
      endIter: TextIter,
      defaultEditable: boolean
    ): boolean
    /**
     * Deletes `mark,` so that it’s no longer located anywhere in the
     * buffer.
     *
     * Removes the reference the buffer holds to the mark, so if
     * you haven’t called g_object_ref() on the mark, it will be freed.
     * Even if the mark isn’t freed, most operations on `mark` become
     * invalid, until it gets added to a buffer again with
     * [method`Gtk`.TextBuffer.add_mark]. Use [method`Gtk`.TextMark.get_deleted]
     * to find out if a mark has been removed from its buffer.
     *
     * The [signal`Gtk`.TextBuffer::mark-deleted] signal will be emitted as
     * notification after the mark is deleted.
     * @param mark a `GtkTextMark` in `buffer`
     */
    deleteMark(mark: TextMark): void
    /**
     * Deletes the mark named `name;` the mark must exist.
     *
     * See [method`Gtk`.TextBuffer.delete_mark] for details.
     * @param name name of a mark in `buffer`
     */
    deleteMarkByName(name: string): void
    /**
     * Deletes the range between the “insert” and “selection_bound” marks,
     * that is, the currently-selected text.
     *
     * If `interactive` is %TRUE, the editability of the selection will be
     * considered (users can’t delete uneditable text).
     * @param interactive whether the deletion is caused by user interaction
     * @param defaultEditable whether the buffer is editable by default
     * @returns whether there was a non-empty selection to delete
     */
    deleteSelection(interactive: boolean, defaultEditable: boolean): boolean
    /**
     * Denotes the end of an action that may not be undone.
     *
     * This will cause any previous operations in the undo/redo
     * queue to be cleared.
     *
     * This should be called after completing modifications to the
     * text buffer after [method`Gtk`.TextBuffer.begin_irreversible_action]
     * was called.
     *
     * You may nest calls to gtk_text_buffer_begin_irreversible_action()
     * and gtk_text_buffer_end_irreversible_action() pairs.
     */
    endIrreversibleAction(): void
    // Has conflict: endUserAction(): void
    /**
     * Retrieves the first and last iterators in the buffer, i.e. the
     * entire buffer lies within the range [`start,``end)`.
     */
    getBounds(): [/* start */ TextIter, /* end */ TextIter]
    /**
     * Gets whether there is a redoable action in the history.
     * @returns %TRUE if there is a redoable action
     */
    getCanRedo(): boolean
    /**
     * Gets whether there is an undoable action in the history.
     * @returns %TRUE if there is an undoable action
     */
    getCanUndo(): boolean
    /**
     * Gets the number of characters in the buffer.
     *
     * Note that characters and bytes are not the same, you can’t e.g.
     * expect the contents of the buffer in string form to be this
     * many bytes long.
     *
     * The character count is cached, so this function is very fast.
     * @returns number of characters in the buffer
     */
    getCharCount(): number
    /**
     * Gets whether the buffer is saving modifications to the buffer
     * to allow for undo and redo actions.
     *
     * See [method`Gtk`.TextBuffer.begin_irreversible_action] and
     * [method`Gtk`.TextBuffer.end_irreversible_action] to create
     * changes to the buffer that cannot be undone.
     * @returns %TRUE if undoing and redoing changes to the buffer is allowed.
     */
    getEnableUndo(): boolean
    /**
     * Initializes `iter` with the “end iterator,” one past the last valid
     * character in the text buffer.
     *
     * If dereferenced with [method`Gtk`.TextIter.get_char], the end
     * iterator has a character value of 0.
     * The entire buffer lies in the range from the first position in
     * the buffer (call [method`Gtk`.TextBuffer.get_start_iter] to get
     * character position 0) to the end iterator.
     */
    getEndIter(): /* iter */ TextIter
    /**
     * Indicates whether the buffer has some text currently selected.
     * @returns %TRUE if the there is text selected
     */
    getHasSelection(): boolean
    /**
     * Returns the mark that represents the cursor (insertion point).
     *
     * Equivalent to calling [method`Gtk`.TextBuffer.get_mark]
     * to get the mark named “insert”, but very slightly more
     * efficient, and involves less typing.
     * @returns insertion point mark
     */
    getInsert(): TextMark
    /**
     * Obtains the location of `anchor` within `buffer`.
     * @param anchor a child anchor that appears in `buffer`
     */
    getIterAtChildAnchor(anchor: TextChildAnchor): /* iter */ TextIter
    /**
     * Initializes `iter` to the start of the given line.
     *
     * If `line_number` is greater than or equal to the number of lines
     * in the `buffer,` the end iterator is returned.
     * @param lineNumber line number counting from 0
     * @returns whether the exact position has been found
     */
    getIterAtLine(
      lineNumber: number
    ): [/* returnType */ boolean, /* iter */ TextIter]
    /**
     * Obtains an iterator pointing to `byte_index` within the given line.
     *
     * `byte_index` must be the start of a UTF-8 character. Note bytes, not
     * characters; UTF-8 may encode one character as multiple bytes.
     *
     * If `line_number` is greater than or equal to the number of lines in the `buffer,`
     * the end iterator is returned. And if `byte_index` is off the
     * end of the line, the iterator at the end of the line is returned.
     * @param lineNumber line number counting from 0
     * @param byteIndex byte index from start of line
     * @returns whether the exact position has been found
     */
    getIterAtLineIndex(
      lineNumber: number,
      byteIndex: number
    ): [/* returnType */ boolean, /* iter */ TextIter]
    /**
     * Obtains an iterator pointing to `char_offset` within the given line.
     *
     * Note characters, not bytes; UTF-8 may encode one character as multiple
     * bytes.
     *
     * If `line_number` is greater than or equal to the number of lines in the `buffer,`
     * the end iterator is returned. And if `char_offset` is off the
     * end of the line, the iterator at the end of the line is returned.
     * @param lineNumber line number counting from 0
     * @param charOffset char offset from start of line
     * @returns whether the exact position has been found
     */
    getIterAtLineOffset(
      lineNumber: number,
      charOffset: number
    ): [/* returnType */ boolean, /* iter */ TextIter]
    /**
     * Initializes `iter` with the current position of `mark`.
     * @param mark a `GtkTextMark` in `buffer`
     */
    getIterAtMark(mark: TextMark): /* iter */ TextIter
    /**
     * Initializes `iter` to a position `char_offset` chars from the start
     * of the entire buffer.
     *
     * If `char_offset` is -1 or greater than the number
     * of characters in the buffer, `iter` is initialized to the end iterator,
     * the iterator one past the last valid character in the buffer.
     * @param charOffset char offset from start of buffer, counting from 0, or -1
     */
    getIterAtOffset(charOffset: number): /* iter */ TextIter
    /**
     * Obtains the number of lines in the buffer.
     *
     * This value is cached, so the function is very fast.
     * @returns number of lines in the buffer
     */
    getLineCount(): number
    /**
     * Returns the mark named `name` in buffer `buffer,` or %NULL if no such
     * mark exists in the buffer.
     * @param name a mark name
     * @returns a `GtkTextMark`
     */
    getMark(name: string): TextMark | null
    /**
     * Gets the maximum number of undo levels to perform.
     *
     * If 0, unlimited undo actions may be performed. Note that this may
     * have a memory usage impact as it requires storing an additional
     * copy of the inserted or removed text within the text buffer.
     * @returns The max number of undo levels allowed (0 indicates unlimited).
     */
    getMaxUndoLevels(): number
    /**
     * Indicates whether the buffer has been modified since the last call
     * to [method`Gtk`.TextBuffer.set_modified] set the modification flag to
     * %FALSE.
     *
     * Used for example to enable a “save” function in a text editor.
     * @returns %TRUE if the buffer has been modified
     */
    getModified(): boolean
    /**
     * Returns the mark that represents the selection bound.
     *
     * Equivalent to calling [method`Gtk`.TextBuffer.get_mark]
     * to get the mark named “selection_bound”, but very slightly
     * more efficient, and involves less typing.
     *
     * The currently-selected text in `buffer` is the region between the
     * “selection_bound” and “insert” marks. If “selection_bound” and
     * “insert” are in the same place, then there is no current selection.
     * [method`Gtk`.TextBuffer.get_selection_bounds] is another convenient
     * function for handling the selection, if you just want to know whether
     * there’s a selection and what its bounds are.
     * @returns selection bound mark
     */
    getSelectionBound(): TextMark
    /**
     * Returns %TRUE if some text is selected; places the bounds
     * of the selection in `start` and `end`.
     *
     * If the selection has length 0, then `start` and `end` are filled
     * in with the same value. `start` and `end` will be in ascending order.
     * If `start` and `end` are %NULL, then they are not filled in, but the
     * return value still indicates whether text is selected.
     * @returns whether the selection has nonzero length
     */
    getSelectionBounds(): [
      /* returnType */ boolean,
      /* start */ TextIter,
      /* end */ TextIter,
    ]
    /**
     * Get a content provider for this buffer.
     *
     * It can be used to make the content of `buffer` available
     * in a `GdkClipboard`, see [method`Gdk`.Clipboard.set_content].
     * @returns a new `GdkContentProvider`.
     */
    getSelectionContent(): Gdk.ContentProvider
    /**
     * Returns the text in the range [`start,``end)`.
     *
     * Excludes undisplayed text (text marked with tags that set the
     * invisibility attribute) if `include_hidden_chars` is %FALSE.
     * The returned string includes a 0xFFFC character whenever the
     * buffer contains embedded images, so byte and character indexes
     * into the returned string do correspond to byte and character
     * indexes into the buffer. Contrast with [method`Gtk`.TextBuffer.get_text].
     * Note that 0xFFFC can occur in normal text as well, so it is not a
     * reliable indicator that a paintable or widget is in the buffer.
     * @param start start of a range
     * @param end end of a range
     * @param includeHiddenChars whether to include invisible text
     * @returns an allocated UTF-8 string
     */
    getSlice(
      start: TextIter,
      end: TextIter,
      includeHiddenChars: boolean
    ): string | null
    /**
     * Initialized `iter` with the first position in the text buffer.
     *
     * This is the same as using [method`Gtk`.TextBuffer.get_iter_at_offset]
     * to get the iter at character offset 0.
     */
    getStartIter(): /* iter */ TextIter
    /**
     * Get the `GtkTextTagTable` associated with this buffer.
     * @returns the buffer’s tag table
     */
    getTagTable(): TextTagTable
    /**
     * Returns the text in the range [`start,``end)`.
     *
     * Excludes undisplayed text (text marked with tags that set the
     * invisibility attribute) if `include_hidden_chars` is %FALSE.
     * Does not include characters representing embedded images, so
     * byte and character indexes into the returned string do not
     * correspond to byte and character indexes into the buffer.
     * Contrast with [method`Gtk`.TextBuffer.get_slice].
     * @param start start of a range
     * @param end end of a range
     * @param includeHiddenChars whether to include invisible text
     * @returns an allocated UTF-8 string
     */
    getText(
      start: TextIter,
      end: TextIter,
      includeHiddenChars: boolean
    ): string | null
    /**
     * Inserts `len` bytes of `text` at position `iter`.
     *
     * If `len` is -1, `text` must be nul-terminated and will be inserted in its
     * entirety. Emits the “insert-text” signal; insertion actually occurs
     * in the default handler for the signal. `iter` is invalidated when
     * insertion occurs (because the buffer contents change), but the
     * default signal handler revalidates it to point to the end of the
     * inserted text.
     * @param iter a position in the buffer
     * @param text text in UTF-8 format
     * @param len length of text in bytes, or -1
     */
    insert(iter: TextIter, text: string, len: number): void
    /**
     * Inserts `text` in `buffer`.
     *
     * Simply calls [method`Gtk`.TextBuffer.insert],
     * using the current cursor position as the insertion point.
     * @param text text in UTF-8 format
     * @param len length of text, in bytes
     */
    insertAtCursor(text: string, len: number): void
    // Has conflict: insertChildAnchor(iter: TextIter, anchor: TextChildAnchor): void
    /**
     * Inserts `text` in `buffer`.
     *
     * Like [method`Gtk`.TextBuffer.insert], but the insertion will not occur
     * if `iter` is at a non-editable location in the buffer. Usually you
     * want to prevent insertions at ineditable locations if the insertion
     * results from a user action (is interactive).
     *
     * `default_editable` indicates the editability of text that doesn't
     * have a tag affecting editability applied to it. Typically the
     * result of [method`Gtk`.TextView.get_editable] is appropriate here.
     * @param iter a position in `buffer`
     * @param text some UTF-8 text
     * @param len length of text in bytes, or -1
     * @param defaultEditable default editability of buffer
     * @returns whether text was actually inserted
     */
    insertInteractive(
      iter: TextIter,
      text: string,
      len: number,
      defaultEditable: boolean
    ): boolean
    /**
     * Inserts `text` in `buffer`.
     *
     * Calls [method`Gtk`.TextBuffer.insert_interactive]
     * at the cursor position.
     *
     * `default_editable` indicates the editability of text that doesn't
     * have a tag affecting editability applied to it. Typically the
     * result of [method`Gtk`.TextView.get_editable] is appropriate here.
     * @param text text in UTF-8 format
     * @param len length of text in bytes, or -1
     * @param defaultEditable default editability of buffer
     * @returns whether text was actually inserted
     */
    insertInteractiveAtCursor(
      text: string,
      len: number,
      defaultEditable: boolean
    ): boolean
    /**
     * Inserts the text in `markup` at position `iter`.
     *
     * `markup` will be inserted in its entirety and must be nul-terminated
     * and valid UTF-8. Emits the [signal`Gtk`.TextBuffer::insert-text] signal,
     * possibly multiple times; insertion actually occurs in the default handler
     * for the signal. `iter` will point to the end of the inserted text on return.
     * @param iter location to insert the markup
     * @param markup a nul-terminated UTF-8 string containing Pango markup
     * @param len length of `markup` in bytes, or -1
     */
    insertMarkup(iter: TextIter, markup: string, len: number): void
    // Has conflict: insertPaintable(iter: TextIter, paintable: Gdk.Paintable): void
    /**
     * Copies text, tags, and paintables between `start` and `end`
     * and inserts the copy at `iter`.
     *
     * The order of `start` and `end` doesn’t matter.
     *
     * Used instead of simply getting/inserting text because it preserves
     * images and tags. If `start` and `end` are in a different buffer from
     * `buffer,` the two buffers must share the same tag table.
     *
     * Implemented via emissions of the ::insert-text and ::apply-tag signals,
     * so expect those.
     * @param iter a position in `buffer`
     * @param start a position in a `GtkTextBuffer`
     * @param end another position in the same buffer as `start`
     */
    insertRange(iter: TextIter, start: TextIter, end: TextIter): void
    /**
     * Copies text, tags, and paintables between `start` and `end`
     * and inserts the copy at `iter`.
     *
     * Same as [method`Gtk`.TextBuffer.insert_range], but does nothing
     * if the insertion point isn’t editable. The `default_editable`
     * parameter indicates whether the text is editable at `iter` if
     * no tags enclosing `iter` affect editability. Typically the result
     * of [method`Gtk`.TextView.get_editable] is appropriate here.
     * @param iter a position in `buffer`
     * @param start a position in a `GtkTextBuffer`
     * @param end another position in the same buffer as `start`
     * @param defaultEditable default editability of the buffer
     * @returns whether an insertion was possible at @iter
     */
    insertRangeInteractive(
      iter: TextIter,
      start: TextIter,
      end: TextIter,
      defaultEditable: boolean
    ): boolean
    /**
     * Moves `mark` to the new location `where`.
     *
     * Emits the [signal`Gtk`.TextBuffer::mark-set] signal
     * as notification of the move.
     * @param mark a `GtkTextMark`
     * @param where new location for `mark` in `buffer`
     */
    moveMark(mark: TextMark, where: TextIter): void
    /**
     * Moves the mark named `name` (which must exist) to location `where`.
     *
     * See [method`Gtk`.TextBuffer.move_mark] for details.
     * @param name name of a mark
     * @param where new location for mark
     */
    moveMarkByName(name: string, where: TextIter): void
    /**
     * Pastes the contents of a clipboard.
     *
     * If `override_location` is %NULL, the pasted text will be inserted
     * at the cursor position, or the buffer selection will be replaced
     * if the selection is non-empty.
     *
     * Note: pasting is asynchronous, that is, we’ll ask for the paste data
     * and return, and at some point later after the main loop runs, the paste
     * data will be inserted.
     * @param clipboard the `GdkClipboard` to paste from
     * @param overrideLocation location to insert pasted text
     * @param defaultEditable whether the buffer is editable by default
     */
    pasteClipboard(
      clipboard: Gdk.Clipboard,
      overrideLocation: TextIter | null,
      defaultEditable: boolean
    ): void
    /**
     * This function moves the “insert” and “selection_bound” marks
     * simultaneously.
     *
     * If you move them to the same place in two steps with
     * [method`Gtk`.TextBuffer.move_mark], you will temporarily select a
     * region in between their old and new locations, which can be pretty
     * inefficient since the temporarily-selected region will force stuff
     * to be recalculated. This function moves them as a unit, which can
     * be optimized.
     * @param where where to put the cursor
     */
    placeCursor(where: TextIter): void
    // Has conflict: redo(): void
    /**
     * Removes all tags in the range between `start` and `end`.
     *
     * Be careful with this function; it could remove tags added in code
     * unrelated to the code you’re currently writing. That is, using this
     * function is probably a bad idea if you have two or more unrelated
     * code sections that add tags.
     * @param start one bound of range to be untagged
     * @param end other bound of range to be untagged
     */
    removeAllTags(start: TextIter, end: TextIter): void
    /**
     * Removes a `GdkClipboard` added with
     * [method`Gtk`.TextBuffer.add_selection_clipboard]
     * @param clipboard a `GdkClipboard` added to `buffer` by   [method`Gtk`.TextBuffer.add_selection_clipboard]
     */
    removeSelectionClipboard(clipboard: Gdk.Clipboard): void
    // Has conflict: removeTag(tag: TextTag, start: TextIter, end: TextIter): void
    /**
     * Emits the “remove-tag” signal.
     *
     * Calls [method`Gtk`.TextTagTable.lookup] on the buffer’s
     * tag table to get a `GtkTextTag`, then calls
     * [method`Gtk`.TextBuffer.remove_tag].
     * @param name name of a `GtkTextTag`
     * @param start one bound of range to be untagged
     * @param end other bound of range to be untagged
     */
    removeTagByName(name: string, start: TextIter, end: TextIter): void
    /**
     * This function moves the “insert” and “selection_bound” marks
     * simultaneously.
     *
     * If you move them in two steps with
     * [method`Gtk`.TextBuffer.move_mark], you will temporarily select a
     * region in between their old and new locations, which can be pretty
     * inefficient since the temporarily-selected region will force stuff
     * to be recalculated. This function moves them as a unit, which can
     * be optimized.
     * @param ins where to put the “insert” mark
     * @param bound where to put the “selection_bound” mark
     */
    selectRange(ins: TextIter, bound: TextIter): void
    /**
     * Sets whether or not to enable undoable actions in the text buffer.
     *
     * Undoable actions in this context are changes to the text content of
     * the buffer. Changes to tags and marks are not tracked.
     *
     * If enabled, the user will be able to undo the last number of actions
     * up to [method`Gtk`.TextBuffer.get_max_undo_levels].
     *
     * See [method`Gtk`.TextBuffer.begin_irreversible_action] and
     * [method`Gtk`.TextBuffer.end_irreversible_action] to create
     * changes to the buffer that cannot be undone.
     * @param enableUndo %TRUE to enable undo
     */
    setEnableUndo(enableUndo: boolean): void
    /**
     * Sets the maximum number of undo levels to perform.
     *
     * If 0, unlimited undo actions may be performed. Note that this may
     * have a memory usage impact as it requires storing an additional
     * copy of the inserted or removed text within the text buffer.
     * @param maxUndoLevels the maximum number of undo actions to perform
     */
    setMaxUndoLevels(maxUndoLevels: number): void
    /**
     * Used to keep track of whether the buffer has been
     * modified since the last time it was saved.
     *
     * Whenever the buffer is saved to disk, call
     * `gtk_text_buffer_set_modified (`buffer,` FALSE)`.
     * When the buffer is modified, it will automatically
     * toggle on the modified bit again. When the modified
     * bit flips, the buffer emits the
     * [signal`Gtk`.TextBuffer::modified-changed] signal.
     * @param setting modification flag setting
     */
    setModified(setting: boolean): void
    /**
     * Deletes current contents of `buffer,` and inserts `text` instead. This is
     * automatically marked as an irreversible action in the undo stack. If you
     * wish to mark this action as part of a larger undo operation, call
     * [method`TextBuffer`.delete] and [method`TextBuffer`.insert] directly instead.
     *
     * If `len` is -1, `text` must be nul-terminated.
     * `text` must be valid UTF-8.
     * @param text UTF-8 text to insert
     * @param len length of `text` in bytes
     */
    setText(text: string, len: number): void
    // Has conflict: undo(): void

    // Own virtual methods of Gtk-4.0.Gtk.TextBuffer

    /**
     * Emits the “apply-tag” signal on `buffer`.
     *
     * The default handler for the signal applies
     * `tag` to the given range. `start` and `end` do
     * not have to be in order.
     * @virtual
     * @param tag a `GtkTextTag`
     * @param start one bound of range to be tagged
     * @param end other bound of range to be tagged
     */
    applyTag(tag: TextTag, start: TextIter, end: TextIter): void
    /**
     * Called to indicate that the buffer operations between here and a
     * call to gtk_text_buffer_end_user_action() are part of a single
     * user-visible operation.
     *
     * The operations between gtk_text_buffer_begin_user_action() and
     * gtk_text_buffer_end_user_action() can then be grouped when creating
     * an undo stack. `GtkTextBuffer` maintains a count of calls to
     * gtk_text_buffer_begin_user_action() that have not been closed with
     * a call to gtk_text_buffer_end_user_action(), and emits the
     * “begin-user-action” and “end-user-action” signals only for the
     * outermost pair of calls. This allows you to build user actions
     * from other user actions.
     *
     * The “interactive” buffer mutation functions, such as
     * [method`Gtk`.TextBuffer.insert_interactive], automatically call
     * begin/end user action around the buffer operations they perform,
     * so there's no need to add extra calls if you user action consists
     * solely of a single call to one of those functions.
     * @virtual
     */
    beginUserAction(): void
    /**
     * The class handler for the `GtkTextBuffer::changed` signal.
     * @virtual
     */
    changed(): void
    /**
     * The class handler for the `GtkTextBuffer::delete-range` signal.
     * @virtual
     * @param start
     * @param end
     */
    deleteRange(start: TextIter, end: TextIter): void
    /**
     * Ends a user-visible operation.
     *
     * Should be paired with a call to
     * [method`Gtk`.TextBuffer.begin_user_action].
     * See that function for a full explanation.
     * @virtual
     */
    endUserAction(): void
    /**
     * Inserts a child widget anchor into the text buffer at `iter`.
     *
     * The anchor will be counted as one character in character counts, and
     * when obtaining the buffer contents as a string, will be represented
     * by the Unicode “object replacement character” 0xFFFC. Note that the
     * “slice” variants for obtaining portions of the buffer as a string
     * include this character for child anchors, but the “text” variants do
     * not. E.g. see [method`Gtk`.TextBuffer.get_slice] and
     * [method`Gtk`.TextBuffer.get_text].
     *
     * Consider [method`Gtk`.TextBuffer.create_child_anchor] as a more
     * convenient alternative to this function. The buffer will add a
     * reference to the anchor, so you can unref it after insertion.
     * @virtual
     * @param iter location to insert the anchor
     * @param anchor a `GtkTextChildAnchor`
     */
    insertChildAnchor(iter: TextIter, anchor: TextChildAnchor): void
    /**
     * Inserts an image into the text buffer at `iter`.
     *
     * The image will be counted as one character in character counts,
     * and when obtaining the buffer contents as a string, will be
     * represented by the Unicode “object replacement character” 0xFFFC.
     * Note that the “slice” variants for obtaining portions of the buffer
     * as a string include this character for paintable, but the “text”
     * variants do not. e.g. see [method`Gtk`.TextBuffer.get_slice] and
     * [method`Gtk`.TextBuffer.get_text].
     * @virtual
     * @param iter location to insert the paintable
     * @param paintable a `GdkPaintable`
     */
    insertPaintable(iter: TextIter, paintable: Gdk.Paintable): void
    /**
     * The class handler for the `GtkTextBuffer::insert-text` signal.
     * @virtual
     * @param pos
     * @param newText
     * @param newTextLength
     */
    insertText(pos: TextIter, newText: string, newTextLength: number): void
    /**
     * The class handler for the `GtkTextBuffer::mark-deleted` signal.
     * @virtual
     * @param mark
     */
    markDeleted(mark: TextMark): void
    /**
     * The class handler for the `GtkTextBuffer::mark-set` signal.
     * @virtual
     * @param location
     * @param mark
     */
    markSet(location: TextIter, mark: TextMark): void
    /**
     * The class handler for the `GtkTextBuffer::modified-changed` signal.
     * @virtual
     */
    modifiedChanged(): void
    /**
     * The class handler for the `GtkTextBuffer::paste-done` signal.
     * @virtual
     * @param clipboard
     */
    pasteDone(clipboard: Gdk.Clipboard): void
    /**
     * Redoes the next redoable action on the buffer, if there is one.
     * @virtual
     */
    redo(): void
    /**
     * Emits the “remove-tag” signal.
     *
     * The default handler for the signal removes all occurrences
     * of `tag` from the given range. `start` and `end` don’t have
     * to be in order.
     * @virtual
     * @param tag a `GtkTextTag`
     * @param start one bound of range to be untagged
     * @param end other bound of range to be untagged
     */
    removeTag(tag: TextTag, start: TextIter, end: TextIter): void
    /**
     * Undoes the last undoable action on the buffer, if there is one.
     * @virtual
     */
    undo(): void

    // Own signals of Gtk-4.0.Gtk.TextBuffer

    connect(
      sigName: "apply-tag",
      callback: TextBuffer.ApplyTagSignalCallback
    ): number
    on(
      sigName: "apply-tag",
      callback: TextBuffer.ApplyTagSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "apply-tag",
      callback: TextBuffer.ApplyTagSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "apply-tag",
      callback: TextBuffer.ApplyTagSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "apply-tag",
      start: TextIter,
      end: TextIter,
      ...args: any[]
    ): void
    connect(
      sigName: "begin-user-action",
      callback: TextBuffer.BeginUserActionSignalCallback
    ): number
    on(
      sigName: "begin-user-action",
      callback: TextBuffer.BeginUserActionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "begin-user-action",
      callback: TextBuffer.BeginUserActionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "begin-user-action",
      callback: TextBuffer.BeginUserActionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "begin-user-action", ...args: any[]): void
    connect(
      sigName: "changed",
      callback: TextBuffer.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: TextBuffer.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: TextBuffer.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: TextBuffer.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void
    connect(
      sigName: "delete-range",
      callback: TextBuffer.DeleteRangeSignalCallback
    ): number
    on(
      sigName: "delete-range",
      callback: TextBuffer.DeleteRangeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "delete-range",
      callback: TextBuffer.DeleteRangeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "delete-range",
      callback: TextBuffer.DeleteRangeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "delete-range", end: TextIter, ...args: any[]): void
    connect(
      sigName: "end-user-action",
      callback: TextBuffer.EndUserActionSignalCallback
    ): number
    on(
      sigName: "end-user-action",
      callback: TextBuffer.EndUserActionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "end-user-action",
      callback: TextBuffer.EndUserActionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "end-user-action",
      callback: TextBuffer.EndUserActionSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "end-user-action", ...args: any[]): void
    connect(
      sigName: "insert-child-anchor",
      callback: TextBuffer.InsertChildAnchorSignalCallback
    ): number
    on(
      sigName: "insert-child-anchor",
      callback: TextBuffer.InsertChildAnchorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-child-anchor",
      callback: TextBuffer.InsertChildAnchorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-child-anchor",
      callback: TextBuffer.InsertChildAnchorSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "insert-child-anchor",
      anchor: TextChildAnchor,
      ...args: any[]
    ): void
    connect(
      sigName: "insert-paintable",
      callback: TextBuffer.InsertPaintableSignalCallback
    ): number
    on(
      sigName: "insert-paintable",
      callback: TextBuffer.InsertPaintableSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-paintable",
      callback: TextBuffer.InsertPaintableSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-paintable",
      callback: TextBuffer.InsertPaintableSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "insert-paintable",
      paintable: Gdk.Paintable,
      ...args: any[]
    ): void
    connect(
      sigName: "insert-text",
      callback: TextBuffer.InsertTextSignalCallback
    ): number
    on(
      sigName: "insert-text",
      callback: TextBuffer.InsertTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-text",
      callback: TextBuffer.InsertTextSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-text",
      callback: TextBuffer.InsertTextSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "insert-text",
      text: string | null,
      len: number,
      ...args: any[]
    ): void
    connect(
      sigName: "mark-deleted",
      callback: TextBuffer.MarkDeletedSignalCallback
    ): number
    on(
      sigName: "mark-deleted",
      callback: TextBuffer.MarkDeletedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mark-deleted",
      callback: TextBuffer.MarkDeletedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mark-deleted",
      callback: TextBuffer.MarkDeletedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mark-deleted", ...args: any[]): void
    connect(
      sigName: "mark-set",
      callback: TextBuffer.MarkSetSignalCallback
    ): number
    on(
      sigName: "mark-set",
      callback: TextBuffer.MarkSetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mark-set",
      callback: TextBuffer.MarkSetSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mark-set",
      callback: TextBuffer.MarkSetSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mark-set", mark: TextMark, ...args: any[]): void
    connect(
      sigName: "modified-changed",
      callback: TextBuffer.ModifiedChangedSignalCallback
    ): number
    on(
      sigName: "modified-changed",
      callback: TextBuffer.ModifiedChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "modified-changed",
      callback: TextBuffer.ModifiedChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "modified-changed",
      callback: TextBuffer.ModifiedChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "modified-changed", ...args: any[]): void
    connect(
      sigName: "paste-done",
      callback: TextBuffer.PasteDoneSignalCallback
    ): number
    on(
      sigName: "paste-done",
      callback: TextBuffer.PasteDoneSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "paste-done",
      callback: TextBuffer.PasteDoneSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "paste-done",
      callback: TextBuffer.PasteDoneSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "paste-done", ...args: any[]): void
    connect(sigName: "redo", callback: TextBuffer.RedoSignalCallback): number
    on(
      sigName: "redo",
      callback: TextBuffer.RedoSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "redo",
      callback: TextBuffer.RedoSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "redo",
      callback: TextBuffer.RedoSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "redo", ...args: any[]): void
    connect(
      sigName: "remove-tag",
      callback: TextBuffer.RemoveTagSignalCallback
    ): number
    on(
      sigName: "remove-tag",
      callback: TextBuffer.RemoveTagSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "remove-tag",
      callback: TextBuffer.RemoveTagSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "remove-tag",
      callback: TextBuffer.RemoveTagSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "remove-tag",
      start: TextIter,
      end: TextIter,
      ...args: any[]
    ): void
    connect(sigName: "undo", callback: TextBuffer.UndoSignalCallback): number
    on(
      sigName: "undo",
      callback: TextBuffer.UndoSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "undo",
      callback: TextBuffer.UndoSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "undo",
      callback: TextBuffer.UndoSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "undo", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.TextBuffer

    connect(
      sigName: "notify::can-redo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-redo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-redo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-redo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-redo", ...args: any[]): void
    connect(
      sigName: "notify::can-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-undo", ...args: any[]): void
    connect(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-position",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-position", ...args: any[]): void
    connect(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-undo",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-undo", ...args: any[]): void
    connect(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-selection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-selection", ...args: any[]): void
    connect(
      sigName: "notify::tag-table",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tag-table",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tag-table",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tag-table",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tag-table", ...args: any[]): void
    connect(sigName: "notify::text", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * Stores text and attributes for display in a `GtkTextView`.
   *
   * You may wish to begin by reading the
   * [text widget conceptual overview](section-text-widget.html),
   * which gives an overview of all the objects and data types
   * related to the text widget and how they work together.
   *
   * GtkTextBuffer can support undoing changes to the buffer
   * content, see [method`Gtk`.TextBuffer.set_enable_undo].
   * @class
   */
  class TextBuffer extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TextBuffer

    static name: string

    // Constructors of Gtk-4.0.Gtk.TextBuffer

    constructor(config?: TextBuffer.ConstructorProperties)
    /**
     * Creates a new text buffer.
     * @constructor
     * @param table a tag table, or %NULL to create a new one
     * @returns a new text buffer
     */
    constructor(table: TextTagTable | null)
    /**
     * Creates a new text buffer.
     * @constructor
     * @param table a tag table, or %NULL to create a new one
     * @returns a new text buffer
     */
    static new(table: TextTagTable | null): TextBuffer
    _init(config?: TextBuffer.ConstructorProperties): void
  }

  module TextChildAnchor {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface TextChildAnchor {
    // Own properties of Gtk-4.0.Gtk.TextChildAnchor

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TextChildAnchor

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.TextChildAnchor

    /**
     * Determines whether a child anchor has been deleted from
     * the buffer.
     *
     * Keep in mind that the child anchor will be unreferenced
     * when removed from the buffer, so you need to hold your own
     * reference (with g_object_ref()) if you plan to use this
     * function — otherwise all deleted child anchors will also
     * be finalized.
     * @returns %TRUE if the child anchor has been deleted from its buffer
     */
    getDeleted(): boolean
    /**
     * Gets a list of all widgets anchored at this child anchor.
     *
     * The order in which the widgets are returned is not defined.
     * @returns an   array of widgets anchored at @anchor
     */
    getWidgets(): Widget[]

    // Class property signals of Gtk-4.0.Gtk.TextChildAnchor

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkTextChildAnchor` is a spot in a `GtkTextBuffer` where child widgets can
   * be “anchored”.
   *
   * The anchor can have multiple widgets anchored, to allow for multiple views.
   * @class
   */
  class TextChildAnchor extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TextChildAnchor

    static name: string

    // Constructors of Gtk-4.0.Gtk.TextChildAnchor

    constructor(config?: TextChildAnchor.ConstructorProperties)
    /**
     * Creates a new `GtkTextChildAnchor`.
     *
     * Usually you would then insert it into a `GtkTextBuffer` with
     * [method`Gtk`.TextBuffer.insert_child_anchor]. To perform the
     * creation and insertion in one step, use the convenience
     * function [method`Gtk`.TextBuffer.create_child_anchor].
     * @constructor
     * @returns a new `GtkTextChildAnchor`
     */
    constructor()
    /**
     * Creates a new `GtkTextChildAnchor`.
     *
     * Usually you would then insert it into a `GtkTextBuffer` with
     * [method`Gtk`.TextBuffer.insert_child_anchor]. To perform the
     * creation and insertion in one step, use the convenience
     * function [method`Gtk`.TextBuffer.create_child_anchor].
     * @constructor
     * @returns a new `GtkTextChildAnchor`
     */
    static new(): TextChildAnchor
    /**
     * Creates a new `GtkTextChildAnchor` with the given replacement character.
     *
     * Usually you would then insert it into a `GtkTextBuffer` with
     * [method`Gtk`.TextBuffer.insert_child_anchor].
     * @constructor
     * @param character
     * @returns a new `GtkTextChildAnchor`
     */
    static newWithReplacement(character: string): TextChildAnchor
    _init(config?: TextChildAnchor.ConstructorProperties): void
  }

  module TextMark {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TextMark

      /**
       * Whether the mark has left gravity.
       *
       * When text is inserted at the mark’s current location, if the mark
       * has left gravity it will be moved to the left of the newly-inserted
       * text, otherwise to the right.
       */
      left_gravity?: boolean | null
      /**
       * The name of the mark or %NULL if the mark is anonymous.
       */
      name?: string | null
    }
  }

  interface TextMark {
    // Own properties of Gtk-4.0.Gtk.TextMark

    /**
     * Whether the mark has left gravity.
     *
     * When text is inserted at the mark’s current location, if the mark
     * has left gravity it will be moved to the left of the newly-inserted
     * text, otherwise to the right.
     */
    readonly leftGravity: boolean
    /**
     * The name of the mark or %NULL if the mark is anonymous.
     */
    readonly name: string | null
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TextMark

    parentInstance: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.TextMark

    /**
     * Gets the buffer this mark is located inside.
     *
     * Returns %NULL if the mark is deleted.
     * @returns the mark’s `GtkTextBuffer`
     */
    getBuffer(): TextBuffer | null
    /**
     * Returns %TRUE if the mark has been removed from its buffer.
     *
     * See [method`Gtk`.TextBuffer.add_mark] for a way to add it
     * to a buffer again.
     * @returns whether the mark is deleted
     */
    getDeleted(): boolean
    /**
     * Determines whether the mark has left gravity.
     * @returns %TRUE if the mark has left gravity, %FALSE otherwise
     */
    getLeftGravity(): boolean
    /**
     * Returns the mark name.
     *
     * Returns %NULL for anonymous marks.
     * @returns mark name
     */
    getName(): string | null
    /**
     * Returns %TRUE if the mark is visible.
     *
     * A cursor is displayed for visible marks.
     * @returns %TRUE if visible
     */
    getVisible(): boolean
    setVisible(setting: boolean): void

    // Class property signals of Gtk-4.0.Gtk.TextMark

    connect(
      sigName: "notify::left-gravity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::left-gravity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::left-gravity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::left-gravity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::left-gravity", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkTextMark` is a position in a `GtkTextbuffer` that is preserved
   * across modifications.
   *
   * You may wish to begin by reading the
   * [text widget conceptual overview](section-text-widget.html),
   * which gives an overview of all the objects and data types
   * related to the text widget and how they work together.
   *
   * A `GtkTextMark` is like a bookmark in a text buffer; it preserves
   * a position in the text. You can convert the mark to an iterator using
   * [method`Gtk`.TextBuffer.get_iter_at_mark]. Unlike iterators, marks remain
   * valid across buffer mutations, because their behavior is defined when
   * text is inserted or deleted. When text containing a mark is deleted,
   * the mark remains in the position originally occupied by the deleted
   * text. When text is inserted at a mark, a mark with “left gravity” will
   * be moved to the beginning of the newly-inserted text, and a mark with
   * “right gravity” will be moved to the end.
   *
   * Note that “left” and “right” here refer to logical direction (left
   * is the toward the start of the buffer); in some languages such as
   * Hebrew the logically-leftmost text is not actually on the left when
   * displayed.
   *
   * Marks are reference counted, but the reference count only controls
   * the validity of the memory; marks can be deleted from the buffer at
   * any time with [method`Gtk`.TextBuffer.delete_mark]. Once deleted from
   * the buffer, a mark is essentially useless.
   *
   * Marks optionally have names; these can be convenient to avoid passing
   * the `GtkTextMark` object around.
   *
   * Marks are typically created using the [method`Gtk`.TextBuffer.create_mark]
   * function.
   * @class
   */
  class TextMark extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TextMark

    static name: string

    // Constructors of Gtk-4.0.Gtk.TextMark

    constructor(config?: TextMark.ConstructorProperties)
    /**
     * Creates a text mark.
     *
     * Add it to a buffer using [method`Gtk`.TextBuffer.add_mark].
     * If `name` is %NULL, the mark is anonymous; otherwise, the mark can be
     * retrieved by name using [method`Gtk`.TextBuffer.get_mark]. If a mark
     * has left gravity, and text is inserted at the mark’s current location,
     * the mark will be moved to the left of the newly-inserted text. If the
     * mark has right gravity (`left_gravity` = %FALSE), the mark will end up
     * on the right of newly-inserted text. The standard left-to-right cursor
     * is a mark with right gravity (when you type, the cursor stays on the
     * right side of the text you’re typing).
     * @constructor
     * @param name mark name
     * @param leftGravity whether the mark should have left gravity
     * @returns new `GtkTextMark`
     */
    constructor(name: string | null, leftGravity: boolean)
    /**
     * Creates a text mark.
     *
     * Add it to a buffer using [method`Gtk`.TextBuffer.add_mark].
     * If `name` is %NULL, the mark is anonymous; otherwise, the mark can be
     * retrieved by name using [method`Gtk`.TextBuffer.get_mark]. If a mark
     * has left gravity, and text is inserted at the mark’s current location,
     * the mark will be moved to the left of the newly-inserted text. If the
     * mark has right gravity (`left_gravity` = %FALSE), the mark will end up
     * on the right of newly-inserted text. The standard left-to-right cursor
     * is a mark with right gravity (when you type, the cursor stays on the
     * right side of the text you’re typing).
     * @constructor
     * @param name mark name
     * @param leftGravity whether the mark should have left gravity
     * @returns new `GtkTextMark`
     */
    static new(name: string | null, leftGravity: boolean): TextMark
    _init(config?: TextMark.ConstructorProperties): void
  }

  module TextTag {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TextTag

      /**
       * Whether the margins accumulate or override each other.
       *
       * When set to %TRUE the margins of this tag are added to the margins
       * of any other non-accumulative margins present. When set to %FALSE
       * the margins override one another (the default).
       */
      accumulative_margin?: boolean | null
      /**
       * Whether breaks are allowed.
       */
      allow_breaks?: boolean | null
      allow_breaks_set?: boolean | null
      /**
       * Background color as a string.
       */
      background?: string | null
      /**
       * Whether the background color fills the entire line height
       * or only the height of the tagged characters.
       */
      background_full_height?: boolean | null
      background_full_height_set?: boolean | null
      /**
       * Background color as a `GdkRGBA`.
       */
      background_rgba?: Gdk.RGBA | null
      background_set?: boolean | null
      /**
       * Text direction, e.g. right-to-left or left-to-right.
       */
      direction?: TextDirection | null
      /**
       * Whether the text can be modified by the user.
       */
      editable?: boolean | null
      editable_set?: boolean | null
      /**
       * Whether font fallback is enabled.
       *
       * When set to %TRUE, other fonts will be substituted
       * where the current font is missing glyphs.
       */
      fallback?: boolean | null
      fallback_set?: boolean | null
      /**
       * Name of the font family, e.g. Sans, Helvetica, Times, Monospace.
       */
      family?: string | null
      family_set?: boolean | null
      /**
       * Font description as string, e.g. \"Sans Italic 12\".
       *
       * Note that the initial value of this property depends on
       * the internals of `PangoFontDescription`.
       */
      font?: string | null
      /**
       * Font description as a `PangoFontDescription`.
       */
      font_desc?: Pango.FontDescription | null
      /**
       * OpenType font features, as a string.
       */
      font_features?: string | null
      font_features_set?: boolean | null
      /**
       * Foreground color as a string.
       */
      foreground?: string | null
      /**
       * Foreground color as a `GdkRGBA`.
       */
      foreground_rgba?: Gdk.RGBA | null
      foreground_set?: boolean | null
      /**
       * Amount to indent the paragraph, in pixels.
       *
       * A negative value of indent will produce a hanging indentation.
       * That is, the first line will have the full width, and subsequent
       * lines will be indented by the absolute value of indent.
       */
      indent?: number | null
      indent_set?: boolean | null
      /**
       * Whether to insert hyphens at breaks.
       */
      insert_hyphens?: boolean | null
      insert_hyphens_set?: boolean | null
      /**
       * Whether this text is hidden.
       *
       * Note that there may still be problems with the support for invisible
       * text, in particular when navigating programmatically inside a buffer
       * containing invisible segments.
       */
      invisible?: boolean | null
      invisible_set?: boolean | null
      /**
       * Left, right, or center justification.
       */
      justification?: Justification | null
      justification_set?: boolean | null
      /**
       * The language this text is in, as an ISO code.
       *
       * Pango can use this as a hint when rendering the text.
       * If not set, an appropriate default will be used.
       *
       * Note that the initial value of this property depends
       * on the current locale, see also [func`Gtk`.get_default_language].
       */
      language?: string | null
      language_set?: boolean | null
      /**
       * Width of the left margin in pixels.
       */
      left_margin?: number | null
      left_margin_set?: boolean | null
      /**
       * Extra spacing between graphemes, in Pango units.
       */
      letter_spacing?: number | null
      letter_spacing_set?: boolean | null
      /**
       * Factor to scale line height by.
       */
      line_height?: number | null
      line_height_set?: boolean | null
      /**
       * The name used to refer to the tag.
       *
       * %NULL for anonymous tags.
       */
      name?: string | null
      /**
       * Style of overline for this text.
       */
      overline?: Pango.Overline | null
      /**
       * This property modifies the color of overlines.
       *
       * If not set, overlines will use the foreground color.
       */
      overline_rgba?: Gdk.RGBA | null
      overline_rgba_set?: boolean | null
      overline_set?: boolean | null
      /**
       * The paragraph background color as a string.
       */
      paragraph_background?: string | null
      /**
       * The paragraph background color as a `GdkRGBA`.
       */
      paragraph_background_rgba?: Gdk.RGBA | null
      paragraph_background_set?: boolean | null
      /**
       * Pixels of blank space above paragraphs.
       */
      pixels_above_lines?: number | null
      pixels_above_lines_set?: boolean | null
      /**
       * Pixels of blank space below paragraphs.
       */
      pixels_below_lines?: number | null
      pixels_below_lines_set?: boolean | null
      /**
       * Pixels of blank space between wrapped lines in a paragraph.
       */
      pixels_inside_wrap?: number | null
      pixels_inside_wrap_set?: boolean | null
      /**
       * Width of the right margin, in pixels.
       */
      right_margin?: number | null
      right_margin_set?: boolean | null
      /**
       * Offset of text above the baseline, in Pango units.
       *
       * Negative values go below the baseline.
       */
      rise?: number | null
      rise_set?: boolean | null
      /**
       * Font size as a scale factor relative to the default font size.
       *
       * This properly adapts to theme changes, etc. so is recommended.
       * Pango predefines some scales such as %PANGO_SCALE_X_LARGE.
       */
      scale?: number | null
      scale_set?: boolean | null
      /**
       * Whether this tag represents a single sentence.
       *
       * This affects cursor movement.
       */
      sentence?: boolean | null
      sentence_set?: boolean | null
      /**
       * How to render invisible characters.
       */
      show_spaces?: Pango.ShowFlags | null
      show_spaces_set?: boolean | null
      /**
       * Font size in Pango units.
       */
      size?: number | null
      /**
       * Font size in points.
       */
      size_points?: number | null
      size_set?: boolean | null
      /**
       * Font stretch as a `PangoStretch`, e.g. %PANGO_STRETCH_CONDENSED.
       */
      stretch?: Pango.Stretch | null
      stretch_set?: boolean | null
      /**
       * Whether to strike through the text.
       */
      strikethrough?: boolean | null
      /**
       * This property modifies the color of strikeouts.
       *
       * If not set, strikeouts will use the foreground color.
       */
      strikethrough_rgba?: Gdk.RGBA | null
      /**
       * If the `strikethrough-rgba` property has been set.
       */
      strikethrough_rgba_set?: boolean | null
      strikethrough_set?: boolean | null
      /**
       * Font style as a `PangoStyle`, e.g. %PANGO_STYLE_ITALIC.
       */
      style?: Pango.Style | null
      style_set?: boolean | null
      /**
       * Custom tabs for this text.
       */
      tabs?: Pango.TabArray | null
      tabs_set?: boolean | null
      /**
       * How to transform the text for display.
       */
      text_transform?: Pango.TextTransform | null
      text_transform_set?: boolean | null
      /**
       * Style of underline for this text.
       */
      underline?: Pango.Underline | null
      /**
       * This property modifies the color of underlines.
       *
       * If not set, underlines will use the foreground color.
       *
       * If [property`Gtk`.TextTag:underline] is set to %PANGO_UNDERLINE_ERROR,
       * an alternate color may be applied instead of the foreground. Setting
       * this property will always override those defaults.
       */
      underline_rgba?: Gdk.RGBA | null
      /**
       * If the `underline-rgba` property has been set.
       */
      underline_rgba_set?: boolean | null
      underline_set?: boolean | null
      /**
       * Font variant as a `PangoVariant`, e.g. %PANGO_VARIANT_SMALL_CAPS.
       */
      variant?: Pango.Variant | null
      variant_set?: boolean | null
      /**
       * Font weight as an integer.
       */
      weight?: number | null
      weight_set?: boolean | null
      /**
       * Whether this tag represents a single word.
       *
       * This affects line breaks and cursor movement.
       */
      word?: boolean | null
      word_set?: boolean | null
      /**
       * Whether to wrap lines never, at word boundaries, or
       * at character boundaries.
       */
      wrap_mode?: WrapMode | null
      wrap_mode_set?: boolean | null
    }
  }

  interface TextTag {
    // Own properties of Gtk-4.0.Gtk.TextTag

    /**
     * Whether the margins accumulate or override each other.
     *
     * When set to %TRUE the margins of this tag are added to the margins
     * of any other non-accumulative margins present. When set to %FALSE
     * the margins override one another (the default).
     */
    accumulativeMargin: boolean
    /**
     * Whether breaks are allowed.
     */
    allowBreaks: boolean
    allowBreaksSet: boolean
    /**
     * Background color as a string.
     */
    background: string | null
    /**
     * Whether the background color fills the entire line height
     * or only the height of the tagged characters.
     */
    backgroundFullHeight: boolean
    backgroundFullHeightSet: boolean
    /**
     * Background color as a `GdkRGBA`.
     */
    backgroundRgba: Gdk.RGBA
    backgroundSet: boolean
    /**
     * Text direction, e.g. right-to-left or left-to-right.
     */
    direction: TextDirection
    /**
     * Whether the text can be modified by the user.
     */
    editable: boolean
    editableSet: boolean
    /**
     * Whether font fallback is enabled.
     *
     * When set to %TRUE, other fonts will be substituted
     * where the current font is missing glyphs.
     */
    fallback: boolean
    fallbackSet: boolean
    /**
     * Name of the font family, e.g. Sans, Helvetica, Times, Monospace.
     */
    family: string | null
    familySet: boolean
    /**
     * Font description as string, e.g. \"Sans Italic 12\".
     *
     * Note that the initial value of this property depends on
     * the internals of `PangoFontDescription`.
     */
    font: string | null
    /**
     * Font description as a `PangoFontDescription`.
     */
    fontDesc: Pango.FontDescription
    /**
     * OpenType font features, as a string.
     */
    fontFeatures: string | null
    fontFeaturesSet: boolean
    /**
     * Foreground color as a string.
     */
    foreground: string | null
    /**
     * Foreground color as a `GdkRGBA`.
     */
    foregroundRgba: Gdk.RGBA
    foregroundSet: boolean
    /**
     * Amount to indent the paragraph, in pixels.
     *
     * A negative value of indent will produce a hanging indentation.
     * That is, the first line will have the full width, and subsequent
     * lines will be indented by the absolute value of indent.
     */
    indent: number
    indentSet: boolean
    /**
     * Whether to insert hyphens at breaks.
     */
    insertHyphens: boolean
    insertHyphensSet: boolean
    /**
     * Whether this text is hidden.
     *
     * Note that there may still be problems with the support for invisible
     * text, in particular when navigating programmatically inside a buffer
     * containing invisible segments.
     */
    invisible: boolean
    invisibleSet: boolean
    /**
     * Left, right, or center justification.
     */
    justification: Justification
    justificationSet: boolean
    /**
     * The language this text is in, as an ISO code.
     *
     * Pango can use this as a hint when rendering the text.
     * If not set, an appropriate default will be used.
     *
     * Note that the initial value of this property depends
     * on the current locale, see also [func`Gtk`.get_default_language].
     */
    language: string | null
    languageSet: boolean
    /**
     * Width of the left margin in pixels.
     */
    leftMargin: number
    leftMarginSet: boolean
    /**
     * Extra spacing between graphemes, in Pango units.
     */
    letterSpacing: number
    letterSpacingSet: boolean
    /**
     * Factor to scale line height by.
     */
    lineHeight: number
    lineHeightSet: boolean
    /**
     * The name used to refer to the tag.
     *
     * %NULL for anonymous tags.
     */
    readonly name: string | null
    /**
     * Style of overline for this text.
     */
    overline: Pango.Overline
    /**
     * This property modifies the color of overlines.
     *
     * If not set, overlines will use the foreground color.
     */
    overlineRgba: Gdk.RGBA
    overlineRgbaSet: boolean
    overlineSet: boolean
    /**
     * The paragraph background color as a string.
     */
    paragraphBackground: string | null
    /**
     * The paragraph background color as a `GdkRGBA`.
     */
    paragraphBackgroundRgba: Gdk.RGBA
    paragraphBackgroundSet: boolean
    /**
     * Pixels of blank space above paragraphs.
     */
    pixelsAboveLines: number
    pixelsAboveLinesSet: boolean
    /**
     * Pixels of blank space below paragraphs.
     */
    pixelsBelowLines: number
    pixelsBelowLinesSet: boolean
    /**
     * Pixels of blank space between wrapped lines in a paragraph.
     */
    pixelsInsideWrap: number
    pixelsInsideWrapSet: boolean
    /**
     * Width of the right margin, in pixels.
     */
    rightMargin: number
    rightMarginSet: boolean
    /**
     * Offset of text above the baseline, in Pango units.
     *
     * Negative values go below the baseline.
     */
    rise: number
    riseSet: boolean
    /**
     * Font size as a scale factor relative to the default font size.
     *
     * This properly adapts to theme changes, etc. so is recommended.
     * Pango predefines some scales such as %PANGO_SCALE_X_LARGE.
     */
    scale: number
    scaleSet: boolean
    /**
     * Whether this tag represents a single sentence.
     *
     * This affects cursor movement.
     */
    sentence: boolean
    sentenceSet: boolean
    /**
     * How to render invisible characters.
     */
    showSpaces: Pango.ShowFlags
    showSpacesSet: boolean
    /**
     * Font size in Pango units.
     */
    size: number
    /**
     * Font size in points.
     */
    sizePoints: number
    sizeSet: boolean
    /**
     * Font stretch as a `PangoStretch`, e.g. %PANGO_STRETCH_CONDENSED.
     */
    stretch: Pango.Stretch
    stretchSet: boolean
    /**
     * Whether to strike through the text.
     */
    strikethrough: boolean
    /**
     * This property modifies the color of strikeouts.
     *
     * If not set, strikeouts will use the foreground color.
     */
    strikethroughRgba: Gdk.RGBA
    /**
     * If the `strikethrough-rgba` property has been set.
     */
    strikethroughRgbaSet: boolean
    strikethroughSet: boolean
    /**
     * Font style as a `PangoStyle`, e.g. %PANGO_STYLE_ITALIC.
     */
    style: Pango.Style
    styleSet: boolean
    /**
     * Custom tabs for this text.
     */
    tabs: Pango.TabArray
    tabsSet: boolean
    /**
     * How to transform the text for display.
     */
    textTransform: Pango.TextTransform
    textTransformSet: boolean
    /**
     * Style of underline for this text.
     */
    underline: Pango.Underline
    /**
     * This property modifies the color of underlines.
     *
     * If not set, underlines will use the foreground color.
     *
     * If [property`Gtk`.TextTag:underline] is set to %PANGO_UNDERLINE_ERROR,
     * an alternate color may be applied instead of the foreground. Setting
     * this property will always override those defaults.
     */
    underlineRgba: Gdk.RGBA
    /**
     * If the `underline-rgba` property has been set.
     */
    underlineRgbaSet: boolean
    underlineSet: boolean
    /**
     * Font variant as a `PangoVariant`, e.g. %PANGO_VARIANT_SMALL_CAPS.
     */
    variant: Pango.Variant
    variantSet: boolean
    /**
     * Font weight as an integer.
     */
    weight: number
    weightSet: boolean
    /**
     * Whether this tag represents a single word.
     *
     * This affects line breaks and cursor movement.
     */
    word: boolean
    wordSet: boolean
    /**
     * Whether to wrap lines never, at word boundaries, or
     * at character boundaries.
     */
    wrapMode: WrapMode
    wrapModeSet: boolean
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TextTag

    parentInstance: GObject.Object
    priv: TextTagPrivate

    // Owm methods of Gtk-4.0.Gtk.TextTag

    /**
     * Emits the [signal`Gtk`.TextTagTable::tag-changed] signal on the
     * `GtkTextTagTable` where the tag is included.
     *
     * The signal is already emitted when setting a `GtkTextTag` property.
     * This function is useful for a `GtkTextTag` subclass.
     * @param sizeChanged whether the change affects the `GtkTextView` layout
     */
    changed(sizeChanged: boolean): void
    /**
     * Get the tag priority.
     * @returns The tag’s priority.
     */
    getPriority(): number
    /**
     * Sets the priority of a `GtkTextTag`.
     *
     * Valid priorities start at 0 and go to one less than
     * [method`Gtk`.TextTagTable.get_size]. Each tag in a table
     * has a unique priority; setting the priority of one tag shifts
     * the priorities of all the other tags in the table to maintain
     * a unique priority for each tag.
     *
     * Higher priority tags “win” if two tags both set the same text
     * attribute. When adding a tag to a tag table, it will be assigned
     * the highest priority in the table by default; so normally the
     * precedence of a set of tags is the order in which they were added
     * to the table, or created with [method`Gtk`.TextBuffer.create_tag],
     * which adds the tag to the buffer’s table automatically.
     * @param priority the new priority
     */
    setPriority(priority: number): void

    // Class property signals of Gtk-4.0.Gtk.TextTag

    connect(
      sigName: "notify::accumulative-margin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accumulative-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accumulative-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accumulative-margin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accumulative-margin", ...args: any[]): void
    connect(
      sigName: "notify::allow-breaks",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::allow-breaks",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::allow-breaks",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::allow-breaks",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::allow-breaks", ...args: any[]): void
    connect(
      sigName: "notify::allow-breaks-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::allow-breaks-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::allow-breaks-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::allow-breaks-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::allow-breaks-set", ...args: any[]): void
    connect(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background", ...args: any[]): void
    connect(
      sigName: "notify::background-full-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-full-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-full-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-full-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-full-height", ...args: any[]): void
    connect(
      sigName: "notify::background-full-height-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-full-height-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-full-height-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-full-height-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-full-height-set", ...args: any[]): void
    connect(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::background-set", ...args: any[]): void
    connect(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::direction",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::direction",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::direction", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable-set", ...args: any[]): void
    connect(
      sigName: "notify::fallback",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fallback",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fallback",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fallback", ...args: any[]): void
    connect(
      sigName: "notify::fallback-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fallback-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fallback-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fallback-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fallback-set", ...args: any[]): void
    connect(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family", ...args: any[]): void
    connect(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::family-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::family-set", ...args: any[]): void
    connect(sigName: "notify::font", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font", ...args: any[]): void
    connect(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-desc",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-desc", ...args: any[]): void
    connect(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-features",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-features", ...args: any[]): void
    connect(
      sigName: "notify::font-features-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::font-features-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::font-features-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::font-features-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::font-features-set", ...args: any[]): void
    connect(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground", ...args: any[]): void
    connect(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-rgba", ...args: any[]): void
    connect(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::foreground-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::foreground-set", ...args: any[]): void
    connect(
      sigName: "notify::indent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::indent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::indent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::indent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::indent", ...args: any[]): void
    connect(
      sigName: "notify::indent-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::indent-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::indent-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::indent-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::indent-set", ...args: any[]): void
    connect(
      sigName: "notify::insert-hyphens",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::insert-hyphens",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::insert-hyphens",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::insert-hyphens",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::insert-hyphens", ...args: any[]): void
    connect(
      sigName: "notify::insert-hyphens-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::insert-hyphens-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::insert-hyphens-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::insert-hyphens-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::insert-hyphens-set", ...args: any[]): void
    connect(
      sigName: "notify::invisible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::invisible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::invisible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::invisible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::invisible", ...args: any[]): void
    connect(
      sigName: "notify::invisible-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::invisible-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::invisible-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::invisible-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::invisible-set", ...args: any[]): void
    connect(
      sigName: "notify::justification",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::justification",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::justification",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::justification",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::justification", ...args: any[]): void
    connect(
      sigName: "notify::justification-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::justification-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::justification-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::justification-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::justification-set", ...args: any[]): void
    connect(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language", ...args: any[]): void
    connect(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::language-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::language-set", ...args: any[]): void
    connect(
      sigName: "notify::left-margin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::left-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::left-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::left-margin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::left-margin", ...args: any[]): void
    connect(
      sigName: "notify::left-margin-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::left-margin-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::left-margin-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::left-margin-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::left-margin-set", ...args: any[]): void
    connect(
      sigName: "notify::letter-spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::letter-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::letter-spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::letter-spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::letter-spacing", ...args: any[]): void
    connect(
      sigName: "notify::letter-spacing-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::letter-spacing-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::letter-spacing-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::letter-spacing-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::letter-spacing-set", ...args: any[]): void
    connect(
      sigName: "notify::line-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::line-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::line-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::line-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::line-height", ...args: any[]): void
    connect(
      sigName: "notify::line-height-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::line-height-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::line-height-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::line-height-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::line-height-set", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::overline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overline", ...args: any[]): void
    connect(
      sigName: "notify::overline-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overline-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overline-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overline-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overline-rgba", ...args: any[]): void
    connect(
      sigName: "notify::overline-rgba-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overline-rgba-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overline-rgba-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overline-rgba-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overline-rgba-set", ...args: any[]): void
    connect(
      sigName: "notify::overline-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overline-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overline-set", ...args: any[]): void
    connect(
      sigName: "notify::paragraph-background",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::paragraph-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::paragraph-background",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::paragraph-background",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::paragraph-background", ...args: any[]): void
    connect(
      sigName: "notify::paragraph-background-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::paragraph-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::paragraph-background-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::paragraph-background-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::paragraph-background-rgba", ...args: any[]): void
    connect(
      sigName: "notify::paragraph-background-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::paragraph-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::paragraph-background-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::paragraph-background-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::paragraph-background-set", ...args: any[]): void
    connect(
      sigName: "notify::pixels-above-lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-above-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-above-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-above-lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-above-lines", ...args: any[]): void
    connect(
      sigName: "notify::pixels-above-lines-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-above-lines-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-above-lines-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-above-lines-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-above-lines-set", ...args: any[]): void
    connect(
      sigName: "notify::pixels-below-lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-below-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-below-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-below-lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-below-lines", ...args: any[]): void
    connect(
      sigName: "notify::pixels-below-lines-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-below-lines-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-below-lines-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-below-lines-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-below-lines-set", ...args: any[]): void
    connect(
      sigName: "notify::pixels-inside-wrap",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-inside-wrap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-inside-wrap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-inside-wrap",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-inside-wrap", ...args: any[]): void
    connect(
      sigName: "notify::pixels-inside-wrap-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-inside-wrap-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-inside-wrap-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-inside-wrap-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-inside-wrap-set", ...args: any[]): void
    connect(
      sigName: "notify::right-margin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::right-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::right-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::right-margin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::right-margin", ...args: any[]): void
    connect(
      sigName: "notify::right-margin-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::right-margin-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::right-margin-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::right-margin-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::right-margin-set", ...args: any[]): void
    connect(sigName: "notify::rise", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise", ...args: any[]): void
    connect(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rise-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rise-set", ...args: any[]): void
    connect(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale", ...args: any[]): void
    connect(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-set", ...args: any[]): void
    connect(
      sigName: "notify::sentence",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sentence",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sentence",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sentence",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sentence", ...args: any[]): void
    connect(
      sigName: "notify::sentence-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sentence-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sentence-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sentence-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sentence-set", ...args: any[]): void
    connect(
      sigName: "notify::show-spaces",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-spaces",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-spaces",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-spaces",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-spaces", ...args: any[]): void
    connect(
      sigName: "notify::show-spaces-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-spaces-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-spaces-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-spaces-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-spaces-set", ...args: any[]): void
    connect(sigName: "notify::size", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size", ...args: any[]): void
    connect(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-points",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-points", ...args: any[]): void
    connect(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::size-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::size-set", ...args: any[]): void
    connect(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch", ...args: any[]): void
    connect(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::stretch-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::stretch-set", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough-rgba", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough-rgba-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough-rgba-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough-rgba-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough-rgba-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough-rgba-set", ...args: any[]): void
    connect(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::strikethrough-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::strikethrough-set", ...args: any[]): void
    connect(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style", ...args: any[]): void
    connect(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::style-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::style-set", ...args: any[]): void
    connect(sigName: "notify::tabs", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tabs", ...args: any[]): void
    connect(
      sigName: "notify::tabs-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tabs-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tabs-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tabs-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tabs-set", ...args: any[]): void
    connect(
      sigName: "notify::text-transform",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-transform",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-transform",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-transform",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-transform", ...args: any[]): void
    connect(
      sigName: "notify::text-transform-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::text-transform-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::text-transform-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::text-transform-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::text-transform-set", ...args: any[]): void
    connect(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline", ...args: any[]): void
    connect(
      sigName: "notify::underline-rgba",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline-rgba",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline-rgba",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline-rgba", ...args: any[]): void
    connect(
      sigName: "notify::underline-rgba-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline-rgba-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline-rgba-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline-rgba-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline-rgba-set", ...args: any[]): void
    connect(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::underline-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::underline-set", ...args: any[]): void
    connect(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant", ...args: any[]): void
    connect(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::variant-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::variant-set", ...args: any[]): void
    connect(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight", ...args: any[]): void
    connect(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::weight-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::weight-set", ...args: any[]): void
    connect(sigName: "notify::word", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::word",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::word",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::word",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::word", ...args: any[]): void
    connect(
      sigName: "notify::word-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::word-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::word-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::word-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::word-set", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode-set", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A tag that can be applied to text contained in a `GtkTextBuffer`.
   *
   * You may wish to begin by reading the
   * [text widget conceptual overview](section-text-widget.html),
   * which gives an overview of all the objects and data types
   * related to the text widget and how they work together.
   *
   * Tags should be in the [class`Gtk`.TextTagTable] for a given
   * `GtkTextBuffer` before using them with that buffer.
   *
   * [method`Gtk`.TextBuffer.create_tag] is the best way to create tags.
   * See “gtk4-demo” for numerous examples.
   *
   * For each property of `GtkTextTag`, there is a “set” property, e.g.
   * “font-set” corresponds to “font”. These “set” properties reflect
   * whether a property has been set or not.
   *
   * They are maintained by GTK and you should not set them independently.
   * @class
   */
  class TextTag extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TextTag

    static name: string

    // Constructors of Gtk-4.0.Gtk.TextTag

    constructor(config?: TextTag.ConstructorProperties)
    /**
     * Creates a `GtkTextTag`.
     * @constructor
     * @param name tag name
     * @returns a new `GtkTextTag`
     */
    constructor(name: string | null)
    /**
     * Creates a `GtkTextTag`.
     * @constructor
     * @param name tag name
     * @returns a new `GtkTextTag`
     */
    static new(name: string | null): TextTag
    _init(config?: TextTag.ConstructorProperties): void
  }

  module TextTagTable {
    // Signal callback interfaces

    /**
     * Signal callback interface for `tag-added`
     */
    interface TagAddedSignalCallback {
      (tag: TextTag): void
    }

    /**
     * Signal callback interface for `tag-changed`
     */
    interface TagChangedSignalCallback {
      (tag: TextTag, sizeChanged: boolean): void
    }

    /**
     * Signal callback interface for `tag-removed`
     */
    interface TagRemovedSignalCallback {
      (tag: TextTag): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface TextTagTable extends Buildable {
    // Own properties of Gtk-4.0.Gtk.TextTagTable

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TextTagTable

    /**
     * Add a tag to the table.
     *
     * The tag is assigned the highest priority in the table.
     *
     * `tag` must not be in a tag table already, and may not have
     * the same name as an already-added tag.
     * @param tag a `GtkTextTag`
     * @returns %TRUE on success.
     */
    add(tag: TextTag): boolean
    /**
     * Calls `func` on each tag in `table,` with user data `data`.
     *
     * Note that the table may not be modified while iterating
     * over it (you can’t add/remove tags).
     * @param func a function to call on each tag
     */
    foreach(func: TextTagTableForeach): void
    /**
     * Returns the size of the table (number of tags)
     * @returns number of tags in @table
     */
    getSize(): number
    /**
     * Look up a named tag.
     * @param name name of a tag
     * @returns The tag
     */
    lookup(name: string): TextTag | null
    /**
     * Remove a tag from the table.
     *
     * If a `GtkTextBuffer` has `table` as its tag table, the tag is
     * removed from the buffer. The table’s reference to the tag is
     * removed, so the tag will end up destroyed if you don’t have
     * a reference to it.
     * @param tag a `GtkTextTag`
     */
    remove(tag: TextTag): void

    // Own signals of Gtk-4.0.Gtk.TextTagTable

    connect(
      sigName: "tag-added",
      callback: TextTagTable.TagAddedSignalCallback
    ): number
    on(
      sigName: "tag-added",
      callback: TextTagTable.TagAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "tag-added",
      callback: TextTagTable.TagAddedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "tag-added",
      callback: TextTagTable.TagAddedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "tag-added", ...args: any[]): void
    connect(
      sigName: "tag-changed",
      callback: TextTagTable.TagChangedSignalCallback
    ): number
    on(
      sigName: "tag-changed",
      callback: TextTagTable.TagChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "tag-changed",
      callback: TextTagTable.TagChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "tag-changed",
      callback: TextTagTable.TagChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "tag-changed", sizeChanged: boolean, ...args: any[]): void
    connect(
      sigName: "tag-removed",
      callback: TextTagTable.TagRemovedSignalCallback
    ): number
    on(
      sigName: "tag-removed",
      callback: TextTagTable.TagRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "tag-removed",
      callback: TextTagTable.TagRemovedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "tag-removed",
      callback: TextTagTable.TagRemovedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "tag-removed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.TextTagTable

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The collection of tags in a `GtkTextBuffer`
   *
   * You may wish to begin by reading the
   * [text widget conceptual overview](section-text-widget.html),
   * which gives an overview of all the objects and data types
   * related to the text widget and how they work together.
   *
   * # GtkTextTagTables as GtkBuildable
   *
   * The `GtkTextTagTable` implementation of the `GtkBuildable` interface
   * supports adding tags by specifying “tag” as the “type” attribute
   * of a `<child>` element.
   *
   * An example of a UI definition fragment specifying tags:
   * ```xml
   * <object class="GtkTextTagTable">
   *  <child type="tag">
   *    <object class="GtkTextTag"/>
   *  </child>
   * </object>
   * ```
   * @class
   */
  class TextTagTable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TextTagTable

    static name: string

    // Constructors of Gtk-4.0.Gtk.TextTagTable

    constructor(config?: TextTagTable.ConstructorProperties)
    /**
     * Creates a new `GtkTextTagTable`.
     *
     * The table contains no tags by default.
     * @constructor
     * @returns a new `GtkTextTagTable`
     */
    constructor()
    /**
     * Creates a new `GtkTextTagTable`.
     *
     * The table contains no tags by default.
     * @constructor
     * @returns a new `GtkTextTagTable`
     */
    static new(): TextTagTable
    _init(config?: TextTagTable.ConstructorProperties): void
  }

  module TextView {
    // Signal callback interfaces

    /**
     * Signal callback interface for `backspace`
     */
    interface BackspaceSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `copy-clipboard`
     */
    interface CopyClipboardSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `cut-clipboard`
     */
    interface CutClipboardSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `delete-from-cursor`
     */
    interface DeleteFromCursorSignalCallback {
      (type: DeleteType, count: number): void
    }

    /**
     * Signal callback interface for `extend-selection`
     */
    interface ExtendSelectionSignalCallback {
      (
        granularity: TextExtendSelection,
        location: TextIter,
        start: TextIter,
        end: TextIter
      ): boolean
    }

    /**
     * Signal callback interface for `insert-at-cursor`
     */
    interface InsertAtCursorSignalCallback {
      (string: string | null): void
    }

    /**
     * Signal callback interface for `insert-emoji`
     */
    interface InsertEmojiSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `move-cursor`
     */
    interface MoveCursorSignalCallback {
      (step: MovementStep, count: number, extendSelection: boolean): void
    }

    /**
     * Signal callback interface for `move-viewport`
     */
    interface MoveViewportSignalCallback {
      (step: ScrollStep, count: number): void
    }

    /**
     * Signal callback interface for `paste-clipboard`
     */
    interface PasteClipboardSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `preedit-changed`
     */
    interface PreeditChangedSignalCallback {
      (preedit: string | null): void
    }

    /**
     * Signal callback interface for `select-all`
     */
    interface SelectAllSignalCallback {
      (select: boolean): void
    }

    /**
     * Signal callback interface for `set-anchor`
     */
    interface SetAnchorSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `toggle-cursor-visible`
     */
    interface ToggleCursorVisibleSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `toggle-overwrite`
     */
    interface ToggleOverwriteSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleText.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Scrollable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TextView

      /**
       * Whether Tab will result in a tab character being entered.
       */
      accepts_tab?: boolean | null
      /**
       * The bottom margin for text in the text view.
       *
       * Note that this property is confusingly named. In CSS terms,
       * the value set here is padding, and it is applied in addition
       * to the padding from the theme.
       *
       * Don't confuse this property with [property`Gtk`.Widget:margin-bottom].
       */
      bottom_margin?: number | null
      /**
       * The buffer which is displayed.
       */
      buffer?: TextBuffer | null
      /**
       * If the insertion cursor is shown.
       */
      cursor_visible?: boolean | null
      editable?: boolean | null
      /**
       * A menu model whose contents will be appended to the context menu.
       */
      extra_menu?: Gio.MenuModel | null
      /**
       * Which IM (input method) module should be used for this text_view.
       *
       * See [class`Gtk`.IMMulticontext].
       *
       * Setting this to a non-%NULL value overrides the system-wide IM module
       * setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module] property.
       */
      im_module?: string | null
      /**
       * Amount to indent the paragraph, in pixels.
       *
       * A negative value of indent will produce a hanging indentation.
       * That is, the first line will have the full width, and subsequent
       * lines will be indented by the absolute value of indent.
       */
      indent?: number | null
      /**
       * Additional hints (beyond [property`Gtk`.TextView:input-purpose])
       * that allow input methods to fine-tune their behaviour.
       */
      input_hints?: InputHints | null
      /**
       * The purpose of this text field.
       *
       * This property can be used by on-screen keyboards and other input
       * methods to adjust their behaviour.
       */
      input_purpose?: InputPurpose | null
      justification?: Justification | null
      /**
       * The default left margin for text in the text view.
       *
       * Tags in the buffer may override the default.
       *
       * Note that this property is confusingly named. In CSS terms,
       * the value set here is padding, and it is applied in addition
       * to the padding from the theme.
       */
      left_margin?: number | null
      /**
       * Whether text should be displayed in a monospace font.
       *
       * If %TRUE, set the .monospace style class on the
       * text view to indicate that a monospace font is desired.
       */
      monospace?: boolean | null
      /**
       * Whether entered text overwrites existing contents.
       */
      overwrite?: boolean | null
      pixels_above_lines?: number | null
      pixels_below_lines?: number | null
      pixels_inside_wrap?: number | null
      /**
       * The default right margin for text in the text view.
       *
       * Tags in the buffer may override the default.
       *
       * Note that this property is confusingly named. In CSS terms,
       * the value set here is padding, and it is applied in addition
       * to the padding from the theme.
       */
      right_margin?: number | null
      tabs?: Pango.TabArray | null
      /**
       * The top margin for text in the text view.
       *
       * Note that this property is confusingly named. In CSS terms,
       * the value set here is padding, and it is applied in addition
       * to the padding from the theme.
       *
       * Don't confuse this property with [property`Gtk`.Widget:margin-top].
       */
      top_margin?: number | null
      wrap_mode?: WrapMode | null
    }
  }

  interface TextView
    extends Accessible,
      AccessibleText,
      Buildable,
      ConstraintTarget,
      Scrollable {
    // Own properties of Gtk-4.0.Gtk.TextView

    /**
     * Whether Tab will result in a tab character being entered.
     */
    acceptsTab: boolean
    /**
     * The bottom margin for text in the text view.
     *
     * Note that this property is confusingly named. In CSS terms,
     * the value set here is padding, and it is applied in addition
     * to the padding from the theme.
     *
     * Don't confuse this property with [property`Gtk`.Widget:margin-bottom].
     */
    bottomMargin: number
    /**
     * The buffer which is displayed.
     */
    buffer: TextBuffer
    /**
     * If the insertion cursor is shown.
     */
    cursorVisible: boolean
    editable: boolean
    /**
     * A menu model whose contents will be appended to the context menu.
     */
    extraMenu: Gio.MenuModel
    /**
     * Which IM (input method) module should be used for this text_view.
     *
     * See [class`Gtk`.IMMulticontext].
     *
     * Setting this to a non-%NULL value overrides the system-wide IM module
     * setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module] property.
     */
    imModule: string | null
    /**
     * Amount to indent the paragraph, in pixels.
     *
     * A negative value of indent will produce a hanging indentation.
     * That is, the first line will have the full width, and subsequent
     * lines will be indented by the absolute value of indent.
     */
    indent: number
    /**
     * Additional hints (beyond [property`Gtk`.TextView:input-purpose])
     * that allow input methods to fine-tune their behaviour.
     */
    inputHints: InputHints
    /**
     * The purpose of this text field.
     *
     * This property can be used by on-screen keyboards and other input
     * methods to adjust their behaviour.
     */
    inputPurpose: InputPurpose
    justification: Justification
    /**
     * The default left margin for text in the text view.
     *
     * Tags in the buffer may override the default.
     *
     * Note that this property is confusingly named. In CSS terms,
     * the value set here is padding, and it is applied in addition
     * to the padding from the theme.
     */
    leftMargin: number
    /**
     * Whether text should be displayed in a monospace font.
     *
     * If %TRUE, set the .monospace style class on the
     * text view to indicate that a monospace font is desired.
     */
    monospace: boolean
    /**
     * Whether entered text overwrites existing contents.
     */
    overwrite: boolean
    pixelsAboveLines: number
    pixelsBelowLines: number
    pixelsInsideWrap: number
    /**
     * The default right margin for text in the text view.
     *
     * Tags in the buffer may override the default.
     *
     * Note that this property is confusingly named. In CSS terms,
     * the value set here is padding, and it is applied in addition
     * to the padding from the theme.
     */
    rightMargin: number
    tabs: Pango.TabArray
    /**
     * The top margin for text in the text view.
     *
     * Note that this property is confusingly named. In CSS terms,
     * the value set here is padding, and it is applied in addition
     * to the padding from the theme.
     *
     * Don't confuse this property with [property`Gtk`.Widget:margin-top].
     */
    topMargin: number
    wrapMode: WrapMode
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TextView

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.TextView

    /**
     * Adds a child widget in the text buffer, at the given `anchor`.
     * @param child a `GtkWidget`
     * @param anchor a `GtkTextChildAnchor` in the `GtkTextBuffer` for `text_view`
     */
    addChildAtAnchor(child: Widget, anchor: TextChildAnchor): void
    /**
     * Adds `child` at a fixed coordinate in the `GtkTextView`'s text window.
     *
     * The `xpos` and `ypos` must be in buffer coordinates (see
     * [method`Gtk`.TextView.get_iter_location] to convert to
     * buffer coordinates).
     *
     * `child` will scroll with the text view.
     *
     * If instead you want a widget that will not move with the
     * `GtkTextView` contents see `GtkOverlay`.
     * @param child a `GtkWidget`
     * @param xpos X position of child in window coordinates
     * @param ypos Y position of child in window coordinates
     */
    addOverlay(child: Widget, xpos: number, ypos: number): void
    /**
     * Moves the given `iter` backward by one display (wrapped) line.
     *
     * A display line is different from a paragraph. Paragraphs are
     * separated by newlines or other paragraph separator characters.
     * Display lines are created by line-wrapping a paragraph. If
     * wrapping is turned off, display lines and paragraphs will be the
     * same. Display lines are divided differently for each view, since
     * they depend on the view’s width; paragraphs are the same in all
     * views, since they depend on the contents of the `GtkTextBuffer`.
     * @param iter a `GtkTextIter`
     * @returns %TRUE if @iter was moved and is not on the end iterator
     */
    backwardDisplayLine(iter: TextIter): boolean
    /**
     * Moves the given `iter` backward to the next display line start.
     *
     * A display line is different from a paragraph. Paragraphs are
     * separated by newlines or other paragraph separator characters.
     * Display lines are created by line-wrapping a paragraph. If
     * wrapping is turned off, display lines and paragraphs will be the
     * same. Display lines are divided differently for each view, since
     * they depend on the view’s width; paragraphs are the same in all
     * views, since they depend on the contents of the `GtkTextBuffer`.
     * @param iter a `GtkTextIter`
     * @returns %TRUE if @iter was moved and is not on the end iterator
     */
    backwardDisplayLineStart(iter: TextIter): boolean
    /**
     * Converts buffer coordinates to window coordinates.
     * @param win a `GtkTextWindowType`
     * @param bufferX buffer x coordinate
     * @param bufferY buffer y coordinate
     */
    bufferToWindowCoords(
      win: TextWindowType,
      bufferX: number,
      bufferY: number
    ): [/* windowX */ number, /* windowY */ number]
    /**
     * Moves the given `iter` forward by one display (wrapped) line.
     *
     * A display line is different from a paragraph. Paragraphs are
     * separated by newlines or other paragraph separator characters.
     * Display lines are created by line-wrapping a paragraph. If
     * wrapping is turned off, display lines and paragraphs will be the
     * same. Display lines are divided differently for each view, since
     * they depend on the view’s width; paragraphs are the same in all
     * views, since they depend on the contents of the `GtkTextBuffer`.
     * @param iter a `GtkTextIter`
     * @returns %TRUE if @iter was moved and is not on the end iterator
     */
    forwardDisplayLine(iter: TextIter): boolean
    /**
     * Moves the given `iter` forward to the next display line end.
     *
     * A display line is different from a paragraph. Paragraphs are
     * separated by newlines or other paragraph separator characters.
     * Display lines are created by line-wrapping a paragraph. If
     * wrapping is turned off, display lines and paragraphs will be the
     * same. Display lines are divided differently for each view, since
     * they depend on the view’s width; paragraphs are the same in all
     * views, since they depend on the contents of the `GtkTextBuffer`.
     * @param iter a `GtkTextIter`
     * @returns %TRUE if @iter was moved and is not on the end iterator
     */
    forwardDisplayLineEnd(iter: TextIter): boolean
    /**
     * Returns whether pressing the <kbd>Tab</kbd> key inserts a tab characters.
     *
     * See [method`Gtk`.TextView.set_accepts_tab].
     * @returns %TRUE if pressing the Tab key inserts a tab character,   %FALSE if pressing the Tab key moves the keyboard focus.
     */
    getAcceptsTab(): boolean
    /**
     * Gets the bottom margin for text in the `text_view`.
     * @returns bottom margin in pixels
     */
    getBottomMargin(): number
    /**
     * Returns the `GtkTextBuffer` being displayed by this text view.
     *
     * The reference count on the buffer is not incremented; the caller
     * of this function won’t own a new reference.
     * @returns a `GtkTextBuffer`
     */
    getBuffer(): TextBuffer
    /**
     * Determine the positions of the strong and weak cursors if the
     * insertion point is at `iter`.
     *
     * The position of each cursor is stored as a zero-width rectangle.
     * The strong cursor location is the location where characters of
     * the directionality equal to the base direction of the paragraph
     * are inserted. The weak cursor location is the location where
     * characters of the directionality opposite to the base direction
     * of the paragraph are inserted.
     *
     * If `iter` is %NULL, the actual cursor position is used.
     *
     * Note that if `iter` happens to be the actual cursor position, and
     * there is currently an IM preedit sequence being entered, the
     * returned locations will be adjusted to account for the preedit
     * cursor’s offset within the preedit sequence.
     *
     * The rectangle position is in buffer coordinates; use
     * [method`Gtk`.TextView.buffer_to_window_coords] to convert these
     * coordinates to coordinates for one of the windows in the text view.
     * @param iter a `GtkTextIter`
     */
    getCursorLocations(
      iter: TextIter | null
    ): [/* strong */ Gdk.Rectangle, /* weak */ Gdk.Rectangle]
    /**
     * Find out whether the cursor should be displayed.
     * @returns whether the insertion mark is visible
     */
    getCursorVisible(): boolean
    /**
     * Returns the default editability of the `GtkTextView`.
     *
     * Tags in the buffer may override this setting for some ranges of text.
     * @returns whether text is editable by default
     */
    getEditable(): boolean
    /**
     * Gets the menu model that gets added to the context menu
     * or %NULL if none has been set.
     * @returns the menu model
     */
    getExtraMenu(): Gio.MenuModel
    /**
     * Gets a `GtkWidget` that has previously been set as gutter.
     *
     * See [method`Gtk`.TextView.set_gutter].
     *
     * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
     * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
     * @param win a `GtkTextWindowType`
     * @returns a `GtkWidget`
     */
    getGutter(win: TextWindowType): Widget | null
    /**
     * Gets the default indentation of paragraphs in `text_view`.
     *
     * Tags in the view’s buffer may override the default.
     * The indentation may be negative.
     * @returns number of pixels of indentation
     */
    getIndent(): number
    /**
     * Gets the `input-hints` of the `GtkTextView`.
     */
    getInputHints(): InputHints
    /**
     * Gets the `input-purpose` of the `GtkTextView`.
     */
    getInputPurpose(): InputPurpose
    /**
     * Retrieves the iterator at buffer coordinates `x` and `y`.
     *
     * Buffer coordinates are coordinates for the entire buffer, not just
     * the currently-displayed portion. If you have coordinates from an
     * event, you have to convert those to buffer coordinates with
     * [method`Gtk`.TextView.window_to_buffer_coords].
     * @param x x position, in buffer coordinates
     * @param y y position, in buffer coordinates
     * @returns %TRUE if the position is over text
     */
    getIterAtLocation(
      x: number,
      y: number
    ): [/* returnType */ boolean, /* iter */ TextIter]
    /**
     * Retrieves the iterator pointing to the character at buffer
     * coordinates `x` and `y`.
     *
     * Buffer coordinates are coordinates for the entire buffer, not just
     * the currently-displayed portion. If you have coordinates from an event,
     * you have to convert those to buffer coordinates with
     * [method`Gtk`.TextView.window_to_buffer_coords].
     *
     * Note that this is different from [method`Gtk`.TextView.get_iter_at_location],
     * which returns cursor locations, i.e. positions between characters.
     * @param x x position, in buffer coordinates
     * @param y y position, in buffer coordinates
     * @returns %TRUE if the position is over text
     */
    getIterAtPosition(
      x: number,
      y: number
    ): [/* returnType */ boolean, /* iter */ TextIter, /* trailing */ number]
    /**
     * Gets a rectangle which roughly contains the character at `iter`.
     *
     * The rectangle position is in buffer coordinates; use
     * [method`Gtk`.TextView.buffer_to_window_coords] to convert these
     * coordinates to coordinates for one of the windows in the text view.
     * @param iter a `GtkTextIter`
     */
    getIterLocation(iter: TextIter): /* location */ Gdk.Rectangle
    /**
     * Gets the default justification of paragraphs in `text_view`.
     *
     * Tags in the buffer may override the default.
     * @returns default justification
     */
    getJustification(): Justification
    /**
     * Gets the default left margin size of paragraphs in the `text_view`.
     *
     * Tags in the buffer may override the default.
     * @returns left margin in pixels
     */
    getLeftMargin(): number
    /**
     * Gets the `GtkTextIter` at the start of the line containing
     * the coordinate `y`.
     *
     * `y` is in buffer coordinates, convert from window coordinates with
     * [method`Gtk`.TextView.window_to_buffer_coords]. If non-%NULL,
     * `line_top` will be filled with the coordinate of the top edge
     * of the line.
     * @param y a y coordinate
     */
    getLineAtY(y: number): [/* targetIter */ TextIter, /* lineTop */ number]
    /**
     * Gets the y coordinate of the top of the line containing `iter,`
     * and the height of the line.
     *
     * The coordinate is a buffer coordinate; convert to window
     * coordinates with [method`Gtk`.TextView.buffer_to_window_coords].
     * @param iter a `GtkTextIter`
     */
    getLineYrange(iter: TextIter): [/* y */ number, /* height */ number]
    /**
     * Gets the `PangoContext` that is used for rendering LTR directed
     * text layouts.
     *
     * The context may be replaced when CSS changes occur.
     * @returns a `PangoContext`
     */
    getLtrContext(): Pango.Context
    /**
     * Gets whether the `GtkTextView` uses monospace styling.
     * @returns %TRUE if monospace fonts are desired
     */
    getMonospace(): boolean
    /**
     * Returns whether the `GtkTextView` is in overwrite mode or not.
     * @returns whether @text_view is in overwrite mode or not.
     */
    getOverwrite(): boolean
    /**
     * Gets the default number of pixels to put above paragraphs.
     *
     * Adding this function with [method`Gtk`.TextView.get_pixels_below_lines]
     * is equal to the line space between each paragraph.
     * @returns default number of pixels above paragraphs
     */
    getPixelsAboveLines(): number
    /**
     * Gets the default number of pixels to put below paragraphs.
     *
     * The line space is the sum of the value returned by this function and
     * the value returned by [method`Gtk`.TextView.get_pixels_above_lines].
     * @returns default number of blank pixels below paragraphs
     */
    getPixelsBelowLines(): number
    /**
     * Gets the default number of pixels to put between wrapped lines
     * inside a paragraph.
     * @returns default number of pixels of blank space between wrapped lines
     */
    getPixelsInsideWrap(): number
    /**
     * Gets the default right margin for text in `text_view`.
     *
     * Tags in the buffer may override the default.
     * @returns right margin in pixels
     */
    getRightMargin(): number
    /**
     * Gets the `PangoContext` that is used for rendering RTL directed
     * text layouts.
     *
     * The context may be replaced when CSS changes occur.
     * @returns a `PangoContext`
     */
    getRtlContext(): Pango.Context
    /**
     * Gets the default tabs for `text_view`.
     *
     * Tags in the buffer may override the defaults. The returned array
     * will be %NULL if “standard” (8-space) tabs are used. Free the
     * return value with [method`Pango`.TabArray.free].
     * @returns copy of default tab array,   or %NULL if standard tabs are used; must be freed with   [method@Pango.TabArray.free].
     */
    getTabs(): Pango.TabArray | null
    /**
     * Gets the top margin for text in the `text_view`.
     * @returns top margin in pixels
     */
    getTopMargin(): number
    /**
     * Fills `visible_rect` with the currently-visible
     * region of the buffer, in buffer coordinates.
     *
     * Convert to window coordinates with
     * [method`Gtk`.TextView.buffer_to_window_coords].
     */
    getVisibleRect(): /* visibleRect */ Gdk.Rectangle
    /**
     * Gets the line wrapping for the view.
     * @returns the line wrap setting
     */
    getWrapMode(): WrapMode
    /**
     * Allow the `GtkTextView` input method to internally handle key press
     * and release events.
     *
     * If this function returns %TRUE, then no further processing should be
     * done for this key event. See [method`Gtk`.IMContext.filter_keypress].
     *
     * Note that you are expected to call this function from your handler
     * when overriding key event handling. This is needed in the case when
     * you need to insert your own key handling between the input method
     * and the default key event handling of the `GtkTextView`.
     *
     * ```c
     * static gboolean
     * gtk_foo_bar_key_press_event (GtkWidget *widget,
     *                              GdkEvent  *event)
     * {
     *   guint keyval;
     *
     *   gdk_event_get_keyval ((GdkEvent*)event, &keyval);
     *
     *   if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
     *     {
     *       if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event))
     *         return TRUE;
     *     }
     *
     *   // Do some stuff
     *
     *   return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
     * }
     * ```
     * @param event the key event
     * @returns %TRUE if the input method handled the key event.
     */
    imContextFilterKeypress(event: Gdk.Event): boolean
    /**
     * Moves a mark within the buffer so that it's
     * located within the currently-visible text area.
     * @param mark a `GtkTextMark`
     * @returns %TRUE if the mark moved (wasn’t already onscreen)
     */
    moveMarkOnscreen(mark: TextMark): boolean
    /**
     * Updates the position of a child.
     *
     * See [method`Gtk`.TextView.add_overlay].
     * @param child a widget already added with [method`Gtk`.TextView.add_overlay]
     * @param xpos new X position in buffer coordinates
     * @param ypos new Y position in buffer coordinates
     */
    moveOverlay(child: Widget, xpos: number, ypos: number): void
    /**
     * Move the iterator a given number of characters visually, treating
     * it as the strong cursor position.
     *
     * If `count` is positive, then the new strong cursor position will
     * be `count` positions to the right of the old cursor position.
     * If `count` is negative then the new strong cursor position will
     * be `count` positions to the left of the old cursor position.
     *
     * In the presence of bi-directional text, the correspondence
     * between logical and visual order will depend on the direction
     * of the current run, and there may be jumps when the cursor
     * is moved off of the end of a run.
     * @param iter a `GtkTextIter`
     * @param count number of characters to move (negative moves left,    positive moves right)
     * @returns %TRUE if @iter moved and is not on the end iterator
     */
    moveVisually(iter: TextIter, count: number): boolean
    /**
     * Moves the cursor to the currently visible region of the
     * buffer.
     * @returns %TRUE if the cursor had to be moved.
     */
    placeCursorOnscreen(): boolean
    /**
     * Removes a child widget from `text_view`.
     * @param child the child to remove
     */
    remove(child: Widget): void
    /**
     * Ensures that the cursor is shown.
     *
     * This also resets the time that it will stay blinking (or
     * visible, in case blinking is disabled).
     *
     * This function should be called in response to user input
     * (e.g. from derived classes that override the textview's
     * event handlers).
     */
    resetCursorBlink(): void
    /**
     * Reset the input method context of the text view if needed.
     *
     * This can be necessary in the case where modifying the buffer
     * would confuse on-going input method behavior.
     */
    resetImContext(): void
    /**
     * Scrolls `text_view` the minimum distance such that `mark` is contained
     * within the visible area of the widget.
     * @param mark a mark in the buffer for `text_view`
     */
    scrollMarkOnscreen(mark: TextMark): void
    /**
     * Scrolls `text_view` so that `iter` is on the screen in the position
     * indicated by `xalign` and `yalign`.
     *
     * An alignment of 0.0 indicates left or top, 1.0 indicates right or
     * bottom, 0.5 means center. If `use_align` is %FALSE, the text scrolls
     * the minimal distance to get the mark onscreen, possibly not scrolling
     * at all. The effective screen for purposes of this function is reduced
     * by a margin of size `within_margin`.
     *
     * Note that this function uses the currently-computed height of the
     * lines in the text buffer. Line heights are computed in an idle
     * handler; so this function may not have the desired effect if it’s
     * called before the height computations. To avoid oddness, consider
     * using [method`Gtk`.TextView.scroll_to_mark] which saves a point to be
     * scrolled to after line validation.
     * @param iter a `GtkTextIter`
     * @param withinMargin margin as a [0.0,0.5) fraction of screen size
     * @param useAlign whether to use alignment arguments (if %FALSE,    just get the mark onscreen)
     * @param xalign horizontal alignment of mark within visible area
     * @param yalign vertical alignment of mark within visible area
     * @returns %TRUE if scrolling occurred
     */
    scrollToIter(
      iter: TextIter,
      withinMargin: number,
      useAlign: boolean,
      xalign: number,
      yalign: number
    ): boolean
    /**
     * Scrolls `text_view` so that `mark` is on the screen in the position
     * indicated by `xalign` and `yalign`.
     *
     * An alignment of 0.0 indicates left or top, 1.0 indicates right or
     * bottom, 0.5 means center. If `use_align` is %FALSE, the text scrolls
     * the minimal distance to get the mark onscreen, possibly not scrolling
     * at all. The effective screen for purposes of this function is reduced
     * by a margin of size `within_margin`.
     * @param mark a `GtkTextMark`
     * @param withinMargin margin as a [0.0,0.5) fraction of screen size
     * @param useAlign whether to use alignment arguments (if %FALSE, just    get the mark onscreen)
     * @param xalign horizontal alignment of mark within visible area
     * @param yalign vertical alignment of mark within visible area
     */
    scrollToMark(
      mark: TextMark,
      withinMargin: number,
      useAlign: boolean,
      xalign: number,
      yalign: number
    ): void
    /**
     * Sets the behavior of the text widget when the <kbd>Tab</kbd> key is pressed.
     *
     * If `accepts_tab` is %TRUE, a tab character is inserted. If `accepts_tab`
     * is %FALSE the keyboard focus is moved to the next widget in the focus
     * chain.
     *
     * Focus can always be moved using <kbd>Ctrl</kbd>+<kbd>Tab</kbd>.
     * @param acceptsTab %TRUE if pressing the Tab key should insert a tab    character, %FALSE, if pressing the Tab key should move the    keyboard focus.
     */
    setAcceptsTab(acceptsTab: boolean): void
    /**
     * Sets the bottom margin for text in `text_view`.
     *
     * Note that this function is confusingly named.
     * In CSS terms, the value set here is padding.
     * @param bottomMargin bottom margin in pixels
     */
    setBottomMargin(bottomMargin: number): void
    /**
     * Sets `buffer` as the buffer being displayed by `text_view`.
     *
     * The previous buffer displayed by the text view is unreferenced, and
     * a reference is added to `buffer`. If you owned a reference to `buffer`
     * before passing it to this function, you must remove that reference
     * yourself; `GtkTextView` will not “adopt” it.
     * @param buffer a `GtkTextBuffer`
     */
    setBuffer(buffer: TextBuffer | null): void
    /**
     * Toggles whether the insertion point should be displayed.
     *
     * A buffer with no editable text probably shouldn’t have a visible
     * cursor, so you may want to turn the cursor off.
     *
     * Note that this property may be overridden by the
     * [property`Gtk`.Settings:gtk-keynav-use-caret] setting.
     * @param setting whether to show the insertion cursor
     */
    setCursorVisible(setting: boolean): void
    /**
     * Sets the default editability of the `GtkTextView`.
     *
     * You can override this default setting with tags in the buffer,
     * using the “editable” attribute of tags.
     * @param setting whether it’s editable
     */
    setEditable(setting: boolean): void
    /**
     * Sets a menu model to add when constructing the context
     * menu for `text_view`.
     *
     * You can pass %NULL to remove a previously set extra menu.
     * @param model a `GMenuModel`
     */
    setExtraMenu(model: Gio.MenuModel | null): void
    /**
     * Places `widget` into the gutter specified by `win`.
     *
     * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
     * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
     * @param win a `GtkTextWindowType`
     * @param widget a `GtkWidget`
     */
    setGutter(win: TextWindowType, widget: Widget | null): void
    /**
     * Sets the default indentation for paragraphs in `text_view`.
     *
     * Tags in the buffer may override the default.
     * @param indent indentation in pixels
     */
    setIndent(indent: number): void
    /**
     * Sets the `input-hints` of the `GtkTextView`.
     *
     * The `input-hints` allow input methods to fine-tune
     * their behaviour.
     * @param hints the hints
     */
    setInputHints(hints: InputHints): void
    /**
     * Sets the `input-purpose` of the `GtkTextView`.
     *
     * The `input-purpose` can be used by on-screen keyboards
     * and other input methods to adjust their behaviour.
     * @param purpose the purpose
     */
    setInputPurpose(purpose: InputPurpose): void
    /**
     * Sets the default justification of text in `text_view`.
     *
     * Tags in the view’s buffer may override the default.
     * @param justification justification
     */
    setJustification(justification: Justification): void
    /**
     * Sets the default left margin for text in `text_view`.
     *
     * Tags in the buffer may override the default.
     *
     * Note that this function is confusingly named.
     * In CSS terms, the value set here is padding.
     * @param leftMargin left margin in pixels
     */
    setLeftMargin(leftMargin: number): void
    /**
     * Sets whether the `GtkTextView` should display text in
     * monospace styling.
     * @param monospace %TRUE to request monospace styling
     */
    setMonospace(monospace: boolean): void
    /**
     * Changes the `GtkTextView` overwrite mode.
     * @param overwrite %TRUE to turn on overwrite mode, %FALSE to turn it off
     */
    setOverwrite(overwrite: boolean): void
    /**
     * Sets the default number of blank pixels above paragraphs in `text_view`.
     *
     * Tags in the buffer for `text_view` may override the defaults.
     * @param pixelsAboveLines pixels above paragraphs
     */
    setPixelsAboveLines(pixelsAboveLines: number): void
    /**
     * Sets the default number of pixels of blank space
     * to put below paragraphs in `text_view`.
     *
     * May be overridden by tags applied to `text_view’`s buffer.
     * @param pixelsBelowLines pixels below paragraphs
     */
    setPixelsBelowLines(pixelsBelowLines: number): void
    /**
     * Sets the default number of pixels of blank space to leave between
     * display/wrapped lines within a paragraph.
     *
     * May be overridden by tags in `text_view’`s buffer.
     * @param pixelsInsideWrap default number of pixels between wrapped lines
     */
    setPixelsInsideWrap(pixelsInsideWrap: number): void
    /**
     * Sets the default right margin for text in the text view.
     *
     * Tags in the buffer may override the default.
     *
     * Note that this function is confusingly named.
     * In CSS terms, the value set here is padding.
     * @param rightMargin right margin in pixels
     */
    setRightMargin(rightMargin: number): void
    /**
     * Sets the default tab stops for paragraphs in `text_view`.
     *
     * Tags in the buffer may override the default.
     * @param tabs tabs as a `PangoTabArray`
     */
    setTabs(tabs: Pango.TabArray): void
    /**
     * Sets the top margin for text in `text_view`.
     *
     * Note that this function is confusingly named.
     * In CSS terms, the value set here is padding.
     * @param topMargin top margin in pixels
     */
    setTopMargin(topMargin: number): void
    /**
     * Sets the line wrapping for the view.
     * @param wrapMode a `GtkWrapMode`
     */
    setWrapMode(wrapMode: WrapMode): void
    /**
     * Determines whether `iter` is at the start of a display line.
     *
     * See [method`Gtk`.TextView.forward_display_line] for an
     * explanation of display lines vs. paragraphs.
     * @param iter a `GtkTextIter`
     * @returns %TRUE if @iter begins a wrapped line
     */
    startsDisplayLine(iter: TextIter): boolean
    /**
     * Converts coordinates on the window identified by `win` to buffer
     * coordinates.
     * @param win a `GtkTextWindowType`
     * @param windowX window x coordinate
     * @param windowY window y coordinate
     */
    windowToBufferCoords(
      win: TextWindowType,
      windowX: number,
      windowY: number
    ): [/* bufferX */ number, /* bufferY */ number]

    // Own virtual methods of Gtk-4.0.Gtk.TextView

    /**
     * The class handler for the `GtkTextView::backspace`
     *   keybinding signal.
     * @virtual
     */
    backspace(): void
    /**
     * The class handler for the `GtkTextView::copy-clipboard`
     *   keybinding signal.
     * @virtual
     */
    copyClipboard(): void
    /**
     * The class handler for the `GtkTextView::cut-clipboard`
     *   keybinding signal
     * @virtual
     */
    cutClipboard(): void
    /**
     * The class handler for the `GtkTextView::delete-from-cursor`
     *   keybinding signal.
     * @virtual
     * @param type
     * @param count
     */
    deleteFromCursor(type: DeleteType, count: number): void
    /**
     * The class handler for the `GtkTextView::extend-selection` signal.
     * @virtual
     * @param granularity
     * @param location
     * @param start
     * @param end
     */
    extendSelection(
      granularity: TextExtendSelection,
      location: TextIter,
      start: TextIter,
      end: TextIter
    ): boolean
    /**
     * The class handler for the `GtkTextView::insert-at-cursor`
     *   keybinding signal.
     * @virtual
     * @param str
     */
    insertAtCursor(str: string): void
    /**
     * The class handler for the `GtkTextView::insert-emoji` signal.
     * @virtual
     */
    insertEmoji(): void
    /**
     * The class handler for the `GtkTextView::move-cursor`
     *   keybinding signal.
     * @virtual
     * @param step
     * @param count
     * @param extendSelection
     */
    moveCursor(
      step: MovementStep,
      count: number,
      extendSelection: boolean
    ): void
    /**
     * The class handler for the `GtkTextView::paste-clipboard`
     *   keybinding signal.
     * @virtual
     */
    pasteClipboard(): void
    /**
     * The class handler for the `GtkTextView::set-anchor`
     *   keybinding signal.
     * @virtual
     */
    setAnchor(): void
    /**
     * The snapshot_layer vfunc is called before and after the text
     *   view is drawing its own text. Applications can override this vfunc
     *   in a subclass to draw customized content underneath or above the
     *   text. In the %GTK_TEXT_VIEW_LAYER_BELOW_TEXT and %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT
     *   layers the drawing is done in the buffer coordinate space.
     * @virtual
     * @param layer
     * @param snapshot
     */
    snapshotLayer(layer: TextViewLayer, snapshot: Snapshot): void
    /**
     * The class handler for the `GtkTextView::toggle-overwrite`
     *   keybinding signal.
     * @virtual
     */
    toggleOverwrite(): void

    // Own signals of Gtk-4.0.Gtk.TextView

    connect(
      sigName: "backspace",
      callback: TextView.BackspaceSignalCallback
    ): number
    on(
      sigName: "backspace",
      callback: TextView.BackspaceSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "backspace",
      callback: TextView.BackspaceSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "backspace",
      callback: TextView.BackspaceSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "backspace", ...args: any[]): void
    connect(
      sigName: "copy-clipboard",
      callback: TextView.CopyClipboardSignalCallback
    ): number
    on(
      sigName: "copy-clipboard",
      callback: TextView.CopyClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "copy-clipboard",
      callback: TextView.CopyClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "copy-clipboard",
      callback: TextView.CopyClipboardSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "copy-clipboard", ...args: any[]): void
    connect(
      sigName: "cut-clipboard",
      callback: TextView.CutClipboardSignalCallback
    ): number
    on(
      sigName: "cut-clipboard",
      callback: TextView.CutClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cut-clipboard",
      callback: TextView.CutClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cut-clipboard",
      callback: TextView.CutClipboardSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cut-clipboard", ...args: any[]): void
    connect(
      sigName: "delete-from-cursor",
      callback: TextView.DeleteFromCursorSignalCallback
    ): number
    on(
      sigName: "delete-from-cursor",
      callback: TextView.DeleteFromCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "delete-from-cursor",
      callback: TextView.DeleteFromCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "delete-from-cursor",
      callback: TextView.DeleteFromCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "delete-from-cursor", count: number, ...args: any[]): void
    connect(
      sigName: "extend-selection",
      callback: TextView.ExtendSelectionSignalCallback
    ): number
    on(
      sigName: "extend-selection",
      callback: TextView.ExtendSelectionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "extend-selection",
      callback: TextView.ExtendSelectionSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "extend-selection",
      callback: TextView.ExtendSelectionSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "extend-selection",
      location: TextIter,
      start: TextIter,
      end: TextIter,
      ...args: any[]
    ): void
    connect(
      sigName: "insert-at-cursor",
      callback: TextView.InsertAtCursorSignalCallback
    ): number
    on(
      sigName: "insert-at-cursor",
      callback: TextView.InsertAtCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-at-cursor",
      callback: TextView.InsertAtCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-at-cursor",
      callback: TextView.InsertAtCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "insert-at-cursor", ...args: any[]): void
    connect(
      sigName: "insert-emoji",
      callback: TextView.InsertEmojiSignalCallback
    ): number
    on(
      sigName: "insert-emoji",
      callback: TextView.InsertEmojiSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "insert-emoji",
      callback: TextView.InsertEmojiSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "insert-emoji",
      callback: TextView.InsertEmojiSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "insert-emoji", ...args: any[]): void
    connect(
      sigName: "move-cursor",
      callback: TextView.MoveCursorSignalCallback
    ): number
    on(
      sigName: "move-cursor",
      callback: TextView.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-cursor",
      callback: TextView.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-cursor",
      callback: TextView.MoveCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "move-cursor",
      count: number,
      extendSelection: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "move-viewport",
      callback: TextView.MoveViewportSignalCallback
    ): number
    on(
      sigName: "move-viewport",
      callback: TextView.MoveViewportSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-viewport",
      callback: TextView.MoveViewportSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-viewport",
      callback: TextView.MoveViewportSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "move-viewport", count: number, ...args: any[]): void
    connect(
      sigName: "paste-clipboard",
      callback: TextView.PasteClipboardSignalCallback
    ): number
    on(
      sigName: "paste-clipboard",
      callback: TextView.PasteClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "paste-clipboard",
      callback: TextView.PasteClipboardSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "paste-clipboard",
      callback: TextView.PasteClipboardSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "paste-clipboard", ...args: any[]): void
    connect(
      sigName: "preedit-changed",
      callback: TextView.PreeditChangedSignalCallback
    ): number
    on(
      sigName: "preedit-changed",
      callback: TextView.PreeditChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "preedit-changed",
      callback: TextView.PreeditChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "preedit-changed",
      callback: TextView.PreeditChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "preedit-changed", ...args: any[]): void
    connect(
      sigName: "select-all",
      callback: TextView.SelectAllSignalCallback
    ): number
    on(
      sigName: "select-all",
      callback: TextView.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-all",
      callback: TextView.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-all",
      callback: TextView.SelectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-all", ...args: any[]): void
    connect(
      sigName: "set-anchor",
      callback: TextView.SetAnchorSignalCallback
    ): number
    on(
      sigName: "set-anchor",
      callback: TextView.SetAnchorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "set-anchor",
      callback: TextView.SetAnchorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "set-anchor",
      callback: TextView.SetAnchorSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "set-anchor", ...args: any[]): void
    connect(
      sigName: "toggle-cursor-visible",
      callback: TextView.ToggleCursorVisibleSignalCallback
    ): number
    on(
      sigName: "toggle-cursor-visible",
      callback: TextView.ToggleCursorVisibleSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggle-cursor-visible",
      callback: TextView.ToggleCursorVisibleSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggle-cursor-visible",
      callback: TextView.ToggleCursorVisibleSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggle-cursor-visible", ...args: any[]): void
    connect(
      sigName: "toggle-overwrite",
      callback: TextView.ToggleOverwriteSignalCallback
    ): number
    on(
      sigName: "toggle-overwrite",
      callback: TextView.ToggleOverwriteSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggle-overwrite",
      callback: TextView.ToggleOverwriteSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggle-overwrite",
      callback: TextView.ToggleOverwriteSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggle-overwrite", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.TextView

    connect(
      sigName: "notify::accepts-tab",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accepts-tab",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accepts-tab",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accepts-tab",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accepts-tab", ...args: any[]): void
    connect(
      sigName: "notify::bottom-margin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::bottom-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::bottom-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::bottom-margin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::bottom-margin", ...args: any[]): void
    connect(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::buffer",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::buffer", ...args: any[]): void
    connect(
      sigName: "notify::cursor-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor-visible", ...args: any[]): void
    connect(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::editable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::editable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::editable", ...args: any[]): void
    connect(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::extra-menu",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::extra-menu", ...args: any[]): void
    connect(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::im-module",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::im-module", ...args: any[]): void
    connect(
      sigName: "notify::indent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::indent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::indent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::indent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::indent", ...args: any[]): void
    connect(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-hints",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-hints", ...args: any[]): void
    connect(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::input-purpose",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::input-purpose", ...args: any[]): void
    connect(
      sigName: "notify::justification",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::justification",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::justification",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::justification",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::justification", ...args: any[]): void
    connect(
      sigName: "notify::left-margin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::left-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::left-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::left-margin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::left-margin", ...args: any[]): void
    connect(
      sigName: "notify::monospace",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::monospace",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::monospace",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::monospace",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::monospace", ...args: any[]): void
    connect(
      sigName: "notify::overwrite",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overwrite",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overwrite",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overwrite",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overwrite", ...args: any[]): void
    connect(
      sigName: "notify::pixels-above-lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-above-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-above-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-above-lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-above-lines", ...args: any[]): void
    connect(
      sigName: "notify::pixels-below-lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-below-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-below-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-below-lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-below-lines", ...args: any[]): void
    connect(
      sigName: "notify::pixels-inside-wrap",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::pixels-inside-wrap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::pixels-inside-wrap",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::pixels-inside-wrap",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::pixels-inside-wrap", ...args: any[]): void
    connect(
      sigName: "notify::right-margin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::right-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::right-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::right-margin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::right-margin", ...args: any[]): void
    connect(sigName: "notify::tabs", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tabs",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tabs", ...args: any[]): void
    connect(
      sigName: "notify::top-margin",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::top-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::top-margin",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::top-margin",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::top-margin", ...args: any[]): void
    connect(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::wrap-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::wrap-mode", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A widget that displays the contents of a [class`Gtk`.TextBuffer].
   *
   * ![An example GtkTextview](multiline-text.png)
   *
   * You may wish to begin by reading the [conceptual overview](section-text-widget.html),
   * which gives an overview of all the objects and data types related to the
   * text widget and how they work together.
   *
   * ## CSS nodes
   *
   * ```
   * textview.view
   * ├── border.top
   * ├── border.left
   * ├── text
   * │   ╰── [selection]
   * ├── border.right
   * ├── border.bottom
   * ╰── [window.popup]
   * ```
   *
   * `GtkTextView` has a main css node with name textview and style class .view,
   * and subnodes for each of the border windows, and the main text area,
   * with names border and text, respectively. The border nodes each get
   * one of the style classes .left, .right, .top or .bottom.
   *
   * A node representing the selection will appear below the text node.
   *
   * If a context menu is opened, the window node will appear as a subnode
   * of the main node.
   *
   * ## Accessibility
   *
   * `GtkTextView` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
   * @class
   */
  class TextView extends Widget {
    // Own properties of Gtk-4.0.Gtk.TextView

    static name: string

    // Constructors of Gtk-4.0.Gtk.TextView

    constructor(config?: TextView.ConstructorProperties)
    /**
     * Creates a new `GtkTextView`.
     *
     * If you don’t call [method`Gtk`.TextView.set_buffer] before using the
     * text view, an empty default buffer will be created for you. Get the
     * buffer with [method`Gtk`.TextView.get_buffer]. If you want to specify
     * your own buffer, consider [ctor`Gtk`.TextView.new_with_buffer].
     * @constructor
     * @returns a new `GtkTextView`
     */
    constructor()
    /**
     * Creates a new `GtkTextView`.
     *
     * If you don’t call [method`Gtk`.TextView.set_buffer] before using the
     * text view, an empty default buffer will be created for you. Get the
     * buffer with [method`Gtk`.TextView.get_buffer]. If you want to specify
     * your own buffer, consider [ctor`Gtk`.TextView.new_with_buffer].
     * @constructor
     * @returns a new `GtkTextView`
     */
    static new(): TextView
    /**
     * Creates a new `GtkTextView` widget displaying the buffer `buffer`.
     *
     * One buffer can be shared among many widgets. `buffer` may be %NULL
     * to create a default buffer, in which case this function is equivalent
     * to [ctor`Gtk`.TextView.new]. The text view adds its own reference count
     * to the buffer; it does not take over an existing reference.
     * @constructor
     * @param buffer a `GtkTextBuffer`
     * @returns a new `GtkTextView`.
     */
    static newWithBuffer(buffer: TextBuffer): TextView
    _init(config?: TextView.ConstructorProperties): void
  }

  module ToggleButton {
    // Signal callback interfaces

    /**
     * Signal callback interface for `toggled`
     */
    interface ToggledSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Actionable.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Button.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.ToggleButton

      /**
       * If the toggle button should be pressed in.
       */
      active?: boolean | null
      /**
       * The toggle button whose group this widget belongs to.
       */
      group?: ToggleButton | null
    }
  }

  interface ToggleButton
    extends Accessible,
      Actionable,
      Buildable,
      ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.ToggleButton

    /**
     * If the toggle button should be pressed in.
     */
    active: boolean
    /**
     * The toggle button whose group this widget belongs to.
     */
    group: ToggleButton
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.ToggleButton

    /**
     * Queries a `GtkToggleButton` and returns its current state.
     *
     * Returns %TRUE if the toggle button is pressed in and %FALSE
     * if it is raised.
     * @returns whether the button is pressed
     */
    getActive(): boolean
    /**
     * Sets the status of the toggle button.
     *
     * Set to %TRUE if you want the `GtkToggleButton` to be “pressed in”,
     * and %FALSE to raise it.
     *
     * If the status of the button changes, this action causes the
     * [signal`Gtk`.ToggleButton::toggled] signal to be emitted.
     * @param isActive %TRUE or %FALSE.
     */
    setActive(isActive: boolean): void
    /**
     * Adds `self` to the group of `group`.
     *
     * In a group of multiple toggle buttons, only one button can be active
     * at a time.
     *
     * Setting up groups in a cycle leads to undefined behavior.
     *
     * Note that the same effect can be achieved via the [iface`Gtk`.Actionable]
     * API, by using the same action with parameter type and state type 's'
     * for all buttons in the group, and giving each button its own target
     * value.
     * @param group another `GtkToggleButton` to   form a group with
     */
    setGroup(group: ToggleButton | null): void
    // Has conflict: toggled(): void

    // Conflicting methods

    /**
     * Signal that causes the button to animate press then
     *    release. Applications should never connect to this signal, but use
     *    the `clicked` signal.
     * @virtual
     */
    activate(): void

    // Overloads of activate

    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean
    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean

    // Own virtual methods of Gtk-4.0.Gtk.ToggleButton

    /**
     * Emits the ::toggled signal on the `GtkToggleButton`.
     * @virtual
     */
    toggled(): void

    // Own signals of Gtk-4.0.Gtk.ToggleButton

    connect(
      sigName: "toggled",
      callback: ToggleButton.ToggledSignalCallback
    ): number
    on(
      sigName: "toggled",
      callback: ToggleButton.ToggledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggled",
      callback: ToggleButton.ToggledSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggled",
      callback: ToggleButton.ToggledSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggled", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.ToggleButton

    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::group",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::group",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::group",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::group", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-shrink",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-shrink", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::label",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::label",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::label", ...args: any[]): void
    connect(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-underline",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-underline", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-name", ...args: any[]): void
    connect(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::action-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::action-target", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkToggleButton` is a button which remains “pressed-in” when
   * clicked.
   *
   * Clicking again will cause the toggle button to return to its normal state.
   *
   * A toggle button is created by calling either [ctor`Gtk`.ToggleButton.new] or
   * [ctor`Gtk`.ToggleButton.new_with_label]. If using the former, it is advisable
   * to pack a widget, (such as a `GtkLabel` and/or a `GtkImage`), into the toggle
   * button’s container. (See [class`Gtk`.Button] for more information).
   *
   * The state of a `GtkToggleButton` can be set specifically using
   * [method`Gtk`.ToggleButton.set_active], and retrieved using
   * [method`Gtk`.ToggleButton.get_active].
   *
   * To simply switch the state of a toggle button, use
   * [method`Gtk`.ToggleButton.toggled].
   *
   * ## Grouping
   *
   * Toggle buttons can be grouped together, to form mutually exclusive
   * groups - only one of the buttons can be toggled at a time, and toggling
   * another one will switch the currently toggled one off.
   *
   * To add a `GtkToggleButton` to a group, use [method`Gtk`.ToggleButton.set_group].
   *
   * ## CSS nodes
   *
   * `GtkToggleButton` has a single CSS node with name button. To differentiate
   * it from a plain `GtkButton`, it gets the `.toggle` style class.
   *
   * ## Accessibility
   *
   * `GtkToggleButton` uses the %GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON role.
   *
   * ## Creating two `GtkToggleButton` widgets.
   *
   * ```c
   * static void
   * output_state (GtkToggleButton *source,
   *               gpointer         user_data)
   * {
   *   g_print ("Toggle button "%s" is active: %s",
   *            gtk_button_get_label (GTK_BUTTON (source)),
   *            gtk_toggle_button_get_active (source) ? "Yes" : "No");
   * }
   *
   * static void
   * make_toggles (void)
   * {
   *   GtkWidget *window, *toggle1, *toggle2;
   *   GtkWidget *box;
   *   const char *text;
   *
   *   window = gtk_window_new ();
   *   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
   *
   *   text = "Hi, I’m toggle button one";
   *   toggle1 = gtk_toggle_button_new_with_label (text);
   *
   *   g_signal_connect (toggle1, "toggled",
   *                     G_CALLBACK (output_state),
   *                     NULL);
   *   gtk_box_append (GTK_BOX (box), toggle1);
   *
   *   text = "Hi, I’m toggle button two";
   *   toggle2 = gtk_toggle_button_new_with_label (text);
   *   g_signal_connect (toggle2, "toggled",
   *                     G_CALLBACK (output_state),
   *                     NULL);
   *   gtk_box_append (GTK_BOX (box), toggle2);
   *
   *   gtk_window_set_child (GTK_WINDOW (window), box);
   *   gtk_window_present (GTK_WINDOW (window));
   * }
   * ```
   * @class
   */
  class ToggleButton extends Button {
    // Own properties of Gtk-4.0.Gtk.ToggleButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.ToggleButton

    constructor(config?: ToggleButton.ConstructorProperties)
    /**
     * Creates a new toggle button.
     *
     * A widget should be packed into the button, as in [ctor`Gtk`.Button.new].
     * @constructor
     * @returns a new toggle button.
     */
    constructor()
    /**
     * Creates a new toggle button.
     *
     * A widget should be packed into the button, as in [ctor`Gtk`.Button.new].
     * @constructor
     * @returns a new toggle button.
     */
    static new(): ToggleButton
    /**
     * Creates a new toggle button with a text label.
     * @constructor
     * @param label a string containing the message to be placed in the toggle button.
     * @returns a new toggle button.
     */
    static newWithLabel(label: string): ToggleButton
    /**
     * Creates a new `GtkToggleButton` containing a label.
     *
     * The label will be created using [ctor`Gtk`.Label.new_with_mnemonic],
     * so underscores in `label` indicate the mnemonic for the button.
     * @constructor
     * @param label the text of the button, with an underscore in front of the   mnemonic character
     * @returns a new `GtkToggleButton`
     */
    static newWithMnemonic(label: string): ToggleButton
    _init(config?: ToggleButton.ConstructorProperties): void
  }

  module Tooltip {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface Tooltip {
    // Own properties of Gtk-4.0.Gtk.Tooltip

    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Tooltip

    /**
     * Replaces the widget packed into the tooltip with
     * `custom_widget`. `custom_widget` does not get destroyed when the tooltip goes
     * away.
     * By default a box with a `GtkImage` and `GtkLabel` is embedded in
     * the tooltip, which can be configured using gtk_tooltip_set_markup()
     * and gtk_tooltip_set_icon().
     * @param customWidget a `GtkWidget`, or %NULL to unset the old custom widget.
     */
    setCustom(customWidget: Widget | null): void
    /**
     * Sets the icon of the tooltip (which is in front of the text) to be
     * `paintable`.  If `paintable` is %NULL, the image will be hidden.
     * @param paintable a `GdkPaintable`
     */
    setIcon(paintable: Gdk.Paintable | null): void
    /**
     * Sets the icon of the tooltip (which is in front of the text)
     * to be the icon indicated by `gicon` with the size indicated
     * by `size`. If `gicon` is %NULL, the image will be hidden.
     * @param gicon a `GIcon` representing the icon
     */
    setIconFromGicon(gicon: Gio.Icon | null): void
    /**
     * Sets the icon of the tooltip (which is in front of the text) to be
     * the icon indicated by `icon_name` with the size indicated
     * by `size`.  If `icon_name` is %NULL, the image will be hidden.
     * @param iconName an icon name
     */
    setIconFromIconName(iconName: string | null): void
    /**
     * Sets the text of the tooltip to be `markup`.
     *
     * The string must be marked up with Pango markup.
     * If `markup` is %NULL, the label will be hidden.
     * @param markup a string with Pango markup or %NLL
     */
    setMarkup(markup: string | null): void
    /**
     * Sets the text of the tooltip to be `text`.
     *
     * If `text` is %NULL, the label will be hidden.
     * See also [method`Gtk`.Tooltip.set_markup].
     * @param text a text string
     */
    setText(text: string | null): void
    /**
     * Sets the area of the widget, where the contents of this tooltip apply,
     * to be `rect` (in widget coordinates).  This is especially useful for
     * properly setting tooltips on `GtkTreeView` rows and cells, `GtkIconViews`,
     * etc.
     *
     * For setting tooltips on `GtkTreeView`, please refer to the convenience
     * functions for this: gtk_tree_view_set_tooltip_row() and
     * gtk_tree_view_set_tooltip_cell().
     * @param rect a `GdkRectangle`
     */
    setTipArea(rect: Gdk.Rectangle): void

    // Class property signals of Gtk-4.0.Gtk.Tooltip

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkTooltip` is an object representing a widget tooltip.
   *
   * Basic tooltips can be realized simply by using
   * [method`Gtk`.Widget.set_tooltip_text] or
   * [method`Gtk`.Widget.set_tooltip_markup] without
   * any explicit tooltip object.
   *
   * When you need a tooltip with a little more fancy contents,
   * like adding an image, or you want the tooltip to have different
   * contents per `GtkTreeView` row or cell, you will have to do a
   * little more work:
   *
   * - Set the [property`Gtk`.Widget:has-tooltip] property to %TRUE.
   *   This will make GTK monitor the widget for motion and related events
   *   which are needed to determine when and where to show a tooltip.
   *
   * - Connect to the [signal`Gtk`.Widget::query-tooltip] signal.
   *   This signal will be emitted when a tooltip is supposed to be shown.
   *   One of the arguments passed to the signal handler is a `GtkTooltip`
   *   object. This is the object that we are about to display as a tooltip,
   *   and can be manipulated in your callback using functions like
   *   [method`Gtk`.Tooltip.set_icon]. There are functions for setting
   *   the tooltip’s markup, setting an image from a named icon, or even
   *   putting in a custom widget.
   *
   * - Return %TRUE from your ::query-tooltip handler. This causes the tooltip
   *   to be show. If you return %FALSE, it will not be shown.
   * @class
   */
  class Tooltip extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.Tooltip

    static name: string

    // Constructors of Gtk-4.0.Gtk.Tooltip

    constructor(config?: Tooltip.ConstructorProperties)
    _init(config?: Tooltip.ConstructorProperties): void
  }

  module TreeExpander {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeExpander

      /**
       * The child widget with the actual contents.
       */
      child?: Widget | null
      /**
       * Whether the expander icon should be hidden in a GtkTreeListRow.
       * Note that this property simply hides the icon.  The actions and keybinding
       * (i.e. collapse and expand) are not affected by this property.
       *
       * A common use for this property would be to bind to the number of children in a
       * GtkTreeListRow's model in order to hide the expander when a row has no children.
       */
      hide_expander?: boolean | null
      /**
       * TreeExpander indents the child according to its depth.
       */
      indent_for_depth?: boolean | null
      /**
       * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
       */
      indent_for_icon?: boolean | null
      /**
       * The list row to track for expander state.
       */
      list_row?: TreeListRow | null
    }
  }

  interface TreeExpander extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.TreeExpander

    /**
     * The child widget with the actual contents.
     */
    child: Widget
    /**
     * Whether the expander icon should be hidden in a GtkTreeListRow.
     * Note that this property simply hides the icon.  The actions and keybinding
     * (i.e. collapse and expand) are not affected by this property.
     *
     * A common use for this property would be to bind to the number of children in a
     * GtkTreeListRow's model in order to hide the expander when a row has no children.
     */
    hideExpander: boolean
    /**
     * TreeExpander indents the child according to its depth.
     */
    indentForDepth: boolean
    /**
     * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
     */
    indentForIcon: boolean
    /**
     * The item held by this expander's row.
     */
    readonly item: GObject.Object
    /**
     * The list row to track for expander state.
     */
    listRow: TreeListRow
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeExpander

    /**
     * Gets the child widget displayed by `self`.
     * @returns The child displayed by @self
     */
    getChild(): Widget | null
    /**
     * Gets whether the TreeExpander should be hidden in a GtkTreeListRow.
     * @returns TRUE if the expander icon should be hidden. Otherwise FALSE.
     */
    getHideExpander(): boolean
    /**
     * TreeExpander indents each level of depth with an additional indent.
     * @returns TRUE if the child should be indented . Otherwise FALSE.
     */
    getIndentForDepth(): boolean
    /**
     * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
     * @returns TRUE if the child should be indented when not expandable. Otherwise FALSE.
     */
    getIndentForIcon(): boolean
    /**
     * Forwards the item set on the `GtkTreeListRow` that `self` is managing.
     *
     * This call is essentially equivalent to calling:
     *
     * ```c
     * gtk_tree_list_row_get_item (gtk_tree_expander_get_list_row (`self)`);
     * ```
     * @returns The item of the row
     */
    getItem(): GObject.Object | null
    /**
     * Gets the list row managed by `self`.
     * @returns The list row displayed by @self
     */
    getListRow(): TreeListRow | null
    /**
     * Sets the content widget to display.
     * @param child a `GtkWidget`
     */
    setChild(child: Widget | null): void
    /**
     * Sets whether the expander icon should be visible in a GtkTreeListRow.
     * @param hideExpander TRUE if the expander should be hidden. Otherwise FALSE.
     */
    setHideExpander(hideExpander: boolean): void
    /**
     * Sets if the TreeExpander should indent the child according to its depth.
     * @param indentForDepth TRUE if the child should be indented. Otherwise FALSE.
     */
    setIndentForDepth(indentForDepth: boolean): void
    /**
     * Sets if the TreeExpander should indent the child by the width of an expander-icon when it is not expandable.
     * @param indentForIcon TRUE if the child should be indented without expander. Otherwise FALSE.
     */
    setIndentForIcon(indentForIcon: boolean): void
    /**
     * Sets the tree list row that this expander should manage.
     * @param listRow a `GtkTreeListRow`
     */
    setListRow(listRow: TreeListRow | null): void

    // Class property signals of Gtk-4.0.Gtk.TreeExpander

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::hide-expander",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-expander",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-expander",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-expander", ...args: any[]): void
    connect(
      sigName: "notify::indent-for-depth",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::indent-for-depth",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::indent-for-depth",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::indent-for-depth",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::indent-for-depth", ...args: any[]): void
    connect(
      sigName: "notify::indent-for-icon",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::indent-for-icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::indent-for-icon",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::indent-for-icon",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::indent-for-icon", ...args: any[]): void
    connect(sigName: "notify::item", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item", ...args: any[]): void
    connect(
      sigName: "notify::list-row",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::list-row",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::list-row",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::list-row",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::list-row", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkTreeExpander` is a widget that provides an expander for a list.
   *
   * It is typically placed as a bottommost child into a `GtkListView`
   * to allow users to expand and collapse children in a list with a
   * [class`Gtk`.TreeListModel]. `GtkTreeExpander` provides the common UI
   * elements, gestures and keybindings for this purpose.
   *
   * On top of this, the "listitem.expand", "listitem.collapse" and
   * "listitem.toggle-expand" actions are provided to allow adding custom
   * UI for managing expanded state.
   *
   * It is important to mention that you want to set the
   * [property`Gtk`.ListItem:focusable] property to FALSE when using this
   * widget, as you want the keyboard focus to be in the treexpander, and not
   * inside the list to make use of the keybindings.
   *
   * The `GtkTreeListModel` must be set to not be passthrough. Then it
   * will provide [class`Gtk`.TreeListRow] items which can be set via
   * [method`Gtk`.TreeExpander.set_list_row] on the expander.
   * The expander will then watch that row item automatically.
   * [method`Gtk`.TreeExpander.set_child] sets the widget that displays
   * the actual row contents.
   *
   * `GtkTreeExpander` can be modified with properties such as
   * [property`Gtk`.TreeExpander:indent-for-icon],
   * [property`Gtk`.TreeExpander:indent-for-depth], and
   * [property`Gtk`.TreeExpander:hide-expander] to achieve a different appearance.
   * This can even be done to influence individual rows, for example by binding
   * the [property`Gtk`.TreeExpander:hide-expander] property to the item count of
   * the model of the treelistrow, to hide the expander for rows without children,
   * even if the row is expandable.
   *
   * ## CSS nodes
   *
   * ```
   * treeexpander
   * ├── [indent]*
   * ├── [expander]
   * ╰── <child>
   * ```
   *
   * `GtkTreeExpander` has zero or one CSS nodes with the name "expander" that
   * should display the expander icon. The node will be `:checked` when it
   * is expanded. If the node is not expandable, an "indent" node will be
   * displayed instead.
   *
   * For every level of depth, another "indent" node is prepended.
   *
   * ## Accessibility
   *
   * Until GTK 4.10, `GtkTreeExpander` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   *
   * Since GTK 4.12, `GtkTreeExpander` uses the `GTK_ACCESSIBLE_ROLE_BUTTON` role.
   * Toggling it will change the `GTK_ACCESSIBLE_STATE_EXPANDED` state.
   * @class
   */
  class TreeExpander extends Widget {
    // Own properties of Gtk-4.0.Gtk.TreeExpander

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeExpander

    constructor(config?: TreeExpander.ConstructorProperties)
    /**
     * Creates a new `GtkTreeExpander`
     * @constructor
     * @returns a new `GtkTreeExpander`
     */
    constructor()
    /**
     * Creates a new `GtkTreeExpander`
     * @constructor
     * @returns a new `GtkTreeExpander`
     */
    static new(): TreeExpander
    _init(config?: TreeExpander.ConstructorProperties): void
  }

  module TreeListModel {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gio.ListModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeListModel

      /**
       * If all rows should be expanded by default.
       */
      autoexpand?: boolean | null
      /**
       * Gets whether the model is in passthrough mode.
       *
       * If %FALSE, the `GListModel` functions for this object return custom
       * [class`Gtk`.TreeListRow] objects. If %TRUE, the values of the child
       * models are pass through unmodified.
       */
      passthrough?: boolean | null
    }
  }

  interface TreeListModel extends Gio.ListModel {
    // Own properties of Gtk-4.0.Gtk.TreeListModel

    /**
     * If all rows should be expanded by default.
     */
    autoexpand: boolean
    /**
     * The type of items. See [method`Gio`.ListModel.get_item_type].
     */
    readonly itemType: GObject.GType
    /**
     * The root model displayed.
     */
    readonly model: Gio.ListModel
    /**
     * The number of items. See [method`Gio`.ListModel.get_n_items].
     */
    readonly nItems: number
    /**
     * Gets whether the model is in passthrough mode.
     *
     * If %FALSE, the `GListModel` functions for this object return custom
     * [class`Gtk`.TreeListRow] objects. If %TRUE, the values of the child
     * models are pass through unmodified.
     */
    readonly passthrough: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeListModel

    /**
     * Gets whether the model is set to automatically expand new rows
     * that get added.
     *
     * This can be either rows added by changes to the underlying
     * models or via [method`Gtk`.TreeListRow.set_expanded].
     * @returns %TRUE if the model is set to autoexpand
     */
    getAutoexpand(): boolean
    /**
     * Gets the row item corresponding to the child at index `position` for
     * `self'`s root model.
     *
     * If `position` is greater than the number of children in the root model,
     * %NULL is returned.
     *
     * Do not confuse this function with [method`Gtk`.TreeListModel.get_row].
     * @param position position of the child to get
     * @returns the child in @position
     */
    getChildRow(position: number): TreeListRow | null
    /**
     * Gets the root model that `self` was created with.
     * @returns the root model
     */
    getModel(): Gio.ListModel
    /**
     * Gets whether the model is passing through original row items.
     *
     * If this function returns %FALSE, the `GListModel` functions for `self`
     * return custom `GtkTreeListRow` objects. You need to call
     * [method`Gtk`.TreeListRow.get_item] on these objects to get the original
     * item.
     *
     * If %TRUE, the values of the child models are passed through in their
     * original state. You then need to call [method`Gtk`.TreeListModel.get_row]
     * to get the custom `GtkTreeListRow`s.
     * @returns %TRUE if the model is passing through original row items
     */
    getPassthrough(): boolean
    /**
     * Gets the row object for the given row.
     *
     * If `position` is greater than the number of items in `self,`
     * %NULL is returned.
     *
     * The row object can be used to expand and collapse rows as
     * well as to inspect its position in the tree. See its
     * documentation for details.
     *
     * This row object is persistent and will refer to the current
     * item as long as the row is present in `self,` independent of
     * other rows being added or removed.
     *
     * If `self` is set to not be passthrough, this function is
     * equivalent to calling g_list_model_get_item().
     *
     * Do not confuse this function with [method`Gtk`.TreeListModel.get_child_row].
     * @param position the position of the row to fetch
     * @returns The row item
     */
    getRow(position: number): TreeListRow | null
    /**
     * Sets whether the model should autoexpand.
     *
     * If set to %TRUE, the model will recursively expand all rows that
     * get added to the model. This can be either rows added by changes
     * to the underlying models or via [method`Gtk`.TreeListRow.set_expanded].
     * @param autoexpand %TRUE to make the model autoexpand its rows
     */
    setAutoexpand(autoexpand: boolean): void

    // Class property signals of Gtk-4.0.Gtk.TreeListModel

    connect(
      sigName: "notify::autoexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::autoexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::autoexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::autoexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::autoexpand", ...args: any[]): void
    connect(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item-type",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item-type", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::n-items",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::n-items", ...args: any[]): void
    connect(
      sigName: "notify::passthrough",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::passthrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::passthrough",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::passthrough",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::passthrough", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkTreeListModel` is a list model that can create child models on demand.
   * @class
   */
  class TreeListModel extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeListModel

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeListModel

    constructor(config?: TreeListModel.ConstructorProperties)
    /**
     * Creates a new empty `GtkTreeListModel` displaying `root`
     * with all rows collapsed.
     * @constructor
     * @param root The `GListModel` to use as root
     * @param passthrough %TRUE to pass through items from the models
     * @param autoexpand %TRUE to set the autoexpand property and expand the `root` model
     * @param createFunc Function to call to create the `GListModel` for the children   of an item
     * @returns a newly created `GtkTreeListModel`.
     */
    constructor(
      root: Gio.ListModel,
      passthrough: boolean,
      autoexpand: boolean,
      createFunc: TreeListModelCreateModelFunc
    )
    /**
     * Creates a new empty `GtkTreeListModel` displaying `root`
     * with all rows collapsed.
     * @constructor
     * @param root The `GListModel` to use as root
     * @param passthrough %TRUE to pass through items from the models
     * @param autoexpand %TRUE to set the autoexpand property and expand the `root` model
     * @param createFunc Function to call to create the `GListModel` for the children   of an item
     * @returns a newly created `GtkTreeListModel`.
     */
    static new(
      root: Gio.ListModel,
      passthrough: boolean,
      autoexpand: boolean,
      createFunc: TreeListModelCreateModelFunc
    ): TreeListModel
    _init(config?: TreeListModel.ConstructorProperties): void
  }

  module TreeListRow {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeListRow

      /**
       * If this row is currently expanded.
       */
      expanded?: boolean | null
    }
  }

  interface TreeListRow {
    // Own properties of Gtk-4.0.Gtk.TreeListRow

    /**
     * The model holding the row's children.
     */
    readonly children: Gio.ListModel
    /**
     * The depth in the tree of this row.
     */
    readonly depth: number
    /**
     * If this row can ever be expanded.
     */
    readonly expandable: boolean
    /**
     * If this row is currently expanded.
     */
    expanded: boolean
    /**
     * The item held in this row.
     */
    readonly item: GObject.Object
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeListRow

    /**
     * If `self` is not expanded or `position` is greater than the
     * number of children, %NULL is returned.
     * @param position position of the child to get
     * @returns the child in @position
     */
    getChildRow(position: number): TreeListRow | null
    /**
     * If the row is expanded, gets the model holding the children of `self`.
     *
     * This model is the model created by the
     * [callback`Gtk`.TreeListModelCreateModelFunc]
     * and contains the original items, no matter what value
     * [property`Gtk`.TreeListModel:passthrough] is set to.
     * @returns The model containing the children
     */
    getChildren(): Gio.ListModel | null
    /**
     * Gets the depth of this row.
     *
     * Rows that correspond to items in the root model have a depth
     * of zero, rows corresponding to items of models of direct children
     * of the root model have a depth of 1 and so on.
     *
     * The depth of a row never changes until the row is removed from its model
     * at which point it will forever return 0.
     * @returns The depth of this row
     */
    getDepth(): number
    /**
     * Gets if a row is currently expanded.
     * @returns %TRUE if the row is expanded
     */
    getExpanded(): boolean
    /**
     * Gets the item corresponding to this row,
     * @returns The item   of this row. This function is only marked as nullable for backwards   compatibility reasons.
     */
    getItem(): GObject.Object | null
    /**
     * Gets the row representing the parent for `self`.
     *
     * That is the row that would need to be collapsed
     * to make this row disappear.
     *
     * If `self` is a row corresponding to the root model,
     * %NULL is returned.
     *
     * The value returned by this function never changes
     * until the row is removed from its model at which point
     * it will forever return %NULL.
     * @returns The parent of @self
     */
    getParent(): TreeListRow | null
    /**
     * Returns the position in the `GtkTreeListModel` that `self` occupies
     * at the moment.
     * @returns The position in the model
     */
    getPosition(): number
    /**
     * Checks if a row can be expanded.
     *
     * This does not mean that the row is actually expanded,
     * this can be checked with [method`Gtk`.TreeListRow.get_expanded].
     *
     * If a row is expandable never changes until the row is removed
     * from its model at which point it will forever return %FALSE.
     * @returns %TRUE if the row is expandable
     */
    isExpandable(): boolean
    /**
     * Expands or collapses a row.
     *
     * If a row is expanded, the model of calling the
     * [callback`Gtk`.TreeListModelCreateModelFunc] for the row's
     * item will be inserted after this row. If a row is collapsed,
     * those items will be removed from the model.
     *
     * If the row is not expandable, this function does nothing.
     * @param expanded %TRUE if the row should be expanded
     */
    setExpanded(expanded: boolean): void

    // Class property signals of Gtk-4.0.Gtk.TreeListRow

    connect(
      sigName: "notify::children",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::children",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::children",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::children",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::children", ...args: any[]): void
    connect(
      sigName: "notify::depth",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::depth",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::depth",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::depth",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::depth", ...args: any[]): void
    connect(
      sigName: "notify::expandable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expandable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expandable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expandable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expandable", ...args: any[]): void
    connect(
      sigName: "notify::expanded",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expanded",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expanded",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expanded", ...args: any[]): void
    connect(sigName: "notify::item", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::item",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::item",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::item", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkTreeListRow` is used by `GtkTreeListModel` to represent items.
   *
   * It allows navigating the model as a tree and modify the state of rows.
   *
   * `GtkTreeListRow` instances are created by a `GtkTreeListModel` only
   * when the [property`Gtk`.TreeListModel:passthrough] property is not set.
   *
   * There are various support objects that can make use of `GtkTreeListRow`
   * objects, such as the [class`Gtk`.TreeExpander] widget that allows displaying
   * an icon to expand or collapse a row or [class`Gtk`.TreeListRowSorter] that
   * makes it possible to sort trees properly.
   * @class
   */
  class TreeListRow extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeListRow

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeListRow

    constructor(config?: TreeListRow.ConstructorProperties)
    _init(config?: TreeListRow.ConstructorProperties): void
  }

  module TreeListRowSorter {
    // Constructor properties interface

    interface ConstructorProperties extends Sorter.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeListRowSorter

      /**
       * The underlying sorter
       */
      sorter?: Sorter | null
    }
  }

  interface TreeListRowSorter {
    // Own properties of Gtk-4.0.Gtk.TreeListRowSorter

    /**
     * The underlying sorter
     */
    sorter: Sorter
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeListRowSorter

    /**
     * Returns the sorter used by `self`.
     * @returns the sorter used
     */
    getSorter(): Sorter | null
    /**
     * Sets the sorter to use for items with the same parent.
     *
     * This sorter will be passed the [property`Gtk`.TreeListRow:item] of
     * the tree list rows passed to `self`.
     * @param sorter The sorter to use
     */
    setSorter(sorter: Sorter | null): void

    // Class property signals of Gtk-4.0.Gtk.TreeListRowSorter

    connect(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sorter",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sorter", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkTreeListRowSorter` is a special-purpose sorter that will apply a given
   * sorter to the levels in a tree.
   *
   * Here is an example for setting up a column view with a tree model and
   * a `GtkTreeListSorter`:
   *
   * ```c
   * column_sorter = gtk_column_view_get_sorter (view);
   * sorter = gtk_tree_list_row_sorter_new (g_object_ref (column_sorter));
   * sort_model = gtk_sort_list_model_new (tree_model, sorter);
   * selection = gtk_single_selection_new (sort_model);
   * gtk_column_view_set_model (view, G_LIST_MODEL (selection));
   * ```
   * @class
   */
  class TreeListRowSorter extends Sorter {
    // Own properties of Gtk-4.0.Gtk.TreeListRowSorter

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeListRowSorter

    constructor(config?: TreeListRowSorter.ConstructorProperties)
    /**
     * Create a special-purpose sorter that applies the sorting
     * of `sorter` to the levels of a `GtkTreeListModel`.
     *
     * Note that this sorter relies on [property`Gtk`.TreeListModel:passthrough]
     * being %FALSE as it can only sort [class`Gtk`.TreeListRow]s.
     * @constructor
     * @param sorter a `GtkSorter`
     * @returns a new `GtkTreeListRowSorter`
     */
    constructor(sorter: Sorter | null)
    /**
     * Create a special-purpose sorter that applies the sorting
     * of `sorter` to the levels of a `GtkTreeListModel`.
     *
     * Note that this sorter relies on [property`Gtk`.TreeListModel:passthrough]
     * being %FALSE as it can only sort [class`Gtk`.TreeListRow]s.
     * @constructor
     * @param sorter a `GtkSorter`
     * @returns a new `GtkTreeListRowSorter`
     */
    static new(sorter: Sorter | null): TreeListRowSorter
    _init(config?: TreeListRowSorter.ConstructorProperties): void
  }

  module TreeModelFilter {
    // Constructor properties interface

    interface ConstructorProperties
      extends TreeDragSource.ConstructorProperties,
        TreeModel.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeModelFilter

      child_model?: TreeModel | null
      virtual_root?: TreePath | null
    }
  }

  interface TreeModelFilter extends TreeDragSource, TreeModel {
    // Own properties of Gtk-4.0.Gtk.TreeModelFilter

    readonly childModel: TreeModel
    readonly virtualRoot: TreePath
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TreeModelFilter

    parent: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.TreeModelFilter

    /**
     * This function should almost never be called. It clears the `filter`
     * of any cached iterators that haven’t been reffed with
     * gtk_tree_model_ref_node(). This might be useful if the child model
     * being filtered is static (and doesn’t change often) and there has been
     * a lot of unreffed access to nodes. As a side effect of this function,
     * all unreffed iters will be invalid.
     */
    clearCache(): void
    /**
     * Sets `filter_iter` to point to the row in `filter` that corresponds to the
     * row pointed at by `child_iter`.  If `filter_iter` was not set, %FALSE is
     * returned.
     * @param childIter A valid `GtkTreeIter` pointing to a row on the child model.
     * @returns %TRUE, if @filter_iter was set, i.e. if @child_iter is a valid iterator pointing to a visible row in child model.
     */
    convertChildIterToIter(
      childIter: TreeIter
    ): [/* returnType */ boolean, /* filterIter */ TreeIter]
    /**
     * Converts `child_path` to a path relative to `filter`. That is, `child_path`
     * points to a path in the child model. The rerturned path will point to the
     * same row in the filtered model. If `child_path` isn’t a valid path on the
     * child model or points to a row which is not visible in `filter,` then %NULL
     * is returned.
     * @param childPath A `GtkTreePath` to convert.
     * @returns A newly allocated `GtkTreePath`
     */
    convertChildPathToPath(childPath: TreePath): TreePath | null
    /**
     * Sets `child_iter` to point to the row pointed to by `filter_iter`.
     * @param filterIter A valid `GtkTreeIter` pointing to a row on `filter`.
     */
    convertIterToChildIter(filterIter: TreeIter): /* childIter */ TreeIter
    /**
     * Converts `filter_path` to a path on the child model of `filter`. That is,
     * `filter_path` points to a location in `filter`. The returned path will
     * point to the same location in the model not being filtered. If `filter_path`
     * does not point to a location in the child model, %NULL is returned.
     * @param filterPath A `GtkTreePath` to convert.
     * @returns A newly allocated `GtkTreePath`
     */
    convertPathToChildPath(filterPath: TreePath): TreePath | null
    /**
     * Returns a pointer to the child model of `filter`.
     * @returns A pointer to a `GtkTreeModel`
     */
    getModel(): TreeModel
    /**
     * Emits ::row_changed for each row in the child model, which causes
     * the filter to re-evaluate whether a row is visible or not.
     */
    refilter(): void
    /**
     * With the `n_columns` and `types` parameters, you give an array of column
     * types for this model (which will be exposed to the parent model/view).
     * The `func,` `data` and `destroy` parameters are for specifying the modify
     * function. The modify function will get called for each
     * data access, the goal of the modify function is to return the data which
     * should be displayed at the location specified using the parameters of the
     * modify function.
     *
     * Note that gtk_tree_model_filter_set_modify_func()
     * can only be called once for a given filter model.
     * @param types The `GType`s of the columns.
     * @param func A `GtkTreeModelFilterModifyFunc`
     */
    setModifyFunc(types: GObject.GType[], func: TreeModelFilterModifyFunc): void
    /**
     * Sets `column` of the child_model to be the column where `filter` should
     * look for visibility information. `columns` should be a column of type
     * %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE
     * if not.
     *
     * Note that gtk_tree_model_filter_set_visible_func() or
     * gtk_tree_model_filter_set_visible_column() can only be called
     * once for a given filter model.
     * @param column A `int` which is the column containing the visible information
     */
    setVisibleColumn(column: number): void
    /**
     * Sets the visible function used when filtering the `filter` to be `func`.
     * The function should return %TRUE if the given row should be visible and
     * %FALSE otherwise.
     *
     * If the condition calculated by the function changes over time (e.g.
     * because it depends on some global parameters), you must call
     * gtk_tree_model_filter_refilter() to keep the visibility information
     * of the model up-to-date.
     *
     * Note that `func` is called whenever a row is inserted, when it may still
     * be empty. The visible function should therefore take special care of empty
     * rows, like in the example below.
     *
     *
     * ```c
     * static gboolean
     * visible_func (GtkTreeModel *model,
     *               GtkTreeIter  *iter,
     *               gpointer      data)
     * {
     *   // Visible if row is non-empty and first column is “HI”
     *   char *str;
     *   gboolean visible = FALSE;
     *
     *   gtk_tree_model_get (model, iter, 0, &str, -1);
     *   if (str && strcmp (str, "HI") == 0)
     *     visible = TRUE;
     *   g_free (str);
     *
     *   return visible;
     * }
     * ```
     *
     *
     * Note that gtk_tree_model_filter_set_visible_func() or
     * gtk_tree_model_filter_set_visible_column() can only be called
     * once for a given filter model.
     * @param func A `GtkTreeModelFilterVisibleFunc`, the visible function
     */
    setVisibleFunc(func: TreeModelFilterVisibleFunc): void

    // Own virtual methods of Gtk-4.0.Gtk.TreeModelFilter

    modify(
      childModel: TreeModel,
      iter: TreeIter,
      value: any,
      column: number
    ): void
    visible(childModel: TreeModel, iter: TreeIter): boolean

    // Class property signals of Gtk-4.0.Gtk.TreeModelFilter

    connect(
      sigName: "notify::child-model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child-model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child-model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child-model", ...args: any[]): void
    connect(
      sigName: "notify::virtual-root",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::virtual-root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::virtual-root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::virtual-root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::virtual-root", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkTreeModel` which hides parts of an underlying tree model
   *
   * A `GtkTreeModelFilter` is a tree model which wraps another tree model,
   * and can do the following things:
   *
   * - Filter specific rows, based on data from a “visible column”, a column
   *   storing booleans indicating whether the row should be filtered or not,
   *   or based on the return value of a “visible function”, which gets a
   *   model, iter and user_data and returns a boolean indicating whether the
   *   row should be filtered or not.
   *
   * - Modify the “appearance” of the model, using a modify function.
   *   This is extremely powerful and allows for just changing some
   *   values and also for creating a completely different model based
   *   on the given child model.
   *
   * - Set a different root node, also known as a “virtual root”. You can pass
   *   in a `GtkTreePath` indicating the root node for the filter at construction
   *   time.
   *
   * The basic API is similar to `GtkTreeModelSort`. For an example on its usage,
   * see the section on `GtkTreeModelSort`.
   *
   * When using `GtkTreeModelFilter`, it is important to realize that
   * `GtkTreeModelFilter` maintains an internal cache of all nodes which are
   * visible in its clients. The cache is likely to be a subtree of the tree
   * exposed by the child model. `GtkTreeModelFilter` will not cache the entire
   * child model when unnecessary to not compromise the caching mechanism
   * that is exposed by the reference counting scheme. If the child model
   * implements reference counting, unnecessary signals may not be emitted
   * because of reference counting rule 3, see the `GtkTreeModel`
   * documentation. (Note that e.g. `GtkTreeStore` does not implement
   * reference counting and will always emit all signals, even when
   * the receiving node is not visible).
   *
   * Because of this, limitations for possible visible functions do apply.
   * In general, visible functions should only use data or properties from
   * the node for which the visibility state must be determined, its siblings
   * or its parents. Usually, having a dependency on the state of any child
   * node is not possible, unless references are taken on these explicitly.
   * When no such reference exists, no signals may be received for these child
   * nodes (see reference counting rule number 3 in the `GtkTreeModel` section).
   *
   * Determining the visibility state of a given node based on the state
   * of its child nodes is a frequently occurring use case. Therefore,
   * `GtkTreeModelFilter` explicitly supports this. For example, when a node
   * does not have any children, you might not want the node to be visible.
   * As soon as the first row is added to the node’s child level (or the
   * last row removed), the node’s visibility should be updated.
   *
   * This introduces a dependency from the node on its child nodes. In order
   * to accommodate this, `GtkTreeModelFilter` must make sure the necessary
   * signals are received from the child model. This is achieved by building,
   * for all nodes which are exposed as visible nodes to `GtkTreeModelFilter`'s
   * clients, the child level (if any) and take a reference on the first node
   * in this level. Furthermore, for every row-inserted, row-changed or
   * row-deleted signal (also these which were not handled because the node
   * was not cached), `GtkTreeModelFilter` will check if the visibility state
   * of any parent node has changed.
   *
   * Beware, however, that this explicit support is limited to these two
   * cases. For example, if you want a node to be visible only if two nodes
   * in a child’s child level (2 levels deeper) are visible, you are on your
   * own. In this case, either rely on `GtkTreeStore` to emit all signals
   * because it does not implement reference counting, or for models that
   * do implement reference counting, obtain references on these child levels
   * yourself.
   * @class
   */
  class TreeModelFilter extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeModelFilter

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeModelFilter

    constructor(config?: TreeModelFilter.ConstructorProperties)
    _init(config?: TreeModelFilter.ConstructorProperties): void
  }

  module TreeModelSort {
    // Constructor properties interface

    interface ConstructorProperties
      extends TreeDragSource.ConstructorProperties,
        TreeModel.ConstructorProperties,
        TreeSortable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeModelSort

      model?: TreeModel | null
    }
  }

  interface TreeModelSort extends TreeDragSource, TreeModel, TreeSortable {
    // Own properties of Gtk-4.0.Gtk.TreeModelSort

    readonly model: TreeModel
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TreeModelSort

    parent: GObject.Object

    // Owm methods of Gtk-4.0.Gtk.TreeModelSort

    /**
     * This function should almost never be called.  It clears the `tree_model_sort`
     * of any cached iterators that haven’t been reffed with
     * gtk_tree_model_ref_node().  This might be useful if the child model being
     * sorted is static (and doesn’t change often) and there has been a lot of
     * unreffed access to nodes.  As a side effect of this function, all unreffed
     * iters will be invalid.
     */
    clearCache(): void
    /**
     * Sets `sort_iter` to point to the row in `tree_model_sort` that corresponds to
     * the row pointed at by `child_iter`.  If `sort_iter` was not set, %FALSE
     * is returned.  Note: a boolean is only returned since 2.14.
     * @param childIter A valid `GtkTreeIter` pointing to a row on the child model
     * @returns %TRUE, if @sort_iter was set, i.e. if @sort_iter is a valid iterator pointer to a visible row in the child model.
     */
    convertChildIterToIter(
      childIter: TreeIter
    ): [/* returnType */ boolean, /* sortIter */ TreeIter]
    /**
     * Converts `child_path` to a path relative to `tree_model_sort`.  That is,
     * `child_path` points to a path in the child model.  The returned path will
     * point to the same row in the sorted model.  If `child_path` isn’t a valid
     * path on the child model, then %NULL is returned.
     * @param childPath A `GtkTreePath` to convert
     * @returns A newly allocated `GtkTreePath`
     */
    convertChildPathToPath(childPath: TreePath): TreePath | null
    /**
     * Sets `child_iter` to point to the row pointed to by `sorted_iter`.
     * @param sortedIter A valid `GtkTreeIter` pointing to a row on `tree_model_sort`.
     */
    convertIterToChildIter(sortedIter: TreeIter): /* childIter */ TreeIter
    /**
     * Converts `sorted_path` to a path on the child model of `tree_model_sort`.
     * That is, `sorted_path` points to a location in `tree_model_sort`.  The
     * returned path will point to the same location in the model not being
     * sorted.  If `sorted_path` does not point to a location in the child model,
     * %NULL is returned.
     * @param sortedPath A `GtkTreePath` to convert
     * @returns A newly allocated `GtkTreePath`
     */
    convertPathToChildPath(sortedPath: TreePath): TreePath | null
    /**
     * Returns the model the `GtkTreeModelSort` is sorting.
     * @returns the "child model" being sorted
     */
    getModel(): TreeModel
    /**
     * > This function is slow. Only use it for debugging and/or testing
     * > purposes.
     *
     * Checks if the given iter is a valid iter for this `GtkTreeModelSort`.
     * @param iter A `GtkTreeIter`
     * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
     */
    iterIsValid(iter: TreeIter): boolean
    /**
     * This resets the default sort function to be in the “unsorted” state.  That
     * is, it is in the same order as the child model. It will re-sort the model
     * to be in the same order as the child model only if the `GtkTreeModelSort`
     * is in “unsorted” state.
     */
    resetDefaultSortFunc(): void

    // Class property signals of Gtk-4.0.Gtk.TreeModelSort

    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A GtkTreeModel which makes an underlying tree model sortable
   *
   * The `GtkTreeModelSort` is a model which implements the `GtkTreeSortable`
   * interface.  It does not hold any data itself, but rather is created with
   * a child model and proxies its data.  It has identical column types to
   * this child model, and the changes in the child are propagated.  The
   * primary purpose of this model is to provide a way to sort a different
   * model without modifying it. Note that the sort function used by
   * `GtkTreeModelSort` is not guaranteed to be stable.
   *
   * The use of this is best demonstrated through an example.  In the
   * following sample code we create two `GtkTreeView` widgets each with a
   * view of the same data.  As the model is wrapped here by a
   * `GtkTreeModelSort`, the two `GtkTreeView`s can each sort their
   * view of the data without affecting the other.  By contrast, if we
   * simply put the same model in each widget, then sorting the first would
   * sort the second.
   *
   * ## Using a `GtkTreeModelSort`
   *
   *
   * ```c
   * {
   *   GtkTreeView *tree_view1;
   *   GtkTreeView *tree_view2;
   *   GtkTreeModel *sort_model1;
   *   GtkTreeModel *sort_model2;
   *   GtkTreeModel *child_model;
   *
   *   // get the child model
   *   child_model = get_my_model ();
   *
   *   // Create the first tree
   *   sort_model1 = gtk_tree_model_sort_new_with_model (child_model);
   *   tree_view1 = gtk_tree_view_new_with_model (sort_model1);
   *
   *   // Create the second tree
   *   sort_model2 = gtk_tree_model_sort_new_with_model (child_model);
   *   tree_view2 = gtk_tree_view_new_with_model (sort_model2);
   *
   *   // Now we can sort the two models independently
   *   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model1),
   *                                         COLUMN_1, GTK_SORT_ASCENDING);
   *   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model2),
   *                                         COLUMN_1, GTK_SORT_DESCENDING);
   * }
   * ```
   *
   *
   * To demonstrate how to access the underlying child model from the sort
   * model, the next example will be a callback for the `GtkTreeSelection`
   * `GtkTreeSelection::changed` signal.  In this callback, we get a string
   * from COLUMN_1 of the model.  We then modify the string, find the same
   * selected row on the child model, and change the row there.
   *
   * ## Accessing the child model of in a selection changed callback
   *
   *
   * ```c
   * void
   * selection_changed (GtkTreeSelection *selection, gpointer data)
   * {
   *   GtkTreeModel *sort_model = NULL;
   *   GtkTreeModel *child_model;
   *   GtkTreeIter sort_iter;
   *   GtkTreeIter child_iter;
   *   char *some_data = NULL;
   *   char *modified_data;
   *
   *   // Get the current selected row and the model.
   *   if (! gtk_tree_selection_get_selected (selection,
   *                                          &sort_model,
   *                                          &sort_iter))
   *     return;
   *
   *   // Look up the current value on the selected row and get
   *   // a new value to change it to.
   *   gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &sort_iter,
   *                       COLUMN_1, &some_data,
   *                       -1);
   *
   *   modified_data = change_the_data (some_data);
   *   g_free (some_data);
   *
   *   // Get an iterator on the child model, instead of the sort model.
   *   gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (sort_model),
   *                                                   &child_iter,
   *                                                   &sort_iter);
   *
   *   // Get the child model and change the value of the row. In this
   *   // example, the child model is a GtkListStore. It could be any other
   *   // type of model, though.
   *   child_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model));
   *   gtk_list_store_set (GTK_LIST_STORE (child_model), &child_iter,
   *                       COLUMN_1, &modified_data,
   *                       -1);
   *   g_free (modified_data);
   * }
   * ```
   *
   * @class
   */
  class TreeModelSort extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeModelSort

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeModelSort

    constructor(config?: TreeModelSort.ConstructorProperties)
    /**
     * Creates a new `GtkTreeModelSort`, with `child_model` as the child model.
     * @constructor
     * @param childModel A `GtkTreeModel`
     * @returns A new `GtkTreeModelSort`.
     */
    static newWithModel(childModel: TreeModel): TreeModelSort
    _init(config?: TreeModelSort.ConstructorProperties): void
  }

  module TreeSelection {
    // Signal callback interfaces

    /**
     * Signal callback interface for `changed`
     */
    interface ChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeSelection

      /**
       * Selection mode.
       * See gtk_tree_selection_set_mode() for more information on this property.
       */
      mode?: SelectionMode | null
    }
  }

  interface TreeSelection {
    // Own properties of Gtk-4.0.Gtk.TreeSelection

    /**
     * Selection mode.
     * See gtk_tree_selection_set_mode() for more information on this property.
     */
    mode: SelectionMode
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeSelection

    /**
     * Returns the number of rows that have been selected in `tree`.
     * @returns The number of rows selected.
     */
    countSelectedRows(): number
    /**
     * Gets the selection mode for `selection`. See
     * gtk_tree_selection_set_mode().
     * @returns the current selection mode
     */
    getMode(): SelectionMode
    /**
     * Sets `iter` to the currently selected node if `selection` is set to
     * %GTK_SELECTION_SINGLE or %GTK_SELECTION_BROWSE.  `iter` may be NULL if you
     * just want to test if `selection` has any selected nodes.  `model` is filled
     * with the current model as a convenience.  This function will not work if you
     * use `selection` is %GTK_SELECTION_MULTIPLE.
     * @returns TRUE, if there is a selected node.
     */
    getSelected(): [
      /* returnType */ boolean,
      /* model */ TreeModel,
      /* iter */ TreeIter,
    ]
    /**
     * Creates a list of path of all selected rows. Additionally, if you are
     * planning on modifying the model after calling this function, you may
     * want to convert the returned list into a list of `GtkTreeRowReference`s.
     * To do this, you can use gtk_tree_row_reference_new().
     *
     * To free the return value, use:
     *
     * ```c
     * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
     * ```
     *
     * @returns A `GList` containing a `GtkTreePath` for each selected row.
     */
    getSelectedRows(): [/* returnType */ TreePath[], /* model */ TreeModel]
    /**
     * Returns the tree view associated with `selection`.
     * @returns A `GtkTreeView`
     */
    getTreeView(): TreeView
    /**
     * Returns %TRUE if the row at `iter` is currently selected.
     * @param iter A valid `GtkTreeIter`
     * @returns %TRUE, if @iter is selected
     */
    iterIsSelected(iter: TreeIter): boolean
    /**
     * Returns %TRUE if the row pointed to by `path` is currently selected.  If `path`
     * does not point to a valid location, %FALSE is returned
     * @param path A `GtkTreePath` to check selection on.
     * @returns %TRUE if @path is selected.
     */
    pathIsSelected(path: TreePath): boolean
    /**
     * Selects all the nodes. `selection` must be set to %GTK_SELECTION_MULTIPLE
     * mode.
     */
    selectAll(): void
    /**
     * Selects the specified iterator.
     * @param iter The `GtkTreeIter` to be selected.
     */
    selectIter(iter: TreeIter): void
    /**
     * Select the row at `path`.
     * @param path The `GtkTreePath` to be selected.
     */
    selectPath(path: TreePath): void
    /**
     * Selects a range of nodes, determined by `start_path` and `end_path` inclusive.
     * `selection` must be set to %GTK_SELECTION_MULTIPLE mode.
     * @param startPath The initial node of the range.
     * @param endPath The final node of the range.
     */
    selectRange(startPath: TreePath, endPath: TreePath): void
    /**
     * Calls a function for each selected node. Note that you cannot modify
     * the tree or selection from within this function. As a result,
     * gtk_tree_selection_get_selected_rows() might be more useful.
     * @param func The function to call for each selected node.
     */
    selectedForeach(func: TreeSelectionForeachFunc): void
    /**
     * Sets the selection mode of the `selection`.  If the previous type was
     * %GTK_SELECTION_MULTIPLE, then the anchor is kept selected, if it was
     * previously selected.
     * @param type The selection mode
     */
    setMode(type: SelectionMode): void
    /**
     * Sets the selection function.
     *
     * If set, this function is called before any node is selected or unselected,
     * giving some control over which nodes are selected. The select function
     * should return %TRUE if the state of the node may be toggled, and %FALSE
     * if the state of the node should be left unchanged.
     * @param func The selection function. May be %NULL
     */
    setSelectFunction(func: TreeSelectionFunc | null): void
    /**
     * Unselects all the nodes.
     */
    unselectAll(): void
    /**
     * Unselects the specified iterator.
     * @param iter The `GtkTreeIter` to be unselected.
     */
    unselectIter(iter: TreeIter): void
    /**
     * Unselects the row at `path`.
     * @param path The `GtkTreePath` to be unselected.
     */
    unselectPath(path: TreePath): void
    /**
     * Unselects a range of nodes, determined by `start_path` and `end_path`
     * inclusive.
     * @param startPath The initial node of the range.
     * @param endPath The initial node of the range.
     */
    unselectRange(startPath: TreePath, endPath: TreePath): void

    // Own signals of Gtk-4.0.Gtk.TreeSelection

    connect(
      sigName: "changed",
      callback: TreeSelection.ChangedSignalCallback
    ): number
    on(
      sigName: "changed",
      callback: TreeSelection.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "changed",
      callback: TreeSelection.ChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "changed",
      callback: TreeSelection.ChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.TreeSelection

    connect(sigName: "notify::mode", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mode", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The selection object for GtkTreeView
   *
   * The `GtkTreeSelection` object is a helper object to manage the selection
   * for a `GtkTreeView` widget.  The `GtkTreeSelection` object is
   * automatically created when a new `GtkTreeView` widget is created, and
   * cannot exist independently of this widget.  The primary reason the
   * `GtkTreeSelection` objects exists is for cleanliness of code and API.
   * That is, there is no conceptual reason all these functions could not be
   * methods on the `GtkTreeView` widget instead of a separate function.
   *
   * The `GtkTreeSelection` object is gotten from a `GtkTreeView` by calling
   * gtk_tree_view_get_selection().  It can be manipulated to check the
   * selection status of the tree, as well as select and deselect individual
   * rows.  Selection is done completely view side.  As a result, multiple
   * views of the same model can have completely different selections.
   * Additionally, you cannot change the selection of a row on the model that
   * is not currently displayed by the view without expanding its parents
   * first.
   *
   * One of the important things to remember when monitoring the selection of
   * a view is that the `GtkTreeSelection`::changed signal is mostly a hint.
   * That is, it may only emit one signal when a range of rows is selected.
   * Additionally, it may on occasion emit a `GtkTreeSelection`::changed signal
   * when nothing has happened (mostly as a result of programmers calling
   * select_row on an already selected row).
   * @class
   */
  class TreeSelection extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeSelection

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeSelection

    constructor(config?: TreeSelection.ConstructorProperties)
    _init(config?: TreeSelection.ConstructorProperties): void
  }

  module TreeStore {
    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        TreeDragDest.ConstructorProperties,
        TreeDragSource.ConstructorProperties,
        TreeModel.ConstructorProperties,
        TreeSortable.ConstructorProperties,
        GObject.Object.ConstructorProperties {}
  }

  interface TreeStore
    extends Buildable,
      TreeDragDest,
      TreeDragSource,
      TreeModel,
      TreeSortable {
    // Own properties of Gtk-4.0.Gtk.TreeStore

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TreeStore

    parent: GObject.Object
    priv: TreeStorePrivate

    // Owm methods of Gtk-4.0.Gtk.TreeStore

    /**
     * Appends a new row to `tree_store`.
     *
     * If `parent` is non-%NULL, then it will append the new row after the last
     * child of `parent,` otherwise it will append a row to the top level.
     *
     * The `iter` parameter will be changed to point to this new row. The row will
     * be empty after this function is called. To fill in values, you need to call
     * gtk_tree_store_set() or gtk_tree_store_set_value().
     * @param parent A valid `GtkTreeIter`
     */
    append(parent: TreeIter | null): /* iter */ TreeIter
    /**
     * Removes all rows from `tree_store`
     */
    clear(): void
    /**
     * Creates a new row at `position`.
     *
     * If parent is non-%NULL, then the row will be made a child of `parent`.
     * Otherwise, the row will be created at the toplevel.
     *
     * If `position` is `-1` or is larger than the number of rows at that level,
     * then the new row will be inserted to the end of the list.
     *
     * The `iter` parameter will be changed to point to this new row. The row
     * will be empty after this function is called. To fill in values, you
     * need to call gtk_tree_store_set() or gtk_tree_store_set_value().
     * @param parent A valid `GtkTreeIter`
     * @param position position to insert the new row, or -1 for last
     */
    insert(parent: TreeIter | null, position: number): /* iter */ TreeIter
    /**
     * Inserts a new row after `sibling`.
     *
     * If `sibling` is %NULL, then the row will be prepended to `parent’`s children.
     *
     * If `parent` and `sibling` are %NULL, then the row will be prepended to the
     * toplevel.
     *
     * If both `sibling` and `parent` are set, then `parent` must be the parent
     * of `sibling`. When `sibling` is set, `parent` is optional.
     *
     * The `iter` parameter will be changed to point to this new row. The row will
     * be empty after this function is called. To fill in values, you need to call
     * gtk_tree_store_set() or gtk_tree_store_set_value().
     * @param parent A valid `GtkTreeIter`
     * @param sibling A valid `GtkTreeIter`
     */
    insertAfter(
      parent: TreeIter | null,
      sibling: TreeIter | null
    ): /* iter */ TreeIter
    /**
     * Inserts a new row before `sibling`.
     *
     * If `sibling` is %NULL, then the row will be appended to `parent’`s children.
     *
     * If `parent` and `sibling` are %NULL, then the row will be appended to the
     * toplevel.
     *
     * If both `sibling` and `parent` are set, then `parent` must be the parent
     * of `sibling`. When `sibling` is set, `parent` is optional.
     *
     * The `iter` parameter will be changed to point to this new row. The row will
     * be empty after this function is called. To fill in values, you need to call
     * gtk_tree_store_set() or gtk_tree_store_set_value().
     * @param parent A valid `GtkTreeIter`
     * @param sibling A valid `GtkTreeIter`
     */
    insertBefore(
      parent: TreeIter | null,
      sibling: TreeIter | null
    ): /* iter */ TreeIter
    /**
     * A variant of gtk_tree_store_insert_with_values() which takes
     * the columns and values as two arrays, instead of varargs.
     *
     * This function is mainly intended for language bindings.
     * @param parent A valid `GtkTreeIter`
     * @param position position to insert the new row, or -1 for last
     * @param columns an array of column numbers
     * @param values an array of GValues
     */
    insertWithValues(
      parent: TreeIter | null,
      position: number,
      columns: number[],
      values: any[]
    ): /* iter */ TreeIter
    /**
     * Checks if `iter` is an ancestor of `descendant`.
     * @param iter A valid `GtkTreeIter`
     * @param descendant A valid `GtkTreeIter`
     * @returns true if @iter is an ancestor of @descendant, and false otherwise
     */
    isAncestor(iter: TreeIter, descendant: TreeIter): boolean
    /**
     * Returns the depth of the position pointed by the iterator
     *
     * The depth will be 0 for anything on the root level, 1 for anything down
     * a level, etc.
     * @param iter A valid `GtkTreeIter`
     * @returns The depth of the position pointed by the iterator
     */
    iterDepth(iter: TreeIter): number
    /**
     * Checks if the given iter is a valid iter for this `GtkTreeStore`.
     *
     * This function is slow. Only use it for debugging and/or testing
     * purposes.
     * @param iter the iterator to check
     * @returns true if the iter is valid, and false otherwise
     */
    iterIsValid(iter: TreeIter): boolean
    /**
     * Moves `iter` in `tree_store` to the position after `position`.
     *
     * `iter` and `position` should be in the same level.
     *
     * Note that this function only works with unsorted stores.
     *
     * If `position` is %NULL, `iter` will be moved to the start of the level.
     * @param iter A `GtkTreeIter`.
     * @param position A `GtkTreeIter`.
     */
    moveAfter(iter: TreeIter, position: TreeIter | null): void
    /**
     * Moves `iter` in `tree_store` to the position before `position`.
     *
     * `iter` and `position` should be in the same level.
     *
     * Note that this function only works with unsorted stores.
     *
     * If `position` is %NULL, `iter` will be moved to the end of the level.
     * @param iter A `GtkTreeIter`
     * @param position A `GtkTreeIter`
     */
    moveBefore(iter: TreeIter, position: TreeIter | null): void
    /**
     * Prepends a new row to `tree_store`.
     *
     * If `parent` is non-%NULL, then it will prepend the new row before the first
     * child of `parent,` otherwise it will prepend a row to the top level. The
     * `iter` parameter will be changed to point to this new row.  The row will
     * be empty after this function is called. To fill in values, you need to
     * call gtk_tree_store_set() or gtk_tree_store_set_value().
     * @param parent A valid `GtkTreeIter`
     */
    prepend(parent: TreeIter | null): /* iter */ TreeIter
    /**
     * Removes `iter` from `tree_store`.
     *
     * After being removed, `iter` is set to the next valid row at that level, or
     * invalidated if it previously pointed to the last one.
     * @param iter A valid `GtkTreeIter`
     * @returns true if @iter is still valid, and false otherwise
     */
    remove(iter: TreeIter): boolean
    /**
     * Sets the type of the columns in a tree store.
     *
     * This function is meant primarily for types that inherit from
     * `GtkTreeStore`, and should only be used when constructing a new
     * `GtkTreeStore`.
     *
     * This functions cannot be called after a row has been added,
     * or a method on the `GtkTreeModel` interface is called on the
     * tree store.
     * @param types An array of `GType` types, one for each column
     */
    setColumnTypes(types: GObject.GType[]): void
    /**
     * Sets the data in the cell specified by `iter` and `column`.
     *
     * The type of `value` must be convertible to the type of the
     * column.
     * @param iter A valid `GtkTreeIter` for the row being modified
     * @param column column number to modify
     * @param value new value for the cell
     */
    setValue(iter: TreeIter, column: number, value: any): void
    /**
     * A variant of gtk_tree_store_set_valist() which takes
     * the columns and values as two arrays, instead of using variadic
     * arguments.
     *
     * This function is mainly intended for language bindings or in case
     * the number of columns to change is not known until run-time.
     * @param iter A valid `GtkTreeIter` for the row being modified
     * @param columns an array of column numbers
     * @param values an array of GValues
     */
    set(iter: TreeIter, columns: number[], values: any[]): void
    /**
     * Swaps `a` and `b` in the same level of `tree_store`.
     *
     * Note that this function only works with unsorted stores.
     * @param a A `GtkTreeIter`.
     * @param b Another `GtkTreeIter`.
     */
    swap(a: TreeIter, b: TreeIter): void

    // Class property signals of Gtk-4.0.Gtk.TreeStore

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A tree-like data structure that can be used with the [class`Gtk`.TreeView].
   *
   * The `GtkTreeStore` object is a list model for use with a `GtkTreeView`
   * widget. It implements the [iface`Gtk`.TreeModel] interface, and consequently,
   * can use all of the methods available there. It also implements the
   * [iface`Gtk`.TreeSortable] interface so it can be sorted by the view.
   * Finally, it also implements the tree [drag][iface`Gtk`.TreeDragSource]
   * and [drop][iface`Gtk`.TreeDragDest] interfaces.
   *
   * `GtkTreeStore` is deprecated since GTK 4.10, and should not be used in newly
   * written code. You should use [class`Gtk`.TreeListModel] for a tree-like model
   * object.
   *
   * ## GtkTreeStore as GtkBuildable
   *
   * The GtkTreeStore implementation of the `GtkBuildable` interface allows
   * to specify the model columns with a `<columns>` element that may contain
   * multiple `<column>` elements, each specifying one model column. The “type”
   * attribute specifies the data type for the column.
   *
   * An example of a UI Definition fragment for a tree store:
   *
   * ```xml
   * <object class="GtkTreeStore">
   *   <columns>
   *     <column type="gchararray"/>
   *     <column type="gchararray"/>
   *     <column type="gint"/>
   *   </columns>
   * </object>
   * ```
   * @class
   */
  class TreeStore extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.TreeStore

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeStore

    constructor(config?: TreeStore.ConstructorProperties)
    /**
     * Creates a new tree store.
     *
     * This constructor is meant for language bindings.
     * @constructor
     * @param types an array of `GType` types for the columns, from first to last
     * @returns a new `GtkTreeStore`
     */
    constructor(types: GObject.GType[])
    /**
     * Creates a new tree store.
     *
     * This constructor is meant for language bindings.
     * @constructor
     * @param types an array of `GType` types for the columns, from first to last
     * @returns a new `GtkTreeStore`
     */
    static new(types: GObject.GType[]): TreeStore
    _init(config?: TreeStore.ConstructorProperties): void
  }

  module TreeView {
    // Signal callback interfaces

    /**
     * Signal callback interface for `columns-changed`
     */
    interface ColumnsChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `cursor-changed`
     */
    interface CursorChangedSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `expand-collapse-cursor-row`
     */
    interface ExpandCollapseCursorRowSignalCallback {
      (object: boolean, p0: boolean, p1: boolean): boolean
    }

    /**
     * Signal callback interface for `move-cursor`
     */
    interface MoveCursorSignalCallback {
      (
        step: MovementStep,
        direction: number,
        extend: boolean,
        modify: boolean
      ): boolean
    }

    /**
     * Signal callback interface for `row-activated`
     */
    interface RowActivatedSignalCallback {
      (path: TreePath, column: TreeViewColumn | null): void
    }

    /**
     * Signal callback interface for `row-collapsed`
     */
    interface RowCollapsedSignalCallback {
      (iter: TreeIter, path: TreePath): void
    }

    /**
     * Signal callback interface for `row-expanded`
     */
    interface RowExpandedSignalCallback {
      (iter: TreeIter, path: TreePath): void
    }

    /**
     * Signal callback interface for `select-all`
     */
    interface SelectAllSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `select-cursor-parent`
     */
    interface SelectCursorParentSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `select-cursor-row`
     */
    interface SelectCursorRowSignalCallback {
      (object: boolean): boolean
    }

    /**
     * Signal callback interface for `start-interactive-search`
     */
    interface StartInteractiveSearchSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `test-collapse-row`
     */
    interface TestCollapseRowSignalCallback {
      (iter: TreeIter, path: TreePath): boolean
    }

    /**
     * Signal callback interface for `test-expand-row`
     */
    interface TestExpandRowSignalCallback {
      (iter: TreeIter, path: TreePath): boolean
    }

    /**
     * Signal callback interface for `toggle-cursor-row`
     */
    interface ToggleCursorRowSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `unselect-all`
     */
    interface UnselectAllSignalCallback {
      (): boolean
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Scrollable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeView

      /**
       * The activate-on-single-click property specifies whether the "row-activated" signal
       * will be emitted after a single click.
       */
      activate_on_single_click?: boolean | null
      enable_grid_lines?: TreeViewGridLines | null
      enable_search?: boolean | null
      enable_tree_lines?: boolean | null
      expander_column?: TreeViewColumn | null
      /**
       * Setting the ::fixed-height-mode property to %TRUE speeds up
       * `GtkTreeView` by assuming that all rows have the same height.
       * Only enable this option if all rows are the same height.
       * Please see gtk_tree_view_set_fixed_height_mode() for more
       * information on this option.
       */
      fixed_height_mode?: boolean | null
      headers_clickable?: boolean | null
      headers_visible?: boolean | null
      /**
       * Enables or disables the hover expansion mode of `tree_view`.
       * Hover expansion makes rows expand or collapse if the pointer moves
       * over them.
       *
       * This mode is primarily intended for treeviews in popups, e.g.
       * in `GtkComboBox` or `GtkEntryCompletion`.
       */
      hover_expand?: boolean | null
      /**
       * Enables or disables the hover selection mode of `tree_view`.
       * Hover selection makes the selected row follow the pointer.
       * Currently, this works only for the selection modes
       * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
       *
       * This mode is primarily intended for treeviews in popups, e.g.
       * in `GtkComboBox` or `GtkEntryCompletion`.
       */
      hover_selection?: boolean | null
      /**
       * Extra indentation for each level.
       */
      level_indentation?: number | null
      model?: TreeModel | null
      reorderable?: boolean | null
      rubber_banding?: boolean | null
      search_column?: number | null
      /**
       * %TRUE if the view has expanders.
       */
      show_expanders?: boolean | null
      tooltip_column?: number | null
    }
  }

  interface TreeView
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Scrollable {
    // Own properties of Gtk-4.0.Gtk.TreeView

    /**
     * The activate-on-single-click property specifies whether the "row-activated" signal
     * will be emitted after a single click.
     */
    activateOnSingleClick: boolean
    enableGridLines: TreeViewGridLines
    enableSearch: boolean
    enableTreeLines: boolean
    expanderColumn: TreeViewColumn
    /**
     * Setting the ::fixed-height-mode property to %TRUE speeds up
     * `GtkTreeView` by assuming that all rows have the same height.
     * Only enable this option if all rows are the same height.
     * Please see gtk_tree_view_set_fixed_height_mode() for more
     * information on this option.
     */
    fixedHeightMode: boolean
    headersClickable: boolean
    headersVisible: boolean
    /**
     * Enables or disables the hover expansion mode of `tree_view`.
     * Hover expansion makes rows expand or collapse if the pointer moves
     * over them.
     *
     * This mode is primarily intended for treeviews in popups, e.g.
     * in `GtkComboBox` or `GtkEntryCompletion`.
     */
    hoverExpand: boolean
    /**
     * Enables or disables the hover selection mode of `tree_view`.
     * Hover selection makes the selected row follow the pointer.
     * Currently, this works only for the selection modes
     * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
     *
     * This mode is primarily intended for treeviews in popups, e.g.
     * in `GtkComboBox` or `GtkEntryCompletion`.
     */
    hoverSelection: boolean
    /**
     * Extra indentation for each level.
     */
    levelIndentation: number
    model: TreeModel
    reorderable: boolean
    rubberBanding: boolean
    searchColumn: number
    /**
     * %TRUE if the view has expanders.
     */
    showExpanders: boolean
    tooltipColumn: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.TreeView

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.TreeView

    /**
     * Appends `column` to the list of columns. If `tree_view` has “fixed_height”
     * mode enabled, then `column` must have its “sizing” property set to be
     * GTK_TREE_VIEW_COLUMN_FIXED.
     * @param column The `GtkTreeViewColumn` to add.
     * @returns The number of columns in @tree_view after appending.
     */
    appendColumn(column: TreeViewColumn): number
    /**
     * Recursively collapses all visible, expanded nodes in `tree_view`.
     */
    collapseAll(): void
    /**
     * Collapses a row (hides its child rows, if they exist).
     * @param path path to a row in the `tree_view`
     * @returns %TRUE if the row was collapsed.
     */
    collapseRow(path: TreePath): boolean
    /**
     * Resizes all columns to their optimal width. Only works after the
     * treeview has been realized.
     */
    columnsAutosize(): void
    /**
     * Converts bin_window coordinates to coordinates for the
     * tree (the full scrollable area of the tree).
     * @param bx X coordinate relative to bin_window
     * @param by Y coordinate relative to bin_window
     */
    convertBinWindowToTreeCoords(
      bx: number,
      by: number
    ): [/* tx */ number, /* ty */ number]
    /**
     * Converts bin_window coordinates to widget relative coordinates.
     * @param bx bin_window X coordinate
     * @param by bin_window Y coordinate
     */
    convertBinWindowToWidgetCoords(
      bx: number,
      by: number
    ): [/* wx */ number, /* wy */ number]
    /**
     * Converts tree coordinates (coordinates in full scrollable area of the tree)
     * to bin_window coordinates.
     * @param tx tree X coordinate
     * @param ty tree Y coordinate
     */
    convertTreeToBinWindowCoords(
      tx: number,
      ty: number
    ): [/* bx */ number, /* by */ number]
    /**
     * Converts tree coordinates (coordinates in full scrollable area of the tree)
     * to widget coordinates.
     * @param tx X coordinate relative to the tree
     * @param ty Y coordinate relative to the tree
     */
    convertTreeToWidgetCoords(
      tx: number,
      ty: number
    ): [/* wx */ number, /* wy */ number]
    /**
     * Converts widget coordinates to coordinates for the bin_window.
     * @param wx X coordinate relative to the widget
     * @param wy Y coordinate relative to the widget
     */
    convertWidgetToBinWindowCoords(
      wx: number,
      wy: number
    ): [/* bx */ number, /* by */ number]
    /**
     * Converts widget coordinates to coordinates for the
     * tree (the full scrollable area of the tree).
     * @param wx X coordinate relative to the widget
     * @param wy Y coordinate relative to the widget
     */
    convertWidgetToTreeCoords(
      wx: number,
      wy: number
    ): [/* tx */ number, /* ty */ number]
    /**
     * Creates a `cairo_surface_t` representation of the row at `path`.
     * This image is used for a drag icon.
     * @param path a `GtkTreePath` in `tree_view`
     * @returns a newly-allocated surface of the drag icon.
     */
    createRowDragIcon(path: TreePath): Gdk.Paintable | null
    /**
     * Turns `tree_view` into a drop destination for automatic DND. Calling
     * this method sets `GtkTreeView`:reorderable to %FALSE.
     * @param formats the target formats that the drag will support
     * @param actions the bitmask of possible actions for a drag from this    widget
     */
    enableModelDragDest(
      formats: Gdk.ContentFormats,
      actions: Gdk.DragAction
    ): void
    /**
     * Turns `tree_view` into a drag source for automatic DND. Calling this
     * method sets `GtkTreeView`:reorderable to %FALSE.
     * @param startButtonMask Mask of allowed buttons to start drag
     * @param formats the target formats that the drag will support
     * @param actions the bitmask of possible actions for a drag from this    widget
     */
    enableModelDragSource(
      startButtonMask: Gdk.ModifierType,
      formats: Gdk.ContentFormats,
      actions: Gdk.DragAction
    ): void
    /**
     * Recursively expands all nodes in the `tree_view`.
     */
    expandAll(): void
    /**
     * Opens the row so its children are visible.
     * @param path path to a row
     * @param openAll whether to recursively expand, or just expand immediate children
     * @returns %TRUE if the row existed and had children
     */
    expandRow(path: TreePath, openAll: boolean): boolean
    /**
     * Expands the row at `path`. This will also expand all parent rows of
     * `path` as necessary.
     * @param path path to a row.
     */
    expandToPath(path: TreePath): void
    /**
     * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
     * @returns %TRUE if row-activated will be emitted on a single click
     */
    getActivateOnSingleClick(): boolean
    /**
     * Fills the bounding rectangle in bin_window coordinates for the cell at the
     * row specified by `path` and the column specified by `column`.  If `path` is
     * %NULL, or points to a node not found in the tree, the `y` and `height` fields of
     * the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width`
     * fields will be filled with 0.  The returned rectangle is equivalent to the
     * `background_area` passed to gtk_cell_renderer_render().  These background
     * areas tile to cover the entire bin window.  Contrast with the `cell_area,`
     * returned by gtk_tree_view_get_cell_area(), which returns only the cell
     * itself, excluding surrounding borders and the tree expander area.
     * @param path a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
     * @param column a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
     */
    getBackgroundArea(
      path: TreePath | null,
      column: TreeViewColumn | null
    ): /* rect */ Gdk.Rectangle
    /**
     * Fills the bounding rectangle in bin_window coordinates for the cell at the
     * row specified by `path` and the column specified by `column`.  If `path` is
     * %NULL, or points to a path not currently displayed, the `y` and `height` fields
     * of the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width`
     * fields will be filled with 0.  The sum of all cell rects does not cover the
     * entire tree; there are extra pixels in between rows, for example. The
     * returned rectangle is equivalent to the `cell_area` passed to
     * gtk_cell_renderer_render().  This function is only valid if `tree_view` is
     * realized.
     * @param path a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
     * @param column a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
     */
    getCellArea(
      path: TreePath | null,
      column: TreeViewColumn | null
    ): /* rect */ Gdk.Rectangle
    /**
     * Gets the `GtkTreeViewColumn` at the given position in the #tree_view.
     * @param n The position of the column, counting from 0.
     * @returns The `GtkTreeViewColumn`, or %NULL if the position is outside the range of columns.
     */
    getColumn(n: number): TreeViewColumn | null
    /**
     * Returns a `GList` of all the `GtkTreeViewColumn`s currently in `tree_view`.
     * The returned list must be freed with g_list_free ().
     * @returns A list of `GtkTreeViewColumn`s
     */
    getColumns(): TreeViewColumn[]
    /**
     * Fills in `path` and `focus_column` with the current path and focus column.  If
     * the cursor isn’t currently set, then *`path` will be %NULL.  If no column
     * currently has focus, then *`focus_column` will be %NULL.
     *
     * The returned `GtkTreePath` must be freed with gtk_tree_path_free() when
     * you are done with it.
     */
    getCursor(): [
      /* path */ TreePath | null,
      /* focusColumn */ TreeViewColumn | null,
    ]

    // Overloads of getCursor

    /**
     * Queries the cursor set on `widget`.
     *
     * See [method`Gtk`.Widget.set_cursor] for details.
     * @returns the cursor   currently in use or %NULL if the cursor is inherited
     */
    getCursor(): Gdk.Cursor | null
    /**
     * Determines the destination row for a given position.  `drag_x` and
     * `drag_y` are expected to be in widget coordinates.  This function is only
     * meaningful if `tree_view` is realized.  Therefore this function will always
     * return %FALSE if `tree_view` is not realized or does not have a model.
     * @param dragX the position to determine the destination row for
     * @param dragY the position to determine the destination row for
     * @returns whether there is a row at the given position, %TRUE if this is indeed the case.
     */
    getDestRowAtPos(
      dragX: number,
      dragY: number
    ): [
      /* returnType */ boolean,
      /* path */ TreePath | null,
      /* pos */ TreeViewDropPosition,
    ]
    /**
     * Gets information about the row that is highlighted for feedback.
     */
    getDragDestRow(): [
      /* path */ TreePath | null,
      /* pos */ TreeViewDropPosition,
    ]
    /**
     * Returns whether or not the tree allows to start interactive searching
     * by typing in text.
     * @returns whether or not to let the user search interactively
     */
    getEnableSearch(): boolean
    /**
     * Returns whether or not tree lines are drawn in `tree_view`.
     * @returns %TRUE if tree lines are drawn in @tree_view, %FALSE otherwise.
     */
    getEnableTreeLines(): boolean
    /**
     * Returns the column that is the current expander column,
     * or %NULL if none has been set.
     * This column has the expander arrow drawn next to it.
     * @returns The expander column.
     */
    getExpanderColumn(): TreeViewColumn | null
    /**
     * Returns whether fixed height mode is turned on for `tree_view`.
     * @returns %TRUE if @tree_view is in fixed height mode
     */
    getFixedHeightMode(): boolean
    /**
     * Returns which grid lines are enabled in `tree_view`.
     * @returns a `GtkTreeView`GridLines value indicating which grid lines are enabled.
     */
    getGridLines(): TreeViewGridLines
    /**
     * Returns whether all header columns are clickable.
     * @returns %TRUE if all header columns are clickable, otherwise %FALSE
     */
    getHeadersClickable(): boolean
    /**
     * Returns %TRUE if the headers on the `tree_view` are visible.
     * @returns Whether the headers are visible or not.
     */
    getHeadersVisible(): boolean
    /**
     * Returns whether hover expansion mode is turned on for `tree_view`.
     * @returns %TRUE if @tree_view is in hover expansion mode
     */
    getHoverExpand(): boolean
    /**
     * Returns whether hover selection mode is turned on for `tree_view`.
     * @returns %TRUE if @tree_view is in hover selection mode
     */
    getHoverSelection(): boolean
    /**
     * Returns the amount, in pixels, of extra indentation for child levels
     * in `tree_view`.
     * @returns the amount of extra indentation for child levels in @tree_view.  A return value of 0 means that this feature is disabled.
     */
    getLevelIndentation(): number
    /**
     * Returns the model the `GtkTreeView` is based on.  Returns %NULL if the
     * model is unset.
     * @returns A `GtkTreeModel`
     */
    getModel(): TreeModel | null
    /**
     * Queries the number of columns in the given `tree_view`.
     * @returns The number of columns in the @tree_view
     */
    getNColumns(): number
    /**
     * Finds the path at the point (`x,` `y)`, relative to bin_window coordinates.
     * That is, `x` and `y` are relative to an events coordinates. Widget-relative
     * coordinates must be converted using
     * gtk_tree_view_convert_widget_to_bin_window_coords(). It is primarily for
     * things like popup menus. If `path` is non-%NULL, then it will be filled
     * with the `GtkTreePath` at that point.  This path should be freed with
     * gtk_tree_path_free().  If `column` is non-%NULL, then it will be filled
     * with the column at that point.  `cell_x` and `cell_y` return the coordinates
     * relative to the cell background (i.e. the `background_area` passed to
     * gtk_cell_renderer_render()).  This function is only meaningful if
     * `tree_view` is realized.  Therefore this function will always return %FALSE
     * if `tree_view` is not realized or does not have a model.
     *
     * For converting widget coordinates (eg. the ones you get from
     * GtkWidget::query-tooltip), please see
     * gtk_tree_view_convert_widget_to_bin_window_coords().
     * @param x The x position to be identified (relative to bin_window).
     * @param y The y position to be identified (relative to bin_window).
     * @returns %TRUE if a row exists at that coordinate.
     */
    getPathAtPos(
      x: number,
      y: number
    ): [
      /* returnType */ boolean,
      /* path */ TreePath | null,
      /* column */ TreeViewColumn | null,
      /* cellX */ number,
      /* cellY */ number,
    ]
    /**
     * Retrieves whether the user can reorder the tree via drag-and-drop. See
     * gtk_tree_view_set_reorderable().
     * @returns %TRUE if the tree can be reordered.
     */
    getReorderable(): boolean
    /**
     * Returns whether rubber banding is turned on for `tree_view`.  If the
     * selection mode is %GTK_SELECTION_MULTIPLE, rubber banding will allow the
     * user to select multiple rows by dragging the mouse.
     * @returns %TRUE if rubber banding in @tree_view is enabled.
     */
    getRubberBanding(): boolean
    /**
     * Gets the column searched on by the interactive search code.
     * @returns the column the interactive search code searches in.
     */
    getSearchColumn(): number
    /**
     * Returns the `GtkEntry` which is currently in use as interactive search
     * entry for `tree_view`.  In case the built-in entry is being used, %NULL
     * will be returned.
     * @returns the entry currently in use as search entry.
     */
    getSearchEntry(): Editable | null
    /**
     * Gets the `GtkTreeSelection` associated with `tree_view`.
     * @returns A `GtkTreeSelection` object.
     */
    getSelection(): TreeSelection
    /**
     * Returns whether or not expanders are drawn in `tree_view`.
     * @returns %TRUE if expanders are drawn in @tree_view, %FALSE otherwise.
     */
    getShowExpanders(): boolean
    /**
     * Returns the column of `tree_view’`s model which is being used for
     * displaying tooltips on `tree_view’`s rows.
     * @returns the index of the tooltip column that is currently being used, or -1 if this is disabled.
     */
    getTooltipColumn(): number
    /**
     * This function is supposed to be used in a ::query-tooltip
     * signal handler for `GtkTreeView`. The `x,` `y` and `keyboard_tip` values
     * which are received in the signal handler, should be passed to this
     * function without modification.
     *
     * The return value indicates whether there is a tree view row at the given
     * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
     * tooltips the row returned will be the cursor row. When %TRUE, then any of
     * `model,` `path` and `iter` which have been provided will be set to point to
     * that row and the corresponding model. `x` and `y` will always be converted
     * to be relative to `tree_view’`s bin_window if `keyboard_tooltip` is %FALSE.
     * @param x the x coordinate (relative to widget coordinates)
     * @param y the y coordinate (relative to widget coordinates)
     * @param keyboardTip whether this is a keyboard tooltip or not
     * @returns whether or not the given tooltip context points to a row
     */
    getTooltipContext(
      x: number,
      y: number,
      keyboardTip: boolean
    ): [
      /* returnType */ boolean,
      /* model */ TreeModel | null,
      /* path */ TreePath,
      /* iter */ TreeIter,
    ]
    /**
     * Sets `start_path` and `end_path` to be the first and last visible path.
     * Note that there may be invisible paths in between.
     *
     * The paths should be freed with gtk_tree_path_free() after use.
     * @returns %TRUE, if valid paths were placed in @start_path and @end_path.
     */
    getVisibleRange(): [
      /* returnType */ boolean,
      /* startPath */ TreePath,
      /* endPath */ TreePath,
    ]
    /**
     * Fills `visible_rect` with the currently-visible region of the
     * buffer, in tree coordinates. Convert to bin_window coordinates with
     * gtk_tree_view_convert_tree_to_bin_window_coords().
     * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
     * scrollable area of the tree.
     */
    getVisibleRect(): /* visibleRect */ Gdk.Rectangle
    /**
     * This inserts the `column` into the `tree_view` at `position`.  If `position` is
     * -1, then the column is inserted at the end. If `tree_view` has
     * “fixed_height” mode enabled, then `column` must have its “sizing” property
     * set to be GTK_TREE_VIEW_COLUMN_FIXED.
     * @param column The `GtkTreeViewColumn` to be inserted.
     * @param position The position to insert `column` in.
     * @returns The number of columns in @tree_view after insertion.
     */
    insertColumn(column: TreeViewColumn, position: number): number
    /**
     * Convenience function that inserts a new column into the `GtkTreeView`
     * with the given cell renderer and a `GtkTreeCellDataFunc` to set cell renderer
     * attributes (normally using data from the model). See also
     * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
     * If `tree_view` has “fixed_height” mode enabled, then the new column will have its
     * “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
     * @param position Position to insert, -1 for append
     * @param title column title
     * @param cell cell renderer for column
     * @param func function to set attributes of cell renderer
     * @returns number of columns in the tree view post-insert
     */
    insertColumnWithDataFunc(
      position: number,
      title: string,
      cell: CellRenderer,
      func: TreeCellDataFunc
    ): number
    /**
     * Determine whether the point (`x,` `y)` in `tree_view` is blank, that is no
     * cell content nor an expander arrow is drawn at the location. If so, the
     * location can be considered as the background. You might wish to take
     * special action on clicks on the background, such as clearing a current
     * selection, having a custom context menu or starting rubber banding.
     *
     * The `x` and `y` coordinate that are provided must be relative to bin_window
     * coordinates.  Widget-relative coordinates must be converted using
     * gtk_tree_view_convert_widget_to_bin_window_coords().
     *
     * For converting widget coordinates (eg. the ones you get from
     * GtkWidget::query-tooltip), please see
     * gtk_tree_view_convert_widget_to_bin_window_coords().
     *
     * The `path,` `column,` `cell_x` and `cell_y` arguments will be filled in
     * likewise as for gtk_tree_view_get_path_at_pos().  Please see
     * gtk_tree_view_get_path_at_pos() for more information.
     * @param x The x position to be identified (relative to bin_window)
     * @param y The y position to be identified (relative to bin_window)
     * @returns %TRUE if the area at the given coordinates is blank, %FALSE otherwise.
     */
    isBlankAtPos(
      x: number,
      y: number
    ): [
      /* returnType */ boolean,
      /* path */ TreePath | null,
      /* column */ TreeViewColumn | null,
      /* cellX */ number,
      /* cellY */ number,
    ]
    /**
     * Returns whether a rubber banding operation is currently being done
     * in `tree_view`.
     * @returns %TRUE if a rubber banding operation is currently being done in @tree_view.
     */
    isRubberBandingActive(): boolean
    /**
     * Calls `func` on all expanded rows.
     * @param func A function to be called
     */
    mapExpandedRows(func: TreeViewMappingFunc): void
    /**
     * Moves `column` to be after to `base_column`.  If `base_column` is %NULL, then
     * `column` is placed in the first position.
     * @param column The `GtkTreeViewColumn` to be moved.
     * @param baseColumn The `GtkTreeViewColumn` to be moved relative to
     */
    moveColumnAfter(
      column: TreeViewColumn,
      baseColumn: TreeViewColumn | null
    ): void
    /**
     * Removes `column` from `tree_view`.
     * @param column The `GtkTreeViewColumn` to remove.
     * @returns The number of columns in @tree_view after removing.
     */
    removeColumn(column: TreeViewColumn): number
    // Has conflict: rowActivated(path: TreePath, column: TreeViewColumn | null): void
    // Has conflict: rowExpanded(path: TreePath): boolean
    /**
     * Moves the alignments of `tree_view` to the position specified by `column` and
     * `path`.  If `column` is %NULL, then no horizontal scrolling occurs.  Likewise,
     * if `path` is %NULL no vertical scrolling occurs.  At a minimum, one of `column`
     * or `path` need to be non-%NULL.  `row_align` determines where the row is
     * placed, and `col_align` determines where `column` is placed.  Both are expected
     * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
     * right/bottom alignment, 0.5 means center.
     *
     * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
     * tree does the minimum amount of work to scroll the cell onto the screen.
     * This means that the cell will be scrolled to the edge closest to its current
     * position.  If the cell is currently visible on the screen, nothing is done.
     *
     * This function only works if the model is set, and `path` is a valid row on the
     * model.  If the model changes before the `tree_view` is realized, the centered
     * path will be modified to reflect this change.
     * @param path The path of the row to move to
     * @param column The `GtkTreeViewColumn` to move horizontally to
     * @param useAlign whether to use alignment arguments, or %FALSE.
     * @param rowAlign The vertical alignment of the row specified by `path`.
     * @param colAlign The horizontal alignment of the column specified by `column`.
     */
    scrollToCell(
      path: TreePath | null,
      column: TreeViewColumn | null,
      useAlign: boolean,
      rowAlign: number,
      colAlign: number
    ): void
    /**
     * Scrolls the tree view such that the top-left corner of the visible
     * area is `tree_x,` `tree_y,` where `tree_x` and `tree_y` are specified
     * in tree coordinates.  The `tree_view` must be realized before
     * this function is called.  If it isn't, you probably want to be
     * using gtk_tree_view_scroll_to_cell().
     *
     * If either `tree_x` or `tree_y` are -1, then that direction isn’t scrolled.
     * @param treeX X coordinate of new top-left pixel of visible area, or -1
     * @param treeY Y coordinate of new top-left pixel of visible area, or -1
     */
    scrollToPoint(treeX: number, treeY: number): void
    /**
     * Cause the `GtkTreeView`::row-activated signal to be emitted
     * on a single click instead of a double click.
     * @param single %TRUE to emit row-activated on a single click
     */
    setActivateOnSingleClick(single: boolean): void
    /**
     * Sets a user function for determining where a column may be dropped when
     * dragged.  This function is called on every column pair in turn at the
     * beginning of a column drag to determine where a drop can take place.  The
     * arguments passed to `func` are: the `tree_view,` the `GtkTreeViewColumn` being
     * dragged, the two `GtkTreeViewColumn`s determining the drop spot, and
     * `user_data`.  If either of the `GtkTreeViewColumn` arguments for the drop spot
     * are %NULL, then they indicate an edge.  If `func` is set to be %NULL, then
     * `tree_view` reverts to the default behavior of allowing all columns to be
     * dropped everywhere.
     * @param func A function to determine which columns are reorderable
     */
    setColumnDragFunction(func: TreeViewColumnDropFunc | null): void
    /**
     * Sets the current keyboard focus to be at `path,` and selects it.  This is
     * useful when you want to focus the user’s attention on a particular row.  If
     * `focus_column` is not %NULL, then focus is given to the column specified by
     * it. Additionally, if `focus_column` is specified, and `start_editing` is
     * %TRUE, then editing should be started in the specified cell.
     * This function is often followed by `gtk_widget_grab_focus` (`tree_view)`
     * in order to give keyboard focus to the widget.  Please note that editing
     * can only happen when the widget is realized.
     *
     * If `path` is invalid for `model,` the current cursor (if any) will be unset
     * and the function will return without failing.
     * @param path A `GtkTreePath`
     * @param focusColumn A `GtkTreeViewColumn`
     * @param startEditing %TRUE if the specified cell should start being edited.
     */
    setCursor(
      path: TreePath,
      focusColumn: TreeViewColumn | null,
      startEditing: boolean
    ): void

    // Overloads of setCursor

    /**
     * Sets the cursor to be shown when pointer devices point
     * towards `widget`.
     *
     * If the `cursor` is NULL, `widget` will use the cursor
     * inherited from the parent widget.
     * @param cursor the new cursor
     */
    setCursor(cursor: Gdk.Cursor | null): void
    /**
     * Sets the current keyboard focus to be at `path,` and selects it.  This is
     * useful when you want to focus the user’s attention on a particular row.  If
     * `focus_column` is not %NULL, then focus is given to the column specified by
     * it. If `focus_column` and `focus_cell` are not %NULL, and `focus_column`
     * contains 2 or more editable or activatable cells, then focus is given to
     * the cell specified by `focus_cell`. Additionally, if `focus_column` is
     * specified, and `start_editing` is %TRUE, then editing should be started in
     * the specified cell.  This function is often followed by
     * `gtk_widget_grab_focus` (`tree_view)` in order to give keyboard focus to the
     * widget.  Please note that editing can only happen when the widget is
     * realized.
     *
     * If `path` is invalid for `model,` the current cursor (if any) will be unset
     * and the function will return without failing.
     * @param path A `GtkTreePath`
     * @param focusColumn A `GtkTreeViewColumn`
     * @param focusCell A `GtkCellRenderer`
     * @param startEditing %TRUE if the specified cell should start being edited.
     */
    setCursorOnCell(
      path: TreePath,
      focusColumn: TreeViewColumn | null,
      focusCell: CellRenderer | null,
      startEditing: boolean
    ): void
    /**
     * Sets the row that is highlighted for feedback.
     * If `path` is %NULL, an existing highlight is removed.
     * @param path The path of the row to highlight
     * @param pos Specifies whether to drop before, after or into the row
     */
    setDragDestRow(path: TreePath | null, pos: TreeViewDropPosition): void
    /**
     * If `enable_search` is set, then the user can type in text to search through
     * the tree interactively (this is sometimes called "typeahead find").
     *
     * Note that even if this is %FALSE, the user can still initiate a search
     * using the “start-interactive-search” key binding.
     * @param enableSearch %TRUE, if the user can search interactively
     */
    setEnableSearch(enableSearch: boolean): void
    /**
     * Sets whether to draw lines interconnecting the expanders in `tree_view`.
     * This does not have any visible effects for lists.
     * @param enabled %TRUE to enable tree line drawing, %FALSE otherwise.
     */
    setEnableTreeLines(enabled: boolean): void
    /**
     * Sets the column to draw the expander arrow at. It must be in `tree_view`.
     * If `column` is %NULL, then the expander arrow is always at the first
     * visible column.
     *
     * If you do not want expander arrow to appear in your tree, set the
     * expander column to a hidden column.
     * @param column %NULL, or the column to draw the expander arrow at.
     */
    setExpanderColumn(column: TreeViewColumn | null): void
    /**
     * Enables or disables the fixed height mode of `tree_view`.
     * Fixed height mode speeds up `GtkTreeView` by assuming that all
     * rows have the same height.
     * Only enable this option if all rows are the same height and all
     * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
     * @param enable %TRUE to enable fixed height mode
     */
    setFixedHeightMode(enable: boolean): void
    /**
     * Sets which grid lines to draw in `tree_view`.
     * @param gridLines a `GtkTreeView`GridLines value indicating which grid lines to enable.
     */
    setGridLines(gridLines: TreeViewGridLines): void
    /**
     * Allow the column title buttons to be clicked.
     * @param setting %TRUE if the columns are clickable.
     */
    setHeadersClickable(setting: boolean): void
    /**
     * Sets the visibility state of the headers.
     * @param headersVisible %TRUE if the headers are visible
     */
    setHeadersVisible(headersVisible: boolean): void
    /**
     * Enables or disables the hover expansion mode of `tree_view`.
     * Hover expansion makes rows expand or collapse if the pointer
     * moves over them.
     * @param expand %TRUE to enable hover selection mode
     */
    setHoverExpand(expand: boolean): void
    /**
     * Enables or disables the hover selection mode of `tree_view`.
     * Hover selection makes the selected row follow the pointer.
     * Currently, this works only for the selection modes
     * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
     * @param hover %TRUE to enable hover selection mode
     */
    setHoverSelection(hover: boolean): void
    /**
     * Sets the amount of extra indentation for child levels to use in `tree_view`
     * in addition to the default indentation.  The value should be specified in
     * pixels, a value of 0 disables this feature and in this case only the default
     * indentation will be used.
     * This does not have any visible effects for lists.
     * @param indentation the amount, in pixels, of extra indentation in `tree_view`.
     */
    setLevelIndentation(indentation: number): void
    /**
     * Sets the model for a `GtkTreeView`.  If the `tree_view` already has a model
     * set, it will remove it before setting the new model.  If `model` is %NULL,
     * then it will unset the old model.
     * @param model The model.
     */
    setModel(model: TreeModel | null): void
    /**
     * This function is a convenience function to allow you to reorder
     * models that support the `GtkTreeDragSourceIface` and the
     * `GtkTreeDragDestIface`.  Both `GtkTreeStore` and `GtkListStore` support
     * these.  If `reorderable` is %TRUE, then the user can reorder the
     * model by dragging and dropping rows. The developer can listen to
     * these changes by connecting to the model’s `GtkTreeModel::row-inserted`
     * and `GtkTreeModel::row-deleted` signals. The reordering is implemented
     * by setting up the tree view as a drag source and destination.
     * Therefore, drag and drop can not be used in a reorderable view for any
     * other purpose.
     *
     * This function does not give you any degree of control over the order -- any
     * reordering is allowed.  If more control is needed, you should probably
     * handle drag and drop manually.
     * @param reorderable %TRUE, if the tree can be reordered.
     */
    setReorderable(reorderable: boolean): void
    /**
     * Sets the row separator function, which is used to determine
     * whether a row should be drawn as a separator. If the row separator
     * function is %NULL, no separators are drawn. This is the default value.
     * @param func a `GtkTreeView`RowSeparatorFunc
     */
    setRowSeparatorFunc(func: TreeViewRowSeparatorFunc | null): void
    /**
     * Enables or disables rubber banding in `tree_view`.  If the selection mode
     * is %GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
     * multiple rows by dragging the mouse.
     * @param enable %TRUE to enable rubber banding
     */
    setRubberBanding(enable: boolean): void
    /**
     * Sets `column` as the column where the interactive search code should
     * search in for the current model.
     *
     * If the search column is set, users can use the “start-interactive-search”
     * key binding to bring up search popup. The enable-search property controls
     * whether simply typing text will also start an interactive search.
     *
     * Note that `column` refers to a column of the current model. The search
     * column is reset to -1 when the model is changed.
     * @param column the column of the model to search in, or -1 to disable searching
     */
    setSearchColumn(column: number): void
    /**
     * Sets the entry which the interactive search code will use for this
     * `tree_view`.  This is useful when you want to provide a search entry
     * in our interface at all time at a fixed position.  Passing %NULL for
     * `entry` will make the interactive search code use the built-in popup
     * entry again.
     * @param entry the entry the interactive search code of `tree_view` should use
     */
    setSearchEntry(entry: Editable | null): void
    /**
     * Sets the compare function for the interactive search capabilities; note
     * that somewhat like strcmp() returning 0 for equality
     * `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
     * @param searchEqualFunc the compare function to use during the search
     */
    setSearchEqualFunc(searchEqualFunc: TreeViewSearchEqualFunc): void
    /**
     * Sets whether to draw and enable expanders and indent child rows in
     * `tree_view`.  When disabled there will be no expanders visible in trees
     * and there will be no way to expand and collapse rows by default.  Also
     * note that hiding the expanders will disable the default indentation.  You
     * can set a custom indentation in this case using
     * gtk_tree_view_set_level_indentation().
     * This does not have any visible effects for lists.
     * @param enabled %TRUE to enable expander drawing, %FALSE otherwise.
     */
    setShowExpanders(enabled: boolean): void
    /**
     * Sets the tip area of `tooltip` to the area `path,` `column` and `cell` have
     * in common.  For example if `path` is %NULL and `column` is set, the tip
     * area will be set to the full area covered by `column`.  See also
     * gtk_tooltip_set_tip_area().
     *
     * Note that if `path` is not specified and `cell` is set and part of a column
     * containing the expander, the tooltip might not show and hide at the correct
     * position.  In such cases `path` must be set to the current node under the
     * mouse cursor for this function to operate correctly.
     *
     * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
     * @param tooltip a `GtkTooltip`
     * @param path a `GtkTreePath`
     * @param column a `GtkTreeViewColumn`
     * @param cell a `GtkCellRenderer`
     */
    setTooltipCell(
      tooltip: Tooltip,
      path: TreePath | null,
      column: TreeViewColumn | null,
      cell: CellRenderer | null
    ): void
    /**
     * If you only plan to have simple (text-only) tooltips on full rows, you
     * can use this function to have `GtkTreeView` handle these automatically
     * for you. `column` should be set to the column in `tree_view’`s model
     * containing the tooltip texts, or -1 to disable this feature.
     *
     * When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
     * `tree_view` will connect a `GtkWidget::query-tooltip` signal handler.
     *
     * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
     * so &, <, etc have to be escaped in the text.
     * @param column an integer, which is a valid column number for `tree_view’`s model
     */
    setTooltipColumn(column: number): void
    /**
     * Sets the tip area of `tooltip` to be the area covered by the row at `path`.
     * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
     * See also gtk_tooltip_set_tip_area().
     * @param tooltip a `GtkTooltip`
     * @param path a `GtkTreePath`
     */
    setTooltipRow(tooltip: Tooltip, path: TreePath): void
    /**
     * Undoes the effect of
     * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
     * `GtkTreeView`:reorderable to %FALSE.
     */
    unsetRowsDragDest(): void
    /**
     * Undoes the effect of
     * gtk_tree_view_enable_model_drag_source(). Calling this method sets
     * `GtkTreeView`:reorderable to %FALSE.
     */
    unsetRowsDragSource(): void

    // Own virtual methods of Gtk-4.0.Gtk.TreeView

    columnsChanged(): void
    cursorChanged(): void
    expandCollapseCursorRow(
      logical: boolean,
      expand: boolean,
      openAll: boolean
    ): boolean
    moveCursor(
      step: MovementStep,
      count: number,
      extend: boolean,
      modify: boolean
    ): boolean
    /**
     * Activates the cell determined by `path` and `column`.
     * @virtual
     * @param path The `GtkTreePath` to be activated.
     * @param column The `GtkTreeViewColumn` to be activated.
     */
    rowActivated(path: TreePath, column: TreeViewColumn | null): void
    rowCollapsed(iter: TreeIter, path: TreePath): void
    rowExpanded(iter: TreeIter, path: TreePath): void
    selectAll(): boolean
    selectCursorParent(): boolean
    selectCursorRow(startEditing: boolean): boolean
    startInteractiveSearch(): boolean
    testCollapseRow(iter: TreeIter, path: TreePath): boolean
    testExpandRow(iter: TreeIter, path: TreePath): boolean
    toggleCursorRow(): boolean
    unselectAll(): boolean

    // Own signals of Gtk-4.0.Gtk.TreeView

    connect(
      sigName: "columns-changed",
      callback: TreeView.ColumnsChangedSignalCallback
    ): number
    on(
      sigName: "columns-changed",
      callback: TreeView.ColumnsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "columns-changed",
      callback: TreeView.ColumnsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "columns-changed",
      callback: TreeView.ColumnsChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "columns-changed", ...args: any[]): void
    connect(
      sigName: "cursor-changed",
      callback: TreeView.CursorChangedSignalCallback
    ): number
    on(
      sigName: "cursor-changed",
      callback: TreeView.CursorChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "cursor-changed",
      callback: TreeView.CursorChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "cursor-changed",
      callback: TreeView.CursorChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "cursor-changed", ...args: any[]): void
    connect(
      sigName: "expand-collapse-cursor-row",
      callback: TreeView.ExpandCollapseCursorRowSignalCallback
    ): number
    on(
      sigName: "expand-collapse-cursor-row",
      callback: TreeView.ExpandCollapseCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "expand-collapse-cursor-row",
      callback: TreeView.ExpandCollapseCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "expand-collapse-cursor-row",
      callback: TreeView.ExpandCollapseCursorRowSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "expand-collapse-cursor-row",
      p0: boolean,
      p1: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "move-cursor",
      callback: TreeView.MoveCursorSignalCallback
    ): number
    on(
      sigName: "move-cursor",
      callback: TreeView.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-cursor",
      callback: TreeView.MoveCursorSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-cursor",
      callback: TreeView.MoveCursorSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "move-cursor",
      direction: number,
      extend: boolean,
      modify: boolean,
      ...args: any[]
    ): void
    connect(
      sigName: "row-activated",
      callback: TreeView.RowActivatedSignalCallback
    ): number
    on(
      sigName: "row-activated",
      callback: TreeView.RowActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-activated",
      callback: TreeView.RowActivatedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-activated",
      callback: TreeView.RowActivatedSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "row-activated",
      column: TreeViewColumn | null,
      ...args: any[]
    ): void
    connect(
      sigName: "row-collapsed",
      callback: TreeView.RowCollapsedSignalCallback
    ): number
    on(
      sigName: "row-collapsed",
      callback: TreeView.RowCollapsedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-collapsed",
      callback: TreeView.RowCollapsedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-collapsed",
      callback: TreeView.RowCollapsedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "row-collapsed", path: TreePath, ...args: any[]): void
    connect(
      sigName: "row-expanded",
      callback: TreeView.RowExpandedSignalCallback
    ): number
    on(
      sigName: "row-expanded",
      callback: TreeView.RowExpandedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "row-expanded",
      callback: TreeView.RowExpandedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "row-expanded",
      callback: TreeView.RowExpandedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "row-expanded", path: TreePath, ...args: any[]): void
    connect(
      sigName: "select-all",
      callback: TreeView.SelectAllSignalCallback
    ): number
    on(
      sigName: "select-all",
      callback: TreeView.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-all",
      callback: TreeView.SelectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-all",
      callback: TreeView.SelectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-all", ...args: any[]): void
    connect(
      sigName: "select-cursor-parent",
      callback: TreeView.SelectCursorParentSignalCallback
    ): number
    on(
      sigName: "select-cursor-parent",
      callback: TreeView.SelectCursorParentSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-cursor-parent",
      callback: TreeView.SelectCursorParentSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-cursor-parent",
      callback: TreeView.SelectCursorParentSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-cursor-parent", ...args: any[]): void
    connect(
      sigName: "select-cursor-row",
      callback: TreeView.SelectCursorRowSignalCallback
    ): number
    on(
      sigName: "select-cursor-row",
      callback: TreeView.SelectCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "select-cursor-row",
      callback: TreeView.SelectCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "select-cursor-row",
      callback: TreeView.SelectCursorRowSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "select-cursor-row", ...args: any[]): void
    connect(
      sigName: "start-interactive-search",
      callback: TreeView.StartInteractiveSearchSignalCallback
    ): number
    on(
      sigName: "start-interactive-search",
      callback: TreeView.StartInteractiveSearchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "start-interactive-search",
      callback: TreeView.StartInteractiveSearchSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "start-interactive-search",
      callback: TreeView.StartInteractiveSearchSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "start-interactive-search", ...args: any[]): void
    connect(
      sigName: "test-collapse-row",
      callback: TreeView.TestCollapseRowSignalCallback
    ): number
    on(
      sigName: "test-collapse-row",
      callback: TreeView.TestCollapseRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "test-collapse-row",
      callback: TreeView.TestCollapseRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "test-collapse-row",
      callback: TreeView.TestCollapseRowSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "test-collapse-row", path: TreePath, ...args: any[]): void
    connect(
      sigName: "test-expand-row",
      callback: TreeView.TestExpandRowSignalCallback
    ): number
    on(
      sigName: "test-expand-row",
      callback: TreeView.TestExpandRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "test-expand-row",
      callback: TreeView.TestExpandRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "test-expand-row",
      callback: TreeView.TestExpandRowSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "test-expand-row", path: TreePath, ...args: any[]): void
    connect(
      sigName: "toggle-cursor-row",
      callback: TreeView.ToggleCursorRowSignalCallback
    ): number
    on(
      sigName: "toggle-cursor-row",
      callback: TreeView.ToggleCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "toggle-cursor-row",
      callback: TreeView.ToggleCursorRowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "toggle-cursor-row",
      callback: TreeView.ToggleCursorRowSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "toggle-cursor-row", ...args: any[]): void
    connect(
      sigName: "unselect-all",
      callback: TreeView.UnselectAllSignalCallback
    ): number
    on(
      sigName: "unselect-all",
      callback: TreeView.UnselectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unselect-all",
      callback: TreeView.UnselectAllSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unselect-all",
      callback: TreeView.UnselectAllSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unselect-all", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.TreeView

    connect(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::activate-on-single-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::activate-on-single-click", ...args: any[]): void
    connect(
      sigName: "notify::enable-grid-lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-grid-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-grid-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-grid-lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-grid-lines", ...args: any[]): void
    connect(
      sigName: "notify::enable-search",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-search",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-search",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-search",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-search", ...args: any[]): void
    connect(
      sigName: "notify::enable-tree-lines",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::enable-tree-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::enable-tree-lines",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::enable-tree-lines",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::enable-tree-lines", ...args: any[]): void
    connect(
      sigName: "notify::expander-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expander-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expander-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expander-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expander-column", ...args: any[]): void
    connect(
      sigName: "notify::fixed-height-mode",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fixed-height-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fixed-height-mode",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fixed-height-mode",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fixed-height-mode", ...args: any[]): void
    connect(
      sigName: "notify::headers-clickable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::headers-clickable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::headers-clickable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::headers-clickable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::headers-clickable", ...args: any[]): void
    connect(
      sigName: "notify::headers-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::headers-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::headers-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::headers-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::headers-visible", ...args: any[]): void
    connect(
      sigName: "notify::hover-expand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hover-expand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hover-expand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hover-expand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hover-expand", ...args: any[]): void
    connect(
      sigName: "notify::hover-selection",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hover-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hover-selection",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hover-selection",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hover-selection", ...args: any[]): void
    connect(
      sigName: "notify::level-indentation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::level-indentation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::level-indentation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::level-indentation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::level-indentation", ...args: any[]): void
    connect(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::model",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::model",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::model", ...args: any[]): void
    connect(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::reorderable", ...args: any[]): void
    connect(
      sigName: "notify::rubber-banding",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::rubber-banding",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::rubber-banding",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::rubber-banding",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::rubber-banding", ...args: any[]): void
    connect(
      sigName: "notify::search-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::search-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::search-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::search-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::search-column", ...args: any[]): void
    connect(
      sigName: "notify::show-expanders",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::show-expanders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::show-expanders",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::show-expanders",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::show-expanders", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-column",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-column",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-column",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-column", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A widget for displaying both trees and lists
   *
   * Widget that displays any object that implements the [iface`Gtk`.TreeModel] interface.
   *
   * Please refer to the [tree widget conceptual overview](section-tree-widget.html)
   * for an overview of all the objects and data types related to the tree
   * widget and how they work together.
   *
   * ## Coordinate systems in GtkTreeView API
   *
   * Several different coordinate systems are exposed in the `GtkTreeView` API.
   * These are:
   *
   * ![](tree-view-coordinates.png)
   *
   * - Widget coordinates: Coordinates relative to the widget (usually `widget->window`).
   *
   * - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
   *
   * - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
   *   coordinates start at (0, 0) for row 0 of the tree.
   *
   * Several functions are available for converting between the different
   * coordinate systems.  The most common translations are between widget and bin
   * window coordinates and between bin window and tree coordinates. For the
   * former you can use [method`Gtk`.TreeView.convert_widget_to_bin_window_coords]
   * (and vice versa), for the latter [method`Gtk`.TreeView.convert_bin_window_to_tree_coords]
   * (and vice versa).
   *
   * ## `GtkTreeView` as `GtkBuildable`
   *
   * The `GtkTreeView` implementation of the `GtkBuildable` interface accepts
   * [class`Gtk`.TreeViewColumn] objects as `<child>` elements and exposes the
   * internal [class`Gtk`.TreeSelection] in UI definitions.
   *
   * An example of a UI definition fragment with `GtkTreeView`:
   *
   * ```xml
   * <object class="GtkTreeView" id="treeview">
   *   <property name="model">liststore1</property>
   *   <child>
   *     <object class="GtkTreeViewColumn" id="test-column">
   *       <property name="title">Test</property>
   *       <child>
   *         <object class="GtkCellRendererText" id="test-renderer"/>
   *         <attributes>
   *           <attribute name="text">1</attribute>
   *         </attributes>
   *       </child>
   *     </object>
   *   </child>
   *   <child internal-child="selection">
   *     <object class="GtkTreeSelection" id="selection">
   *       <signal name="changed" handler="on_treeview_selection_changed"/>
   *     </object>
   *   </child>
   * </object>
   * ```
   *
   * ## CSS nodes
   *
   * ```
   * treeview.view
   * ├── header
   * │   ├── button
   * │   │   ╰── [sort-indicator]
   * ┊   ┊
   * │   ╰── button
   * │       ╰── [sort-indicator]
   * │
   * ├── [rubberband]
   * ╰── [dndtarget]
   * ```
   *
   * `GtkTreeView` has a main CSS node with name `treeview` and style class `.view`.
   * It has a subnode with name `header`, which is the parent for all the column
   * header widgets' CSS nodes.
   *
   * Each column header consists of a `button`, which among other content, has a
   * child with name `sort-indicator`, which carries the `.ascending` or `.descending`
   * style classes when the column header should show a sort indicator. The CSS
   * is expected to provide a suitable image using the `-gtk-icon-source` property.
   *
   * For rubberband selection, a subnode with name `rubberband` is used.
   *
   * For the drop target location during DND, a subnode with name `dndtarget` is used.
   * @class
   */
  class TreeView extends Widget {
    // Own properties of Gtk-4.0.Gtk.TreeView

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeView

    constructor(config?: TreeView.ConstructorProperties)
    /**
     * Creates a new `GtkTreeView` widget.
     * @constructor
     * @returns A newly created `GtkTreeView` widget.
     */
    constructor()
    /**
     * Creates a new `GtkTreeView` widget.
     * @constructor
     * @returns A newly created `GtkTreeView` widget.
     */
    static new(): TreeView
    /**
     * Creates a new `GtkTreeView` widget with the model initialized to `model`.
     * @constructor
     * @param model the model.
     * @returns A newly created `GtkTreeView` widget.
     */
    static newWithModel(model: TreeModel): TreeView
    _init(config?: TreeView.ConstructorProperties): void
  }

  module TreeViewColumn {
    // Signal callback interfaces

    /**
     * Signal callback interface for `clicked`
     */
    interface ClickedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Buildable.ConstructorProperties,
        CellLayout.ConstructorProperties,
        GObject.InitiallyUnowned.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.TreeViewColumn

      alignment?: number | null
      /**
       * The `GtkCellArea` used to layout cell renderers for this column.
       *
       * If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area()
       * a horizontally oriented `GtkCellAreaBox` will be used.
       */
      cell_area?: CellArea | null
      clickable?: boolean | null
      expand?: boolean | null
      fixed_width?: number | null
      max_width?: number | null
      min_width?: number | null
      reorderable?: boolean | null
      resizable?: boolean | null
      sizing?: TreeViewColumnSizing | null
      /**
       * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
       * clickable. Set to -1 to make the column unsortable.
       */
      sort_column_id?: number | null
      sort_indicator?: boolean | null
      sort_order?: SortType | null
      spacing?: number | null
      title?: string | null
      visible?: boolean | null
      widget?: Widget | null
    }
  }

  interface TreeViewColumn extends Buildable, CellLayout {
    // Own properties of Gtk-4.0.Gtk.TreeViewColumn

    alignment: number
    /**
     * The `GtkCellArea` used to layout cell renderers for this column.
     *
     * If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area()
     * a horizontally oriented `GtkCellAreaBox` will be used.
     */
    readonly cellArea: CellArea
    clickable: boolean
    expand: boolean
    fixedWidth: number
    maxWidth: number
    minWidth: number
    reorderable: boolean
    resizable: boolean
    sizing: TreeViewColumnSizing
    /**
     * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
     * clickable. Set to -1 to make the column unsortable.
     */
    sortColumnId: number
    sortIndicator: boolean
    sortOrder: SortType
    spacing: number
    title: string | null
    visible: boolean
    widget: Widget
    readonly width: number
    readonly xOffset: number
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.TreeViewColumn

    /**
     * Adds an attribute mapping to the list in `tree_column`.
     *
     * The `column` is the
     * column of the model to get a value from, and the `attribute` is the
     * parameter on `cell_renderer` to be set from the value. So for example
     * if column 2 of the model contains strings, you could have the
     * “text” attribute of a `GtkCellRendererText` get its values from
     * column 2.
     * @param cellRenderer the `GtkCellRenderer` to set attributes on
     * @param attribute An attribute on the renderer
     * @param column The column position on the model to get the attribute from.
     */
    addAttribute(
      cellRenderer: CellRenderer,
      attribute: string,
      column: number
    ): void

    // Overloads of addAttribute

    /**
     * Adds an attribute mapping to the list in `cell_layout`.
     *
     * The `column` is the column of the model to get a value from, and the
     * `attribute` is the property on `cell` to be set from that value. So for
     * example if column 2 of the model contains strings, you could have the
     * “text” attribute of a `GtkCellRendererText` get its values from column 2.
     * In this context "attribute" and "property" are used interchangeably.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param attribute a property on the renderer
     * @param column the column position on the model to get the attribute from
     */
    addAttribute(cell: CellRenderer, attribute: string, column: number): void
    /**
     * Obtains the horizontal position and size of a cell in a column.
     *
     * If the  cell is not found in the column, `start_pos` and `width`
     * are not changed and %FALSE is returned.
     * @param cellRenderer a `GtkCellRenderer`
     * @returns %TRUE if @cell belongs to @tree_column
     */
    cellGetPosition(
      cellRenderer: CellRenderer
    ): [/* returnType */ boolean, /* xOffset */ number, /* width */ number]
    /**
     * Obtains the width and height needed to render the column.  This is used
     * primarily by the `GtkTreeView`.
     */
    cellGetSize(): [
      /* xOffset */ number,
      /* yOffset */ number,
      /* width */ number,
      /* height */ number,
    ]
    /**
     * Returns %TRUE if any of the cells packed into the `tree_column` are visible.
     * For this to be meaningful, you must first initialize the cells with
     * gtk_tree_view_column_cell_set_cell_data()
     * @returns %TRUE, if any of the cells packed into the @tree_column are currently visible
     */
    cellIsVisible(): boolean
    /**
     * Sets the cell renderer based on the `tree_model` and `iter`.  That is, for
     * every attribute mapping in `tree_column,` it will get a value from the set
     * column on the `iter,` and use that value to set the attribute on the cell
     * renderer.  This is used primarily by the `GtkTreeView`.
     * @param treeModel The `GtkTreeModel` to get the cell renderers attributes from.
     * @param iter The `GtkTreeIter` to get the cell renderer’s attributes from.
     * @param isExpander %TRUE, if the row has children
     * @param isExpanded %TRUE, if the row has visible children
     */
    cellSetCellData(
      treeModel: TreeModel,
      iter: TreeIter,
      isExpander: boolean,
      isExpanded: boolean
    ): void
    /**
     * Unsets all the mappings on all renderers on the `tree_column`.
     */
    clear(): void

    // Overloads of clear

    /**
     * Unsets all the mappings on all renderers on `cell_layout` and
     * removes all renderers from `cell_layout`.
     * @virtual
     */
    clear(): void
    /**
     * Clears all existing attributes previously set with
     * gtk_tree_view_column_set_attributes().
     * @param cellRenderer a `GtkCellRenderer` to clear the attribute mapping on.
     */
    clearAttributes(cellRenderer: CellRenderer): void

    // Overloads of clearAttributes

    /**
     * Clears all existing attributes previously set with
     * gtk_cell_layout_set_attributes().
     * @virtual
     * @param cell a `GtkCellRenderer` to clear the attribute mapping on
     */
    clearAttributes(cell: CellRenderer): void
    /**
     * Emits the “clicked” signal on the column.  This function will only work if
     * `tree_column` is clickable.
     */
    clicked(): void
    /**
     * Sets the current keyboard focus to be at `cell,` if the column contains
     * 2 or more editable and activatable cells.
     * @param cell A `GtkCellRenderer`
     */
    focusCell(cell: CellRenderer): void
    /**
     * Returns the current x alignment of `tree_column`.  This value can range
     * between 0.0 and 1.0.
     * @returns The current alignent of @tree_column.
     */
    getAlignment(): number
    /**
     * Returns the button used in the treeview column header
     * @returns The button for the column header.
     */
    getButton(): Widget
    /**
     * Returns %TRUE if the user can click on the header for the column.
     * @returns %TRUE if user can click the column header.
     */
    getClickable(): boolean
    /**
     * Returns %TRUE if the column expands to fill available space.
     * @returns %TRUE if the column expands to fill available space.
     */
    getExpand(): boolean
    /**
     * Gets the fixed width of the column.  This may not be the actual displayed
     * width of the column; for that, use gtk_tree_view_column_get_width().
     * @returns The fixed width of the column.
     */
    getFixedWidth(): number
    /**
     * Returns the maximum width in pixels of the `tree_column,` or -1 if no maximum
     * width is set.
     * @returns The maximum width of the @tree_column.
     */
    getMaxWidth(): number
    /**
     * Returns the minimum width in pixels of the `tree_column,` or -1 if no minimum
     * width is set.
     * @returns The minimum width of the @tree_column.
     */
    getMinWidth(): number
    /**
     * Returns %TRUE if the `tree_column` can be reordered by the user.
     * @returns %TRUE if the @tree_column can be reordered by the user.
     */
    getReorderable(): boolean
    /**
     * Returns %TRUE if the `tree_column` can be resized by the end user.
     * @returns %TRUE, if the @tree_column can be resized.
     */
    getResizable(): boolean
    /**
     * Returns the current type of `tree_column`.
     * @returns The type of @tree_column.
     */
    getSizing(): TreeViewColumnSizing
    /**
     * Gets the logical `sort_column_id` that the model sorts on
     * when this column is selected for sorting.
     *
     * See [method`Gtk`.TreeViewColumn.set_sort_column_id].
     * @returns the current @sort_column_id for this column, or -1 if   this column can’t be used for sorting
     */
    getSortColumnId(): number
    /**
     * Gets the value set by gtk_tree_view_column_set_sort_indicator().
     * @returns whether the sort indicator arrow is displayed
     */
    getSortIndicator(): boolean
    /**
     * Gets the value set by gtk_tree_view_column_set_sort_order().
     * @returns the sort order the sort indicator is indicating
     */
    getSortOrder(): SortType
    /**
     * Returns the spacing of `tree_column`.
     * @returns the spacing of @tree_column.
     */
    getSpacing(): number
    /**
     * Returns the title of the widget.
     * @returns the title of the column. This string should not be modified or freed.
     */
    getTitle(): string
    /**
     * Returns the `GtkTreeView` wherein `tree_column` has been inserted.
     * If `column` is currently not inserted in any tree view, %NULL is
     * returned.
     * @returns The tree view wherein @column   has been inserted
     */
    getTreeView(): Widget | null
    /**
     * Returns %TRUE if `tree_column` is visible.
     * @returns whether the column is visible or not.  If it is visible, then the tree will show the column.
     */
    getVisible(): boolean
    /**
     * Returns the `GtkWidget` in the button on the column header.
     *
     * If a custom widget has not been set then %NULL is returned.
     * @returns The `GtkWidget` in the column header
     */
    getWidget(): Widget | null
    /**
     * Returns the current size of `tree_column` in pixels.
     * @returns The current width of @tree_column.
     */
    getWidth(): number
    /**
     * Returns the current X offset of `tree_column` in pixels.
     * @returns The current X offset of @tree_column.
     */
    getXOffset(): number
    /**
     * Adds the `cell` to end of the column. If `expand` is %FALSE, then the `cell`
     * is allocated no more space than it needs. Any unused space is divided
     * evenly between cells for which `expand` is %TRUE.
     * @param cell The `GtkCellRenderer`
     * @param expand %TRUE if `cell` is to be given extra space allocated to `tree_column`.
     */
    packEnd(cell: CellRenderer, expand: boolean): void

    // Overloads of packEnd

    /**
     * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
     * `cell` is allocated no more space than it needs. Any unused space is
     * divided evenly between cells for which `expand` is %TRUE.
     *
     * Note that reusing the same cell renderer is not supported.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param expand %TRUE if `cell` is to be given extra space allocated to `cell_layout`
     */
    packEnd(cell: CellRenderer, expand: boolean): void
    /**
     * Packs the `cell` into the beginning of the column. If `expand` is %FALSE, then
     * the `cell` is allocated no more space than it needs. Any unused space is divided
     * evenly between cells for which `expand` is %TRUE.
     * @param cell The `GtkCellRenderer`
     * @param expand %TRUE if `cell` is to be given extra space allocated to `tree_column`.
     */
    packStart(cell: CellRenderer, expand: boolean): void

    // Overloads of packStart

    /**
     * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
     * then the `cell` is allocated no more space than it needs. Any unused space
     * is divided evenly between cells for which `expand` is %TRUE.
     *
     * Note that reusing the same cell renderer is not supported.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param expand %TRUE if `cell` is to be given extra space allocated to `cell_layout`
     */
    packStart(cell: CellRenderer, expand: boolean): void
    /**
     * Flags the column, and the cell renderers added to this column, to have
     * their sizes renegotiated.
     */
    queueResize(): void
    /**
     * Sets the alignment of the title or custom widget inside the column header.
     * The alignment determines its location inside the button -- 0.0 for left, 0.5
     * for center, 1.0 for right.
     * @param xalign The alignment, which is between [0.0 and 1.0] inclusive.
     */
    setAlignment(xalign: number): void
    /**
     * Sets the `GtkTreeCellDataFunc` to use for the column.
     *
     * This
     * function is used instead of the standard attributes mapping for
     * setting the column value, and should set the value of `tree_column'`s
     * cell renderer as appropriate.  `func` may be %NULL to remove an
     * older one.
     * @param cellRenderer A `GtkCellRenderer`
     * @param func The `GtkTreeCellDataFunc` to use.
     */
    setCellDataFunc(
      cellRenderer: CellRenderer,
      func: TreeCellDataFunc | null
    ): void

    // Overloads of setCellDataFunc

    /**
     * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
     *
     * This function is used instead of the standard attributes mapping
     * for setting the column value, and should set the value of `cell_layout’`s
     * cell renderer(s) as appropriate.
     *
     * `func` may be %NULL to remove a previously set function.
     * @virtual
     * @param cell a `GtkCellRenderer`
     * @param func the `GtkCellLayout`DataFunc to use
     */
    setCellDataFunc(cell: CellRenderer, func: CellLayoutDataFunc | null): void
    /**
     * Sets the header to be active if `clickable` is %TRUE.  When the header is
     * active, then it can take keyboard focus, and can be clicked.
     * @param clickable %TRUE if the header is active.
     */
    setClickable(clickable: boolean): void
    /**
     * Sets the column to take available extra space.  This space is shared equally
     * amongst all columns that have the expand set to %TRUE.  If no column has this
     * option set, then the last column gets all extra space.  By default, every
     * column is created with this %FALSE.
     *
     * Along with “fixed-width”, the “expand” property changes when the column is
     * resized by the user.
     * @param expand %TRUE if the column should expand to fill available space.
     */
    setExpand(expand: boolean): void
    /**
     * If `fixed_width` is not -1, sets the fixed width of `tree_column;` otherwise
     * unsets it.  The effective value of `fixed_width` is clamped between the
     * minimum and maximum width of the column; however, the value stored in the
     * “fixed-width” property is not clamped.  If the column sizing is
     * %GTK_TREE_VIEW_COLUMN_GROW_ONLY or %GTK_TREE_VIEW_COLUMN_AUTOSIZE, setting
     * a fixed width overrides the automatically calculated width.  Note that
     * `fixed_width` is only a hint to GTK; the width actually allocated to the
     * column may be greater or less than requested.
     *
     * Along with “expand”, the “fixed-width” property changes when the column is
     * resized by the user.
     * @param fixedWidth The new fixed width, in pixels, or -1.
     */
    setFixedWidth(fixedWidth: number): void
    /**
     * Sets the maximum width of the `tree_column`.  If `max_width` is -1, then the
     * maximum width is unset.  Note, the column can actually be wider than max
     * width if it’s the last column in a view.  In this case, the column expands to
     * fill any extra space.
     * @param maxWidth The maximum width of the column in pixels, or -1.
     */
    setMaxWidth(maxWidth: number): void
    /**
     * Sets the minimum width of the `tree_column`.  If `min_width` is -1, then the
     * minimum width is unset.
     * @param minWidth The minimum width of the column in pixels, or -1.
     */
    setMinWidth(minWidth: number): void
    /**
     * If `reorderable` is %TRUE, then the column can be reordered by the end user
     * dragging the header.
     * @param reorderable %TRUE, if the column can be reordered.
     */
    setReorderable(reorderable: boolean): void
    /**
     * If `resizable` is %TRUE, then the user can explicitly resize the column by
     * grabbing the outer edge of the column button.
     *
     * If resizable is %TRUE and
     * sizing mode of the column is %GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
     * mode is changed to %GTK_TREE_VIEW_COLUMN_GROW_ONLY.
     * @param resizable %TRUE, if the column can be resized
     */
    setResizable(resizable: boolean): void
    /**
     * Sets the growth behavior of `tree_column` to `type`.
     * @param type The `GtkTreeViewColumn`Sizing.
     */
    setSizing(type: TreeViewColumnSizing): void
    /**
     * Sets the logical `sort_column_id` that this column sorts on when this column
     * is selected for sorting.  Doing so makes the column header clickable.
     * @param sortColumnId The `sort_column_id` of the model to sort on.
     */
    setSortColumnId(sortColumnId: number): void
    /**
     * Call this function with a `setting` of %TRUE to display an arrow in
     * the header button indicating the column is sorted. Call
     * gtk_tree_view_column_set_sort_order() to change the direction of
     * the arrow.
     * @param setting %TRUE to display an indicator that the column is sorted
     */
    setSortIndicator(setting: boolean): void
    /**
     * Changes the appearance of the sort indicator.
     *
     * This does not actually sort the model.  Use
     * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
     * support.  This function is primarily for custom sorting behavior, and should
     * be used in conjunction with gtk_tree_sortable_set_sort_column_id() to do
     * that. For custom models, the mechanism will vary.
     *
     * The sort indicator changes direction to indicate normal sort or reverse sort.
     * Note that you must have the sort indicator enabled to see anything when
     * calling this function; see gtk_tree_view_column_set_sort_indicator().
     * @param order sort order that the sort indicator should indicate
     */
    setSortOrder(order: SortType): void
    /**
     * Sets the spacing field of `tree_column,` which is the number of pixels to
     * place between cell renderers packed into it.
     * @param spacing distance between cell renderers in pixels.
     */
    setSpacing(spacing: number): void
    /**
     * Sets the title of the `tree_column`.  If a custom widget has been set, then
     * this value is ignored.
     * @param title The title of the `tree_column`.
     */
    setTitle(title: string): void
    /**
     * Sets the visibility of `tree_column`.
     * @param visible %TRUE if the `tree_column` is visible.
     */
    setVisible(visible: boolean): void
    /**
     * Sets the widget in the header to be `widget`.  If widget is %NULL, then the
     * header button is set with a `GtkLabel` set to the title of `tree_column`.
     * @param widget A child `GtkWidget`
     */
    setWidget(widget: Widget | null): void

    // Own signals of Gtk-4.0.Gtk.TreeViewColumn

    connect(
      sigName: "clicked",
      callback: TreeViewColumn.ClickedSignalCallback
    ): number
    on(
      sigName: "clicked",
      callback: TreeViewColumn.ClickedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "clicked",
      callback: TreeViewColumn.ClickedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "clicked",
      callback: TreeViewColumn.ClickedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "clicked", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.TreeViewColumn

    connect(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::alignment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::alignment", ...args: any[]): void
    connect(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cell-area",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cell-area", ...args: any[]): void
    connect(
      sigName: "notify::clickable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::clickable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::clickable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::clickable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::clickable", ...args: any[]): void
    connect(
      sigName: "notify::expand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::expand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::expand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::expand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::expand", ...args: any[]): void
    connect(
      sigName: "notify::fixed-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fixed-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fixed-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fixed-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fixed-width", ...args: any[]): void
    connect(
      sigName: "notify::max-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::max-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::max-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::max-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::max-width", ...args: any[]): void
    connect(
      sigName: "notify::min-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::min-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::min-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::min-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::min-width", ...args: any[]): void
    connect(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::reorderable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::reorderable", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::sizing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sizing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sizing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sizing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sizing", ...args: any[]): void
    connect(
      sigName: "notify::sort-column-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sort-column-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sort-column-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sort-column-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sort-column-id", ...args: any[]): void
    connect(
      sigName: "notify::sort-indicator",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sort-indicator",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sort-indicator",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sort-indicator",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sort-indicator", ...args: any[]): void
    connect(
      sigName: "notify::sort-order",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sort-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sort-order",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sort-order",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sort-order", ...args: any[]): void
    connect(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::spacing",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::spacing", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width", ...args: any[]): void
    connect(
      sigName: "notify::x-offset",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::x-offset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::x-offset",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::x-offset",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::x-offset", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A visible column in a [class`Gtk`.TreeView] widget
   *
   * The `GtkTreeViewColumn` object represents a visible column in a `GtkTreeView` widget.
   * It allows to set properties of the column header, and functions as a holding pen
   * for the cell renderers which determine how the data in the column is displayed.
   *
   * Please refer to the [tree widget conceptual overview](section-tree-widget.html)
   * for an overview of all the objects and data types related to the tree widget and
   * how they work together, and to the [class`Gtk`.TreeView] documentation for specifics
   * about the CSS node structure for treeviews and their headers.
   * @class
   */
  class TreeViewColumn extends GObject.InitiallyUnowned {
    // Own properties of Gtk-4.0.Gtk.TreeViewColumn

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeViewColumn

    constructor(config?: TreeViewColumn.ConstructorProperties)
    /**
     * Creates a new `GtkTreeViewColumn`.
     * @constructor
     * @returns A newly created `GtkTreeViewColumn`.
     */
    constructor()
    /**
     * Creates a new `GtkTreeViewColumn`.
     * @constructor
     * @returns A newly created `GtkTreeViewColumn`.
     */
    static new(): TreeViewColumn
    /**
     * Creates a new `GtkTreeViewColumn` using `area` to render its cells.
     * @constructor
     * @param area the `GtkCellArea` that the newly created column should use to layout cells.
     * @returns A newly created `GtkTreeViewColumn`.
     */
    static newWithArea(area: CellArea): TreeViewColumn
    _init(config?: TreeViewColumn.ConstructorProperties): void
  }

  module UriLauncher {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.UriLauncher

      /**
       * The uri to launch.
       */
      uri?: string | null
    }
  }

  interface UriLauncher {
    // Own properties of Gtk-4.0.Gtk.UriLauncher

    /**
     * The uri to launch.
     */
    uri: string | null
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.UriLauncher

    /**
     * Gets the uri that will be opened.
     * @returns the uri
     */
    getUri(): string | null
    /**
     * Launch an application to open the uri.
     *
     * This may present an app chooser dialog to the user.
     *
     * The `callback` will be called when the operation is completed.
     * It should call [method`Gtk`.UriLauncher.launch_finish] to obtain
     * the result.
     * @param parent the parent `GtkWindow`
     * @param cancellable a `GCancellable` to cancel the operation
     * @param callback a callback to call when the operation is complete
     */
    launch(
      parent: Window | null,
      cancellable: Gio.Cancellable | null,
      callback: Gio.AsyncReadyCallback | null
    ): void
    /**
     * Finishes the [method`Gtk`.UriLauncher.launch] call and
     * returns the result.
     * @param result a `GAsyncResult`
     * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
     */
    launchFinish(result: Gio.AsyncResult): boolean
    /**
     * Sets the uri that will be opened.
     * @param uri the uri
     */
    setUri(uri: string | null): void

    // Class property signals of Gtk-4.0.Gtk.UriLauncher

    connect(sigName: "notify::uri", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::uri",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::uri",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::uri", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkUriLauncher` object collects the arguments that are needed to open a uri
   * with an application.
   *
   * Depending on system configuration, user preferences and available APIs, this
   * may or may not show an app chooser dialog or launch the default application
   * right away.
   *
   * The operation is started with the [method`Gtk`.UriLauncher.launch] function.
   * This API follows the GIO async pattern, and the result can be obtained by
   * calling [method`Gtk`.UriLauncher.launch_finish].
   *
   * To launch a file, use [class`Gtk`.FileLauncher].
   * @class
   */
  class UriLauncher extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.UriLauncher

    static name: string

    // Constructors of Gtk-4.0.Gtk.UriLauncher

    constructor(config?: UriLauncher.ConstructorProperties)
    /**
     * Creates a new `GtkUriLauncher` object.
     * @constructor
     * @param uri the uri to open
     * @returns the new `GtkUriLauncher`
     */
    constructor(uri: string | null)
    /**
     * Creates a new `GtkUriLauncher` object.
     * @constructor
     * @param uri the uri to open
     * @returns the new `GtkUriLauncher`
     */
    static new(uri: string | null): UriLauncher
    _init(config?: UriLauncher.ConstructorProperties): void
  }

  module Video {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Video

      /**
       * If the video should automatically begin playing.
       */
      autoplay?: boolean | null
      /**
       * The file played by this video if the video is playing a file.
       */
      file?: Gio.File | null
      /**
       * Whether to enable graphics offload.
       */
      graphics_offload?: GraphicsOffloadEnabled | null
      /**
       * If new media files should be set to loop.
       */
      loop?: boolean | null
      /**
       * The media-stream played
       */
      media_stream?: MediaStream | null
    }
  }

  interface Video extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Video

    /**
     * If the video should automatically begin playing.
     */
    autoplay: boolean
    /**
     * The file played by this video if the video is playing a file.
     */
    file: Gio.File
    /**
     * Whether to enable graphics offload.
     */
    graphicsOffload: GraphicsOffloadEnabled
    /**
     * If new media files should be set to loop.
     */
    loop: boolean
    /**
     * The media-stream played
     */
    mediaStream: MediaStream
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Video

    /**
     * Returns %TRUE if videos have been set to loop.
     * @returns %TRUE if streams should autoplay
     */
    getAutoplay(): boolean
    /**
     * Gets the file played by `self` or %NULL if not playing back
     * a file.
     * @returns The file played by @self
     */
    getFile(): Gio.File | null
    /**
     * Returns whether graphics offload is enabled.
     *
     * See [class`Gtk`.GraphicsOffload] for more information on graphics offload.
     * @returns the graphics offload status
     */
    getGraphicsOffload(): GraphicsOffloadEnabled
    /**
     * Returns %TRUE if videos have been set to loop.
     * @returns %TRUE if streams should loop
     */
    getLoop(): boolean
    /**
     * Gets the media stream managed by `self` or %NULL if none.
     * @returns The media stream managed by @self
     */
    getMediaStream(): MediaStream | null
    /**
     * Sets whether `self` automatically starts playback when it
     * becomes visible or when a new file gets loaded.
     * @param autoplay whether media streams should autoplay
     */
    setAutoplay(autoplay: boolean): void
    /**
     * Makes `self` play the given `file`.
     * @param file the file to play
     */
    setFile(file: Gio.File | null): void
    /**
     * Makes `self` play the given `filename`.
     *
     * This is a utility function that calls gtk_video_set_file(),
     * @param filename the filename to play
     */
    setFilename(filename: string | null): void
    /**
     * Sets whether to enable graphics offload.
     *
     * See [class`Gtk`.GraphicsOffload] for more information on graphics offload.
     * @param enabled the new graphics offload status
     */
    setGraphicsOffload(enabled: GraphicsOffloadEnabled): void
    /**
     * Sets whether new files loaded by `self` should be set to loop.
     * @param loop whether media streams should loop
     */
    setLoop(loop: boolean): void
    /**
     * Sets the media stream to be played back.
     *
     * `self` will take full control of managing the media stream. If you
     * want to manage a media stream yourself, consider using a
     * [class`Gtk`.Picture] for display.
     *
     * If you want to display a file, consider using [method`Gtk`.Video.set_file]
     * instead.
     * @param stream The media stream to play or %NULL to unset
     */
    setMediaStream(stream: MediaStream | null): void
    /**
     * Makes `self` play the resource at the given `resource_path`.
     *
     * This is a utility function that calls [method`Gtk`.Video.set_file].
     * @param resourcePath the resource to set
     */
    setResource(resourcePath: string | null): void

    // Class property signals of Gtk-4.0.Gtk.Video

    connect(
      sigName: "notify::autoplay",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::autoplay",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::autoplay",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::autoplay",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::autoplay", ...args: any[]): void
    connect(sigName: "notify::file", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::file",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::file",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::file", ...args: any[]): void
    connect(
      sigName: "notify::graphics-offload",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::graphics-offload",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::graphics-offload",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::graphics-offload",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::graphics-offload", ...args: any[]): void
    connect(sigName: "notify::loop", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::loop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::loop",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::loop",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::loop", ...args: any[]): void
    connect(
      sigName: "notify::media-stream",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::media-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::media-stream",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::media-stream",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::media-stream", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkVideo` is a widget to show a `GtkMediaStream` with media controls.
   *
   * ![An example GtkVideo](video.png)
   *
   * The controls are available separately as [class`Gtk`.MediaControls].
   * If you just want to display a video without controls, you can treat it
   * like any other paintable and for example put it into a [class`Gtk`.Picture].
   *
   * `GtkVideo` aims to cover use cases such as previews, embedded animations,
   * etc. It supports autoplay, looping, and simple media controls. It does
   * not have support for video overlays, multichannel audio, device
   * selection, or input. If you are writing a full-fledged video player,
   * you may want to use the [iface`Gdk`.Paintable] API and a media framework
   * such as Gstreamer directly.
   * @class
   */
  class Video extends Widget {
    // Own properties of Gtk-4.0.Gtk.Video

    static name: string

    // Constructors of Gtk-4.0.Gtk.Video

    constructor(config?: Video.ConstructorProperties)
    /**
     * Creates a new empty `GtkVideo`.
     * @constructor
     * @returns a new `GtkVideo`
     */
    constructor()
    /**
     * Creates a new empty `GtkVideo`.
     * @constructor
     * @returns a new `GtkVideo`
     */
    static new(): Video
    /**
     * Creates a `GtkVideo` to play back the given `file`.
     * @constructor
     * @param file a `GFile`
     * @returns a new `GtkVideo`
     */
    static newForFile(file: Gio.File | null): Video
    /**
     * Creates a `GtkVideo` to play back the given `filename`.
     *
     * This is a utility function that calls [ctor`Gtk`.Video.new_for_file],
     * See that function for details.
     * @constructor
     * @param filename filename to play back
     * @returns a new `GtkVideo`
     */
    static newForFilename(filename: string | null): Video
    /**
     * Creates a `GtkVideo` to play back the given `stream`.
     * @constructor
     * @param stream a `GtkMediaStream`
     * @returns a new `GtkVideo`
     */
    static newForMediaStream(stream: MediaStream | null): Video
    /**
     * Creates a `GtkVideo` to play back the resource at the
     * given `resource_path`.
     *
     * This is a utility function that calls [ctor`Gtk`.Video.new_for_file].
     * @constructor
     * @param resourcePath resource path to play back
     * @returns a new `GtkVideo`
     */
    static newForResource(resourcePath: string | null): Video
    _init(config?: Video.ConstructorProperties): void
  }

  module Viewport {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Scrollable.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Viewport

      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Whether to scroll when the focus changes.
       *
       * Before 4.6.2, this property was mistakenly defaulting to FALSE, so if your
       * code needs to work with older versions, consider setting it explicitly to
       * TRUE.
       */
      scroll_to_focus?: boolean | null
    }
  }

  interface Viewport
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Scrollable {
    // Own properties of Gtk-4.0.Gtk.Viewport

    /**
     * The child widget.
     */
    child: Widget
    /**
     * Whether to scroll when the focus changes.
     *
     * Before 4.6.2, this property was mistakenly defaulting to FALSE, so if your
     * code needs to work with older versions, consider setting it explicitly to
     * TRUE.
     */
    scrollToFocus: boolean
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.Viewport

    /**
     * Gets the child widget of `viewport`.
     * @returns the child widget of @viewport
     */
    getChild(): Widget | null
    /**
     * Gets whether the viewport is scrolling to keep the focused
     * child in view.
     * @returns %TRUE if the viewport keeps the focus child scrolled to view
     */
    getScrollToFocus(): boolean
    /**
     * Scrolls a descendant of the viewport into view.
     *
     * The viewport and the descendant must be visible and mapped for
     * this function to work, otherwise no scrolling will be performed.
     * @param descendant a descendant widget of the viewport
     * @param scroll details of how to perform   the scroll operation or NULL to scroll into view
     */
    scrollTo(descendant: Widget, scroll: ScrollInfo | null): void
    /**
     * Sets the child widget of `viewport`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets whether the viewport should automatically scroll
     * to keep the focused child in view.
     * @param scrollToFocus whether to keep the focus widget scrolled to view
     */
    setScrollToFocus(scrollToFocus: boolean): void

    // Class property signals of Gtk-4.0.Gtk.Viewport

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::scroll-to-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scroll-to-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scroll-to-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scroll-to-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scroll-to-focus", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hadjustment", ...args: any[]): void
    connect(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hscroll-policy", ...args: any[]): void
    connect(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vadjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vadjustment", ...args: any[]): void
    connect(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vscroll-policy",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vscroll-policy", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkViewport` implements scrollability for widgets that lack their
   * own scrolling capabilities.
   *
   * Use `GtkViewport` to scroll child widgets such as `GtkGrid`,
   * `GtkBox`, and so on.
   *
   * The `GtkViewport` will start scrolling content only if allocated
   * less than the child widget’s minimum size in a given orientation.
   *
   * # CSS nodes
   *
   * `GtkViewport` has a single CSS node with name `viewport`.
   *
   * # Accessibility
   *
   * Until GTK 4.10, `GtkViewport` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   *
   * Starting from GTK 4.12, `GtkViewport` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
   * @class
   */
  class Viewport extends Widget {
    // Own properties of Gtk-4.0.Gtk.Viewport

    static name: string

    // Constructors of Gtk-4.0.Gtk.Viewport

    constructor(config?: Viewport.ConstructorProperties)
    /**
     * Creates a new `GtkViewport`.
     *
     * The new viewport uses the given adjustments, or default
     * adjustments if none are given.
     * @constructor
     * @param hadjustment horizontal adjustment
     * @param vadjustment vertical adjustment
     * @returns a new `GtkViewport`
     */
    constructor(hadjustment: Adjustment | null, vadjustment: Adjustment | null)
    /**
     * Creates a new `GtkViewport`.
     *
     * The new viewport uses the given adjustments, or default
     * adjustments if none are given.
     * @constructor
     * @param hadjustment horizontal adjustment
     * @param vadjustment vertical adjustment
     * @returns a new `GtkViewport`
     */
    static new(
      hadjustment: Adjustment | null,
      vadjustment: Adjustment | null
    ): Viewport
    _init(config?: Viewport.ConstructorProperties): void
  }

  module VolumeButton {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        AccessibleRange.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Orientable.ConstructorProperties,
        ScaleButton.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.VolumeButton

      /**
       * Whether to use symbolic icons as the icons.
       *
       * Note that if the symbolic icons are not available in your installed
       * theme, then the normal (potentially colorful) icons will be used.
       */
      use_symbolic?: boolean | null
    }
  }

  interface VolumeButton
    extends Accessible,
      AccessibleRange,
      Buildable,
      ConstraintTarget,
      Orientable {
    // Own properties of Gtk-4.0.Gtk.VolumeButton

    /**
     * Whether to use symbolic icons as the icons.
     *
     * Note that if the symbolic icons are not available in your installed
     * theme, then the normal (potentially colorful) icons will be used.
     */
    useSymbolic: boolean
    __gtype__: number

    // Conflicting properties

    parentInstance: any

    // Own fields of Gtk-4.0.Gtk.VolumeButton

    readonly parent: ScaleButton & Widget

    // Class property signals of Gtk-4.0.Gtk.VolumeButton

    connect(
      sigName: "notify::use-symbolic",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::use-symbolic",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::use-symbolic",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::use-symbolic",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::use-symbolic", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::active", ...args: any[]): void
    connect(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::adjustment",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::adjustment", ...args: any[]): void
    connect(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-frame",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-frame", ...args: any[]): void
    connect(
      sigName: "notify::icons",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icons",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icons",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icons", ...args: any[]): void
    connect(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::value",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::value",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::value", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::orientation",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::orientation", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkVolumeButton` is a `GtkScaleButton` subclass tailored for
   * volume control.
   *
   * ![An example GtkVolumeButton](volumebutton.png)
   * @class
   */
  class VolumeButton extends ScaleButton {
    // Own properties of Gtk-4.0.Gtk.VolumeButton

    static name: string

    // Constructors of Gtk-4.0.Gtk.VolumeButton

    constructor(config?: VolumeButton.ConstructorProperties)
    /**
     * Creates a `GtkVolumeButton`.
     *
     * The button has a range between 0.0 and 1.0, with a stepping of 0.02.
     * Volume values can be obtained and modified using the functions from
     * [class`Gtk`.ScaleButton].
     * @constructor
     * @returns a new `GtkVolumeButton`
     */
    constructor()
    /**
     * Creates a `GtkVolumeButton`.
     *
     * The button has a range between 0.0 and 1.0, with a stepping of 0.02.
     * Volume values can be obtained and modified using the functions from
     * [class`Gtk`.ScaleButton].
     * @constructor
     * @returns a new `GtkVolumeButton`
     */
    static new(): VolumeButton

    // Overloads of new

    /**
     * Creates a `GtkScaleButton`.
     *
     * The new scale button has a range between `min` and `max,`
     * with a stepping of `step`.
     * @constructor
     * @param min the minimum value of the scale (usually 0)
     * @param max the maximum value of the scale (usually 100)
     * @param step the stepping of value when a scroll-wheel event,   or up/down arrow event occurs (usually 2)
     * @param icons a %NULL-terminated   array of icon names, or %NULL if you want to set the list   later with gtk_scale_button_set_icons()
     * @returns a new `GtkScaleButton`
     */
    static new(
      min: number,
      max: number,
      step: number,
      icons: string[] | null
    ): ScaleButton
    _init(config?: VolumeButton.ConstructorProperties): void
  }

  module Widget {
    // Signal callback interfaces

    /**
     * Signal callback interface for `destroy`
     */
    interface DestroySignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `direction-changed`
     */
    interface DirectionChangedSignalCallback {
      (previousDirection: TextDirection): void
    }

    /**
     * Signal callback interface for `hide`
     */
    interface HideSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `keynav-failed`
     */
    interface KeynavFailedSignalCallback {
      (direction: DirectionType): boolean
    }

    /**
     * Signal callback interface for `map`
     */
    interface MapSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `mnemonic-activate`
     */
    interface MnemonicActivateSignalCallback {
      (groupCycling: boolean): boolean
    }

    /**
     * Signal callback interface for `move-focus`
     */
    interface MoveFocusSignalCallback {
      (direction: DirectionType): void
    }

    /**
     * Signal callback interface for `query-tooltip`
     */
    interface QueryTooltipSignalCallback {
      (x: number, y: number, keyboardMode: boolean, tooltip: Tooltip): boolean
    }

    /**
     * Signal callback interface for `realize`
     */
    interface RealizeSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `show`
     */
    interface ShowSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `state-flags-changed`
     */
    interface StateFlagsChangedSignalCallback {
      (flags: StateFlags): void
    }

    /**
     * Signal callback interface for `unmap`
     */
    interface UnmapSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `unrealize`
     */
    interface UnrealizeSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        GObject.InitiallyUnowned.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Widget

      /**
       * Whether the widget or any of its descendents can accept
       * the input focus.
       *
       * This property is meant to be set by widget implementations,
       * typically in their instance init function.
       */
      can_focus?: boolean | null
      /**
       * Whether the widget can receive pointer events.
       */
      can_target?: boolean | null
      /**
       * A list of css classes applied to this widget.
       */
      css_classes?: string[] | null
      /**
       * The name of this widget in the CSS tree.
       *
       * This property is meant to be set by widget implementations,
       * typically in their instance init function.
       */
      css_name?: string | null
      /**
       * The cursor used by `widget`.
       */
      cursor?: Gdk.Cursor | null
      /**
       * Whether the widget should grab focus when it is clicked with the mouse.
       *
       * This property is only relevant for widgets that can take focus.
       */
      focus_on_click?: boolean | null
      /**
       * Whether this widget itself will accept the input focus.
       */
      focusable?: boolean | null
      /**
       * How to distribute horizontal space if widget gets extra space.
       */
      halign?: Align | null
      /**
       * Enables or disables the emission of the ::query-tooltip signal on `widget`.
       *
       * A value of %TRUE indicates that `widget` can have a tooltip, in this case
       * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
       * determine whether it will provide a tooltip or not.
       */
      has_tooltip?: boolean | null
      /**
       * Override for height request of the widget.
       *
       * If this is -1, the natural request will be used.
       */
      height_request?: number | null
      /**
       * Whether to expand horizontally.
       */
      hexpand?: boolean | null
      /**
       * Whether to use the `hexpand` property.
       */
      hexpand_set?: boolean | null
      /**
       * The `GtkLayoutManager` instance to use to compute the preferred size
       * of the widget, and allocate its children.
       *
       * This property is meant to be set by widget implementations,
       * typically in their instance init function.
       */
      layout_manager?: LayoutManager | null
      /**
       * Margin on bottom side of widget.
       *
       * This property adds margin outside of the widget's normal size
       * request, the margin will be added in addition to the size from
       * [method`Gtk`.Widget.set_size_request] for example.
       */
      margin_bottom?: number | null
      /**
       * Margin on end of widget, horizontally.
       *
       * This property supports left-to-right and right-to-left text
       * directions.
       *
       * This property adds margin outside of the widget's normal size
       * request, the margin will be added in addition to the size from
       * [method`Gtk`.Widget.set_size_request] for example.
       */
      margin_end?: number | null
      /**
       * Margin on start of widget, horizontally.
       *
       * This property supports left-to-right and right-to-left text
       * directions.
       *
       * This property adds margin outside of the widget's normal size
       * request, the margin will be added in addition to the size from
       * [method`Gtk`.Widget.set_size_request] for example.
       */
      margin_start?: number | null
      /**
       * Margin on top side of widget.
       *
       * This property adds margin outside of the widget's normal size
       * request, the margin will be added in addition to the size from
       * [method`Gtk`.Widget.set_size_request] for example.
       */
      margin_top?: number | null
      /**
       * The name of the widget.
       */
      name?: string | null
      /**
       * The requested opacity of the widget.
       */
      opacity?: number | null
      /**
       * How content outside the widget's content area is treated.
       *
       * This property is meant to be set by widget implementations,
       * typically in their instance init function.
       */
      overflow?: Overflow | null
      /**
       * Whether the widget will receive the default action when it is focused.
       */
      receives_default?: boolean | null
      /**
       * Whether the widget responds to input.
       */
      sensitive?: boolean | null
      /**
       * Sets the text of tooltip to be the given string, which is marked up
       * with Pango markup.
       *
       * Also see [method`Gtk`.Tooltip.set_markup].
       *
       * This is a convenience property which will take care of getting the
       * tooltip shown if the given string is not %NULL:
       * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
       * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
       * the default signal handler.
       *
       * Note that if both [property`Gtk`.Widget:tooltip-text] and
       * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
       */
      tooltip_markup?: string | null
      /**
       * Sets the text of tooltip to be the given string.
       *
       * Also see [method`Gtk`.Tooltip.set_text].
       *
       * This is a convenience property which will take care of getting the
       * tooltip shown if the given string is not %NULL:
       * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
       * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
       * the default signal handler.
       *
       * Note that if both [property`Gtk`.Widget:tooltip-text] and
       * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
       */
      tooltip_text?: string | null
      /**
       * How to distribute vertical space if widget gets extra space.
       */
      valign?: Align | null
      /**
       * Whether to expand vertically.
       */
      vexpand?: boolean | null
      /**
       * Whether to use the `vexpand` property.
       */
      vexpand_set?: boolean | null
      /**
       * Whether the widget is visible.
       */
      visible?: boolean | null
      /**
       * Override for width request of the widget.
       *
       * If this is -1, the natural request will be used.
       */
      width_request?: number | null
    }
  }

  interface Widget extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.Widget

    /**
     * Whether the widget or any of its descendents can accept
     * the input focus.
     *
     * This property is meant to be set by widget implementations,
     * typically in their instance init function.
     */
    canFocus: boolean
    /**
     * Whether the widget can receive pointer events.
     */
    canTarget: boolean
    /**
     * A list of css classes applied to this widget.
     */
    cssClasses: string[]
    /**
     * The name of this widget in the CSS tree.
     *
     * This property is meant to be set by widget implementations,
     * typically in their instance init function.
     */
    readonly cssName: string | null
    /**
     * The cursor used by `widget`.
     */
    cursor: Gdk.Cursor
    /**
     * Whether the widget should grab focus when it is clicked with the mouse.
     *
     * This property is only relevant for widgets that can take focus.
     */
    focusOnClick: boolean
    /**
     * Whether this widget itself will accept the input focus.
     */
    focusable: boolean
    /**
     * How to distribute horizontal space if widget gets extra space.
     */
    halign: Align
    /**
     * Whether the widget is the default widget.
     */
    readonly hasDefault: boolean
    /**
     * Whether the widget has the input focus.
     */
    readonly hasFocus: boolean
    /**
     * Enables or disables the emission of the ::query-tooltip signal on `widget`.
     *
     * A value of %TRUE indicates that `widget` can have a tooltip, in this case
     * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
     * determine whether it will provide a tooltip or not.
     */
    hasTooltip: boolean
    /**
     * Override for height request of the widget.
     *
     * If this is -1, the natural request will be used.
     */
    heightRequest: number
    /**
     * Whether to expand horizontally.
     */
    hexpand: boolean
    /**
     * Whether to use the `hexpand` property.
     */
    hexpandSet: boolean
    /**
     * The `GtkLayoutManager` instance to use to compute the preferred size
     * of the widget, and allocate its children.
     *
     * This property is meant to be set by widget implementations,
     * typically in their instance init function.
     */
    layoutManager: LayoutManager
    /**
     * Margin on bottom side of widget.
     *
     * This property adds margin outside of the widget's normal size
     * request, the margin will be added in addition to the size from
     * [method`Gtk`.Widget.set_size_request] for example.
     */
    marginBottom: number
    /**
     * Margin on end of widget, horizontally.
     *
     * This property supports left-to-right and right-to-left text
     * directions.
     *
     * This property adds margin outside of the widget's normal size
     * request, the margin will be added in addition to the size from
     * [method`Gtk`.Widget.set_size_request] for example.
     */
    marginEnd: number
    /**
     * Margin on start of widget, horizontally.
     *
     * This property supports left-to-right and right-to-left text
     * directions.
     *
     * This property adds margin outside of the widget's normal size
     * request, the margin will be added in addition to the size from
     * [method`Gtk`.Widget.set_size_request] for example.
     */
    marginStart: number
    /**
     * Margin on top side of widget.
     *
     * This property adds margin outside of the widget's normal size
     * request, the margin will be added in addition to the size from
     * [method`Gtk`.Widget.set_size_request] for example.
     */
    marginTop: number
    /**
     * The name of the widget.
     */
    name: string | null
    /**
     * The requested opacity of the widget.
     */
    opacity: number
    /**
     * How content outside the widget's content area is treated.
     *
     * This property is meant to be set by widget implementations,
     * typically in their instance init function.
     */
    overflow: Overflow
    /**
     * The parent widget of this widget.
     */
    readonly parent: Widget
    /**
     * Whether the widget will receive the default action when it is focused.
     */
    receivesDefault: boolean
    // Has conflict: readonly root: Root
    /**
     * The scale factor of the widget.
     */
    readonly scaleFactor: number
    /**
     * Whether the widget responds to input.
     */
    sensitive: boolean
    /**
     * Sets the text of tooltip to be the given string, which is marked up
     * with Pango markup.
     *
     * Also see [method`Gtk`.Tooltip.set_markup].
     *
     * This is a convenience property which will take care of getting the
     * tooltip shown if the given string is not %NULL:
     * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
     * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
     * the default signal handler.
     *
     * Note that if both [property`Gtk`.Widget:tooltip-text] and
     * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
     */
    tooltipMarkup: string | null
    /**
     * Sets the text of tooltip to be the given string.
     *
     * Also see [method`Gtk`.Tooltip.set_text].
     *
     * This is a convenience property which will take care of getting the
     * tooltip shown if the given string is not %NULL:
     * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
     * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
     * the default signal handler.
     *
     * Note that if both [property`Gtk`.Widget:tooltip-text] and
     * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
     */
    tooltipText: string | null
    /**
     * How to distribute vertical space if widget gets extra space.
     */
    valign: Align
    /**
     * Whether to expand vertically.
     */
    vexpand: boolean
    /**
     * Whether to use the `vexpand` property.
     */
    vexpandSet: boolean
    /**
     * Whether the widget is visible.
     */
    visible: boolean
    /**
     * Override for width request of the widget.
     *
     * If this is -1, the natural request will be used.
     */
    widthRequest: number
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Widget

    parentInstance: GObject.InitiallyUnowned

    // Owm methods of Gtk-4.0.Gtk.Widget

    /**
     * Enable or disable an action installed with
     * gtk_widget_class_install_action().
     * @param actionName action name, such as "clipboard.paste"
     * @param enabled whether the action is now enabled
     */
    actionSetEnabled(actionName: string, enabled: boolean): void
    /**
     * For widgets that can be “activated” (buttons, menu items, etc.),
     * this function activates them.
     *
     * The activation will emit the signal set using
     * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
     *
     * Activation is what happens when you press <kbd>Enter</kbd>
     * on a widget during key navigation.
     *
     * If you wish to handle the activation keybinding yourself, it is
     * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
     * created with [ctor`Gtk`.SignalAction.new].
     *
     * If `widget` isn't activatable, the function returns %FALSE.
     * @returns %TRUE if the widget was activatable
     */
    activate(): boolean
    /**
     * Looks up the action in the action groups associated with
     * `widget` and its ancestors, and activates it.
     *
     * If the action is in an action group added with
     * [method`Gtk`.Widget.insert_action_group], the `name` is expected
     * to be prefixed with the prefix that was used when the group was
     * inserted.
     *
     * The arguments must match the actions expected parameter type,
     * as returned by `g_action_get_parameter_type()`.
     * @param name the name of the action to activate
     * @param args parameters to use
     * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
     */
    activateAction(name: string, args: GLib.Variant | null): boolean
    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    // Has conflict: addCssClass(cssClass: string): void
    /**
     * Adds a widget to the list of mnemonic labels for this widget.
     *
     * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
     * list of mnemonic labels for the widget is cleared when the
     * widget is destroyed, so the caller must make sure to update
     * its internal state at this point as well.
     * @param label a `GtkWidget` that acts as a mnemonic label for `widget`
     */
    addMnemonicLabel(label: Widget): void
    /**
     * Queues an animation frame update and adds a callback to be called
     * before each frame.
     *
     * Until the tick callback is removed, it will be called frequently
     * (usually at the frame rate of the output device or as quickly as
     * the application can be repainted, whichever is slower). For this
     * reason, is most suitable for handling graphics that change every
     * frame or every few frames. The tick callback does not automatically
     * imply a relayout or repaint. If you want a repaint or relayout, and
     * aren’t changing widget properties that would trigger that (for example,
     * changing the text of a `GtkLabel`), then you will have to call
     * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
     * yourself.
     *
     * [method`Gdk`.FrameClock.get_frame_time] should generally be used
     * for timing continuous animations and
     * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
     * trying to display isolated frames at particular times.
     *
     * This is a more convenient alternative to connecting directly to the
     * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
     * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
     * @param callback function to call for updating animations
     * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
     */
    addTickCallback(callback: TickCallback): number
    /**
     * This function is only used by `GtkWidget` subclasses, to
     * assign a size, position and (optionally) baseline to their
     * child widgets.
     *
     * In this function, the allocation and baseline may be adjusted.
     * The given allocation will be forced to be bigger than the
     * widget's minimum size, as well as at least 0×0 in size.
     *
     * For a version that does not take a transform, see
     * [method`Gtk`.Widget.size_allocate].
     * @param width New width of `widget`
     * @param height New height of `widget`
     * @param baseline New baseline of `widget,` or -1
     * @param transform Transformation to be applied to `widget`
     */
    allocate(
      width: number,
      height: number,
      baseline: number,
      transform: Gsk.Transform | null
    ): void
    /**
     * Called by widgets as the user moves around the window using
     * keyboard shortcuts.
     *
     * The `direction` argument indicates what kind of motion is taking place (up,
     * down, left, right, tab forward, tab backward).
     *
     * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
     * can override the virtual function in order to implement appropriate focus
     * behavior.
     *
     * The default `focus()` virtual function for a widget should return `TRUE` if
     * moving in `direction` left the focus on a focusable location inside that
     * widget, and `FALSE` if moving in `direction` moved the focus outside the
     * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
     * to place the focus accordingly; when returning `FALSE`, they don’t modify
     * the current focus location.
     *
     * This function is used by custom widget implementations; if you're
     * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
     * the focus to a particular widget.
     * @param direction direction of focus movement
     * @returns %TRUE if focus ended up inside @widget
     */
    childFocus(direction: DirectionType): boolean
    /**
     * Computes the bounds for `widget` in the coordinate space of `target`.
     *
     * The bounds of widget are (the bounding box of) the region that it is
     * expected to draw in. See the [coordinate system](coordinates.html)
     * overview to learn more.
     *
     * If the operation is successful, %TRUE is returned. If `widget` has no
     * bounds or the bounds cannot be expressed in `target'`s coordinate space
     * (for example if both widgets are in different windows), %FALSE is
     * returned and `bounds` is set to the zero rectangle.
     *
     * It is valid for `widget` and `target` to be the same widget.
     * @param target the `GtkWidget`
     * @returns %TRUE if the bounds could be computed
     */
    computeBounds(
      target: Widget
    ): [/* returnType */ boolean, /* outBounds */ Graphene.Rect]
    // Has conflict: computeExpand(orientation: Orientation): boolean
    /**
     * Translates the given `point` in `widget'`s coordinates to coordinates
     * relative to `target’`s coordinate system.
     *
     * In order to perform this operation, both widgets must share a
     * common ancestor.
     * @param target the `GtkWidget` to transform into
     * @param point a point in `widget'`s coordinate system
     * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
     */
    computePoint(
      target: Widget,
      point: Graphene.Point
    ): [/* returnType */ boolean, /* outPoint */ Graphene.Point]
    /**
     * Computes a matrix suitable to describe a transformation from
     * `widget'`s coordinate system into `target'`s coordinate system.
     *
     * The transform can not be computed in certain cases, for example
     * when `widget` and `target` do not share a common ancestor. In that
     * case `out_transform` gets set to the identity matrix.
     *
     * To learn more about widget coordinate systems, see the coordinate
     * system [overview](coordinates.html).
     * @param target the target widget that the matrix will transform to
     * @returns %TRUE if the transform could be computed, %FALSE otherwise
     */
    computeTransform(
      target: Widget
    ): [/* returnType */ boolean, /* outTransform */ Graphene.Matrix]
    // Has conflict: contains(x: number, y: number): boolean
    /**
     * Creates a new `PangoContext` with the appropriate font map,
     * font options, font description, and base direction for drawing
     * text for this widget.
     *
     * See also [method`Gtk`.Widget.get_pango_context].
     * @returns the new `PangoContext`
     */
    createPangoContext(): Pango.Context
    /**
     * Creates a new `PangoLayout` with the appropriate font map,
     * font description, and base direction for drawing text for
     * this widget.
     *
     * If you keep a `PangoLayout` created in this way around,
     * you need to re-create it when the widget `PangoContext`
     * is replaced. This can be tracked by listening to changes
     * of the [property`Gtk`.Widget:root] property on the widget.
     * @param text text to set on the layout
     * @returns the new `PangoLayout`
     */
    createPangoLayout(text: string | null): Pango.Layout
    /**
     * Clears the template children for the given widget.
     *
     * This function is the opposite of [method`Gtk`.Widget.init_template], and
     * it is used to clear all the template children from a widget instance.
     * If you bound a template child to a field in the instance structure, or
     * in the instance private data structure, the field will be set to `NULL`
     * after this function returns.
     *
     * You should call this function inside the `GObjectClass.dispose()`
     * implementation of any widget that called `gtk_widget_init_template()`.
     * Typically, you will want to call this function last, right before
     * chaining up to the parent type's dispose implementation, e.g.
     *
     * ```c
     * static void
     * some_widget_dispose (GObject *gobject)
     * {
     *   SomeWidget *self = SOME_WIDGET (gobject);
     *
     *   // Clear the template data for SomeWidget
     *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
     *
     *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
     * }
     * ```
     * @param widgetType the type of the widget to finalize the template for
     */
    disposeTemplate(widgetType: GObject.GType): void
    /**
     * Checks to see if a drag movement has passed the GTK drag threshold.
     * @param startX X coordinate of start of drag
     * @param startY Y coordinate of start of drag
     * @param currentX current X coordinate
     * @param currentY current Y coordinate
     * @returns %TRUE if the drag threshold has been passed.
     */
    dragCheckThreshold(
      startX: number,
      startY: number,
      currentX: number,
      currentY: number
    ): boolean
    /**
     * Notifies the user about an input-related error on this widget.
     *
     * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
     * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
     *
     * Note that the effect of [method`Gdk`.Surface.beep] can be configured
     * in many ways, depending on the windowing backend and the desktop
     * environment or window manager that is used.
     */
    errorBell(): void
    /**
     * Returns the baseline that has currently been allocated to `widget`.
     *
     * This function is intended to be used when implementing handlers
     * for the `GtkWidget`Class.snapshot() function, and when allocating
     * child widgets in `GtkWidget`Class.size_allocate().
     * @returns the baseline of the @widget, or -1 if none
     */
    getAllocatedBaseline(): number
    /**
     * Returns the height that has currently been allocated to `widget`.
     *
     * To learn more about widget sizes, see the coordinate
     * system [overview](coordinates.html).
     * @returns the height of the @widget
     */
    getAllocatedHeight(): number
    /**
     * Returns the width that has currently been allocated to `widget`.
     *
     * To learn more about widget sizes, see the coordinate
     * system [overview](coordinates.html).
     * @returns the width of the @widget
     */
    getAllocatedWidth(): number
    /**
     * Retrieves the widget’s allocation.
     *
     * Note, when implementing a layout container: a widget’s allocation
     * will be its “adjusted” allocation, that is, the widget’s parent
     * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
     * and that allocation is then adjusted (to handle margin
     * and alignment for example) before assignment to the widget.
     * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
     * was actually assigned to the widget. The adjusted allocation is
     * guaranteed to be completely contained within the
     * [method`Gtk`.Widget.size_allocate] allocation, however.
     *
     * So a layout container is guaranteed that its children stay inside
     * the assigned bounds, but not that they have exactly the bounds the
     * container assigned.
     */
    getAllocation(): /* allocation */ Allocation
    /**
     * Gets the first ancestor of `widget` with type `widget_type`.
     *
     * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
     * gets the first `GtkBox` that’s an ancestor of `widget`. No
     * reference will be added to the returned widget; it should
     * not be unreferenced.
     *
     * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
     * considers `widget` to be an ancestor of itself.
     * @param widgetType ancestor type
     * @returns the ancestor widget
     */
    getAncestor(widgetType: GObject.GType): Widget | null
    /**
     * Returns the baseline that has currently been allocated to `widget`.
     *
     * This function is intended to be used when implementing handlers
     * for the `GtkWidget`Class.snapshot() function, and when allocating
     * child widgets in `GtkWidget`Class.size_allocate().
     * @returns the baseline of the @widget, or -1 if none
     */
    getBaseline(): number
    /**
     * Determines whether the input focus can enter `widget` or any
     * of its children.
     *
     * See [method`Gtk`.Widget.set_focusable].
     * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
     */
    getCanFocus(): boolean
    /**
     * Queries whether `widget` can be the target of pointer events.
     * @returns %TRUE if @widget can receive pointer events
     */
    getCanTarget(): boolean
    /**
     * Gets the value set with gtk_widget_set_child_visible().
     *
     * If you feel a need to use this function, your code probably
     * needs reorganization.
     *
     * This function is only useful for container implementations
     * and should never be called by an application.
     * @returns %TRUE if the widget is mapped with the parent.
     */
    getChildVisible(): boolean
    /**
     * Gets the clipboard object for `widget`.
     *
     * This is a utility function to get the clipboard object for the
     * `GdkDisplay` that `widget` is using.
     *
     * Note that this function always works, even when `widget` is not
     * realized yet.
     * @returns the appropriate clipboard object
     */
    getClipboard(): Gdk.Clipboard
    /**
     * Gets the current foreground color for the widget’s
     * CSS style.
     *
     * This function should only be used in snapshot
     * implementations that need to do custom
     * drawing with the foreground color.
     */
    getColor(): /* color */ Gdk.RGBA
    /**
     * Returns the list of style classes applied to `widget`.
     * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
     */
    getCssClasses(): string[]
    /**
     * Returns the CSS name that is used for `self`.
     * @returns the CSS name
     */
    getCssName(): string
    /**
     * Queries the cursor set on `widget`.
     *
     * See [method`Gtk`.Widget.set_cursor] for details.
     * @returns the cursor   currently in use or %NULL if the cursor is inherited
     */
    getCursor(): Gdk.Cursor | null
    /**
     * Gets the reading direction for a particular widget.
     *
     * See [method`Gtk`.Widget.set_direction].
     * @returns the reading direction for the widget.
     */
    getDirection(): TextDirection
    /**
     * Get the `GdkDisplay` for the toplevel window associated with
     * this widget.
     *
     * This function can only be called after the widget has been
     * added to a widget hierarchy with a `GtkWindow` at the top.
     *
     * In general, you should only create display specific
     * resources when a widget has been realized, and you should
     * free those resources when the widget is unrealized.
     * @returns the `GdkDisplay` for the toplevel   for this widget.
     */
    getDisplay(): Gdk.Display
    /**
     * Returns the widget’s first child.
     *
     * This API is primarily meant for widget implementations.
     * @returns The widget's first child
     */
    getFirstChild(): Widget | null
    /**
     * Returns the current focus child of `widget`.
     * @returns The current focus   child of @widget
     */
    getFocusChild(): Widget | null
    /**
     * Returns whether the widget should grab focus when it is clicked
     * with the mouse.
     *
     * See [method`Gtk`.Widget.set_focus_on_click].
     * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
     */
    getFocusOnClick(): boolean
    /**
     * Determines whether `widget` can own the input focus.
     *
     * See [method`Gtk`.Widget.set_focusable].
     * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
     */
    getFocusable(): boolean
    /**
     * Gets the font map of `widget`.
     *
     * See [method`Gtk`.Widget.set_font_map].
     * @returns A `PangoFontMap`
     */
    getFontMap(): Pango.FontMap | null
    /**
     * Returns the `cairo_font_options_t` of widget.
     *
     * Seee [method`Gtk`.Widget.set_font_options].
     * @returns the `cairo_font_options_t`   of widget
     */
    getFontOptions(): cairo.FontOptions | null
    /**
     * Obtains the frame clock for a widget.
     *
     * The frame clock is a global “ticker” that can be used to drive
     * animations and repaints. The most common reason to get the frame
     * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
     * to get a time to use for animating. For example you might record
     * the start of the animation with an initial value from
     * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
     * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
     *
     * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
     * clock, but won’t necessarily repaint any widgets. To repaint a
     * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
     * the widget (thus scheduling it to receive a draw on the next
     * frame). gtk_widget_queue_draw() will also end up requesting a frame
     * on the appropriate frame clock.
     *
     * A widget’s frame clock will not change while the widget is
     * mapped. Reparenting a widget (which implies a temporary unmap) can
     * change the widget’s frame clock.
     *
     * Unrealized widgets do not have a frame clock.
     * @returns a `GdkFrameClock`
     */
    getFrameClock(): Gdk.FrameClock | null
    /**
     * Gets the horizontal alignment of `widget`.
     *
     * For backwards compatibility reasons this method will never return
     * one of the baseline alignments, but instead it will convert it to
     * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
     *
     * Baselines are not supported for horizontal alignment.
     * @returns the horizontal alignment of @widget
     */
    getHalign(): Align
    /**
     * Returns the current value of the `has-tooltip` property.
     * @returns current value of `has-tooltip` on @widget.
     */
    getHasTooltip(): boolean
    /**
     * Returns the content height of the widget.
     *
     * This function returns the height passed to its
     * size-allocate implementation, which is the height you
     * should be using in [vfunc`Gtk`.Widget.snapshot].
     *
     * For pointer events, see [method`Gtk`.Widget.contains].
     *
     * To learn more about widget sizes, see the coordinate
     * system [overview](coordinates.html).
     * @returns The height of @widget
     */
    getHeight(): number
    /**
     * Gets whether the widget would like any available extra horizontal
     * space.
     *
     * When a user resizes a `GtkWindow`, widgets with expand=TRUE
     * generally receive the extra space. For example, a list or
     * scrollable area or document in your window would often be set to
     * expand.
     *
     * Containers should use [method`Gtk`.Widget.compute_expand] rather
     * than this function, to see whether a widget, or any of its children,
     * has the expand flag set. If any child of a widget wants to
     * expand, the parent may ask to expand also.
     *
     * This function only looks at the widget’s own hexpand flag, rather
     * than computing whether the entire widget tree rooted at this widget
     * wants to expand.
     * @returns whether hexpand flag is set
     */
    getHexpand(): boolean
    /**
     * Gets whether gtk_widget_set_hexpand() has been used
     * to explicitly set the expand flag on this widget.
     *
     * If [property`Gtk`.Widget:hexpand] property is set, then it
     * overrides any computed expand value based on child widgets.
     * If `hexpand` is not set, then the expand value depends on
     * whether any children of the widget would like to expand.
     *
     * There are few reasons to use this function, but it’s here
     * for completeness and consistency.
     * @returns whether hexpand has been explicitly set
     */
    getHexpandSet(): boolean
    /**
     * Returns the widget’s last child.
     *
     * This API is primarily meant for widget implementations.
     * @returns The widget's last child
     */
    getLastChild(): Widget | null
    /**
     * Retrieves the layout manager used by `widget`.
     *
     * See [method`Gtk`.Widget.set_layout_manager].
     * @returns a `GtkLayoutManager`
     */
    getLayoutManager(): LayoutManager | null
    /**
     * Whether the widget is mapped.
     * @returns %TRUE if the widget is mapped, %FALSE otherwise.
     */
    getMapped(): boolean
    /**
     * Gets the bottom margin of `widget`.
     * @returns The bottom margin of @widget
     */
    getMarginBottom(): number
    /**
     * Gets the end margin of `widget`.
     * @returns The end margin of @widget
     */
    getMarginEnd(): number
    /**
     * Gets the start margin of `widget`.
     * @returns The start margin of @widget
     */
    getMarginStart(): number
    /**
     * Gets the top margin of `widget`.
     * @returns The top margin of @widget
     */
    getMarginTop(): number
    /**
     * Retrieves the name of a widget.
     *
     * See [method`Gtk`.Widget.set_name] for the significance of widget names.
     * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
     */
    getName(): string
    /**
     * Returns the nearest `GtkNative` ancestor of `widget`.
     *
     * This function will return %NULL if the widget is not
     * contained inside a widget tree with a native ancestor.
     *
     * `GtkNative` widgets will return themselves here.
     * @returns the `GtkNative` ancestor of @widget
     */
    getNative(): Native | null
    /**
     * Returns the widget’s next sibling.
     *
     * This API is primarily meant for widget implementations.
     * @returns The widget's next sibling
     */
    getNextSibling(): Widget | null
    /**
     * #Fetches the requested opacity for this widget.
     *
     * See [method`Gtk`.Widget.set_opacity].
     * @returns the requested opacity for this widget.
     */
    getOpacity(): number
    /**
     * Returns the widget’s overflow value.
     * @returns The widget's overflow.
     */
    getOverflow(): Overflow
    /**
     * Gets a `PangoContext` with the appropriate font map, font description,
     * and base direction for this widget.
     *
     * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
     * this context is owned by the widget (it can be used until the screen
     * for the widget changes or the widget is removed from its toplevel),
     * and will be updated to match any changes to the widget’s attributes.
     * This can be tracked by listening to changes of the
     * [property`Gtk`.Widget:root] property on the widget.
     * @returns the `PangoContext` for the widget.
     */
    getPangoContext(): Pango.Context
    /**
     * Returns the parent widget of `widget`.
     * @returns the parent widget of @widget
     */
    getParent(): Widget | null
    /**
     * Retrieves the minimum and natural size of a widget, taking
     * into account the widget’s preference for height-for-width management.
     *
     * This is used to retrieve a suitable size by container widgets which do
     * not impose any restrictions on the child placement. It can be used
     * to deduce toplevel window and menu sizes as well as child widgets in
     * free-form containers such as `GtkFixed`.
     *
     * Handle with care. Note that the natural height of a height-for-width
     * widget will generally be a smaller size than the minimum height, since
     * the required height for the natural width is generally smaller than the
     * required height for the minimum width.
     *
     * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
     */
    getPreferredSize(): [
      /* minimumSize */ Requisition,
      /* naturalSize */ Requisition,
    ]
    /**
     * Returns the widget’s previous sibling.
     *
     * This API is primarily meant for widget implementations.
     * @returns The widget's previous sibling
     */
    getPrevSibling(): Widget | null
    /**
     * Gets the primary clipboard of `widget`.
     *
     * This is a utility function to get the primary clipboard object
     * for the `GdkDisplay` that `widget` is using.
     *
     * Note that this function always works, even when `widget` is not
     * realized yet.
     * @returns the appropriate clipboard object
     */
    getPrimaryClipboard(): Gdk.Clipboard
    /**
     * Determines whether `widget` is realized.
     * @returns %TRUE if @widget is realized, %FALSE otherwise
     */
    getRealized(): boolean
    /**
     * Determines whether `widget` is always treated as the default widget
     * within its toplevel when it has the focus, even if another widget
     * is the default.
     *
     * See [method`Gtk`.Widget.set_receives_default].
     * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
     */
    getReceivesDefault(): boolean
    // Has conflict: getRequestMode(): SizeRequestMode
    /**
     * Returns the `GtkRoot` widget of `widget`.
     *
     * This function will return %NULL if the widget is not contained
     * inside a widget tree with a root widget.
     *
     * `GtkRoot` widgets will return themselves here.
     * @returns the root widget of @widget
     */
    getRoot(): Root | null
    /**
     * Retrieves the internal scale factor that maps from window
     * coordinates to the actual device pixels.
     *
     * On traditional systems this is 1, on high density outputs,
     * it can be a higher value (typically 2).
     *
     * See [method`Gdk`.Surface.get_scale_factor].
     * @returns the scale factor for @widget
     */
    getScaleFactor(): number
    /**
     * Returns the widget’s sensitivity.
     *
     * This function returns the value that has been set using
     * [method`Gtk`.Widget.set_sensitive]).
     *
     * The effective sensitivity of a widget is however determined
     * by both its own and its parent widget’s sensitivity.
     * See [method`Gtk`.Widget.is_sensitive].
     * @returns %TRUE if the widget is sensitive
     */
    getSensitive(): boolean
    /**
     * Gets the settings object holding the settings used for this widget.
     *
     * Note that this function can only be called when the `GtkWidget`
     * is attached to a toplevel, since the settings object is specific
     * to a particular `GdkDisplay`. If you want to monitor the widget for
     * changes in its settings, connect to the `notify::display` signal.
     * @returns the relevant `GtkSettings` object
     */
    getSettings(): Settings
    /**
     * Returns the content width or height of the widget.
     *
     * Which dimension is returned depends on `orientation`.
     *
     * This is equivalent to calling [method`Gtk`.Widget.get_width]
     * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
     * for %GTK_ORIENTATION_VERTICAL, but can be used when
     * writing orientation-independent code, such as when
     * implementing [iface`Gtk`.Orientable] widgets.
     *
     * To learn more about widget sizes, see the coordinate
     * system [overview](coordinates.html).
     * @param orientation the orientation to query
     * @returns The size of @widget in @orientation.
     */
    getSize(orientation: Orientation): number
    /**
     * Gets the size request that was explicitly set for the widget using
     * gtk_widget_set_size_request().
     *
     * A value of -1 stored in `width` or `height` indicates that that
     * dimension has not been set explicitly and the natural requisition
     * of the widget will be used instead. See
     * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
     * actually request, call [method`Gtk`.Widget.measure] instead of
     * this function.
     */
    getSizeRequest(): [/* width */ number, /* height */ number]
    /**
     * Returns the widget state as a flag set.
     *
     * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
     * state will be returned, that is, also based on parent insensitivity,
     * even if `widget` itself is sensitive.
     *
     * Also note that if you are looking for a way to obtain the
     * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
     * method, you should look at [method`Gtk`.StyleContext.get_state].
     * @returns The state flags for widget
     */
    getStateFlags(): StateFlags
    /**
     * Returns the style context associated to `widget`.
     *
     * The returned object is guaranteed to be the same
     * for the lifetime of `widget`.
     * @returns the widget’s `GtkStyleContext`
     */
    getStyleContext(): StyleContext
    /**
     * Fetch an object build from the template XML for `widget_type` in
     * this `widget` instance.
     *
     * This will only report children which were previously declared
     * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
     * variants.
     *
     * This function is only meant to be called for code which is private
     * to the `widget_type` which declared the child and is meant for language
     * bindings which cannot easily make use of the GObject structure offsets.
     * @param widgetType The `GType` to get a template child for
     * @param name The “id” of the child defined in the template XML
     * @returns The object built in the template XML with   the id @name
     */
    getTemplateChild(widgetType: GObject.GType, name: string): GObject.Object
    /**
     * Gets the contents of the tooltip for `widget`.
     *
     * If the tooltip has not been set using
     * [method`Gtk`.Widget.set_tooltip_markup], this
     * function returns %NULL.
     * @returns the tooltip text
     */
    getTooltipMarkup(): string | null
    /**
     * Gets the contents of the tooltip for `widget`.
     *
     * If the `widget'`s tooltip was set using
     * [method`Gtk`.Widget.set_tooltip_markup],
     * this function will return the escaped text.
     * @returns the tooltip text
     */
    getTooltipText(): string | null
    /**
     * Gets the vertical alignment of `widget`.
     * @returns the vertical alignment of @widget
     */
    getValign(): Align
    /**
     * Gets whether the widget would like any available extra vertical
     * space.
     *
     * See [method`Gtk`.Widget.get_hexpand] for more detail.
     * @returns whether vexpand flag is set
     */
    getVexpand(): boolean
    /**
     * Gets whether gtk_widget_set_vexpand() has been used to
     * explicitly set the expand flag on this widget.
     *
     * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
     * @returns whether vexpand has been explicitly set
     */
    getVexpandSet(): boolean
    /**
     * Determines whether the widget is visible.
     *
     * If you want to take into account whether the widget’s
     * parent is also marked as visible, use
     * [method`Gtk`.Widget.is_visible] instead.
     *
     * This function does not check if the widget is
     * obscured in any way.
     *
     * See [method`Gtk`.Widget.set_visible].
     * @returns %TRUE if the widget is visible
     */
    getVisible(): boolean
    /**
     * Returns the content width of the widget.
     *
     * This function returns the width passed to its
     * size-allocate implementation, which is the width you
     * should be using in [vfunc`Gtk`.Widget.snapshot].
     *
     * For pointer events, see [method`Gtk`.Widget.contains].
     *
     * To learn more about widget sizes, see the coordinate
     * system [overview](coordinates.html).
     * @returns The width of @widget
     */
    getWidth(): number
    // Has conflict: grabFocus(): boolean
    /**
     * Returns whether `css_class` is currently applied to `widget`.
     * @param cssClass A style class, without the leading '.'   used for notation of style classes
     * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
     */
    hasCssClass(cssClass: string): boolean
    /**
     * Determines if the widget should show a visible indication that
     * it has the global input focus.
     *
     * This is a convenience function that takes into account whether
     * focus indication should currently be shown in the toplevel window
     * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
     * information about focus indication.
     *
     * To find out if the widget has the global input focus, use
     * [method`Gtk`.Widget.has_focus].
     * @returns %TRUE if the widget should display a “focus rectangle”
     */
    hasVisibleFocus(): boolean
    // Has conflict: hide(): void
    /**
     * Returns whether the widget is currently being destroyed.
     *
     * This information can sometimes be used to avoid doing
     * unnecessary work.
     * @returns %TRUE if @widget is being destroyed
     */
    inDestruction(): boolean
    /**
     * Creates and initializes child widgets defined in templates.
     *
     * This function must be called in the instance initializer
     * for any class which assigned itself a template using
     * [method`Gtk`.WidgetClass.set_template].
     *
     * It is important to call this function in the instance initializer
     * of a `GtkWidget` subclass and not in `GObject.constructed()` or
     * `GObject.constructor()` for two reasons:
     *
     *  - derived widgets will assume that the composite widgets
     *    defined by its parent classes have been created in their
     *    relative instance initializers
     *  - when calling `g_object_new()` on a widget with composite templates,
     *    it’s important to build the composite widgets before the construct
     *    properties are set. Properties passed to `g_object_new()` should
     *    take precedence over properties set in the private template XML
     *
     * A good rule of thumb is to call this function as the first thing in
     * an instance initialization function.
     */
    initTemplate(): void
    /**
     * Inserts `group` into `widget`.
     *
     * Children of `widget` that implement [iface`Gtk`.Actionable] can
     * then be associated with actions in `group` by setting their
     * “action-name” to `prefix`.`action-name`.
     *
     * Note that inheritance is defined for individual actions. I.e.
     * even if you insert a group with prefix `prefix,` actions with
     * the same prefix will still be inherited from the parent, unless
     * the group contains an action with the same name.
     *
     * If `group` is %NULL, a previously inserted group for `name` is
     * removed from `widget`.
     * @param name the prefix for actions in `group`
     * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for `name`
     */
    insertActionGroup(name: string, group: Gio.ActionGroup | null): void
    /**
     * Inserts `widget` into the child widget list of `parent`.
     *
     * It will be placed after `previous_sibling,` or at the beginning if
     * `previous_sibling` is %NULL.
     *
     * After calling this function, `gtk_widget_get_prev_sibling(widget)`
     * will return `previous_sibling`.
     *
     * If `parent` is already set as the parent widget of `widget,` this
     * function can also be used to reorder `widget` in the child widget
     * list of `parent`.
     *
     * This API is primarily meant for widget implementations; if you are
     * just using a widget, you *must* use its own API for adding children.
     * @param parent the parent `GtkWidget` to insert `widget` into
     * @param previousSibling the new previous sibling of `widget`
     */
    insertAfter(parent: Widget, previousSibling: Widget | null): void
    /**
     * Inserts `widget` into the child widget list of `parent`.
     *
     * It will be placed before `next_sibling,` or at the end if
     * `next_sibling` is %NULL.
     *
     * After calling this function, `gtk_widget_get_next_sibling(widget)`
     * will return `next_sibling`.
     *
     * If `parent` is already set as the parent widget of `widget,` this function
     * can also be used to reorder `widget` in the child widget list of `parent`.
     *
     * This API is primarily meant for widget implementations; if you are
     * just using a widget, you *must* use its own API for adding children.
     * @param parent the parent `GtkWidget` to insert `widget` into
     * @param nextSibling the new next sibling of `widget`
     */
    insertBefore(parent: Widget, nextSibling: Widget | null): void
    /**
     * Determines whether `widget` is somewhere inside `ancestor,`
     * possibly with intermediate containers.
     * @param ancestor another `GtkWidget`
     * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
     */
    isAncestor(ancestor: Widget): boolean
    /**
     * Determines whether `widget` can be drawn to.
     *
     * A widget can be drawn if it is mapped and visible.
     * @returns %TRUE if @widget is drawable, %FALSE otherwise
     */
    isDrawable(): boolean
    /**
     * Determines if the widget is the focus widget within its
     * toplevel.
     *
     * This does not mean that the [property`Gtk`.Widget:has-focus]
     * property is necessarily set; [property`Gtk`.Widget:has-focus]
     * will only be set if the toplevel widget additionally has the
     * global input focus.
     * @returns %TRUE if the widget is the focus widget.
     */
    isFocus(): boolean
    /**
     * Returns the widget’s effective sensitivity.
     *
     * This means it is sensitive itself and also its
     * parent widget is sensitive.
     * @returns %TRUE if the widget is effectively sensitive
     */
    isSensitive(): boolean
    /**
     * Determines whether the widget and all its parents are marked as
     * visible.
     *
     * This function does not check if the widget is obscured in any way.
     *
     * See also [method`Gtk`.Widget.get_visible] and
     * [method`Gtk`.Widget.set_visible].
     * @returns %TRUE if the widget and all its parents are visible
     */
    isVisible(): boolean
    // Has conflict: keynavFailed(direction: DirectionType): boolean
    /**
     * Returns the widgets for which this widget is the target of a
     * mnemonic.
     *
     * Typically, these widgets will be labels. See, for example,
     * [method`Gtk`.Label.set_mnemonic_widget].
     *
     * The widgets in the list are not individually referenced.
     * If you want to iterate through the list and perform actions
     * involving callbacks that might destroy the widgets, you
     * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
     * first, and then unref all the widgets afterwards.
     * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
     */
    listMnemonicLabels(): Widget[]
    // Has conflict: map(): void
    // Has conflict: measure(orientation: Orientation, forSize: number): [ /* minimum */ number, /* natural */ number, /* minimumBaseline */ number, /* naturalBaseline */ number ]
    // Has conflict: mnemonicActivate(groupCycling: boolean): boolean
    /**
     * Returns a `GListModel` to track the children of `widget`.
     *
     * Calling this function will enable extra internal bookkeeping
     * to track children and emit signals on the returned listmodel.
     * It may slow down operations a lot.
     *
     * Applications should try hard to avoid calling this function
     * because of the slowdowns.
     * @returns a `GListModel` tracking @widget's children
     */
    observeChildren(): Gio.ListModel
    /**
     * Returns a `GListModel` to track the [class`Gtk`.EventController]s
     * of `widget`.
     *
     * Calling this function will enable extra internal bookkeeping
     * to track controllers and emit signals on the returned listmodel.
     * It may slow down operations a lot.
     *
     * Applications should try hard to avoid calling this function
     * because of the slowdowns.
     * @returns a `GListModel` tracking @widget's controllers
     */
    observeControllers(): Gio.ListModel
    /**
     * Finds the descendant of `widget` closest to the point (`x,` `y)`.
     *
     * The point must be given in widget coordinates, so (0, 0) is assumed
     * to be the top left of `widget'`s content area.
     *
     * Usually widgets will return %NULL if the given coordinate is not
     * contained in `widget` checked via [method`Gtk`.Widget.contains].
     * Otherwise they will recursively try to find a child that does
     * not return %NULL. Widgets are however free to customize their
     * picking algorithm.
     *
     * This function is used on the toplevel to determine the widget
     * below the mouse cursor for purposes of hover highlighting and
     * delivering events.
     * @param x X coordinate to test, relative to `widget'`s origin
     * @param y Y coordinate to test, relative to `widget'`s origin
     * @param flags Flags to influence what is picked
     * @returns The widget descendant at   the given point
     */
    pick(x: number, y: number, flags: PickFlags): Widget | null
    /**
     * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
     * function.
     *
     * Use this function instead of [method`Gtk`.Widget.queue_resize]
     * when the `widget'`s size request didn't change but it wants to
     * reposition its contents.
     *
     * An example user of this function is [method`Gtk`.Widget.set_halign].
     *
     * This function is only for use in widget implementations.
     */
    queueAllocate(): void
    /**
     * Schedules this widget to be redrawn in the paint phase
     * of the current or the next frame.
     *
     * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
     * implementation will be called.
     */
    queueDraw(): void
    /**
     * Flags a widget to have its size renegotiated.
     *
     * This should be called when a widget for some reason has a new
     * size request. For example, when you change the text in a
     * [class`Gtk`.Label], the label queues a resize to ensure there’s
     * enough space for the new text.
     *
     * Note that you cannot call gtk_widget_queue_resize() on a widget
     * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
     * virtual method. Calls to gtk_widget_queue_resize() from inside
     * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
     *
     * This function is only for use in widget implementations.
     */
    queueResize(): void
    // Has conflict: realize(): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void
    // Has conflict: removeCssClass(cssClass: string): void
    /**
     * Removes a widget from the list of mnemonic labels for this widget.
     *
     * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
     * have previously been added to the list with
     * [method`Gtk`.Widget.add_mnemonic_label].
     * @param label a `GtkWidget` that was previously set as a mnemonic   label for `widget` with [method`Gtk`.Widget.add_mnemonic_label]
     */
    removeMnemonicLabel(label: Widget): void
    /**
     * Removes a tick callback previously registered with
     * gtk_widget_add_tick_callback().
     * @param id an id returned by [method`Gtk`.Widget.add_tick_callback]
     */
    removeTickCallback(id: number): void
    /**
     * Specifies whether the input focus can enter the widget
     * or any of its children.
     *
     * Applications should set `can_focus` to %FALSE to mark a
     * widget as for pointer/touch use only.
     *
     * Note that having `can_focus` be %TRUE is only one of the
     * necessary conditions for being focusable. A widget must
     * also be sensitive and focusable and not have an ancestor
     * that is marked as not can-focus in order to receive input
     * focus.
     *
     * See [method`Gtk`.Widget.grab_focus] for actually setting
     * the input focus on a widget.
     * @param canFocus whether or not the input focus can enter   the widget or any of its children
     */
    setCanFocus(canFocus: boolean): void
    /**
     * Sets whether `widget` can be the target of pointer events.
     * @param canTarget whether this widget should be able to   receive pointer events
     */
    setCanTarget(canTarget: boolean): void
    /**
     * Sets whether `widget` should be mapped along with its parent.
     *
     * The child visibility can be set for widget before it is added
     * to a container with [method`Gtk`.Widget.set_parent], to avoid
     * mapping children unnecessary before immediately unmapping them.
     * However it will be reset to its default state of %TRUE when the
     * widget is removed from a container.
     *
     * Note that changing the child visibility of a widget does not
     * queue a resize on the widget. Most of the time, the size of
     * a widget is computed from all visible children, whether or
     * not they are mapped. If this is not the case, the container
     * can queue a resize itself.
     *
     * This function is only useful for container implementations
     * and should never be called by an application.
     * @param childVisible if %TRUE, `widget` should be mapped along   with its parent.
     */
    setChildVisible(childVisible: boolean): void
    /**
     * Clear all style classes applied to `widget`
     * and replace them with `classes`.
     * @param classes %NULL-terminated list of style classes to apply to `widget`.
     */
    setCssClasses(classes: string[]): void
    /**
     * Sets the cursor to be shown when pointer devices point
     * towards `widget`.
     *
     * If the `cursor` is NULL, `widget` will use the cursor
     * inherited from the parent widget.
     * @param cursor the new cursor
     */
    setCursor(cursor: Gdk.Cursor | null): void
    /**
     * Sets a named cursor to be shown when pointer devices point
     * towards `widget`.
     *
     * This is a utility function that creates a cursor via
     * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
     * with [method`Gtk`.Widget.set_cursor]. See those functions for
     * details.
     *
     * On top of that, this function allows `name` to be %NULL, which
     * will do the same as calling [method`Gtk`.Widget.set_cursor]
     * with a %NULL cursor.
     * @param name The name of the cursor
     */
    setCursorFromName(name: string | null): void
    /**
     * Sets the reading direction on a particular widget.
     *
     * This direction controls the primary direction for widgets
     * containing text, and also the direction in which the children
     * of a container are packed. The ability to set the direction is
     * present in order so that correct localization into languages with
     * right-to-left reading directions can be done. Generally, applications
     * will let the default reading direction present, except for containers
     * where the containers are arranged in an order that is explicitly
     * visual rather than logical (such as buttons for text justification).
     *
     * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
     * set by [func`Gtk`.Widget.set_default_direction] will be used.
     * @param dir the new direction
     */
    setDirection(dir: TextDirection): void
    // Has conflict: setFocusChild(child: Widget | null): void
    /**
     * Sets whether the widget should grab focus when it is clicked
     * with the mouse.
     *
     * Making mouse clicks not grab focus is useful in places like
     * toolbars where you don’t want the keyboard focus removed from
     * the main area of the application.
     * @param focusOnClick whether the widget should grab focus when clicked   with the mouse
     */
    setFocusOnClick(focusOnClick: boolean): void
    /**
     * Specifies whether `widget` can own the input focus.
     *
     * Widget implementations should set `focusable` to %TRUE in
     * their init() function if they want to receive keyboard input.
     *
     * Note that having `focusable` be %TRUE is only one of the
     * necessary conditions for being focusable. A widget must
     * also be sensitive and can-focus and not have an ancestor
     * that is marked as not can-focus in order to receive input
     * focus.
     *
     * See [method`Gtk`.Widget.grab_focus] for actually setting
     * the input focus on a widget.
     * @param focusable whether or not `widget` can own the input focus
     */
    setFocusable(focusable: boolean): void
    /**
     * Sets the font map to use for Pango rendering.
     *
     * The font map is the object that is used to look up fonts.
     * Setting a custom font map can be useful in special situations,
     * e.g. when you need to add application-specific fonts to the set
     * of available fonts.
     *
     * When not set, the widget will inherit the font map from its parent.
     * @param fontMap a `PangoFontMap`, or %NULL to unset any   previously set font map
     */
    setFontMap(fontMap: Pango.FontMap | null): void
    /**
     * Sets the `cairo_font_options_t` used for Pango rendering
     * in this widget.
     *
     * When not set, the default font options for the `GdkDisplay`
     * will be used.
     * @param options a `cairo_font_options_t`   to unset any previously set default font options
     */
    setFontOptions(options: cairo.FontOptions | null): void
    /**
     * Sets the horizontal alignment of `widget`.
     * @param align the horizontal alignment
     */
    setHalign(align: Align): void
    /**
     * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
     * @param hasTooltip whether or not `widget` has a tooltip.
     */
    setHasTooltip(hasTooltip: boolean): void
    /**
     * Sets whether the widget would like any available extra horizontal
     * space.
     *
     * When a user resizes a `GtkWindow`, widgets with expand=TRUE
     * generally receive the extra space. For example, a list or
     * scrollable area or document in your window would often be set to
     * expand.
     *
     * Call this function to set the expand flag if you would like your
     * widget to become larger horizontally when the window has extra
     * room.
     *
     * By default, widgets automatically expand if any of their children
     * want to expand. (To see if a widget will automatically expand given
     * its current children and state, call [method`Gtk`.Widget.compute_expand].
     * A container can decide how the expandability of children affects the
     * expansion of the container by overriding the compute_expand virtual
     * method on `GtkWidget`.).
     *
     * Setting hexpand explicitly with this function will override the
     * automatic expand behavior.
     *
     * This function forces the widget to expand or not to expand,
     * regardless of children.  The override occurs because
     * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
     * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
     * value to be used, rather than looking at children and widget state.
     * @param expand whether to expand
     */
    setHexpand(expand: boolean): void
    /**
     * Sets whether the hexpand flag will be used.
     *
     * The [property`Gtk`.Widget:hexpand-set] property will be set
     * automatically when you call [method`Gtk`.Widget.set_hexpand]
     * to set hexpand, so the most likely reason to use this function
     * would be to unset an explicit expand flag.
     *
     * If hexpand is set, then it overrides any computed
     * expand value based on child widgets. If hexpand is not
     * set, then the expand value depends on whether any
     * children of the widget would like to expand.
     *
     * There are few reasons to use this function, but it’s here
     * for completeness and consistency.
     * @param set value for hexpand-set property
     */
    setHexpandSet(set: boolean): void
    /**
     * Sets the layout manager delegate instance that provides an
     * implementation for measuring and allocating the children of `widget`.
     * @param layoutManager a `GtkLayoutManager`
     */
    setLayoutManager(layoutManager: LayoutManager | null): void
    /**
     * Sets the bottom margin of `widget`.
     * @param margin the bottom margin
     */
    setMarginBottom(margin: number): void
    /**
     * Sets the end margin of `widget`.
     * @param margin the end margin
     */
    setMarginEnd(margin: number): void
    /**
     * Sets the start margin of `widget`.
     * @param margin the start margin
     */
    setMarginStart(margin: number): void
    /**
     * Sets the top margin of `widget`.
     * @param margin the top margin
     */
    setMarginTop(margin: number): void
    /**
     * Sets a widgets name.
     *
     * Setting a name allows you to refer to the widget from a
     * CSS file. You can apply a style to widgets with a particular name
     * in the CSS file. See the documentation for the CSS syntax (on the
     * same page as the docs for [class`Gtk`.StyleContext].
     *
     * Note that the CSS syntax has certain special characters to delimit
     * and represent elements in a selector (period, #, >, *...), so using
     * these will make your widget impossible to match by name. Any combination
     * of alphanumeric symbols, dashes and underscores will suffice.
     * @param name name for the widget
     */
    setName(name: string): void
    /**
     * Request the `widget` to be rendered partially transparent.
     *
     * An opacity of 0 is fully transparent and an opacity of 1
     * is fully opaque.
     *
     * Opacity works on both toplevel widgets and child widgets, although
     * there are some limitations: For toplevel widgets, applying opacity
     * depends on the capabilities of the windowing system. On X11, this
     * has any effect only on X displays with a compositing manager,
     * see gdk_display_is_composited(). On Windows and Wayland it should
     * always work, although setting a window’s opacity after the window
     * has been shown may cause some flicker.
     *
     * Note that the opacity is inherited through inclusion — if you set
     * a toplevel to be partially translucent, all of its content will
     * appear translucent, since it is ultimatively rendered on that
     * toplevel. The opacity value itself is not inherited by child
     * widgets (since that would make widgets deeper in the hierarchy
     * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
     * and other [iface`Gtk`.Native] widgets with their own surface will use their
     * own opacity value, and thus by default appear non-translucent,
     * even if they are attached to a toplevel that is translucent.
     * @param opacity desired opacity, between 0 and 1
     */
    setOpacity(opacity: number): void
    /**
     * Sets how `widget` treats content that is drawn outside the
     * widget's content area.
     *
     * See the definition of [enum`Gtk`.Overflow] for details.
     *
     * This setting is provided for widget implementations and
     * should not be used by application code.
     *
     * The default value is %GTK_OVERFLOW_VISIBLE.
     * @param overflow desired overflow
     */
    setOverflow(overflow: Overflow): void
    /**
     * Sets `parent` as the parent widget of `widget`.
     *
     * This takes care of details such as updating the state and style
     * of the child to reflect its new location and resizing the parent.
     * The opposite function is [method`Gtk`.Widget.unparent].
     *
     * This function is useful only when implementing subclasses of
     * `GtkWidget`.
     * @param parent parent widget
     */
    setParent(parent: Widget): void
    /**
     * Specifies whether `widget` will be treated as the default
     * widget within its toplevel when it has the focus, even if
     * another widget is the default.
     * @param receivesDefault whether or not `widget` can be a default widget.
     */
    setReceivesDefault(receivesDefault: boolean): void
    /**
     * Sets the sensitivity of a widget.
     *
     * A widget is sensitive if the user can interact with it.
     * Insensitive widgets are “grayed out” and the user can’t
     * interact with them. Insensitive widgets are known as
     * “inactive”, “disabled”, or “ghosted” in some other toolkits.
     * @param sensitive %TRUE to make the widget sensitive
     */
    setSensitive(sensitive: boolean): void
    /**
     * Sets the minimum size of a widget.
     *
     * That is, the widget’s size request will be at least `width`
     * by `height`. You can use this function to force a widget to
     * be larger than it normally would be.
     *
     * In most cases, [method`Gtk`.Window.set_default_size] is a better
     * choice for toplevel windows than this function; setting the default
     * size will still allow users to shrink the window. Setting the size
     * request will force them to leave the window at least as large as
     * the size request.
     *
     * Note the inherent danger of setting any fixed size - themes,
     * translations into other languages, different fonts, and user action
     * can all change the appropriate size for a given widget. So, it's
     * basically impossible to hardcode a size that will always be
     * correct.
     *
     * The size request of a widget is the smallest size a widget can
     * accept while still functioning well and drawing itself correctly.
     * However in some strange cases a widget may be allocated less than
     * its requested size, and in many cases a widget may be allocated more
     * space than it requested.
     *
     * If the size request in a given direction is -1 (unset), then
     * the “natural” size request of the widget will be used instead.
     *
     * The size request set here does not include any margin from the
     * properties
     * [property`Gtk`.Widget:margin-start],
     * [property`Gtk`.Widget:margin-end],
     * [property`Gtk`.Widget:margin-top], and
     * [property`Gtk`.Widget:margin-bottom], but it does include pretty
     * much all other padding or border properties set by any subclass
     * of `GtkWidget`.
     * @param width width `widget` should request, or -1 to unset
     * @param height height `widget` should request, or -1 to unset
     */
    setSizeRequest(width: number, height: number): void
    /**
     * Turns on flag values in the current widget state.
     *
     * Typical widget states are insensitive, prelighted, etc.
     *
     * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
     * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
     * the widget's direction, use [method`Gtk`.Widget.set_direction].
     *
     * This function is for use in widget implementations.
     * @param flags State flags to turn on
     * @param clear Whether to clear state before turning on `flags`
     */
    setStateFlags(flags: StateFlags, clear: boolean): void
    /**
     * Sets `markup` as the contents of the tooltip, which is marked
     * up with Pango markup.
     *
     * This function will take care of setting the
     * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
     * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
     *
     * See also [method`Gtk`.Tooltip.set_markup].
     * @param markup the contents of the tooltip for `widget`
     */
    setTooltipMarkup(markup: string | null): void
    /**
     * Sets `text` as the contents of the tooltip.
     *
     * If `text` contains any markup, it will be escaped.
     *
     * This function will take care of setting
     * [property`Gtk`.Widget:has-tooltip] as a side effect,
     * and of the default handler for the
     * [signal`Gtk`.Widget::query-tooltip] signal.
     *
     * See also [method`Gtk`.Tooltip.set_text].
     * @param text the contents of the tooltip for `widget`
     */
    setTooltipText(text: string | null): void
    /**
     * Sets the vertical alignment of `widget`.
     * @param align the vertical alignment
     */
    setValign(align: Align): void
    /**
     * Sets whether the widget would like any available extra vertical
     * space.
     *
     * See [method`Gtk`.Widget.set_hexpand] for more detail.
     * @param expand whether to expand
     */
    setVexpand(expand: boolean): void
    /**
     * Sets whether the vexpand flag will be used.
     *
     * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
     * @param set value for vexpand-set property
     */
    setVexpandSet(set: boolean): void
    /**
     * Sets the visibility state of `widget`.
     *
     * Note that setting this to %TRUE doesn’t mean the widget is
     * actually viewable, see [method`Gtk`.Widget.get_visible].
     * @param visible whether the widget should be shown or not
     */
    setVisible(visible: boolean): void
    /**
     * Returns whether `widget` should contribute to
     * the measuring and allocation of its parent.
     *
     * This is %FALSE for invisible children, but also
     * for children that have their own surface.
     * @returns %TRUE if child should be included in   measuring and allocating
     */
    shouldLayout(): boolean
    // Has conflict: show(): void
    // Has conflict: sizeAllocate(allocation: Allocation, baseline: number): void
    /**
     * Snapshot the a child of `widget`.
     *
     * When a widget receives a call to the snapshot function,
     * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
     * to all children. This function provides a convenient way
     * of doing this. A widget, when it receives a call to its
     * [vfunc`Gtk`.Widget.snapshot] function, calls
     * gtk_widget_snapshot_child() once for each child, passing in
     * the `snapshot` the widget received.
     *
     * gtk_widget_snapshot_child() takes care of translating the origin of
     * `snapshot,` and deciding whether the child needs to be snapshot.
     *
     * This function does nothing for children that implement `GtkNative`.
     * @param child a child of `widget`
     * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
     */
    snapshotChild(child: Widget, snapshot: Snapshot): void
    /**
     * Translate coordinates relative to `src_widget’`s allocation
     * to coordinates relative to `dest_widget’`s allocations.
     *
     * In order to perform this operation, both widget must share
     * a common ancestor.
     * @param destWidget a `GtkWidget`
     * @param srcX X position relative to `src_widget`
     * @param srcY Y position relative to `src_widget`
     * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
     */
    translateCoordinates(
      destWidget: Widget,
      srcX: number,
      srcY: number
    ): [/* returnType */ boolean, /* destX */ number, /* destY */ number]
    /**
     * Triggers a tooltip query on the display where the toplevel
     * of `widget` is located.
     */
    triggerTooltipQuery(): void
    // Has conflict: unmap(): void
    /**
     * Dissociate `widget` from its parent.
     *
     * This function is only for use in widget implementations,
     * typically in dispose.
     */
    unparent(): void
    // Has conflict: unrealize(): void
    /**
     * Turns off flag values for the current widget state.
     *
     * See [method`Gtk`.Widget.set_state_flags].
     *
     * This function is for use in widget implementations.
     * @param flags State flags to turn off
     */
    unsetStateFlags(flags: StateFlags): void
    /**
     * Adds a style class to `widget`.
     *
     * After calling this function, the widget’s style will match
     * for `css_class,` according to CSS matching rules.
     *
     * Use [method`Gtk`.Widget.remove_css_class] to remove the
     * style again.
     * @param cssClass The style class to add to `widget,` without   the leading '.' used for notation of style classes
     */
    addCssClass(classNames: string[]): void
    /**
     * Removes a style from `widget`.
     *
     * After this, the style of `widget` will stop matching for `css_class`.
     * @param cssClass The style class to remove from `widget,` without   the leading '.' used for notation of style classes
     */
    removeCssClass(classNames: string[]): void

    // Own virtual methods of Gtk-4.0.Gtk.Widget

    /**
     * Computes whether a container should give this
     *   widget extra space when possible.
     * @virtual
     * @param hexpandP
     * @param vexpandP
     */
    computeExpand(hexpandP: boolean, vexpandP: boolean): void
    /**
     * Tests if the point at (`x,` `y)` is contained in `widget`.
     *
     * The coordinates for (`x,` `y)` must be in widget coordinates, so
     * (0, 0) is assumed to be the top left of `widget'`s content area.
     * @virtual
     * @param x X coordinate to test, relative to `widget'`s origin
     * @param y Y coordinate to test, relative to `widget'`s origin
     * @returns %TRUE if @widget contains (@x, @y).
     */
    contains(x: number, y: number): boolean
    /**
     * Vfunc called when the CSS used by widget was changed. Widgets
     *   should then discard their caches that depend on CSS and queue resizes or
     *   redraws accordingly. The default implementation will take care of this for
     *   all the default CSS properties, so implementations must chain up.
     * @virtual
     * @param change
     */
    cssChanged(change: CssStyleChange): void
    /**
     * Signal emitted when the text direction of a
     *   widget changes.
     * @virtual
     * @param previousDirection
     */
    directionChanged(previousDirection: TextDirection): void
    /**
     * Vfunc for gtk_widget_child_focus()
     * @virtual
     * @param direction
     */
    focus(direction: DirectionType): boolean
    /**
     * Gets whether the widget prefers a height-for-width layout
     * or a width-for-height layout.
     *
     * Single-child widgets generally propagate the preference of
     * their child, more complex widgets need to request something
     * either in context of their children or in context of their
     * allocation capabilities.
     * @virtual
     * @returns The `GtkSizeRequestMode` preferred by @widget.
     */
    getRequestMode(): SizeRequestMode
    /**
     * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
     *
     * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
     * implementation cannot transfer the focus to a descendant of `widget`
     * that is focusable, it will not take focus and %FALSE will be returned.
     *
     * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
     * is allowed, should not have an effect, and return %TRUE.
     * @virtual
     * @returns %TRUE if focus is now inside @widget.
     */
    grabFocus(): boolean
    /**
     * Reverses the effects of gtk_widget_show().
     *
     * This is causing the widget to be hidden (invisible to the user).
     * @virtual
     */
    hide(): void
    /**
     * Emits the `::keynav-failed` signal on the widget.
     *
     * This function should be called whenever keyboard navigation
     * within a single widget hits a boundary.
     *
     * The return value of this function should be interpreted
     * in a way similar to the return value of
     * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
     * stay in the widget, the failed keyboard  navigation is OK
     * and/or there is nowhere we can/should move the focus to.
     * When %FALSE is returned, the caller should continue with
     * keyboard navigation outside the widget, e.g. by calling
     * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
     *
     * The default [signal`Gtk`.Widget::keynav-failed] handler returns
     * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
     * For the other values of `GtkDirectionType` it returns %TRUE.
     *
     * Whenever the default handler returns %TRUE, it also calls
     * [method`Gtk`.Widget.error_bell] to notify the user of the
     * failed keyboard navigation.
     *
     * A use case for providing an own implementation of ::keynav-failed
     * (either by connecting to it or by overriding it) would be a row of
     * [class`Gtk`.Entry] widgets where the user should be able to navigate
     * the entire row with the cursor keys, as e.g. known from user
     * interfaces that require entering license keys.
     * @virtual
     * @param direction direction of focus movement
     * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
     */
    keynavFailed(direction: DirectionType): boolean
    /**
     * Causes a widget to be mapped if it isn’t already.
     *
     * This function is only for use in widget implementations.
     * @virtual
     */
    map(): void
    /**
     * Measures `widget` in the orientation `orientation` and for the given `for_size`.
     *
     * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
     * is 300, this functions will compute the minimum and natural width of `widget`
     * if it is allocated at a height of 300 pixels.
     *
     * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
     * a more details on implementing `GtkWidgetClass.measure()`.
     * @virtual
     * @param orientation the orientation to measure
     * @param forSize Size for the opposite of `orientation,` i.e.   if `orientation` is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
     */
    measure(
      orientation: Orientation,
      forSize: number
    ): [
      /* minimum */ number,
      /* natural */ number,
      /* minimumBaseline */ number,
      /* naturalBaseline */ number,
    ]
    /**
     * Emits the ::mnemonic-activate signal.
     *
     * See [signal`Gtk`.Widget::mnemonic-activate].
     * @virtual
     * @param groupCycling %TRUE if there are other widgets with the same mnemonic
     * @returns %TRUE if the signal has been handled
     */
    mnemonicActivate(groupCycling: boolean): boolean
    /**
     * Signal emitted when a change of focus is requested
     * @virtual
     * @param direction
     */
    moveFocus(direction: DirectionType): void
    /**
     * Signal emitted when “has-tooltip” is %TRUE and the
     *   hover timeout has expired with the cursor hovering “above”
     *   widget; or emitted when widget got focus in keyboard mode.
     * @virtual
     * @param x
     * @param y
     * @param keyboardTooltip
     * @param tooltip
     */
    queryTooltip(
      x: number,
      y: number,
      keyboardTooltip: boolean,
      tooltip: Tooltip
    ): boolean
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Called when the widget gets added to a `GtkRoot` widget. Must
     *   chain up
     * @virtual
     */
    root(): void
    /**
     * Set `child` as the current focus child of `widget`.
     *
     * This function is only suitable for widget implementations.
     * If you want a certain widget to get the input focus, call
     * [method`Gtk`.Widget.grab_focus] on it.
     * @virtual
     * @param child a direct child widget of `widget` or %NULL   to unset the focus child of `widget`
     */
    setFocusChild(child: Widget | null): void
    /**
     * Flags a widget to be displayed.
     *
     * Any widget that isn’t shown will not appear on the screen.
     *
     * Remember that you have to show the containers containing a widget,
     * in addition to the widget itself, before it will appear onscreen.
     *
     * When a toplevel container is shown, it is immediately realized and
     * mapped; other shown widgets are realized and mapped when their
     * toplevel container is realized and mapped.
     * @virtual
     */
    show(): void
    /**
     * Called to set the allocation, if the widget does
     *   not have a layout manager.
     * @virtual
     * @param width
     * @param height
     * @param baseline
     */
    sizeAllocate(width: number, height: number, baseline: number): void
    /**
     * Vfunc called when a new snapshot of the widget has to be taken.
     * @virtual
     * @param snapshot
     */
    snapshot(snapshot: Snapshot): void
    /**
     * Signal emitted when the widget state changes,
     *   see gtk_widget_get_state_flags().
     * @virtual
     * @param previousStateFlags
     */
    stateFlagsChanged(previousStateFlags: StateFlags): void
    /**
     * Emitted when a system setting was changed. Must chain up.
     * @virtual
     * @param settings
     */
    systemSettingChanged(settings: SystemSetting): void
    /**
     * Causes a widget to be unmapped if it’s currently mapped.
     *
     * This function is only for use in widget implementations.
     * @virtual
     */
    unmap(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Called when the widget is about to be removed from its
     *   `GtkRoot` widget. Must chain up
     * @virtual
     */
    unroot(): void

    // Own signals of Gtk-4.0.Gtk.Widget

    connect(sigName: "destroy", callback: Widget.DestroySignalCallback): number
    on(
      sigName: "destroy",
      callback: Widget.DestroySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "destroy",
      callback: Widget.DestroySignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "destroy",
      callback: Widget.DestroySignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "destroy", ...args: any[]): void
    connect(
      sigName: "direction-changed",
      callback: Widget.DirectionChangedSignalCallback
    ): number
    on(
      sigName: "direction-changed",
      callback: Widget.DirectionChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "direction-changed",
      callback: Widget.DirectionChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "direction-changed",
      callback: Widget.DirectionChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "direction-changed", ...args: any[]): void
    connect(sigName: "hide", callback: Widget.HideSignalCallback): number
    on(
      sigName: "hide",
      callback: Widget.HideSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "hide",
      callback: Widget.HideSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "hide",
      callback: Widget.HideSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "hide", ...args: any[]): void
    connect(
      sigName: "keynav-failed",
      callback: Widget.KeynavFailedSignalCallback
    ): number
    on(
      sigName: "keynav-failed",
      callback: Widget.KeynavFailedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "keynav-failed",
      callback: Widget.KeynavFailedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "keynav-failed",
      callback: Widget.KeynavFailedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "keynav-failed", ...args: any[]): void
    connect(sigName: "map", callback: Widget.MapSignalCallback): number
    on(
      sigName: "map",
      callback: Widget.MapSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "map",
      callback: Widget.MapSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(sigName: "map", callback: Widget.MapSignalCallback): NodeJS.EventEmitter
    emit(sigName: "map", ...args: any[]): void
    connect(
      sigName: "mnemonic-activate",
      callback: Widget.MnemonicActivateSignalCallback
    ): number
    on(
      sigName: "mnemonic-activate",
      callback: Widget.MnemonicActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "mnemonic-activate",
      callback: Widget.MnemonicActivateSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "mnemonic-activate",
      callback: Widget.MnemonicActivateSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "mnemonic-activate", ...args: any[]): void
    connect(
      sigName: "move-focus",
      callback: Widget.MoveFocusSignalCallback
    ): number
    on(
      sigName: "move-focus",
      callback: Widget.MoveFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "move-focus",
      callback: Widget.MoveFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "move-focus",
      callback: Widget.MoveFocusSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "move-focus", ...args: any[]): void
    connect(
      sigName: "query-tooltip",
      callback: Widget.QueryTooltipSignalCallback
    ): number
    on(
      sigName: "query-tooltip",
      callback: Widget.QueryTooltipSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "query-tooltip",
      callback: Widget.QueryTooltipSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "query-tooltip",
      callback: Widget.QueryTooltipSignalCallback
    ): NodeJS.EventEmitter
    emit(
      sigName: "query-tooltip",
      y: number,
      keyboardMode: boolean,
      tooltip: Tooltip,
      ...args: any[]
    ): void
    connect(sigName: "realize", callback: Widget.RealizeSignalCallback): number
    on(
      sigName: "realize",
      callback: Widget.RealizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "realize",
      callback: Widget.RealizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "realize",
      callback: Widget.RealizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "realize", ...args: any[]): void
    connect(sigName: "show", callback: Widget.ShowSignalCallback): number
    on(
      sigName: "show",
      callback: Widget.ShowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "show",
      callback: Widget.ShowSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "show",
      callback: Widget.ShowSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "show", ...args: any[]): void
    connect(
      sigName: "state-flags-changed",
      callback: Widget.StateFlagsChangedSignalCallback
    ): number
    on(
      sigName: "state-flags-changed",
      callback: Widget.StateFlagsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "state-flags-changed",
      callback: Widget.StateFlagsChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "state-flags-changed",
      callback: Widget.StateFlagsChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "state-flags-changed", ...args: any[]): void
    connect(sigName: "unmap", callback: Widget.UnmapSignalCallback): number
    on(
      sigName: "unmap",
      callback: Widget.UnmapSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unmap",
      callback: Widget.UnmapSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unmap",
      callback: Widget.UnmapSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unmap", ...args: any[]): void
    connect(
      sigName: "unrealize",
      callback: Widget.UnrealizeSignalCallback
    ): number
    on(
      sigName: "unrealize",
      callback: Widget.UnrealizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "unrealize",
      callback: Widget.UnrealizeSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "unrealize",
      callback: Widget.UnrealizeSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "unrealize", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Widget

    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * The base class for all widgets.
   *
   * `GtkWidget` is the base class all widgets in GTK derive from. It manages the
   * widget lifecycle, layout, states and style.
   *
   * ### Height-for-width Geometry Management
   *
   * GTK uses a height-for-width (and width-for-height) geometry management
   * system. Height-for-width means that a widget can change how much
   * vertical space it needs, depending on the amount of horizontal space
   * that it is given (and similar for width-for-height). The most common
   * example is a label that reflows to fill up the available width, wraps
   * to fewer lines, and therefore needs less height.
   *
   * Height-for-width geometry management is implemented in GTK by way
   * of two virtual methods:
   *
   * - [vfunc`Gtk`.Widget.get_request_mode]
   * - [vfunc`Gtk`.Widget.measure]
   *
   * There are some important things to keep in mind when implementing
   * height-for-width and when using it in widget implementations.
   *
   * If you implement a direct `GtkWidget` subclass that supports
   * height-for-width or width-for-height geometry management for itself
   * or its child widgets, the [vfunc`Gtk`.Widget.get_request_mode] virtual
   * function must be implemented as well and return the widget's preferred
   * request mode. The default implementation of this virtual function
   * returns %GTK_SIZE_REQUEST_CONSTANT_SIZE, which means that the widget will
   * only ever get -1 passed as the for_size value to its
   * [vfunc`Gtk`.Widget.measure] implementation.
   *
   * The geometry management system will query a widget hierarchy in
   * only one orientation at a time. When widgets are initially queried
   * for their minimum sizes it is generally done in two initial passes
   * in the [enum`Gtk`.SizeRequestMode] chosen by the toplevel.
   *
   * For example, when queried in the normal %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode:
   *
   * First, the default minimum and natural width for each widget
   * in the interface will be computed using [method`Gtk`.Widget.measure] with an
   * orientation of %GTK_ORIENTATION_HORIZONTAL and a for_size of -1.
   * Because the preferred widths for each widget depend on the preferred
   * widths of their children, this information propagates up the hierarchy,
   * and finally a minimum and natural width is determined for the entire
   * toplevel. Next, the toplevel will use the minimum width to query for the
   * minimum height contextual to that width using [method`Gtk`.Widget.measure] with an
   * orientation of %GTK_ORIENTATION_VERTICAL and a for_size of the just computed
   * width. This will also be a highly recursive operation. The minimum height
   * for the minimum width is normally used to set the minimum size constraint
   * on the toplevel.
   *
   * After the toplevel window has initially requested its size in both
   * dimensions it can go on to allocate itself a reasonable size (or a size
   * previously specified with [method`Gtk`.Window.set_default_size]). During the
   * recursive allocation process it’s important to note that request cycles
   * will be recursively executed while widgets allocate their children.
   * Each widget, once allocated a size, will go on to first share the
   * space in one orientation among its children and then request each child's
   * height for its target allocated width or its width for allocated height,
   * depending. In this way a `GtkWidget` will typically be requested its size
   * a number of times before actually being allocated a size. The size a
   * widget is finally allocated can of course differ from the size it has
   * requested. For this reason, `GtkWidget` caches a  small number of results
   * to avoid re-querying for the same sizes in one allocation cycle.
   *
   * If a widget does move content around to intelligently use up the
   * allocated size then it must support the request in both
   * `GtkSizeRequestMode`s even if the widget in question only
   * trades sizes in a single orientation.
   *
   * For instance, a [class`Gtk`.Label] that does height-for-width word wrapping
   * will not expect to have [vfunc`Gtk`.Widget.measure] with an orientation of
   * %GTK_ORIENTATION_VERTICAL called because that call is specific to a
   * width-for-height request. In this case the label must return the height
   * required for its own minimum possible width. By following this rule any
   * widget that handles height-for-width or width-for-height requests will
   * always be allocated at least enough space to fit its own content.
   *
   * Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget
   * generally deals with width-for-height requests:
   *
   * ```c
   * static void
   * foo_widget_measure (GtkWidget      *widget,
   *                     GtkOrientation  orientation,
   *                     int             for_size,
   *                     int            *minimum_size,
   *                     int            *natural_size,
   *                     int            *minimum_baseline,
   *                     int            *natural_baseline)
   * {
   *   if (orientation == GTK_ORIENTATION_HORIZONTAL)
   *     {
   *       // Calculate minimum and natural width
   *     }
   *   else // VERTICAL
   *     {
   *       if (i_am_in_height_for_width_mode)
   *         {
   *           int min_width, dummy;
   *
   *           // First, get the minimum width of our widget
   *           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
   *                                                   &min_width, &dummy, &dummy, &dummy);
   *
   *           // Now use the minimum width to retrieve the minimum and natural height to display
   *           // that width.
   *           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
   *                                                   minimum_size, natural_size, &dummy, &dummy);
   *         }
   *       else
   *         {
   *           // ... some widgets do both.
   *         }
   *     }
   * }
   * ```
   *
   * Often a widget needs to get its own request during size request or
   * allocation. For example, when computing height it may need to also
   * compute width. Or when deciding how to use an allocation, the widget
   * may need to know its natural size. In these cases, the widget should
   * be careful to call its virtual methods directly, like in the code
   * example above.
   *
   * It will not work to use the wrapper function [method`Gtk`.Widget.measure]
   * inside your own [vfunc`Gtk`.Widget.size_allocate] implementation.
   * These return a request adjusted by [class`Gtk`.SizeGroup], the widget's
   * align and expand flags, as well as its CSS style.
   *
   * If a widget used the wrappers inside its virtual method implementations,
   * then the adjustments (such as widget margins) would be applied
   * twice. GTK therefore does not allow this and will warn if you try
   * to do it.
   *
   * Of course if you are getting the size request for another widget, such
   * as a child widget, you must use [method`Gtk`.Widget.measure]; otherwise, you
   * would not properly consider widget margins, [class`Gtk`.SizeGroup], and
   * so forth.
   *
   * GTK also supports baseline vertical alignment of widgets. This
   * means that widgets are positioned such that the typographical baseline of
   * widgets in the same row are aligned. This happens if a widget supports
   * baselines, has a vertical alignment using baselines, and is inside
   * a widget that supports baselines and has a natural “row” that it aligns to
   * the baseline, or a baseline assigned to it by the grandparent.
   *
   * Baseline alignment support for a widget is also done by the
   * [vfunc`Gtk`.Widget.measure] virtual function. It allows you to report
   * both a minimum and natural size.
   *
   * If a widget ends up baseline aligned it will be allocated all the space in
   * the parent as if it was %GTK_ALIGN_FILL, but the selected baseline can be
   * found via [method`Gtk`.Widget.get_baseline]. If the baseline has a
   * value other than -1 you need to align the widget such that the baseline
   * appears at the position.
   *
   * ### GtkWidget as GtkBuildable
   *
   * The `GtkWidget` implementation of the `GtkBuildable` interface
   * supports various custom elements to specify additional aspects of widgets
   * that are not directly expressed as properties.
   *
   * If the widget uses a [class`Gtk`.LayoutManager], `GtkWidget` supports
   * a custom `<layout>` element, used to define layout properties:
   *
   * ```xml
   * <object class="GtkGrid" id="my_grid">
   *   <child>
   *     <object class="GtkLabel" id="label1">
   *       <property name="label">Description</property>
   *       <layout>
   *         <property name="column">0</property>
   *         <property name="row">0</property>
   *         <property name="row-span">1</property>
   *         <property name="column-span">1</property>
   *       </layout>
   *     </object>
   *   </child>
   *   <child>
   *     <object class="GtkEntry" id="description_entry">
   *       <layout>
   *         <property name="column">1</property>
   *         <property name="row">0</property>
   *         <property name="row-span">1</property>
   *         <property name="column-span">1</property>
   *       </layout>
   *     </object>
   *   </child>
   * </object>
   * ```
   *
   * `GtkWidget` allows style information such as style classes to
   * be associated with widgets, using the custom `<style>` element:
   *
   * ```xml
   * <object class="GtkButton" id="button1">
   *   <style>
   *     <class name="my-special-button-class"/>
   *     <class name="dark-button"/>
   *   </style>
   * </object>
   * ```
   *
   * `GtkWidget` allows defining accessibility information, such as properties,
   * relations, and states, using the custom `<accessibility>` element:
   *
   * ```xml
   * <object class="GtkButton" id="button1">
   *   <accessibility>
   *     <property name="label">Download</property>
   *     <relation name="labelled-by">label1</relation>
   *   </accessibility>
   * </object>
   * ```
   *
   * ### Building composite widgets from template XML
   *
   * `GtkWidget `exposes some facilities to automate the procedure
   * of creating composite widgets using "templates".
   *
   * To create composite widgets with `GtkBuilder` XML, one must associate
   * the interface description with the widget class at class initialization
   * time using [method`Gtk`.WidgetClass.set_template].
   *
   * The interface description semantics expected in composite template descriptions
   * is slightly different from regular [class`Gtk`.Builder] XML.
   *
   * Unlike regular interface descriptions, [method`Gtk`.WidgetClass.set_template]
   * will expect a `<template>` tag as a direct child of the toplevel
   * `<interface>` tag. The `<template>` tag must specify the “class” attribute
   * which must be the type name of the widget. Optionally, the “parent”
   * attribute may be specified to specify the direct parent type of the widget
   * type; this is ignored by `GtkBuilder` but can be used by UI design tools to
   * introspect what kind of properties and internal children exist for a given
   * type when the actual type does not exist.
   *
   * The XML which is contained inside the `<template>` tag behaves as if it were
   * added to the `<object>` tag defining the widget itself. You may set properties
   * on a widget by inserting `<property>` tags into the `<template>` tag, and also
   * add `<child>` tags to add children and extend a widget in the normal way you
   * would with `<object>` tags.
   *
   * Additionally, `<object>` tags can also be added before and after the initial
   * `<template>` tag in the normal way, allowing one to define auxiliary objects
   * which might be referenced by other widgets declared as children of the
   * `<template>` tag.
   *
   * Since, unlike the `<object>` tag, the `<template>` tag does not contain an
   * “id” attribute, if you need to refer to the instance of the object itself that
   * the template will create, simply refer to the template class name in an
   * applicable element content.
   *
   * Here is an example of a template definition, which includes an example of
   * this in the `<signal>` tag:
   *
   * ```xml
   * <interface>
   *   <template class="FooWidget" parent="GtkBox">
   *     <property name="orientation">horizontal</property>
   *     <property name="spacing">4</property>
   *     <child>
   *       <object class="GtkButton" id="hello_button">
   *         <property name="label">Hello World</property>
   *         <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
   *       </object>
   *     </child>
   *     <child>
   *       <object class="GtkButton" id="goodbye_button">
   *         <property name="label">Goodbye World</property>
   *       </object>
   *     </child>
   *   </template>
   * </interface>
   * ```
   *
   * Typically, you'll place the template fragment into a file that is
   * bundled with your project, using `GResource`. In order to load the
   * template, you need to call [method`Gtk`.WidgetClass.set_template_from_resource]
   * from the class initialization of your `GtkWidget` type:
   *
   * ```c
   * static void
   * foo_widget_class_init (FooWidgetClass *klass)
   * {
   *   // ...
   *
   *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
   *                                                "/com/example/ui/foowidget.ui");
   * }
   * ```
   *
   * You will also need to call [method`Gtk`.Widget.init_template] from the
   * instance initialization function:
   *
   * ```c
   * static void
   * foo_widget_init (FooWidget *self)
   * {
   *   gtk_widget_init_template (GTK_WIDGET (self));
   *
   *   // Initialize the rest of the widget...
   * }
   * ```
   *
   * as well as calling [method`Gtk`.Widget.dispose_template] from the dispose
   * function:
   *
   * ```c
   * static void
   * foo_widget_dispose (GObject *gobject)
   * {
   *   FooWidget *self = FOO_WIDGET (gobject);
   *
   *   // Dispose objects for which you have a reference...
   *
   *   // Clear the template children for this widget type
   *   gtk_widget_dispose_template (GTK_WIDGET (self), FOO_TYPE_WIDGET);
   *
   *   G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
   * }
   * ```
   *
   * You can access widgets defined in the template using the
   * [method`Gtk`.Widget.get_template_child] function, but you will typically declare
   * a pointer in the instance private data structure of your type using the same
   * name as the widget in the template definition, and call
   * [method`Gtk`.WidgetClass.bind_template_child_full] (or one of its wrapper macros
   * [func`Gtk`.widget_class_bind_template_child] and [func`Gtk`.widget_class_bind_template_child_private])
   * with that name, e.g.
   *
   * ```c
   * typedef struct {
   *   GtkWidget *hello_button;
   *   GtkWidget *goodbye_button;
   * } FooWidgetPrivate;
   *
   * G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)
   *
   * static void
   * foo_widget_dispose (GObject *gobject)
   * {
   *   gtk_widget_dispose_template (GTK_WIDGET (gobject), FOO_TYPE_WIDGET);
   *
   *   G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
   * }
   *
   * static void
   * foo_widget_class_init (FooWidgetClass *klass)
   * {
   *   // ...
   *   G_OBJECT_CLASS (klass)->dispose = foo_widget_dispose;
   *
   *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
   *                                                "/com/example/ui/foowidget.ui");
   *   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
   *                                                 FooWidget, hello_button);
   *   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
   *                                                 FooWidget, goodbye_button);
   * }
   *
   * static void
   * foo_widget_init (FooWidget *widget)
   * {
   *   gtk_widget_init_template (GTK_WIDGET (widget));
   * }
   * ```
   *
   * You can also use [method`Gtk`.WidgetClass.bind_template_callback_full] (or
   * is wrapper macro [func`Gtk`.widget_class_bind_template_callback]) to connect
   * a signal callback defined in the template with a function visible in the
   * scope of the class, e.g.
   *
   * ```c
   * // the signal handler has the instance and user data swapped
   * // because of the swapped="yes" attribute in the template XML
   * static void
   * hello_button_clicked (FooWidget *self,
   *                       GtkButton *button)
   * {
   *   g_print ("Hello, world!\n");
   * }
   *
   * static void
   * foo_widget_class_init (FooWidgetClass *klass)
   * {
   *   // ...
   *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
   *                                                "/com/example/ui/foowidget.ui");
   *   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
   * }
   * ```
   * @interface
   */
  class Widget extends GObject.InitiallyUnowned {
    // Own properties of Gtk-4.0.Gtk.Widget

    static name: string

    // Constructors of Gtk-4.0.Gtk.Widget

    constructor(config?: Widget.ConstructorProperties)
    _init(config?: Widget.ConstructorProperties): void
    /**
     * Obtains the current default reading direction.
     *
     * See [func`Gtk`.Widget.set_default_direction].
     * @returns the current default direction.
     */
    static getDefaultDirection(): TextDirection
    /**
     * Sets the default reading direction for widgets.
     *
     * See [method`Gtk`.Widget.set_direction].
     * @param dir the new default direction. This cannot be %GTK_TEXT_DIR_NONE.
     */
    static setDefaultDirection(dir: TextDirection): void
    /**
     * Installs a shortcut in `widget_class`.
     *
     * Every instance created for `widget_class` or its subclasses will
     * inherit this shortcut and trigger it.
     *
     * Shortcuts added this way will be triggered in the %GTK_PHASE_BUBBLE
     * phase, which means they may also trigger if child widgets have focus.
     *
     * This function must only be used in class initialization functions
     * otherwise it is not guaranteed that the shortcut will be installed.
     * @param shortcut the `GtkShortcut` to add
     */
    static addShortcut(
      widget_class: Widget | Function | GObject.GType,
      shortcut: Shortcut
    ): void
    /**
     * Declares a `callback_symbol` to handle `callback_name` from
     * the template XML defined for `widget_type`.
     *
     * This function is not supported after [method`Gtk`.WidgetClass.set_template_scope]
     * has been used on `widget_class`. See [method`Gtk`.BuilderCScope.add_callback_symbol].
     *
     * Note that this must be called from a composite widget classes
     * class initializer after calling [method`Gtk`.WidgetClass.set_template].
     * @param callbackName The name of the callback as expected in the template XML
     * @param callbackSymbol The callback symbol
     */
    static bindTemplateCallbackFull(
      widget_class: Widget | Function | GObject.GType,
      callbackName: string,
      callbackSymbol: GObject.Callback
    ): void
    /**
     * Automatically assign an object declared in the class template XML to
     * be set to a location on a freshly built instance’s private data, or
     * alternatively accessible via [method`Gtk`.Widget.get_template_child].
     *
     * The struct can point either into the public instance, then you should
     * use `G_STRUCT_OFFSET(WidgetType, member)` for `struct_offset,` or in the
     * private struct, then you should use `G_PRIVATE_OFFSET(WidgetType, member)`.
     *
     * An explicit strong reference will be held automatically for the duration
     * of your instance’s life cycle, it will be released automatically when
     * `GObjectClass.dispose()` runs on your instance and if a `struct_offset`
     * that is `!= 0` is specified, then the automatic location in your instance
     * public or private data will be set to %NULL. You can however access an
     * automated child pointer the first time your classes `GObjectClass.dispose()`
     * runs, or alternatively in [signal`Gtk`.Widget::destroy].
     *
     * If `internal_child` is specified, [vfunc`Gtk`.Buildable.get_internal_child]
     * will be automatically implemented by the `GtkWidget` class so there is no
     * need to implement it manually.
     *
     * The wrapper macros [func`Gtk`.widget_class_bind_template_child],
     * [func`Gtk`.widget_class_bind_template_child_internal],
     * [func`Gtk`.widget_class_bind_template_child_private] and
     * [func`Gtk`.widget_class_bind_template_child_internal_private]
     * might be more convenient to use.
     *
     * Note that this must be called from a composite widget classes class
     * initializer after calling [method`Gtk`.WidgetClass.set_template].
     * @param name The “id” of the child defined in the template XML
     * @param internalChild Whether the child should be accessible as an “internal-child”   when this class is used in GtkBuilder XML
     * @param structOffset The structure offset into the composite widget’s instance   public or private structure where the automated child pointer should be set,   or 0 to not assign the pointer.
     */
    static bindTemplateChildFull(
      widget_class: Widget | Function | GObject.GType,
      name: string,
      internalChild: boolean,
      structOffset: number
    ): void
    /**
     * Retrieves the accessible role used by the given `GtkWidget` class.
     *
     * Different accessible roles have different states, and are rendered
     * differently by assistive technologies.
     *
     * See also: [method`Gtk`.Accessible.get_accessible_role].
     * @returns the accessible role for the widget class
     */
    static getAccessibleRole(
      widget_class: Widget | Function | GObject.GType
    ): AccessibleRole
    /**
     * Retrieves the signal id for the activation signal.
     *
     * the activation signal is set using
     * [method`Gtk`.WidgetClass.set_activate_signal].
     * @returns a signal id, or 0 if the widget class does not   specify an activation signal
     */
    static getActivateSignal(
      widget_class: Widget | Function | GObject.GType
    ): number
    /**
     * Gets the name used by this class for matching in CSS code.
     *
     * See [method`Gtk`.WidgetClass.set_css_name] for details.
     * @returns the CSS name of the given class
     */
    static getCssName(widget_class: Widget | Function | GObject.GType): string
    /**
     * Retrieves the type of the [class`Gtk`.LayoutManager]
     * used by widgets of class `widget_class`.
     *
     * See also: [method`Gtk`.WidgetClass.set_layout_manager_type].
     * @returns type of a `GtkLayoutManager` subclass, or %G_TYPE_INVALID
     */
    static getLayoutManagerType(
      widget_class: Widget | Function | GObject.GType
    ): GObject.GType
    /**
     * This should be called at class initialization time to specify
     * actions to be added for all instances of this class.
     *
     * Actions installed by this function are stateless. The only state
     * they have is whether they are enabled or not (which can be changed with
     * [method`Gtk`.Widget.action_set_enabled]).
     * @param actionName a prefixed action name, such as "clipboard.paste"
     * @param parameterType the parameter type
     * @param activate callback to use when the action is activated
     */
    static installAction(
      widget_class: Widget | Function | GObject.GType,
      actionName: string,
      parameterType: string | null,
      activate: WidgetActionActivateFunc
    ): void
    /**
     * Installs an action called `action_name` on `widget_class` and
     * binds its state to the value of the `property_name` property.
     *
     * This function will perform a few sanity checks on the property selected
     * via `property_name`. Namely, the property must exist, must be readable,
     * writable and must not be construct-only. There are also restrictions
     * on the type of the given property, it must be boolean, int, unsigned int,
     * double or string. If any of these conditions are not met, a critical
     * warning will be printed and no action will be added.
     *
     * The state type of the action matches the property type.
     *
     * If the property is boolean, the action will have no parameter and
     * toggle the property value. Otherwise, the action will have a parameter
     * of the same type as the property.
     * @param actionName name of the action
     * @param propertyName name of the property in instances of `widget_class`   or any parent class.
     */
    static installPropertyAction(
      widget_class: Widget | Function | GObject.GType,
      actionName: string,
      propertyName: string
    ): void
    /**
     * Returns details about the `index_-th` action that has been
     * installed for `widget_class` during class initialization.
     *
     * See [method`Gtk`.WidgetClass.install_action] for details on
     * how to install actions.
     *
     * Note that this function will also return actions defined
     * by parent classes. You can identify those by looking
     * at `owner`.
     * @param index position of the action to query
     * @returns %TRUE if the action was found, %FALSE if @index_   is out of range
     */
    static queryAction(
      widget_class: Widget | Function | GObject.GType,
      index: number
    ): [
      /* returnType */ boolean,
      /* owner */ GObject.GType,
      /* actionName */ string,
      /* parameterType */ GLib.VariantType | null,
      /* propertyName */ string | null,
    ]
    /**
     * Sets the accessible role used by the given `GtkWidget` class.
     *
     * Different accessible roles have different states, and are
     * rendered differently by assistive technologies.
     * @param accessibleRole the `GtkAccessibleRole` used by the `widget_class`
     */
    static setAccessibleRole(
      widget_class: Widget | Function | GObject.GType,
      accessibleRole: AccessibleRole
    ): void
    /**
     * Sets the `GtkWidgetClass.activate_signal` field with the
     * given `signal_id`.
     *
     * The signal will be emitted when calling [method`Gtk`.Widget.activate].
     *
     * The `signal_id` must have been registered with `g_signal_new()`
     * or g_signal_newv() before calling this function.
     * @param signalId the id for the activate signal
     */
    static setActivateSignal(
      widget_class: Widget | Function | GObject.GType,
      signalId: number
    ): void
    /**
     * Sets the `GtkWidgetClass.activate_signal` field with the signal id for
     * the given `signal_name`.
     *
     * The signal will be emitted when calling [method`Gtk`.Widget.activate].
     *
     * The `signal_name` of `widget_type` must have been registered with
     * g_signal_new() or g_signal_newv() before calling this function.
     * @param signalName the name of the activate signal of `widget_type`
     */
    static setActivateSignalFromName(
      widget_class: Widget | Function | GObject.GType,
      signalName: string
    ): void
    /**
     * Sets the name to be used for CSS matching of widgets.
     *
     * If this function is not called for a given class, the name
     * set on the parent class is used. By default, `GtkWidget`
     * uses the name "widget".
     * @param name name to use
     */
    static setCssName(
      widget_class: Widget | Function | GObject.GType,
      name: string
    ): void
    /**
     * Sets the type to be used for creating layout managers for
     * widgets of `widget_class`.
     *
     * The given `type` must be a subtype of [class`Gtk`.LayoutManager].
     *
     * This function should only be called from class init functions
     * of widgets.
     * @param type The object type that implements the `GtkLayoutManager`   for `widget_class`
     */
    static setLayoutManagerType(
      widget_class: Widget | Function | GObject.GType,
      type: GObject.GType
    ): void
    /**
     * This should be called at class initialization time to specify
     * the `GtkBuilder` XML to be used to extend a widget.
     *
     * For convenience, [method`Gtk`.WidgetClass.set_template_from_resource]
     * is also provided.
     *
     * Note that any class that installs templates must call
     * [method`Gtk`.Widget.init_template] in the widget’s instance initializer.
     * @param templateBytes A `GBytes` holding the `GtkBuilder` XML
     */
    static setTemplate(
      widget_class: Widget | Function | GObject.GType,
      templateBytes: any
    ): void
    /**
     * A convenience function that calls [method`Gtk`.WidgetClass.set_template]
     * with the contents of a `GResource`.
     *
     * Note that any class that installs templates must call
     * [method`Gtk`.Widget.init_template] in the widget’s instance
     * initializer.
     * @param resourceName The name of the resource to load the template from
     */
    static setTemplateFromResource(
      widget_class: Widget | Function | GObject.GType,
      resourceName: string
    ): void
    /**
     * For use in language bindings, this will override the default
     * `GtkBuilderScope` to be used when parsing GtkBuilder XML from
     * this class’s template data.
     *
     * Note that this must be called from a composite widget classes class
     * initializer after calling [method`Gtk`.WidgetClass.set_template].
     * @param scope The `GtkBuilderScope` to use when loading   the class template
     */
    static setTemplateScope(
      widget_class: Widget | Function | GObject.GType,
      scope: BuilderScope
    ): void
  }

  module WidgetPaintable {
    // Constructor properties interface

    interface ConstructorProperties
      extends Gdk.Paintable.ConstructorProperties,
        GObject.Object.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.WidgetPaintable

      /**
       * The observed widget or %NULL if none.
       */
      widget?: Widget | null
    }
  }

  interface WidgetPaintable extends Gdk.Paintable {
    // Own properties of Gtk-4.0.Gtk.WidgetPaintable

    /**
     * The observed widget or %NULL if none.
     */
    widget: Widget
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.WidgetPaintable

    /**
     * Returns the widget that is observed or %NULL if none.
     * @returns the observed widget.
     */
    getWidget(): Widget | null
    /**
     * Sets the widget that should be observed.
     * @param widget the widget to observe
     */
    setWidget(widget: Widget | null): void

    // Class property signals of Gtk-4.0.Gtk.WidgetPaintable

    connect(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::widget", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkWidgetPaintable` is a `GdkPaintable` that displays the contents
   * of a widget.
   *
   * `GtkWidgetPaintable` will also take care of the widget not being in a
   * state where it can be drawn (like when it isn't shown) and just draw
   * nothing or where it does not have a size (like when it is hidden) and
   * report no size in that case.
   *
   * Of course, `GtkWidgetPaintable` allows you to monitor widgets for size
   * changes by emitting the [signal`Gdk`.Paintable::invalidate-size] signal
   * whenever the size of the widget changes as well as for visual changes by
   * emitting the [signal`Gdk`.Paintable::invalidate-contents] signal whenever
   * the widget changes.
   *
   * You can use a `GtkWidgetPaintable` everywhere a `GdkPaintable` is allowed,
   * including using it on a `GtkPicture` (or one of its parents) that it was
   * set on itself via gtk_picture_set_paintable(). The paintable will take care
   * of recursion when this happens. If you do this however, ensure that the
   * [property`Gtk`.Picture:can-shrink] property is set to %TRUE or you might
   * end up with an infinitely growing widget.
   * @class
   */
  class WidgetPaintable extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.WidgetPaintable

    static name: string

    // Constructors of Gtk-4.0.Gtk.WidgetPaintable

    constructor(config?: WidgetPaintable.ConstructorProperties)
    /**
     * Creates a new widget paintable observing the given widget.
     * @constructor
     * @param widget a `GtkWidget`
     * @returns a new `GtkWidgetPaintable`
     */
    constructor(widget: Widget | null)
    /**
     * Creates a new widget paintable observing the given widget.
     * @constructor
     * @param widget a `GtkWidget`
     * @returns a new `GtkWidgetPaintable`
     */
    static new(widget: Widget | null): WidgetPaintable
    _init(config?: WidgetPaintable.ConstructorProperties): void
  }

  module Window {
    // Signal callback interfaces

    /**
     * Signal callback interface for `activate-default`
     */
    interface ActivateDefaultSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `activate-focus`
     */
    interface ActivateFocusSignalCallback {
      (): void
    }

    /**
     * Signal callback interface for `close-request`
     */
    interface CloseRequestSignalCallback {
      (): boolean
    }

    /**
     * Signal callback interface for `enable-debugging`
     */
    interface EnableDebuggingSignalCallback {
      (toggle: boolean): boolean
    }

    /**
     * Signal callback interface for `keys-changed`
     */
    interface KeysChangedSignalCallback {
      (): void
    }

    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Native.ConstructorProperties,
        Root.ConstructorProperties,
        ShortcutManager.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.Window

      /**
       * The `GtkApplication` associated with the window.
       *
       * The application will be kept alive for at least as long as it
       * has any windows associated with it (see g_application_hold()
       * for a way to keep it alive without windows).
       *
       * Normally, the connection between the application and the window
       * will remain until the window is destroyed, but you can explicitly
       * remove it by setting the :application property to %NULL.
       */
      application?: Application | null
      /**
       * The child widget.
       */
      child?: Widget | null
      /**
       * Whether the window should have a frame (also known as *decorations*).
       */
      decorated?: boolean | null
      /**
       * The default height of the window.
       */
      default_height?: number | null
      /**
       * The default widget.
       */
      default_widget?: Widget | null
      /**
       * The default width of the window.
       */
      default_width?: number | null
      /**
       * Whether the window frame should have a close button.
       */
      deletable?: boolean | null
      /**
       * If this window should be destroyed when the parent is destroyed.
       */
      destroy_with_parent?: boolean | null
      /**
       * The display that will display this window.
       */
      display?: Gdk.Display | null
      /**
       * Whether 'focus rectangles' are currently visible in this window.
       *
       * This property is maintained by GTK based on user input
       * and should not be set by applications.
       */
      focus_visible?: boolean | null
      /**
       * The focus widget.
       */
      focus_widget?: Widget | null
      /**
       * Whether the window is fullscreen.
       *
       * Setting this property is the equivalent of calling
       * [method`Gtk`.Window.fullscreen] or [method`Gtk`.Window.unfullscreen];
       * either operation is asynchronous, which means you will need to
       * connect to the ::notify signal in order to know whether the
       * operation was successful.
       */
      fullscreened?: boolean | null
      /**
       * Whether the window frame should handle F10 for activating
       * menubars.
       */
      handle_menubar_accel?: boolean | null
      /**
       * If this window should be hidden when the users clicks the close button.
       */
      hide_on_close?: boolean | null
      /**
       * Specifies the name of the themed icon to use as the window icon.
       *
       * See [class`Gtk`.IconTheme] for more details.
       */
      icon_name?: string | null
      /**
       * Whether the window is maximized.
       *
       * Setting this property is the equivalent of calling
       * [method`Gtk`.Window.maximize] or [method`Gtk`.Window.unmaximize];
       * either operation is asynchronous, which means you will need to
       * connect to the ::notify signal in order to know whether the
       * operation was successful.
       */
      maximized?: boolean | null
      /**
       * Whether mnemonics are currently visible in this window.
       *
       * This property is maintained by GTK based on user input,
       * and should not be set by applications.
       */
      mnemonics_visible?: boolean | null
      /**
       * If %TRUE, the window is modal.
       */
      modal?: boolean | null
      /**
       * If %TRUE, users can resize the window.
       */
      resizable?: boolean | null
      /**
       * A write-only property for setting window's startup notification identifier.
       */
      startup_id?: string | null
      /**
       * The title of the window.
       */
      title?: string | null
      /**
       * The titlebar widget.
       */
      titlebar?: Widget | null
      /**
       * The transient parent of the window.
       */
      transient_for?: Window | null
    }
  }

  interface Window
    extends Accessible,
      Buildable,
      ConstraintTarget,
      Native,
      Root,
      ShortcutManager {
    // Own properties of Gtk-4.0.Gtk.Window

    /**
     * The `GtkApplication` associated with the window.
     *
     * The application will be kept alive for at least as long as it
     * has any windows associated with it (see g_application_hold()
     * for a way to keep it alive without windows).
     *
     * Normally, the connection between the application and the window
     * will remain until the window is destroyed, but you can explicitly
     * remove it by setting the :application property to %NULL.
     */
    application: Application
    /**
     * The child widget.
     */
    child: Widget
    /**
     * Whether the window should have a frame (also known as *decorations*).
     */
    decorated: boolean
    /**
     * The default height of the window.
     */
    defaultHeight: number
    /**
     * The default widget.
     */
    defaultWidget: Widget
    /**
     * The default width of the window.
     */
    defaultWidth: number
    /**
     * Whether the window frame should have a close button.
     */
    deletable: boolean
    /**
     * If this window should be destroyed when the parent is destroyed.
     */
    destroyWithParent: boolean
    /**
     * The display that will display this window.
     */
    display: Gdk.Display
    /**
     * Whether 'focus rectangles' are currently visible in this window.
     *
     * This property is maintained by GTK based on user input
     * and should not be set by applications.
     */
    focusVisible: boolean
    /**
     * The focus widget.
     */
    focusWidget: Widget
    /**
     * Whether the window is fullscreen.
     *
     * Setting this property is the equivalent of calling
     * [method`Gtk`.Window.fullscreen] or [method`Gtk`.Window.unfullscreen];
     * either operation is asynchronous, which means you will need to
     * connect to the ::notify signal in order to know whether the
     * operation was successful.
     */
    fullscreened: boolean
    /**
     * Whether the window frame should handle F10 for activating
     * menubars.
     */
    handleMenubarAccel: boolean
    /**
     * If this window should be hidden when the users clicks the close button.
     */
    hideOnClose: boolean
    /**
     * Specifies the name of the themed icon to use as the window icon.
     *
     * See [class`Gtk`.IconTheme] for more details.
     */
    iconName: string | null
    /**
     * Whether the toplevel is the currently active window.
     */
    readonly isActive: boolean
    /**
     * Whether the window is maximized.
     *
     * Setting this property is the equivalent of calling
     * [method`Gtk`.Window.maximize] or [method`Gtk`.Window.unmaximize];
     * either operation is asynchronous, which means you will need to
     * connect to the ::notify signal in order to know whether the
     * operation was successful.
     */
    maximized: boolean
    /**
     * Whether mnemonics are currently visible in this window.
     *
     * This property is maintained by GTK based on user input,
     * and should not be set by applications.
     */
    mnemonicsVisible: boolean
    /**
     * If %TRUE, the window is modal.
     */
    modal: boolean
    /**
     * If %TRUE, users can resize the window.
     */
    resizable: boolean
    /**
     * A write-only property for setting window's startup notification identifier.
     */
    startupId: string | null
    /**
     * Whether the window is suspended.
     *
     * See [method`Gtk`.Window.is_suspended] for details about what suspended means.
     */
    readonly suspended: boolean
    /**
     * The title of the window.
     */
    title: string | null
    /**
     * The titlebar widget.
     */
    titlebar: Widget
    /**
     * The transient parent of the window.
     */
    transientFor: Window
    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.Window

    parentInstance: any

    // Owm methods of Gtk-4.0.Gtk.Window

    /**
     * Requests that the window is closed.
     *
     * This is similar to what happens when a window manager
     * close button is clicked.
     *
     * This function can be used with close buttons in custom
     * titlebars.
     */
    close(): void
    /**
     * Drop the internal reference GTK holds on toplevel windows.
     */
    destroy(): void
    /**
     * Asks to place `window` in the fullscreen state.
     *
     * Note that you shouldn’t assume the window is definitely fullscreen
     * afterward, because other entities (e.g. the user or window manager)
     * unfullscreen it again, and not all window managers honor requests
     * to fullscreen windows.
     *
     * You can track the result of this operation via the
     * [property`Gdk`.Toplevel:state] property, or by listening to
     * notifications of the [property`Gtk`.Window:fullscreened] property.
     */
    fullscreen(): void
    /**
     * Asks to place `window` in the fullscreen state on the given `monitor`.
     *
     * Note that you shouldn't assume the window is definitely fullscreen
     * afterward, or that the windowing system allows fullscreen windows on
     * any given monitor.
     *
     * You can track the result of this operation via the
     * [property`Gdk`.Toplevel:state] property, or by listening to
     * notifications of the [property`Gtk`.Window:fullscreened] property.
     * @param monitor which monitor to go fullscreen on
     */
    fullscreenOnMonitor(monitor: Gdk.Monitor): void
    /**
     * Gets the `GtkApplication` associated with the window.
     * @returns a `GtkApplication`
     */
    getApplication(): Application | null
    /**
     * Gets the child widget of `window`.
     * @returns the child widget of @window
     */
    getChild(): Widget | null
    /**
     * Returns whether the window has been set to have decorations.
     * @returns %TRUE if the window has been set to have decorations
     */
    getDecorated(): boolean
    /**
     * Gets the default size of the window.
     *
     * A value of 0 for the width or height indicates that a default
     * size has not been explicitly set for that dimension, so the
     * “natural” size of the window will be used.
     *
     * This function is the recommended way for [saving window state
     * across restarts of applications](https://developer.gnome.org/documentation/tutorials/save-state.html).
     */
    getDefaultSize(): [/* width */ number, /* height */ number]
    /**
     * Returns the default widget for `window`.
     * @returns the default widget
     */
    getDefaultWidget(): Widget | null
    /**
     * Returns whether the window has been set to have a close button.
     * @returns %TRUE if the window has been set to have a close button
     */
    getDeletable(): boolean
    /**
     * Returns whether the window will be destroyed with its transient parent.
     * @returns %TRUE if the window will be destroyed with its transient parent.
     */
    getDestroyWithParent(): boolean
    /**
     * Retrieves the current focused widget within the window.
     *
     * Note that this is the widget that would have the focus
     * if the toplevel window focused; if the toplevel window
     * is not focused then `gtk_widget_has_focus (widget)` will
     * not be %TRUE for the widget.
     * @returns the currently focused widget
     */
    getFocus(): Widget | null
    /**
     * Gets whether “focus rectangles” are supposed to be visible.
     * @returns %TRUE if “focus rectangles” are supposed to be visible   in this window.
     */
    getFocusVisible(): boolean
    /**
     * Returns the group for `window`.
     *
     * If the window has no group, then the default group is returned.
     * @returns the `GtkWindowGroup` for a window   or the default group
     */
    getGroup(): WindowGroup
    /**
     * Returns whether this window reacts to F10 key presses by
     * activating a menubar it contains.
     * @returns %TRUE if the window handles F10
     */
    getHandleMenubarAccel(): boolean
    /**
     * Returns whether the window will be hidden when the close button is clicked.
     * @returns %TRUE if the window will be hidden
     */
    getHideOnClose(): boolean
    /**
     * Returns the name of the themed icon for the window.
     * @returns the icon name
     */
    getIconName(): string | null
    /**
     * Gets whether mnemonics are supposed to be visible.
     * @returns %TRUE if mnemonics are supposed to be visible   in this window.
     */
    getMnemonicsVisible(): boolean
    /**
     * Returns whether the window is modal.
     * @returns %TRUE if the window is set to be modal and   establishes a grab when shown
     */
    getModal(): boolean
    /**
     * Gets the value set by gtk_window_set_resizable().
     * @returns %TRUE if the user can resize the window
     */
    getResizable(): boolean
    /**
     * Retrieves the title of the window.
     * @returns the title of the window
     */
    getTitle(): string | null
    /**
     * Returns the custom titlebar that has been set with
     * gtk_window_set_titlebar().
     * @returns the custom titlebar
     */
    getTitlebar(): Widget | null
    /**
     * Fetches the transient parent for this window.
     * @returns the transient parent for this window
     */
    getTransientFor(): Window | null
    /**
     * Returns whether `window` has an explicit window group.
     * @returns %TRUE if @window has an explicit window group.
     */
    hasGroup(): boolean
    /**
     * Retrieves the current fullscreen state of `window`.
     *
     * Note that since fullscreening is ultimately handled by the window
     * manager and happens asynchronously to an application request, you
     * shouldn’t assume the return value of this function changing
     * immediately (or at all), as an effect of calling
     * [method`Gtk`.Window.fullscreen] or [method`Gtk`.Window.unfullscreen].
     *
     * If the window isn't yet mapped, the value returned will whether the
     * initial requested state is fullscreen.
     * @returns whether the window has a fullscreen state.
     */
    isFullscreen(): boolean
    /**
     * Retrieves the current maximized state of `window`.
     *
     * Note that since maximization is ultimately handled by the window
     * manager and happens asynchronously to an application request, you
     * shouldn’t assume the return value of this function changing
     * immediately (or at all), as an effect of calling
     * [method`Gtk`.Window.maximize] or [method`Gtk`.Window.unmaximize].
     *
     * If the window isn't yet mapped, the value returned will whether the
     * initial requested state is maximized.
     * @returns whether the window has a maximized state.
     */
    isMaximized(): boolean
    /**
     * Retrieves the current suspended state of `window`.
     *
     * A window being suspended means it's currently not visible to the user, for
     * example by being on a inactive workspace, minimized, obstructed.
     * @returns whether the window is suspended.
     */
    isSuspended(): boolean
    /**
     * Asks to maximize `window,` so that it fills the screen.
     *
     * Note that you shouldn’t assume the window is definitely maximized
     * afterward, because other entities (e.g. the user or window manager)
     * could unmaximize it again, and not all window managers support
     * maximization.
     *
     * It’s permitted to call this function before showing a window,
     * in which case the window will be maximized when it appears onscreen
     * initially.
     *
     * You can track the result of this operation via the
     * [property`Gdk`.Toplevel:state] property, or by listening to
     * notifications on the [property`Gtk`.Window:maximized]
     * property.
     */
    maximize(): void
    /**
     * Asks to minimize the specified `window`.
     *
     * Note that you shouldn’t assume the window is definitely minimized
     * afterward, because the windowing system might not support this
     * functionality; other entities (e.g. the user or the window manager)
     * could unminimize it again, or there may not be a window manager in
     * which case minimization isn’t possible, etc.
     *
     * It’s permitted to call this function before showing a window,
     * in which case the window will be minimized before it ever appears
     * onscreen.
     *
     * You can track result of this operation via the
     * [property`Gdk`.Toplevel:state] property.
     */
    minimize(): void
    /**
     * Presents a window to the user.
     *
     * This may mean raising the window in the stacking order,
     * unminimizing it, moving it to the current desktop and/or
     * giving it the keyboard focus (possibly dependent on the user’s
     * platform, window manager and preferences).
     *
     * If `window` is hidden, this function also makes it visible.
     */
    present(): void
    /**
     * Presents a window to the user in response to an user interaction.
     *
     * See [method`Gtk`.Window.present] for more details.
     *
     * The timestamp should be gathered when the window was requested
     * to be shown (when clicking a link for example), rather than once
     * the window is ready to be shown.
     * @param timestamp the timestamp of the user interaction (typically a   button or key press event) which triggered this call
     */
    presentWithTime(timestamp: number): void
    /**
     * Sets or unsets the `GtkApplication` associated with the window.
     *
     * The application will be kept alive for at least as long as it has
     * any windows associated with it (see g_application_hold() for a way
     * to keep it alive without windows).
     *
     * Normally, the connection between the application and the window will
     * remain until the window is destroyed, but you can explicitly remove
     * it by setting the `application` to %NULL.
     *
     * This is equivalent to calling [method`Gtk`.Application.remove_window]
     * and/or [method`Gtk`.Application.add_window] on the old/new applications
     * as relevant.
     * @param application a `GtkApplication`, or %NULL to unset
     */
    setApplication(application: Application | null): void
    /**
     * Sets the child widget of `window`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void
    /**
     * Sets whether the window should be decorated.
     *
     * By default, windows are decorated with a title bar, resize
     * controls, etc. Some window managers allow GTK to disable these
     * decorations, creating a borderless window. If you set the decorated
     * property to %FALSE using this function, GTK will do its best to
     * convince the window manager not to decorate the window. Depending on
     * the system, this function may not have any effect when called on a
     * window that is already visible, so you should call it before calling
     * [method`Gtk`.Widget.show].
     *
     * On Windows, this function always works, since there’s no window manager
     * policy involved.
     * @param setting %TRUE to decorate the window
     */
    setDecorated(setting: boolean): void
    /**
     * Sets the default size of a window.
     *
     * The default size of a window is the size that will be used if no other constraints apply.
     *
     * The default size will be updated whenever the window is resized
     * to reflect the new size, unless the window is forced to a size,
     * like when it is maximized or fullscreened.
     *
     * If the window’s minimum size request is larger than
     * the default, the default will be ignored.
     *
     * Setting the default size to a value <= 0 will cause it to be
     * ignored and the natural size request will be used instead. It
     * is possible to do this while the window is showing to "reset"
     * it to its initial size.
     *
     * Unlike [method`Gtk`.Widget.set_size_request], which sets a size
     * request for a widget and thus would keep users from shrinking
     * the window, this function only sets the initial size, just as
     * if the user had resized the window themselves. Users can still
     * shrink the window again as they normally would. Setting a default
     * size of -1 means to use the “natural” default size (the size request
     * of the window).
     *
     * If you use this function to reestablish a previously saved window size,
     * note that the appropriate size to save is the one returned by
     * [method`Gtk`.Window.get_default_size]. Using the window allocation
     * directly will not work in all circumstances and can lead to growing
     * or shrinking windows.
     * @param width width in pixels, or -1 to unset the default width
     * @param height height in pixels, or -1 to unset the default height
     */
    setDefaultSize(width: number, height: number): void
    /**
     * Sets the default widget.
     *
     * The default widget is the widget that is activated when the user
     * presses Enter in a dialog (for example).
     * @param defaultWidget widget to be the default   to unset the default widget for the toplevel
     */
    setDefaultWidget(defaultWidget: Widget | null): void
    /**
     * Sets whether the window should be deletable.
     *
     * By default, windows have a close button in the window frame.
     * Some  window managers allow GTK to disable this button. If you
     * set the deletable property to %FALSE using this function, GTK
     * will do its best to convince the window manager not to show a
     * close button. Depending on the system, this function may not
     * have any effect when called on a window that is already visible,
     * so you should call it before calling [method`Gtk`.Widget.show].
     *
     * On Windows, this function always works, since there’s no window
     * manager policy involved.
     * @param setting %TRUE to decorate the window as deletable
     */
    setDeletable(setting: boolean): void
    /**
     * If `setting` is %TRUE, then destroying the transient parent of `window`
     * will also destroy `window` itself.
     *
     * This is useful for dialogs that shouldn’t persist beyond the lifetime
     * of the main window they are associated with, for example.
     * @param setting whether to destroy `window` with its transient parent
     */
    setDestroyWithParent(setting: boolean): void
    /**
     * Sets the `GdkDisplay` where the `window` is displayed.
     *
     * If the window is already mapped, it will be unmapped,
     * and then remapped on the new display.
     * @param display a `GdkDisplay`
     */
    setDisplay(display: Gdk.Display): void
    /**
     * Sets the focus widget.
     *
     * If `focus` is not the current focus widget, and is focusable,
     * sets it as the focus widget for the window. If `focus` is %NULL,
     * unsets the focus widget for this window. To set the focus to a
     * particular widget in the toplevel, it is usually more convenient
     * to use [method`Gtk`.Widget.grab_focus] instead of this function.
     * @param focus widget to be the new focus widget, or %NULL to unset   any focus widget for the toplevel window.
     */
    setFocus(focus: Widget | null): void
    /**
     * Sets whether “focus rectangles” are supposed to be visible.
     *
     * This property is maintained by GTK based on user input,
     * and should not be set by applications.
     * @param setting the new value
     */
    setFocusVisible(setting: boolean): void
    /**
     * Sets whether this window should react to F10 key presses
     * by activating a menubar it contains.
     * @param handleMenubarAccel %TRUE to make `window` handle F10
     */
    setHandleMenubarAccel(handleMenubarAccel: boolean): void
    /**
     * If `setting` is %TRUE, then clicking the close button on the window
     * will not destroy it, but only hide it.
     * @param setting whether to hide the window when it is closed
     */
    setHideOnClose(setting: boolean): void
    /**
     * Sets the icon for the window from a named themed icon.
     *
     * See the docs for [class`Gtk`.IconTheme] for more details.
     * On some platforms, the window icon is not used at all.
     *
     * Note that this has nothing to do with the WM_ICON_NAME
     * property which is mentioned in the ICCCM.
     * @param name the name of the themed icon
     */
    setIconName(name: string | null): void
    /**
     * Sets whether mnemonics are supposed to be visible.
     *
     * This property is maintained by GTK based on user input,
     * and should not be set by applications.
     * @param setting the new value
     */
    setMnemonicsVisible(setting: boolean): void
    /**
     * Sets a window modal or non-modal.
     *
     * Modal windows prevent interaction with other windows in the same
     * application. To keep modal dialogs on top of main application windows,
     * use [method`Gtk`.Window.set_transient_for] to make the dialog transient
     * for the parent; most window managers will then disallow lowering the
     * dialog below the parent.
     * @param modal whether the window is modal
     */
    setModal(modal: boolean): void
    /**
     * Sets whether the user can resize a window.
     *
     * Windows are user resizable by default.
     * @param resizable %TRUE if the user can resize this window
     */
    setResizable(resizable: boolean): void
    /**
     * Sets the startup notification ID.
     *
     * Startup notification identifiers are used by desktop environment
     * to track application startup, to provide user feedback and other
     * features. This function changes the corresponding property on the
     * underlying `GdkSurface`.
     *
     * Normally, startup identifier is managed automatically and you should
     * only use this function in special cases like transferring focus from
     * other processes. You should use this function before calling
     * [method`Gtk`.Window.present] or any equivalent function generating
     * a window map event.
     *
     * This function is only useful on X11, not with other GTK targets.
     * @param startupId a string with startup-notification identifier
     */
    setStartupId(startupId: string): void
    /**
     * Sets the title of the `GtkWindow`.
     *
     * The title of a window will be displayed in its title bar; on the
     * X Window System, the title bar is rendered by the window manager
     * so exactly how the title appears to users may vary according to a
     * user’s exact configuration. The title should help a user distinguish
     * this window from other windows they may have open. A good title might
     * include the application name and current document filename, for example.
     *
     * Passing %NULL does the same as setting the title to an empty string.
     * @param title title of the window
     */
    setTitle(title: string | null): void
    /**
     * Sets a custom titlebar for `window`.
     *
     * A typical widget used here is [class`Gtk`.HeaderBar], as it
     * provides various features expected of a titlebar while allowing
     * the addition of child widgets to it.
     *
     * If you set a custom titlebar, GTK will do its best to convince
     * the window manager not to put its own titlebar on the window.
     * Depending on the system, this function may not work for a window
     * that is already visible, so you set the titlebar before calling
     * [method`Gtk`.Widget.show].
     * @param titlebar the widget to use as titlebar
     */
    setTitlebar(titlebar: Widget | null): void
    /**
     * Dialog windows should be set transient for the main application
     * window they were spawned from. This allows window managers to e.g.
     * keep the dialog on top of the main window, or center the dialog
     * over the main window. [ctor`Gtk`.Dialog.new_with_buttons] and other
     * convenience functions in GTK will sometimes call
     * gtk_window_set_transient_for() on your behalf.
     *
     * Passing %NULL for `parent` unsets the current transient window.
     *
     * On Windows, this function puts the child window on top of the parent,
     * much as the window manager would have done on X.
     * @param parent parent window
     */
    setTransientFor(parent: Window | null): void
    /**
     * Asks to remove the fullscreen state for `window,` and return to
     * its previous state.
     *
     * Note that you shouldn’t assume the window is definitely not
     * fullscreen afterward, because other entities (e.g. the user or
     * window manager) could fullscreen it again, and not all window
     * managers honor requests to unfullscreen windows; normally the
     * window will end up restored to its normal state. Just don’t
     * write code that crashes if not.
     *
     * You can track the result of this operation via the
     * [property`Gdk`.Toplevel:state] property, or by listening to
     * notifications of the [property`Gtk`.Window:fullscreened] property.
     */
    unfullscreen(): void
    /**
     * Asks to unmaximize `window`.
     *
     * Note that you shouldn’t assume the window is definitely unmaximized
     * afterward, because other entities (e.g. the user or window manager)
     * maximize it again, and not all window managers honor requests to
     * unmaximize.
     *
     * You can track the result of this operation via the
     * [property`Gdk`.Toplevel:state] property, or by listening to
     * notifications on the [property`Gtk`.Window:maximized] property.
     */
    unmaximize(): void
    /**
     * Asks to unminimize the specified `window`.
     *
     * Note that you shouldn’t assume the window is definitely unminimized
     * afterward, because the windowing system might not support this
     * functionality; other entities (e.g. the user or the window manager)
     * could minimize it again, or there may not be a window manager in
     * which case minimization isn’t possible, etc.
     *
     * You can track result of this operation via the
     * [property`Gdk`.Toplevel:state] property.
     */
    unminimize(): void

    // Conflicting methods

    /**
     * Realizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    realize(): void

    // Overloads of realize

    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Creates the GDK resources associated with a widget.
     *
     * Normally realization happens implicitly; if you show a widget
     * and all its parent containers, then the widget will be realized
     * and mapped automatically.
     *
     * Realizing a widget requires all the widget’s parent widgets to be
     * realized; calling this function realizes the widget’s parents
     * in addition to `widget` itself. If a widget is not yet inside a
     * toplevel window when you realize it, bad things will happen.
     *
     * This function is primarily used in widget implementations, and
     * isn’t very useful otherwise. Many times when you think you might
     * need it, a better approach is to connect to a signal that will be
     * called after the widget is realized automatically, such as
     * [signal`Gtk`.Widget::realize].
     * @virtual
     */
    realize(): void
    /**
     * Unrealizes a `GtkNative`.
     *
     * This should only be used by subclasses.
     */
    unrealize(): void

    // Overloads of unrealize

    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Causes a widget to be unrealized (frees all GDK resources
     * associated with the widget).
     *
     * This function is only useful in widget implementations.
     * @virtual
     */
    unrealize(): void
    /**
     * Add a `GtkShortcutController` to be managed.
     * @virtual
     * @param controller
     */
    addController(controller: ShortcutController): void
    /**
     * Adds `controller` to `widget` so that it will receive events.
     *
     * You will usually want to call this function right after
     * creating any kind of [class`Gtk`.EventController].
     * @param controller a `GtkEventController` that hasn't been   added to a widget yet
     */
    addController(controller: EventController): void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @virtual
     * @param controller
     */
    removeController(controller: ShortcutController): void
    /**
     * Removes `controller` from `widget,` so that it doesn't process
     * events anymore.
     *
     * It should not be used again.
     *
     * Widgets will remove all event controllers automatically when they
     * are destroyed, there is normally no need to call this function.
     * @param controller a `GtkEventController`
     */
    removeController(controller: EventController): void

    // Own virtual methods of Gtk-4.0.Gtk.Window

    /**
     * Activates the default widget for the window.
     * @virtual
     */
    activateDefault(): void

    // Overloads of activateDefault

    /**
     * Activates the `default.activate` action from `widget`.
     */
    activateDefault(): void
    /**
     * Activates the current focused widget within the window.
     * @virtual
     */
    activateFocus(): void
    /**
     * Class handler for the `GtkWindow::close-request` signal.
     * @virtual
     */
    closeRequest(): boolean
    /**
     * Class handler for the `GtkWindow::enable-debugging`
     *   keybinding signal.
     * @virtual
     * @param toggle
     */
    enableDebugging(toggle: boolean): boolean
    /**
     * Signal gets emitted when the set of accelerators or
     *   mnemonics that are associated with window changes.
     * @virtual
     */
    keysChanged(): void

    // Own signals of Gtk-4.0.Gtk.Window

    connect(
      sigName: "activate-default",
      callback: Window.ActivateDefaultSignalCallback
    ): number
    on(
      sigName: "activate-default",
      callback: Window.ActivateDefaultSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-default",
      callback: Window.ActivateDefaultSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-default",
      callback: Window.ActivateDefaultSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-default", ...args: any[]): void
    connect(
      sigName: "activate-focus",
      callback: Window.ActivateFocusSignalCallback
    ): number
    on(
      sigName: "activate-focus",
      callback: Window.ActivateFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "activate-focus",
      callback: Window.ActivateFocusSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "activate-focus",
      callback: Window.ActivateFocusSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "activate-focus", ...args: any[]): void
    connect(
      sigName: "close-request",
      callback: Window.CloseRequestSignalCallback
    ): number
    on(
      sigName: "close-request",
      callback: Window.CloseRequestSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "close-request",
      callback: Window.CloseRequestSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "close-request",
      callback: Window.CloseRequestSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "close-request", ...args: any[]): void
    connect(
      sigName: "enable-debugging",
      callback: Window.EnableDebuggingSignalCallback
    ): number
    on(
      sigName: "enable-debugging",
      callback: Window.EnableDebuggingSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "enable-debugging",
      callback: Window.EnableDebuggingSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "enable-debugging",
      callback: Window.EnableDebuggingSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "enable-debugging", ...args: any[]): void
    connect(
      sigName: "keys-changed",
      callback: Window.KeysChangedSignalCallback
    ): number
    on(
      sigName: "keys-changed",
      callback: Window.KeysChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "keys-changed",
      callback: Window.KeysChangedSignalCallback,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "keys-changed",
      callback: Window.KeysChangedSignalCallback
    ): NodeJS.EventEmitter
    emit(sigName: "keys-changed", ...args: any[]): void

    // Class property signals of Gtk-4.0.Gtk.Window

    connect(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::application",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::application",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::application", ...args: any[]): void
    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decorated",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decorated", ...args: any[]): void
    connect(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-height",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-height", ...args: any[]): void
    connect(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-widget", ...args: any[]): void
    connect(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::default-width",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::default-width", ...args: any[]): void
    connect(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::deletable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::deletable", ...args: any[]): void
    connect(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::destroy-with-parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::destroy-with-parent", ...args: any[]): void
    connect(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::display",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::display",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::display", ...args: any[]): void
    connect(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-visible", ...args: any[]): void
    connect(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-widget",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-widget", ...args: any[]): void
    connect(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::fullscreened",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::fullscreened", ...args: any[]): void
    connect(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::handle-menubar-accel",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::handle-menubar-accel", ...args: any[]): void
    connect(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hide-on-close",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hide-on-close", ...args: any[]): void
    connect(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::icon-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::icon-name", ...args: any[]): void
    connect(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::is-active",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::is-active", ...args: any[]): void
    connect(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::maximized",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::maximized", ...args: any[]): void
    connect(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::mnemonics-visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::mnemonics-visible", ...args: any[]): void
    connect(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::modal",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::modal",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::modal", ...args: any[]): void
    connect(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::resizable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::resizable", ...args: any[]): void
    connect(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::startup-id",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::startup-id", ...args: any[]): void
    connect(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::suspended",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::suspended", ...args: any[]): void
    connect(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::title",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::title",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::title", ...args: any[]): void
    connect(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::titlebar",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::titlebar", ...args: any[]): void
    connect(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::transient-for",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::transient-for", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * A `GtkWindow` is a toplevel window which can contain other widgets.
   *
   * ![An example GtkWindow](window.png)
   *
   * Windows normally have decorations that are under the control
   * of the windowing system and allow the user to manipulate the window
   * (resize it, move it, close it,...).
   *
   * # GtkWindow as GtkBuildable
   *
   * The `GtkWindow` implementation of the [iface`Gtk`.Buildable] interface supports
   * setting a child as the titlebar by specifying “titlebar” as the “type”
   * attribute of a `<child>` element.
   *
   * # CSS nodes
   *
   * ```
   * window.background [.csd / .solid-csd / .ssd] [.maximized / .fullscreen / .tiled]
   * ├── <child>
   * ╰── <titlebar child>.titlebar [.default-decoration]
   * ```
   *
   * `GtkWindow` has a main CSS node with name window and style class .background.
   *
   * Style classes that are typically used with the main CSS node are .csd (when
   * client-side decorations are in use), .solid-csd (for client-side decorations
   * without invisible borders), .ssd (used by mutter when rendering server-side
   * decorations). GtkWindow also represents window states with the following
   * style classes on the main node: .maximized, .fullscreen, .tiled (when supported,
   * also .tiled-top, .tiled-left, .tiled-right, .tiled-bottom).
   *
   * `GtkWindow` subclasses often add their own discriminating style classes,
   * such as .dialog, .popup or .tooltip.
   *
   * Generally, some CSS properties don't make sense on the toplevel window node,
   * such as margins or padding. When client-side decorations without invisible
   * borders are in use (i.e. the .solid-csd style class is added to the
   * main window node), the CSS border of the toplevel window is used for
   * resize drags. In the .csd case, the shadow area outside of the window
   * can be used to resize it.
   *
   * `GtkWindow` adds the .titlebar and .default-decoration style classes to the
   * widget that is added as a titlebar child.
   *
   * # Accessibility
   *
   * Until GTK 4.10, `GtkWindow` used the `GTK_ACCESSIBLE_ROLE_WINDOW` role.
   *
   * Since GTK 4.12, `GtkWindow` uses the `GTK_ACCESSIBLE_ROLE_APPLICATION` role.
   *
   * # Actions
   *
   * `GtkWindow` defines a set of built-in actions:
   * - `default.activate`: Activate the default widget.
   * - `window.minimize`: Minimize the window.
   * - `window.toggle-maximized`: Maximize or restore the window.
   * - `window.close`: Close the window.
   * @class
   */
  class Window extends Widget {
    // Own properties of Gtk-4.0.Gtk.Window

    static name: string

    // Constructors of Gtk-4.0.Gtk.Window

    constructor(config?: Window.ConstructorProperties)
    /**
     * Creates a new `GtkWindow`.
     *
     * To get an undecorated window (no window borders), use
     * [method`Gtk`.Window.set_decorated].
     *
     * All top-level windows created by gtk_window_new() are stored
     * in an internal top-level window list. This list can be obtained
     * from [func`Gtk`.Window.list_toplevels]. Due to GTK keeping a
     * reference to the window internally, gtk_window_new() does not
     * return a reference to the caller.
     *
     * To delete a `GtkWindow`, call [method`Gtk`.Window.destroy].
     * @constructor
     * @returns a new `GtkWindow`.
     */
    constructor()
    /**
     * Creates a new `GtkWindow`.
     *
     * To get an undecorated window (no window borders), use
     * [method`Gtk`.Window.set_decorated].
     *
     * All top-level windows created by gtk_window_new() are stored
     * in an internal top-level window list. This list can be obtained
     * from [func`Gtk`.Window.list_toplevels]. Due to GTK keeping a
     * reference to the window internally, gtk_window_new() does not
     * return a reference to the caller.
     *
     * To delete a `GtkWindow`, call [method`Gtk`.Window.destroy].
     * @constructor
     * @returns a new `GtkWindow`.
     */
    static new(): Window
    _init(config?: Window.ConstructorProperties): void
    /**
     * Returns the fallback icon name for windows.
     *
     * The returned string is owned by GTK and should not
     * be modified. It is only valid until the next call to
     * [func`Gtk`.Window.set_default_icon_name].
     * @returns the fallback icon name for windows
     */
    static getDefaultIconName(): string | null
    /**
     * Returns a list of all existing toplevel windows.
     *
     * If you want to iterate through the list and perform actions involving
     * callbacks that might destroy the widgets or add new ones, be aware that
     * the list of toplevels will change and emit the "items-changed" signal.
     * @returns the list   of toplevel widgets
     */
    static getToplevels(): Gio.ListModel
    /**
     * Returns a list of all existing toplevel windows.
     *
     * The widgets in the list are not individually referenced.
     * If you want to iterate through the list and perform actions
     * involving callbacks that might destroy the widgets, you must
     * call `g_list_foreach (result, (GFunc)g_object_ref, NULL)` first,
     * and then unref all the widgets afterwards.
     * @returns list of   toplevel widgets
     */
    static listToplevels(): Widget[]
    /**
     * Sets whether the window should request startup notification.
     *
     * By default, after showing the first `GtkWindow`, GTK calls
     * [method`Gdk`.Toplevel.set_startup_id]. Call this function
     * to disable the automatic startup notification. You might do this
     * if your first window is a splash screen, and you want to delay
     * notification until after your real main window has been shown,
     * for example.
     *
     * In that example, you would disable startup notification
     * temporarily, show your splash screen, then re-enable it so that
     * showing the main window would automatically result in notification.
     * @param setting %TRUE to automatically do startup notification
     */
    static setAutoStartupNotification(setting: boolean): void
    /**
     * Sets an icon to be used as fallback.
     *
     * The fallback icon is used for windows that
     * haven't had [method`Gtk`.Window.set_icon_name]
     * called on them.
     * @param name the name of the themed icon
     */
    static setDefaultIconName(name: string): void
    /**
     * Opens or closes the [interactive debugger](running.html#interactive-debugging).
     *
     * The debugger offers access to the widget hierarchy of the application
     * and to useful debugging tools.
     * @param enable %TRUE to enable interactive debugging
     */
    static setInteractiveDebugging(enable: boolean): void
  }

  module WindowControls {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.WindowControls

      /**
       * The decoration layout for window buttons.
       *
       * If this property is not set, the
       * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
       */
      decoration_layout?: string | null
      /**
       * Whether the widget shows start or end side of the decoration layout.
       *
       * See [property`Gtk`.WindowControls:decoration_layout].
       */
      side?: PackType | null
    }
  }

  interface WindowControls extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.WindowControls

    /**
     * The decoration layout for window buttons.
     *
     * If this property is not set, the
     * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
     */
    decorationLayout: string | null
    /**
     * Whether the widget has any window buttons.
     */
    readonly empty: boolean
    /**
     * Whether the widget shows start or end side of the decoration layout.
     *
     * See [property`Gtk`.WindowControls:decoration_layout].
     */
    side: PackType
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.WindowControls

    /**
     * Gets the decoration layout of this `GtkWindowControls`.
     * @returns the decoration layout or %NULL if it is unset
     */
    getDecorationLayout(): string | null
    /**
     * Gets whether the widget has any window buttons.
     * @returns %TRUE if the widget has window buttons, otherwise %FALSE
     */
    getEmpty(): boolean
    /**
     * Gets the side to which this `GtkWindowControls` instance belongs.
     * @returns the side
     */
    getSide(): PackType
    /**
     * Sets the decoration layout for the title buttons.
     *
     * This overrides the [property`Gtk`.Settings:gtk-decoration-layout]
     * setting.
     *
     * The format of the string is button names, separated by commas.
     * A colon separates the buttons that should appear on the left
     * from those on the right. Recognized button names are minimize,
     * maximize, close and icon (the window icon).
     *
     * For example, “icon:minimize,maximize,close” specifies a icon
     * on the left, and minimize, maximize and close buttons on the right.
     *
     * If [property`Gtk`.WindowControls:side] value is `GTK_PACK_START,` `self`
     * will display the part before the colon, otherwise after that.
     * @param layout a decoration layout, or %NULL to unset the layout
     */
    setDecorationLayout(layout: string | null): void
    /**
     * Determines which part of decoration layout the `GtkWindowControls` uses.
     *
     * See [property`Gtk`.WindowControls:decoration-layout].
     * @param side a side
     */
    setSide(side: PackType): void

    // Class property signals of Gtk-4.0.Gtk.WindowControls

    connect(
      sigName: "notify::decoration-layout",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::decoration-layout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::decoration-layout",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::decoration-layout",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::decoration-layout", ...args: any[]): void
    connect(
      sigName: "notify::empty",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::empty",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::empty",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::empty",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::empty", ...args: any[]): void
    connect(sigName: "notify::side", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::side",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::side",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::side",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::side", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkWindowControls` shows window frame controls.
   *
   * Typical window frame controls are minimize, maximize and close buttons,
   * and the window icon.
   *
   * ![An example GtkWindowControls](windowcontrols.png)
   *
   * `GtkWindowControls` only displays start or end side of the controls (see
   * [property`Gtk`.WindowControls:side]), so it's intended to be always used
   * in pair with another `GtkWindowControls` for the opposite side, for example:
   *
   * ```xml
   * <object class="GtkBox">
   *   <child>
   *     <object class="GtkWindowControls">
   *       <property name="side">start</property>
   *     </object>
   *   </child>
   *
   *   ...
   *
   *   <child>
   *     <object class="GtkWindowControls">
   *       <property name="side">end</property>
   *     </object>
   *   </child>
   * </object>
   * ```
   *
   * # CSS nodes
   *
   * ```
   * windowcontrols
   * ├── [image.icon]
   * ├── [button.minimize]
   * ├── [button.maximize]
   * ╰── [button.close]
   * ```
   *
   * A `GtkWindowControls`' CSS node is called windowcontrols. It contains
   * subnodes corresponding to each title button. Which of the title buttons
   * exist and where they are placed exactly depends on the desktop environment
   * and [property`Gtk`.WindowControls:decoration-layout] value.
   *
   * When [property`Gtk`.WindowControls:empty] is %TRUE, it gets the .empty
   * style class.
   *
   * # Accessibility
   *
   * `GtkWindowControls` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
   * @class
   */
  class WindowControls extends Widget {
    // Own properties of Gtk-4.0.Gtk.WindowControls

    static name: string

    // Constructors of Gtk-4.0.Gtk.WindowControls

    constructor(config?: WindowControls.ConstructorProperties)
    /**
     * Creates a new `GtkWindowControls`.
     * @constructor
     * @param side the side
     * @returns a new `GtkWindowControls`.
     */
    constructor(side: PackType)
    /**
     * Creates a new `GtkWindowControls`.
     * @constructor
     * @param side the side
     * @returns a new `GtkWindowControls`.
     */
    static new(side: PackType): WindowControls
    _init(config?: WindowControls.ConstructorProperties): void
  }

  module WindowGroup {
    // Constructor properties interface

    interface ConstructorProperties
      extends GObject.Object.ConstructorProperties {}
  }

  interface WindowGroup {
    // Own properties of Gtk-4.0.Gtk.WindowGroup

    __gtype__: number

    // Own fields of Gtk-4.0.Gtk.WindowGroup

    parentInstance: GObject.Object
    priv: WindowGroupPrivate

    // Owm methods of Gtk-4.0.Gtk.WindowGroup

    /**
     * Adds a window to a `GtkWindowGroup`.
     * @param window the `GtkWindow` to add
     */
    addWindow(window: Window): void
    /**
     * Returns a list of the `GtkWindows` that belong to `window_group`.
     * @returns A   newly-allocated list of windows inside the group.
     */
    listWindows(): Window[]
    /**
     * Removes a window from a `GtkWindowGroup`.
     * @param window the `GtkWindow` to remove
     */
    removeWindow(window: Window): void

    // Class property signals of Gtk-4.0.Gtk.WindowGroup

    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkWindowGroup` makes group of windows behave like separate applications.
   *
   * It achieves this by limiting the effect of GTK grabs and modality
   * to windows in the same group.
   *
   * A window can be a member in at most one window group at a time.
   * Windows that have not been explicitly assigned to a group are
   * implicitly treated like windows of the default window group.
   *
   * `GtkWindowGroup` objects are referenced by each window in the group,
   * so once you have added all windows to a `GtkWindowGroup`, you can drop
   * the initial reference to the window group with g_object_unref(). If the
   * windows in the window group are subsequently destroyed, then they will
   * be removed from the window group and drop their references on the window
   * group; when all window have been removed, the window group will be
   * freed.
   * @class
   */
  class WindowGroup extends GObject.Object {
    // Own properties of Gtk-4.0.Gtk.WindowGroup

    static name: string

    // Constructors of Gtk-4.0.Gtk.WindowGroup

    constructor(config?: WindowGroup.ConstructorProperties)
    /**
     * Creates a new `GtkWindowGroup` object.
     *
     * Modality of windows only affects windows
     * within the same `GtkWindowGroup`.
     * @constructor
     * @returns a new `GtkWindowGroup`.
     */
    constructor()
    /**
     * Creates a new `GtkWindowGroup` object.
     *
     * Modality of windows only affects windows
     * within the same `GtkWindowGroup`.
     * @constructor
     * @returns a new `GtkWindowGroup`.
     */
    static new(): WindowGroup
    _init(config?: WindowGroup.ConstructorProperties): void
  }

  module WindowHandle {
    // Constructor properties interface

    interface ConstructorProperties
      extends Accessible.ConstructorProperties,
        Buildable.ConstructorProperties,
        ConstraintTarget.ConstructorProperties,
        Widget.ConstructorProperties {
      // Own constructor properties of Gtk-4.0.Gtk.WindowHandle

      /**
       * The child widget.
       */
      child?: Widget | null
    }
  }

  interface WindowHandle extends Accessible, Buildable, ConstraintTarget {
    // Own properties of Gtk-4.0.Gtk.WindowHandle

    /**
     * The child widget.
     */
    child: Widget
    __gtype__: number

    // Owm methods of Gtk-4.0.Gtk.WindowHandle

    /**
     * Gets the child widget of `self`.
     * @returns the child widget of @self
     */
    getChild(): Widget | null
    /**
     * Sets the child widget of `self`.
     * @param child the child widget
     */
    setChild(child: Widget | null): void

    // Class property signals of Gtk-4.0.Gtk.WindowHandle

    connect(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::child",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::child",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::child", ...args: any[]): void
    connect(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::__gtype__",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::__gtype__", ...args: any[]): void
    connect(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-focus", ...args: any[]): void
    connect(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::can-target",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::can-target", ...args: any[]): void
    connect(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-classes",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-classes", ...args: any[]): void
    connect(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::css-name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::css-name", ...args: any[]): void
    connect(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::cursor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::cursor", ...args: any[]): void
    connect(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focus-on-click",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focus-on-click", ...args: any[]): void
    connect(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::focusable",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::focusable", ...args: any[]): void
    connect(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::halign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::halign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::halign", ...args: any[]): void
    connect(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-default", ...args: any[]): void
    connect(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-focus",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-focus", ...args: any[]): void
    connect(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::has-tooltip",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::has-tooltip", ...args: any[]): void
    connect(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::height-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::height-request", ...args: any[]): void
    connect(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand", ...args: any[]): void
    connect(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::hexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::hexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::layout-manager",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::layout-manager", ...args: any[]): void
    connect(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-bottom",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-bottom", ...args: any[]): void
    connect(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-end",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-end", ...args: any[]): void
    connect(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-start",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-start", ...args: any[]): void
    connect(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::margin-top",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::margin-top", ...args: any[]): void
    connect(sigName: "notify::name", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::name",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::name",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::name", ...args: any[]): void
    connect(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::opacity",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::opacity", ...args: any[]): void
    connect(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::overflow",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::overflow", ...args: any[]): void
    connect(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::parent",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::parent",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::parent", ...args: any[]): void
    connect(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::receives-default",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::receives-default", ...args: any[]): void
    connect(sigName: "notify::root", callback: (...args: any[]) => void): number
    on(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::root",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::root",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::root", ...args: any[]): void
    connect(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::scale-factor",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::scale-factor", ...args: any[]): void
    connect(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::sensitive",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::sensitive", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-markup",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-markup", ...args: any[]): void
    connect(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::tooltip-text",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::tooltip-text", ...args: any[]): void
    connect(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::valign",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::valign",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::valign", ...args: any[]): void
    connect(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand", ...args: any[]): void
    connect(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::vexpand-set",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::vexpand-set", ...args: any[]): void
    connect(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::visible",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::visible",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::visible", ...args: any[]): void
    connect(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::width-request",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::width-request", ...args: any[]): void
    connect(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): number
    on(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: "notify::accessible-role",
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: "notify::accessible-role", ...args: any[]): void
    connect(sigName: string, callback: (...args: any[]) => void): number
    on(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    once(
      sigName: string,
      callback: (...args: any[]) => void,
      after?: boolean
    ): NodeJS.EventEmitter
    off(
      sigName: string,
      callback: (...args: any[]) => void
    ): NodeJS.EventEmitter
    emit(sigName: string, ...args: any[]): void
    disconnect(id: number): void
  }

  /**
   * `GtkWindowHandle` is a titlebar area widget.
   *
   * When added into a window, it can be dragged to move the window, and handles
   * right click, double click and middle click as expected of a titlebar.
   *
   * # CSS nodes
   *
   * `GtkWindowHandle` has a single CSS node with the name `windowhandle`.
   *
   * # Accessibility
   *
   * Until GTK 4.10, `GtkWindowHandle` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
   *
   * Starting from GTK 4.12, `GtkWindowHandle` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
   * @class
   */
  class WindowHandle extends Widget {
    // Own properties of Gtk-4.0.Gtk.WindowHandle

    static name: string

    // Constructors of Gtk-4.0.Gtk.WindowHandle

    constructor(config?: WindowHandle.ConstructorProperties)
    /**
     * Creates a new `GtkWindowHandle`.
     * @constructor
     * @returns a new `GtkWindowHandle`.
     */
    constructor()
    /**
     * Creates a new `GtkWindowHandle`.
     * @constructor
     * @returns a new `GtkWindowHandle`.
     */
    static new(): WindowHandle
    _init(config?: WindowHandle.ConstructorProperties): void
  }

  interface ATContextClass {}

  abstract class ATContextClass {
    // Own properties of Gtk-4.0.Gtk.ATContextClass

    static name: string
  }

  interface AccessibleInterface {
    // Own fields of Gtk-4.0.Gtk.AccessibleInterface

    gIface: GObject.TypeInterface
    /**
     * retrieve the platform-specific accessibility context
     *   for the accessible implementation
     * @field
     */
    getAtContext: (self: Accessible) => ATContext | null
    /**
     * retrieve the accessible state
     * @field
     */
    getPlatformState: (
      self: Accessible,
      state: AccessiblePlatformState
    ) => boolean
    getAccessibleParent: (self: Accessible) => Accessible | null
    getFirstAccessibleChild: (self: Accessible) => Accessible | null
    getNextAccessibleSibling: (self: Accessible) => Accessible | null
    getBounds: (
      self: Accessible
    ) => [
      /* returnType */ boolean,
      /* x */ number,
      /* y */ number,
      /* width */ number,
      /* height */ number,
    ]
  }

  /**
   * The common interface for accessible objects.
   * @record
   */
  abstract class AccessibleInterface {
    // Own properties of Gtk-4.0.Gtk.AccessibleInterface

    static name: string
  }

  interface AccessibleList {
    // Owm methods of Gtk-4.0.Gtk.AccessibleList

    /**
     * Gets the list of objects this boxed type holds
     * @returns a shallow copy of the objects
     */
    getObjects(): Accessible[]
  }

  /**
   * A boxed type which wraps a list of references to GtkAccessible objects.
   * @record
   */
  class AccessibleList {
    // Own properties of Gtk-4.0.Gtk.AccessibleList

    static name: string

    // Constructors of Gtk-4.0.Gtk.AccessibleList

    /**
     * Allocates a new list of accessible instances.
     * @constructor
     * @param accessibles array of GtkAccessible
     * @returns the newly created list of accessible instances
     */
    static newFromArray(accessibles: Accessible[]): AccessibleList
    /**
     * Allocates a new `GtkAccessibleList`, doing a shallow copy of the
     * passed list of `GtkAccessible` instances.
     * @constructor
     * @param list a reference to a `GList` containing a list of accessible values
     * @returns the list of accessible instances
     */
    static newFromList(list: Accessible[]): AccessibleList
  }

  interface AccessibleRangeInterface {
    // Own fields of Gtk-4.0.Gtk.AccessibleRangeInterface

    gIface: GObject.TypeInterface
    setCurrentValue: (self: AccessibleRange, value: number) => boolean
  }

  abstract class AccessibleRangeInterface {
    // Own properties of Gtk-4.0.Gtk.AccessibleRangeInterface

    static name: string
  }

  interface AccessibleTextInterface {
    // Own fields of Gtk-4.0.Gtk.AccessibleTextInterface

    getContents: (self: AccessibleText, start: number, end: number) => any
    getContentsAt: (
      self: AccessibleText,
      offset: number,
      granularity: AccessibleTextGranularity
    ) => [/* returnType */ any, /* start */ number, /* end */ number]
    getCaretPosition: (self: AccessibleText) => number
    getSelection: (
      self: AccessibleText
    ) => [/* returnType */ boolean, /* ranges */ AccessibleTextRange[]]
    getAttributes: (
      self: AccessibleText,
      offset: number
    ) => [
      /* returnType */ boolean,
      /* ranges */ AccessibleTextRange[],
      /* attributeNames */ string[],
      /* attributeValues */ string[],
    ]
    getDefaultAttributes: (
      self: AccessibleText
    ) => [/* attributeNames */ string[], /* attributeValues */ string[]]
  }

  /**
   * The interface vtable for accessible objects containing text.
   * @record
   */
  abstract class AccessibleTextInterface {
    // Own properties of Gtk-4.0.Gtk.AccessibleTextInterface

    static name: string
  }

  interface AccessibleTextRange {
    // Own fields of Gtk-4.0.Gtk.AccessibleTextRange

    /**
     * the start of the range, in characters
     * @field
     */
    start: number
    /**
     * the length of the range, in characters
     * @field
     */
    length: number
  }

  /**
   * A range inside the text of an accessible object.
   * @record
   */
  class AccessibleTextRange {
    // Own properties of Gtk-4.0.Gtk.AccessibleTextRange

    static name: string
  }

  interface ActionableInterface {
    // Own fields of Gtk-4.0.Gtk.ActionableInterface

    /**
     * virtual function for [method`Actionable`.get_action_name]
     * @field
     */
    getActionName: (actionable: Actionable) => string | null
    /**
     * virtual function for [method`Actionable`.set_action_name]
     * @field
     */
    setActionName: (actionable: Actionable, actionName: string | null) => void
    /**
     * virtual function for [method`Actionable`.get_action_target_value]
     * @field
     */
    getActionTargetValue: (actionable: Actionable) => GLib.Variant | null
    /**
     * virtual function for [method`Actionable`.set_action_target_value]
     * @field
     */
    setActionTargetValue: (
      actionable: Actionable,
      targetValue: GLib.Variant | null
    ) => void
  }

  /**
   * The interface vtable for `GtkActionable`.
   * @record
   */
  abstract class ActionableInterface {
    // Own properties of Gtk-4.0.Gtk.ActionableInterface

    static name: string
  }

  interface ActivateActionClass {}

  abstract class ActivateActionClass {
    // Own properties of Gtk-4.0.Gtk.ActivateActionClass

    static name: string
  }

  interface AdjustmentClass {
    // Own fields of Gtk-4.0.Gtk.AdjustmentClass

    parentClass: GObject.InitiallyUnownedClass
    changed: (adjustment: Adjustment) => void
    valueChanged: (adjustment: Adjustment) => void
  }

  abstract class AdjustmentClass {
    // Own properties of Gtk-4.0.Gtk.AdjustmentClass

    static name: string
  }

  interface AlertDialogClass {
    // Own fields of Gtk-4.0.Gtk.AlertDialogClass

    parentClass: GObject.ObjectClass
  }

  abstract class AlertDialogClass {
    // Own properties of Gtk-4.0.Gtk.AlertDialogClass

    static name: string
  }

  interface AlternativeTriggerClass {}

  abstract class AlternativeTriggerClass {
    // Own properties of Gtk-4.0.Gtk.AlternativeTriggerClass

    static name: string
  }

  interface AnyFilterClass {}

  abstract class AnyFilterClass {
    // Own properties of Gtk-4.0.Gtk.AnyFilterClass

    static name: string
  }

  interface ApplicationClass {
    // Own fields of Gtk-4.0.Gtk.ApplicationClass

    /**
     * The parent class.
     * @field
     */
    parentClass: Gio.ApplicationClass
    /**
     * Signal emitted when a `GtkWindow` is added to
     *    application through gtk_application_add_window().
     * @field
     */
    windowAdded: (application: Application, window: Window) => void
    /**
     * Signal emitted when a `GtkWindow` is removed from
     *    application, either as a side-effect of being destroyed or
     *    explicitly through gtk_application_remove_window().
     * @field
     */
    windowRemoved: (application: Application, window: Window) => void
  }

  abstract class ApplicationClass {
    // Own properties of Gtk-4.0.Gtk.ApplicationClass

    static name: string
  }

  interface ApplicationWindowClass {
    // Own fields of Gtk-4.0.Gtk.ApplicationWindowClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WindowClass
  }

  abstract class ApplicationWindowClass {
    // Own properties of Gtk-4.0.Gtk.ApplicationWindowClass

    static name: string
  }

  interface BinLayoutClass {
    // Own fields of Gtk-4.0.Gtk.BinLayoutClass

    parentClass: LayoutManagerClass
  }

  abstract class BinLayoutClass {
    // Own properties of Gtk-4.0.Gtk.BinLayoutClass

    static name: string
  }

  interface Bitset {
    // Owm methods of Gtk-4.0.Gtk.Bitset

    /**
     * Adds `value` to `self` if it wasn't part of it before.
     * @param value value to add
     * @returns %TRUE if @value was not part of @self and @self   was changed
     */
    add(value: number): boolean
    /**
     * Adds all values from `start` (inclusive) to `start` + `n_items`
     * (exclusive) in `self`.
     * @param start first value to add
     * @param nItems number of consecutive values to add
     */
    addRange(start: number, nItems: number): void
    /**
     * Adds the closed range [`first,` `last]`, so `first,` `last` and all
     * values in between. `first` must be smaller than `last`.
     * @param first first value to add
     * @param last last value to add
     */
    addRangeClosed(first: number, last: number): void
    /**
     * Interprets the values as a 2-dimensional boolean grid with the given `stride`
     * and inside that grid, adds a rectangle with the given `width` and `height`.
     * @param start first value to add
     * @param width width of the rectangle
     * @param height height of the rectangle
     * @param stride row stride of the grid
     */
    addRectangle(
      start: number,
      width: number,
      height: number,
      stride: number
    ): void
    /**
     * Checks if the given `value` has been added to `self`
     * @param value the value to check
     * @returns %TRUE if @self contains @value
     */
    contains(value: number): boolean
    /**
     * Creates a copy of `self`.
     * @returns A new bitset that contains the same   values as @self
     */
    copy(): Bitset
    /**
     * Sets `self` to be the symmetric difference of `self` and `other`.
     *
     * The symmetric difference is set `self` to contain all values that
     * were either contained in `self` or in `other,` but not in both.
     * This operation is also called an XOR.
     *
     * It is allowed for `self` and `other` to be the same bitset. The bitset
     * will be emptied in that case.
     * @param other the `GtkBitset` to compute the difference from
     */
    difference(other: Bitset): void
    /**
     * Returns %TRUE if `self` and `other` contain the same values.
     * @param other another `GtkBitset`
     * @returns %TRUE if @self and @other contain the same values
     */
    equals(other: Bitset): boolean
    /**
     * Returns the largest value in `self`.
     *
     * If `self` is empty, 0 is returned.
     * @returns The largest value in @self
     */
    getMaximum(): number
    /**
     * Returns the smallest value in `self`.
     *
     * If `self` is empty, `G_MAXUINT` is returned.
     * @returns The smallest value in @self
     */
    getMinimum(): number
    /**
     * Returns the value of the `nth` item in self.
     *
     * If `nth` is >= the size of `self,` 0 is returned.
     * @param nth index of the item to get
     * @returns the value of the @nth item in @self
     */
    getNth(nth: number): number
    /**
     * Gets the number of values that were added to the set.
     *
     * For example, if the set is empty, 0 is returned.
     *
     * Note that this function returns a `guint64`, because when all
     * values are set, the return value is `G_MAXUINT + 1`. Unless you
     * are sure this cannot happen (it can't with `GListModel`), be sure
     * to use a 64bit type.
     * @returns The number of values in the set.
     */
    getSize(): number
    /**
     * Gets the number of values that are part of the set from `first` to `last`
     * (inclusive).
     *
     * Note that this function returns a `guint64`, because when all values are
     * set, the return value is `G_MAXUINT + 1`. Unless you are sure this cannot
     * happen (it can't with `GListModel`), be sure to use a 64bit type.
     * @param first the first element to include
     * @param last the last element to include
     * @returns The number of values in the set from @first to @last.
     */
    getSizeInRange(first: number, last: number): number
    /**
     * Sets `self` to be the intersection of `self` and `other`.
     *
     * In other words, remove all values from `self` that are not part of `other`.
     *
     * It is allowed for `self` and `other` to be the same bitset. Nothing will
     * happen in that case.
     * @param other the `GtkBitset` to intersect with
     */
    intersect(other: Bitset): void
    /**
     * Check if no value is contained in bitset.
     * @returns %TRUE if @self is empty
     */
    isEmpty(): boolean
    /**
     * Acquires a reference on the given `GtkBitset`.
     * @returns the `GtkBitset` with an additional reference
     */
    ref(): Bitset
    /**
     * Removes `value` from `self` if it was part of it before.
     * @param value value to remove
     * @returns %TRUE if @value was part of @self and @self   was changed
     */
    remove(value: number): boolean
    /**
     * Removes all values from the bitset so that it is empty again.
     */
    removeAll(): void
    /**
     * Removes all values from `start` (inclusive) to `start` + `n_items` (exclusive)
     * in `self`.
     * @param start first value to remove
     * @param nItems number of consecutive values to remove
     */
    removeRange(start: number, nItems: number): void
    /**
     * Removes the closed range [`first,` `last]`, so `first,` `last` and all
     * values in between. `first` must be smaller than `last`.
     * @param first first value to remove
     * @param last last value to remove
     */
    removeRangeClosed(first: number, last: number): void
    /**
     * Interprets the values as a 2-dimensional boolean grid with the given `stride`
     * and inside that grid, removes a rectangle with the given `width` and `height`.
     * @param start first value to remove
     * @param width width of the rectangle
     * @param height height of the rectangle
     * @param stride row stride of the grid
     */
    removeRectangle(
      start: number,
      width: number,
      height: number,
      stride: number
    ): void
    /**
     * Shifts all values in `self` to the left by `amount`.
     *
     * Values smaller than `amount` are discarded.
     * @param amount amount to shift all values to the left
     */
    shiftLeft(amount: number): void
    /**
     * Shifts all values in `self` to the right by `amount`.
     *
     * Values that end up too large to be held in a #guint are discarded.
     * @param amount amount to shift all values to the right
     */
    shiftRight(amount: number): void
    /**
     * This is a support function for `GListModel` handling, by mirroring
     * the `GlistModel::items-changed` signal.
     *
     * First, it "cuts" the values from `position` to `removed` from
     * the bitset. That is, it removes all those values and shifts
     * all larger values to the left by `removed` places.
     *
     * Then, it "pastes" new room into the bitset by shifting all values
     * larger than `position` by `added` spaces to the right. This frees
     * up space that can then be filled.
     * @param position position at which to slice
     * @param removed number of values to remove
     * @param added number of values to add
     */
    splice(position: number, removed: number, added: number): void
    /**
     * Sets `self` to be the subtraction of `other` from `self`.
     *
     * In other words, remove all values from `self` that are part of `other`.
     *
     * It is allowed for `self` and `other` to be the same bitset. The bitset
     * will be emptied in that case.
     * @param other the `GtkBitset` to subtract
     */
    subtract(other: Bitset): void
    /**
     * Sets `self` to be the union of `self` and `other`.
     *
     * That is, add all values from `other` into `self` that weren't part of it.
     *
     * It is allowed for `self` and `other` to be the same bitset. Nothing will
     * happen in that case.
     * @param other the `GtkBitset` to union with
     */
    union(other: Bitset): void
    /**
     * Releases a reference on the given `GtkBitset`.
     *
     * If the reference was the last, the resources associated to the `self` are
     * freed.
     */
    unref(): void
  }

  /**
   * A `GtkBitset` represents a set of unsigned integers.
   *
   * Another name for this data structure is "bitmap".
   *
   * The current implementation is based on [roaring bitmaps](https://roaringbitmap.org/).
   *
   * A bitset allows adding a set of integers and provides support for set operations
   * like unions, intersections and checks for equality or if a value is contained
   * in the set. `GtkBitset` also contains various functions to query metadata about
   * the bitset, such as the minimum or maximum values or its size.
   *
   * The fastest way to iterate values in a bitset is [struct`Gtk`.BitsetIter].
   *
   * The main use case for `GtkBitset` is implementing complex selections for
   * [iface`Gtk`.SelectionModel].
   * @record
   */
  class Bitset {
    // Own properties of Gtk-4.0.Gtk.Bitset

    static name: string

    // Constructors of Gtk-4.0.Gtk.Bitset

    /**
     * Creates a new empty bitset.
     * @constructor
     * @returns A new empty bitset
     */
    static newEmpty(): Bitset
    /**
     * Creates a bitset with the given range set.
     * @constructor
     * @param start first value to add
     * @param nItems number of consecutive values to add
     * @returns A new bitset
     */
    static newRange(start: number, nItems: number): Bitset
  }

  interface BitsetIter {
    // Owm methods of Gtk-4.0.Gtk.BitsetIter

    /**
     * Gets the current value that `iter` points to.
     *
     * If `iter` is not valid and [method`Gtk`.BitsetIter.is_valid]
     * returns %FALSE, this function returns 0.
     * @returns The current value pointer to by @iter
     */
    getValue(): number
    /**
     * Checks if `iter` points to a valid value.
     * @returns %TRUE if @iter points to a valid value
     */
    isValid(): boolean
    /**
     * Moves `iter` to the next value in the set.
     *
     * If it was already pointing to the last value in the set,
     * %FALSE is returned and `iter` is invalidated.
     * @returns %TRUE if a next value existed
     */
    next(): [/* returnType */ boolean, /* value */ number]
    /**
     * Moves `iter` to the previous value in the set.
     *
     * If it was already pointing to the first value in the set,
     * %FALSE is returned and `iter` is invalidated.
     * @returns %TRUE if a previous value existed
     */
    previous(): [/* returnType */ boolean, /* value */ number]
  }

  /**
   * An opaque, stack-allocated struct for iterating
   * over the elements of a `GtkBitset`.
   *
   * Before a `GtkBitsetIter` can be used, it needs to be initialized with
   * [func`Gtk`.BitsetIter.init_first], [func`Gtk`.BitsetIter.init_last]
   * or [func`Gtk`.BitsetIter.init_at].
   * @record
   */
  class BitsetIter {
    // Own properties of Gtk-4.0.Gtk.BitsetIter

    static name: string

    // Constructors of Gtk-4.0.Gtk.BitsetIter

    /**
     * Initializes `iter` to point to `target`.
     *
     * If `target` is not found, finds the next value after it.
     * If no value >= `target` exists in `set,` this function returns %FALSE.
     * @param set a `GtkBitset`
     * @param target target value to start iterating at
     * @returns %TRUE if a value was found.
     */
    static initAt(
      set: Bitset,
      target: number
    ): [/* returnType */ boolean, /* iter */ BitsetIter, /* value */ number]
    /**
     * Initializes an iterator for `set` and points it to the first
     * value in `set`.
     *
     * If `set` is empty, %FALSE is returned and `value` is set to %G_MAXUINT.
     * @param set a `GtkBitset`
     * @returns %TRUE if @set isn't empty.
     */
    static initFirst(
      set: Bitset
    ): [/* returnType */ boolean, /* iter */ BitsetIter, /* value */ number]
    /**
     * Initializes an iterator for `set` and points it to the last
     * value in `set`.
     *
     * If `set` is empty, %FALSE is returned.
     * @param set a `GtkBitset`
     * @returns %TRUE if @set isn't empty.
     */
    static initLast(
      set: Bitset
    ): [/* returnType */ boolean, /* iter */ BitsetIter, /* value */ number]
  }

  interface BookmarkListClass {
    // Own fields of Gtk-4.0.Gtk.BookmarkListClass

    parentClass: GObject.ObjectClass
  }

  abstract class BookmarkListClass {
    // Own properties of Gtk-4.0.Gtk.BookmarkListClass

    static name: string
  }

  interface BoolFilterClass {
    // Own fields of Gtk-4.0.Gtk.BoolFilterClass

    parentClass: FilterClass
  }

  abstract class BoolFilterClass {
    // Own properties of Gtk-4.0.Gtk.BoolFilterClass

    static name: string
  }

  interface Border {
    // Own fields of Gtk-4.0.Gtk.Border

    /**
     * The width of the left border
     * @field
     */
    left: number
    /**
     * The width of the right border
     * @field
     */
    right: number
    /**
     * The width of the top border
     * @field
     */
    top: number
    /**
     * The width of the bottom border
     * @field
     */
    bottom: number

    // Owm methods of Gtk-4.0.Gtk.Border

    /**
     * Copies a `GtkBorder`.
     * @returns a copy of @border_.
     */
    copy(): Border
    /**
     * Frees a `GtkBorder`.
     */
    free(): void
  }

  /**
   * A struct that specifies a border around a rectangular area.
   *
   * Each side can have different width.
   * @record
   */
  class Border {
    // Own properties of Gtk-4.0.Gtk.Border

    static name: string

    // Constructors of Gtk-4.0.Gtk.Border

    /**
     * Allocates a new `GtkBorder` struct and initializes its elements to zero.
     * @constructor
     * @returns a newly allocated `GtkBorder` struct.  Free with [method@Gtk.Border.free]
     */
    constructor()
    /**
     * Allocates a new `GtkBorder` struct and initializes its elements to zero.
     * @constructor
     * @returns a newly allocated `GtkBorder` struct.  Free with [method@Gtk.Border.free]
     */
    static new(): Border
  }

  interface BoxClass {
    // Own fields of Gtk-4.0.Gtk.BoxClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WidgetClass
  }

  abstract class BoxClass {
    // Own properties of Gtk-4.0.Gtk.BoxClass

    static name: string
  }

  interface BoxLayoutClass {
    // Own fields of Gtk-4.0.Gtk.BoxLayoutClass

    parentClass: LayoutManagerClass
  }

  abstract class BoxLayoutClass {
    // Own properties of Gtk-4.0.Gtk.BoxLayoutClass

    static name: string
  }

  interface BuildableIface {
    // Own fields of Gtk-4.0.Gtk.BuildableIface

    /**
     * the parent class
     * @field
     */
    gIface: GObject.TypeInterface
    /**
     * Stores the id attribute given in the `GtkBuilder` UI definition.
     *   `GtkWidget` stores the name as object data. Implement this method if your
     *   object has some notion of “ID” and it makes sense to map the XML id
     *   attribute to it.
     * @field
     */
    setId: (buildable: Buildable, id: string) => void
    /**
     * The getter corresponding to `set_id`. Implement this
     *   if you implement `set_id`.
     * @field
     */
    getId: (buildable: Buildable) => string
    /**
     * Adds a child. The `type` parameter can be used to
     *   differentiate the kind of child. `GtkWidget` implements this
     *   to add event controllers to the widget, `GtkNotebook` uses
     *   the `type` to distinguish between page labels (of type "page-label")
     *   and normal children.
     * @field
     */
    addChild: (
      buildable: Buildable,
      builder: Builder,
      child: GObject.Object,
      type: string | null
    ) => void
    /**
     * Sets a property of a buildable object.
     *  It is normally not necessary to implement this, g_object_set_property()
     *  is used by default. `GtkWindow` implements this to delay showing itself
     *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
     *  interface is created.
     * @field
     */
    setBuildableProperty: (
      buildable: Buildable,
      builder: Builder,
      name: string,
      value: any
    ) => void
    /**
     * Implement this if the buildable needs to parse
     *  content below `<child>`. To handle an element, the implementation
     *  must fill in the `parser` and `user_data` and return %TRUE.
     *  `GtkWidget` implements this to parse accessible attributes specified
     *  in `<accessibility>` elements.
     *  Note that `user_data` must be freed in `custom_tag_end` or `custom_finished`.
     * @field
     */
    customTagStart: (
      buildable: Buildable,
      builder: Builder,
      child: GObject.Object | null,
      tagname: string
    ) => [
      /* returnType */ boolean,
      /* parser */ BuildableParser,
      /* data */ any | null,
    ]
    /**
     * Called for the end tag of each custom element that is
     *  handled by the buildable (see `custom_tag_start)`.
     * @field
     */
    customTagEnd: (
      buildable: Buildable,
      builder: Builder,
      child: GObject.Object | null,
      tagname: string,
      data: any | null
    ) => void
    /**
     * Called for each custom tag handled by the buildable
     *  when the builder finishes parsing (see `custom_tag_start)`
     * @field
     */
    customFinished: (
      buildable: Buildable,
      builder: Builder,
      child: GObject.Object | null,
      tagname: string,
      data: any | null
    ) => void
    /**
     * Called when a builder finishes the parsing
     *  of a UI definition. It is normally not necessary to implement this,
     *  unless you need to perform special cleanup actions. `GtkWindow` sets
     *  the `GtkWidget:visible` property here.
     * @field
     */
    parserFinished: (buildable: Buildable, builder: Builder) => void
    /**
     * Returns an internal child of a buildable.
     *  `GtkDialog` implements this to give access to its `vbox,` making
     *  it possible to add children to the vbox in a UI definition.
     *  Implement this if the buildable has internal children that may
     *  need to be accessed from a UI definition.
     * @field
     */
    getInternalChild: (
      buildable: Buildable,
      builder: Builder,
      childname: string
    ) => GObject.Object
  }

  /**
   * The `GtkBuildableIface` interface contains methods that are
   * necessary to allow `GtkBuilder` to construct an object from
   * a `GtkBuilder` UI definition.
   * @record
   */
  abstract class BuildableIface {
    // Own properties of Gtk-4.0.Gtk.BuildableIface

    static name: string
  }

  interface BuildableParseContext {
    // Owm methods of Gtk-4.0.Gtk.BuildableParseContext

    /**
     * Retrieves the name of the currently open element.
     *
     * If called from the start_element or end_element handlers this will
     * give the element_name as passed to those functions. For the parent
     * elements, see gtk_buildable_parse_context_get_element_stack().
     * @returns the name of the currently open element
     */
    getElement(): string | null
    /**
     * Retrieves the element stack from the internal state of the parser.
     *
     * The returned `GPtrArray` is an array of strings where the last item is
     * the currently open tag (as would be returned by
     * gtk_buildable_parse_context_get_element()) and the previous item is its
     * immediate parent.
     *
     * This function is intended to be used in the start_element and
     * end_element handlers where gtk_buildable_parse_context_get_element()
     * would merely return the name of the element that is being
     * processed.
     * @returns the element stack, which must not be modified
     */
    getElementStack(): string[]
    /**
     * Retrieves the current line number and the number of the character on
     * that line. Intended for use in error messages; there are no strict
     * semantics for what constitutes the "current" line number other than
     * "the best number we could come up with for error messages."
     */
    getPosition(): [/* lineNumber */ number, /* charNumber */ number]
    /**
     * Completes the process of a temporary sub-parser redirection.
     *
     * This function exists to collect the user_data allocated by a
     * matching call to gtk_buildable_parse_context_push(). It must be called
     * in the end_element handler corresponding to the start_element
     * handler during which gtk_buildable_parse_context_push() was called.
     * You must not call this function from the error callback -- the
     * `user_data` is provided directly to the callback in that case.
     *
     * This function is not intended to be directly called by users
     * interested in invoking subparsers. Instead, it is intended to
     * be used by the subparsers themselves to implement a higher-level
     * interface.
     * @returns the user data passed to gtk_buildable_parse_context_push()
     */
    pop(): any | null
    /**
     * Temporarily redirects markup data to a sub-parser.
     *
     * This function may only be called from the start_element handler of
     * a `GtkBuildableParser`. It must be matched with a corresponding call to
     * gtk_buildable_parse_context_pop() in the matching end_element handler
     * (except in the case that the parser aborts due to an error).
     *
     * All tags, text and other data between the matching tags is
     * redirected to the subparser given by `parser`. `user_data` is used
     * as the user_data for that parser. `user_data` is also passed to the
     * error callback in the event that an error occurs. This includes
     * errors that occur in subparsers of the subparser.
     *
     * The end tag matching the start tag for which this call was made is
     * handled by the previous parser (which is given its own user_data)
     * which is why gtk_buildable_parse_context_pop() is provided to allow "one
     * last access" to the `user_data` provided to this function. In the
     * case of error, the `user_data` provided here is passed directly to
     * the error callback of the subparser and gtk_buildable_parse_context_pop()
     * should not be called. In either case, if `user_data` was allocated
     * then it ought to be freed from both of these locations.
     *
     * This function is not intended to be directly called by users
     * interested in invoking subparsers. Instead, it is intended to be
     * used by the subparsers themselves to implement a higher-level
     * interface.
     *
     * For an example of how to use this, see g_markup_parse_context_push() which
     * has the same kind of API.
     * @param parser a `GtkBuildableParser`
     * @param userData user data to pass to `GtkBuildableParser` functions
     */
    push(parser: BuildableParser, userData: any | null): void
  }

  /**
   * An opaque context struct for `GtkBuildableParser`.
   * @record
   */
  class BuildableParseContext {
    // Own properties of Gtk-4.0.Gtk.BuildableParseContext

    static name: string
  }

  interface BuildableParser {
    // Own fields of Gtk-4.0.Gtk.BuildableParser

    /**
     * function called for open elements
     * @field
     */
    startElement: (
      context: BuildableParseContext,
      elementName: string,
      attributeNames: string,
      attributeValues: string
    ) => void
    /**
     * function called for close elements
     * @field
     */
    endElement: (context: BuildableParseContext, elementName: string) => void
    /**
     * function called for character data
     * @field
     */
    text: (
      context: BuildableParseContext,
      text: string,
      textLen: number
    ) => void
    /**
     * function called on error
     * @field
     */
    error: (context: BuildableParseContext, error: GLib.Error) => void
  }

  /**
   * A sub-parser for `GtkBuildable` implementations.
   * @record
   */
  class BuildableParser {
    // Own properties of Gtk-4.0.Gtk.BuildableParser

    static name: string
  }

  interface BuilderCScopeClass {
    // Own fields of Gtk-4.0.Gtk.BuilderCScopeClass

    parentClass: GObject.ObjectClass
  }

  abstract class BuilderCScopeClass {
    // Own properties of Gtk-4.0.Gtk.BuilderCScopeClass

    static name: string
  }

  interface BuilderClass {}

  abstract class BuilderClass {
    // Own properties of Gtk-4.0.Gtk.BuilderClass

    static name: string
  }

  interface BuilderListItemFactoryClass {}

  abstract class BuilderListItemFactoryClass {
    // Own properties of Gtk-4.0.Gtk.BuilderListItemFactoryClass

    static name: string
  }

  interface BuilderScopeInterface {
    // Own fields of Gtk-4.0.Gtk.BuilderScopeInterface

    /**
     * Try to lookup a `GType` via the its name. See
     *   gtk_builder_get_type_from_name() for more details.
     *   The C implementation will use g_type_from_name() and if that fails try to guess the
     *   correct function name for registering the type and then use dlsym() to load it.
     *   The default implementation just tries g_type_from_name() and otherwise fails.
     * @field
     */
    getTypeFromName: (
      self: BuilderScope,
      builder: Builder,
      typeName: string
    ) => GObject.GType
    /**
     * Try to lookup a `GType` via the given function name, specified
     *   explicitly in a GtkBuilder file, like via the "type-func" attribute in the `<object>` tag.
     *   This function is very rarely used.
     *   The C implementation will use dlsym() and call the resulting function as a `GTypeFunc`.
     *   The default implementation will fail and just return %G_TYPE_INVALID.
     * @field
     */
    getTypeFromFunction: (
      self: BuilderScope,
      builder: Builder,
      functionName: string
    ) => GObject.GType
    /**
     * Create a closure with the given arguments. See gtk_builder_create_closure()
     *   for more details on those.
     *   The C implementation will try to use dlsym() to locate the function name and then
     *   g_cclosure_new() to create a closure for the symbol.
     *   The default implementation just fails and returns %NULL.
     * @field
     */
    createClosure: (
      self: BuilderScope,
      builder: Builder,
      functionName: string,
      flags: BuilderClosureFlags,
      object: GObject.Object
    ) => GObject.TClosure
  }

  /**
   * The virtual function table to implement for `GtkBuilderScope` implementations.
   * Default implementations for each function do exist, but they usually just fail,
   * so it is suggested that implementations implement all of them.
   * @record
   */
  abstract class BuilderScopeInterface {
    // Own properties of Gtk-4.0.Gtk.BuilderScopeInterface

    static name: string
  }

  interface ButtonClass {
    // Own fields of Gtk-4.0.Gtk.ButtonClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WidgetClass
    /**
     * Signal emitted when the button has been activated (pressed and released).
     * @field
     */
    clicked: (button: Button) => void
    /**
     * Signal that causes the button to animate press then
     *    release. Applications should never connect to this signal, but use
     *    the `clicked` signal.
     * @field
     */
    activate: (button: Button) => void
  }

  abstract class ButtonClass {
    // Own properties of Gtk-4.0.Gtk.ButtonClass

    static name: string
  }

  interface ButtonPrivate {}

  class ButtonPrivate {
    // Own properties of Gtk-4.0.Gtk.ButtonPrivate

    static name: string
  }

  interface CallbackActionClass {}

  abstract class CallbackActionClass {
    // Own properties of Gtk-4.0.Gtk.CallbackActionClass

    static name: string
  }

  interface CellAreaClass {
    // Own fields of Gtk-4.0.Gtk.CellAreaClass

    /**
     * adds a `GtkCellRenderer` to the area.
     * @field
     */
    add: (area: CellArea, renderer: CellRenderer) => void
    /**
     * removes a `GtkCellRenderer` from the area.
     * @field
     */
    remove: (area: CellArea, renderer: CellRenderer) => void
    /**
     * calls the `GtkCellCallback` function on every `GtkCellRenderer` in
     *   the area with the provided user data until the callback returns %TRUE.
     * @field
     */
    foreach: (area: CellArea, callback: CellCallback) => void
    /**
     * Calls the `GtkCellAllocCallback` function on every
     *   `GtkCellRenderer` in the area with the allocated area for the cell
     *   and the provided user data until the callback returns %TRUE.
     * @field
     */
    foreachAlloc: (
      area: CellArea,
      context: CellAreaContext,
      widget: Widget,
      cellArea: Gdk.Rectangle,
      backgroundArea: Gdk.Rectangle,
      callback: CellAllocCallback
    ) => void
    /**
     * Handle an event in the area, this is generally used to activate
     *   a cell at the event location for button events but can also be used
     *   to generically pass events to `GtkWidget`s drawn onto the area.
     * @field
     */
    event: (
      area: CellArea,
      context: CellAreaContext,
      widget: Widget,
      event: Gdk.Event,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ) => number
    /**
     * Actually snapshot the area’s cells to the specified rectangle,
     *   `background_area` should be correctly distributed to the cells
     *   corresponding background areas.
     * @field
     */
    snapshot: (
      area: CellArea,
      context: CellAreaContext,
      widget: Widget,
      snapshot: Snapshot,
      backgroundArea: Gdk.Rectangle,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState,
      paintFocus: boolean
    ) => void
    /**
     * Apply the cell attributes to the cells. This is
     *   implemented as a signal and generally `GtkCellArea` subclasses don't
     *   need to implement it since it is handled by the base class.
     * @field
     */
    applyAttributes: (
      area: CellArea,
      treeModel: TreeModel,
      iter: TreeIter,
      isExpander: boolean,
      isExpanded: boolean
    ) => void
    /**
     * Creates and returns a class specific `GtkCellAreaContext`
     *   to store cell alignment and allocation details for a said `GtkCellArea`
     *   class.
     * @field
     */
    createContext: (area: CellArea) => CellAreaContext
    /**
     * Creates a new `GtkCellAreaContext` in the same state as
     *   the passed `context` with any cell alignment data and allocations intact.
     * @field
     */
    copyContext: (area: CellArea, context: CellAreaContext) => CellAreaContext
    /**
     * This allows an area to tell its layouting widget whether
     *   it prefers to be allocated in %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or
     *   %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.
     * @field
     */
    getRequestMode: (area: CellArea) => SizeRequestMode
    /**
     * Calculates the minimum and natural width of the
     *   areas cells with the current attributes applied while considering
     *   the particular layouting details of the said `GtkCellArea`. While
     *   requests are performed over a series of rows, alignments and overall
     *   minimum and natural sizes should be stored in the corresponding
     *   `GtkCellAreaContext`.
     * @field
     */
    getPreferredWidth: (
      area: CellArea,
      context: CellAreaContext,
      widget: Widget
    ) => [/* minimumWidth */ number, /* naturalWidth */ number]
    /**
     * Calculates the minimum and natural height
     *   for the area if the passed `context` would be allocated the given width.
     *   When implementing this virtual method it is safe to assume that `context`
     *   has already stored the aligned cell widths for every `GtkTreeModel` row
     *   that `context` will be allocated for since this information was stored
     *   at `GtkCellAreaClass.get_preferred_width()` time. This virtual method
     *   should also store any necessary alignments of cell heights for the
     *   case that the context is allocated a height.
     * @field
     */
    getPreferredHeightForWidth: (
      area: CellArea,
      context: CellAreaContext,
      widget: Widget,
      width: number
    ) => [/* minimumHeight */ number, /* naturalHeight */ number]
    /**
     * Calculates the minimum and natural height of the
     *   areas cells with the current attributes applied. Essentially this is
     *   the same as `GtkCellAreaClass.get_preferred_width()` only for areas
     *   that are being requested as %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT.
     * @field
     */
    getPreferredHeight: (
      area: CellArea,
      context: CellAreaContext,
      widget: Widget
    ) => [/* minimumHeight */ number, /* naturalHeight */ number]
    /**
     * Calculates the minimum and natural width
     *   for the area if the passed `context` would be allocated the given
     *   height. The same as `GtkCellAreaClass.get_preferred_height_for_width()`
     *   only for handling requests in the %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT
     *   mode.
     * @field
     */
    getPreferredWidthForHeight: (
      area: CellArea,
      context: CellAreaContext,
      widget: Widget,
      height: number
    ) => [/* minimumWidth */ number, /* naturalWidth */ number]
    /**
     * This should be implemented to handle changes in child
     *   cell properties for a given `GtkCellRenderer` that were previously
     *   installed on the `GtkCellAreaClass` with gtk_cell_area_class_install_cell_property().
     * @field
     */
    setCellProperty: (
      area: CellArea,
      renderer: CellRenderer,
      propertyId: number,
      value: any,
      pspec: GObject.ParamSpec
    ) => void
    /**
     * This should be implemented to report the values of
     *   child cell properties for a given child `GtkCellRenderer`.
     * @field
     */
    getCellProperty: (
      area: CellArea,
      renderer: CellRenderer,
      propertyId: number,
      value: any,
      pspec: GObject.ParamSpec
    ) => void
    /**
     * This virtual method should be implemented to navigate focus from
     *   cell to cell inside the `GtkCellArea`. The `GtkCellArea` should move
     *   focus from cell to cell inside the area and return %FALSE if focus
     *   logically leaves the area with the following exceptions: When the
     *   area contains no activatable cells, the entire area receives focus.
     *   Focus should not be given to cells that are actually “focus siblings”
     *   of other sibling cells (see gtk_cell_area_get_focus_from_sibling()).
     *   Focus is set by calling gtk_cell_area_set_focus_cell().
     * @field
     */
    focus: (area: CellArea, direction: DirectionType) => boolean
    /**
     * Returns whether the `GtkCellArea` can respond to
     *   `GtkCellAreaClass.activate()`, usually this does not need to be
     *   implemented since the base class takes care of this however it can
     *   be enhanced if the `GtkCellArea` subclass can handle activation in
     *   other ways than activating its `GtkCellRenderers`.
     * @field
     */
    isActivatable: (area: CellArea) => boolean
    /**
     * This is called when the layouting widget rendering the
     *   `GtkCellArea` activates the focus cell (see gtk_cell_area_get_focus_cell()).
     * @field
     */
    activate: (
      area: CellArea,
      context: CellAreaContext,
      widget: Widget,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState,
      editOnly: boolean
    ) => boolean
  }

  abstract class CellAreaClass {
    // Own properties of Gtk-4.0.Gtk.CellAreaClass

    static name: string

    // Owm static methods of Gtk-4.0.Gtk.CellAreaClass

    /**
     * Finds a cell property of a cell area class by name.
     * @param propertyName the name of the child property to find
     * @returns the `GParamSpec` of the child property
     */
    static findCellProperty(
      aclass: CellArea | Function | GObject.GType,
      propertyName: string
    ): GObject.ParamSpec
    /**
     * Installs a cell property on a cell area class.
     * @param propertyId the id for the property
     * @param pspec the `GParamSpec` for the property
     */
    static installCellProperty(
      aclass: CellArea | Function | GObject.GType,
      propertyId: number,
      pspec: GObject.ParamSpec
    ): void
    /**
     * Returns all cell properties of a cell area class.
     * @returns a newly     allocated %NULL-terminated array of `GParamSpec`*.  The array     must be freed with g_free().
     */
    static listCellProperties(
      aclass: CellArea | Function | GObject.GType
    ): GObject.ParamSpec[]
  }

  interface CellAreaContextClass {
    // Own fields of Gtk-4.0.Gtk.CellAreaContextClass

    /**
     * This tells the context that an allocation width or height
     *   (or both) have been decided for a group of rows. The context should
     *   store any allocations for internally aligned cells at this point so
     *   that they dont need to be recalculated at gtk_cell_area_render() time.
     * @field
     */
    allocate: (context: CellAreaContext, width: number, height: number) => void
    /**
     * Clear any previously stored information about requested and
     *   allocated sizes for the context.
     * @field
     */
    reset: (context: CellAreaContext) => void
    /**
     * Returns the aligned height for the given
     *   width that context must store while collecting sizes for it’s rows.
     * @field
     */
    getPreferredHeightForWidth: (
      context: CellAreaContext,
      width: number
    ) => [/* minimumHeight */ number, /* naturalHeight */ number]
    /**
     * Returns the aligned width for the given
     *   height that context must store while collecting sizes for it’s rows.
     * @field
     */
    getPreferredWidthForHeight: (
      context: CellAreaContext,
      height: number
    ) => [/* minimumWidth */ number, /* naturalWidth */ number]
  }

  abstract class CellAreaContextClass {
    // Own properties of Gtk-4.0.Gtk.CellAreaContextClass

    static name: string
  }

  interface CellAreaContextPrivate {}

  class CellAreaContextPrivate {
    // Own properties of Gtk-4.0.Gtk.CellAreaContextPrivate

    static name: string
  }

  interface CellEditableIface {
    // Own fields of Gtk-4.0.Gtk.CellEditableIface

    /**
     * Signal is a sign for the cell renderer to update its
     *    value from the cell_editable.
     * @field
     */
    editingDone: (cellEditable: CellEditable) => void
    /**
     * Signal is meant to indicate that the cell is
     *    finished editing, and the widget may now be destroyed.
     * @field
     */
    removeWidget: (cellEditable: CellEditable) => void
    /**
     * Begins editing on a cell_editable.
     * @field
     */
    startEditing: (cellEditable: CellEditable, event: Gdk.Event | null) => void
  }

  abstract class CellEditableIface {
    // Own properties of Gtk-4.0.Gtk.CellEditableIface

    static name: string
  }

  interface CellLayoutIface {
    // Own fields of Gtk-4.0.Gtk.CellLayoutIface

    /**
     * Packs the cell into the beginning of cell_layout.
     * @field
     */
    packStart: (
      cellLayout: CellLayout,
      cell: CellRenderer,
      expand: boolean
    ) => void
    /**
     * Adds the cell to the end of cell_layout.
     * @field
     */
    packEnd: (
      cellLayout: CellLayout,
      cell: CellRenderer,
      expand: boolean
    ) => void
    /**
     * Unsets all the mappings on all renderers on cell_layout and
     *    removes all renderers from cell_layout.
     * @field
     */
    clear: (cellLayout: CellLayout) => void
    /**
     * Adds an attribute mapping to the list in
     *    cell_layout.
     * @field
     */
    addAttribute: (
      cellLayout: CellLayout,
      cell: CellRenderer,
      attribute: string,
      column: number
    ) => void
    /**
     * Sets the `GtkCellLayout`DataFunc to use for
     *    cell_layout.
     * @field
     */
    setCellDataFunc: (
      cellLayout: CellLayout,
      cell: CellRenderer,
      func: CellLayoutDataFunc | null
    ) => void
    /**
     * Clears all existing attributes previously set
     *    with gtk_cell_layout_set_attributes().
     * @field
     */
    clearAttributes: (cellLayout: CellLayout, cell: CellRenderer) => void
    /**
     * Re-inserts cell at position.
     * @field
     */
    reorder: (
      cellLayout: CellLayout,
      cell: CellRenderer,
      position: number
    ) => void
    /**
     * Get the cell renderers which have been added to
     *    cell_layout.
     * @field
     */
    getCells: (cellLayout: CellLayout) => CellRenderer[]
    /**
     * Get the underlying `GtkCellArea` which might be
     *    cell_layout if called on a `GtkCellArea` or might be NULL if no
     *    `GtkCellArea` is used by cell_layout.
     * @field
     */
    getArea: (cellLayout: CellLayout) => CellArea | null
  }

  abstract class CellLayoutIface {
    // Own properties of Gtk-4.0.Gtk.CellLayoutIface

    static name: string
  }

  interface CellRendererClass {
    // Own fields of Gtk-4.0.Gtk.CellRendererClass

    /**
     * Called to gets whether the cell renderer prefers
     *    a height-for-width layout or a width-for-height layout.
     * @field
     */
    getRequestMode: (cell: CellRenderer) => SizeRequestMode
    /**
     * Called to get a renderer’s natural width.
     * @field
     */
    getPreferredWidth: (
      cell: CellRenderer,
      widget: Widget
    ) => [/* minimumSize */ number, /* naturalSize */ number]
    /**
     * Called to get a renderer’s natural height for width.
     * @field
     */
    getPreferredHeightForWidth: (
      cell: CellRenderer,
      widget: Widget,
      width: number
    ) => [/* minimumHeight */ number, /* naturalHeight */ number]
    /**
     * Called to get a renderer’s natural height.
     * @field
     */
    getPreferredHeight: (
      cell: CellRenderer,
      widget: Widget
    ) => [/* minimumSize */ number, /* naturalSize */ number]
    /**
     * Called to get a renderer’s natural width for height.
     * @field
     */
    getPreferredWidthForHeight: (
      cell: CellRenderer,
      widget: Widget,
      height: number
    ) => [/* minimumWidth */ number, /* naturalWidth */ number]
    /**
     * Called to get the aligned area used by `cell` inside `cell_area`.
     * @field
     */
    getAlignedArea: (
      cell: CellRenderer,
      widget: Widget,
      flags: CellRendererState,
      cellArea: Gdk.Rectangle
    ) => /* alignedArea */ Gdk.Rectangle
    /**
     * Called to snapshot the content of the `GtkCellRenderer`.
     * @field
     */
    snapshot: (
      cell: CellRenderer,
      snapshot: Snapshot,
      widget: Widget,
      backgroundArea: Gdk.Rectangle,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ) => void
    /**
     * Called to activate the content of the `GtkCellRenderer`.
     * @field
     */
    activate: (
      cell: CellRenderer,
      event: Gdk.Event,
      widget: Widget,
      path: string,
      backgroundArea: Gdk.Rectangle,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ) => boolean
    /**
     * Called to initiate editing the content of the `GtkCellRenderer`.
     * @field
     */
    startEditing: (
      cell: CellRenderer,
      event: Gdk.Event | null,
      widget: Widget,
      path: string,
      backgroundArea: Gdk.Rectangle,
      cellArea: Gdk.Rectangle,
      flags: CellRendererState
    ) => CellEditable | null
    /**
     * Signal gets emitted when the user cancels the process of editing a cell.
     * @field
     */
    editingCanceled: (cell: CellRenderer) => void
    /**
     * Signal gets emitted when a cell starts to be edited.
     * @field
     */
    editingStarted: (
      cell: CellRenderer,
      editable: CellEditable,
      path: string
    ) => void
  }

  abstract class CellRendererClass {
    // Own properties of Gtk-4.0.Gtk.CellRendererClass

    static name: string
  }

  interface CellRendererClassPrivate {}

  class CellRendererClassPrivate {
    // Own properties of Gtk-4.0.Gtk.CellRendererClassPrivate

    static name: string
  }

  interface CellRendererPrivate {}

  class CellRendererPrivate {
    // Own properties of Gtk-4.0.Gtk.CellRendererPrivate

    static name: string
  }

  interface CellRendererTextClass {
    // Own fields of Gtk-4.0.Gtk.CellRendererTextClass

    parentClass: CellRendererClass
    edited: (
      cellRendererText: CellRendererText,
      path: string,
      newText: string
    ) => void
  }

  abstract class CellRendererTextClass {
    // Own properties of Gtk-4.0.Gtk.CellRendererTextClass

    static name: string
  }

  interface CenterBoxClass {}

  abstract class CenterBoxClass {
    // Own properties of Gtk-4.0.Gtk.CenterBoxClass

    static name: string
  }

  interface CenterLayoutClass {
    // Own fields of Gtk-4.0.Gtk.CenterLayoutClass

    parentClass: LayoutManagerClass
  }

  abstract class CenterLayoutClass {
    // Own properties of Gtk-4.0.Gtk.CenterLayoutClass

    static name: string
  }

  interface CheckButtonClass {
    // Own fields of Gtk-4.0.Gtk.CheckButtonClass

    parentClass: WidgetClass
    toggled: (checkButton: CheckButton) => void
    activate: (checkButton: CheckButton) => void
  }

  abstract class CheckButtonClass {
    // Own properties of Gtk-4.0.Gtk.CheckButtonClass

    static name: string
  }

  interface ColorChooserInterface {
    // Own fields of Gtk-4.0.Gtk.ColorChooserInterface

    baseInterface: GObject.TypeInterface
    getRgba: (chooser: ColorChooser) => /* color */ Gdk.RGBA
    setRgba: (chooser: ColorChooser, color: Gdk.RGBA) => void
    addPalette: (
      chooser: ColorChooser,
      orientation: Orientation,
      colorsPerLine: number,
      colors: Gdk.RGBA[] | null
    ) => void
    colorActivated: (chooser: ColorChooser, color: Gdk.RGBA) => void
  }

  abstract class ColorChooserInterface {
    // Own properties of Gtk-4.0.Gtk.ColorChooserInterface

    static name: string
  }

  interface ColorDialogButtonClass {
    // Own fields of Gtk-4.0.Gtk.ColorDialogButtonClass

    parentClass: WidgetClass
  }

  abstract class ColorDialogButtonClass {
    // Own properties of Gtk-4.0.Gtk.ColorDialogButtonClass

    static name: string
  }

  interface ColorDialogClass {
    // Own fields of Gtk-4.0.Gtk.ColorDialogClass

    parentClass: GObject.ObjectClass
  }

  abstract class ColorDialogClass {
    // Own properties of Gtk-4.0.Gtk.ColorDialogClass

    static name: string
  }

  interface ColumnViewCellClass {}

  abstract class ColumnViewCellClass {
    // Own properties of Gtk-4.0.Gtk.ColumnViewCellClass

    static name: string
  }

  interface ColumnViewClass {}

  abstract class ColumnViewClass {
    // Own properties of Gtk-4.0.Gtk.ColumnViewClass

    static name: string
  }

  interface ColumnViewColumnClass {}

  abstract class ColumnViewColumnClass {
    // Own properties of Gtk-4.0.Gtk.ColumnViewColumnClass

    static name: string
  }

  interface ColumnViewRowClass {}

  abstract class ColumnViewRowClass {
    // Own properties of Gtk-4.0.Gtk.ColumnViewRowClass

    static name: string
  }

  interface ColumnViewSorterClass {
    // Own fields of Gtk-4.0.Gtk.ColumnViewSorterClass

    parentClass: SorterClass
  }

  abstract class ColumnViewSorterClass {
    // Own properties of Gtk-4.0.Gtk.ColumnViewSorterClass

    static name: string
  }

  interface ComboBoxClass {
    // Own fields of Gtk-4.0.Gtk.ComboBoxClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WidgetClass
    /**
     * Signal is emitted when the active item is changed.
     * @field
     */
    changed: (comboBox: ComboBox) => void
    /**
     * Signal which allows you to change how the text
     *    displayed in a combo box’s entry is displayed.
     * @field
     */
    formatEntryText: (comboBox: ComboBox, path: string) => string | null
    activate: (comboBox: ComboBox) => void
  }

  abstract class ComboBoxClass {
    // Own properties of Gtk-4.0.Gtk.ComboBoxClass

    static name: string
  }

  interface ConstraintClass {
    // Own fields of Gtk-4.0.Gtk.ConstraintClass

    parentClass: GObject.ObjectClass
  }

  abstract class ConstraintClass {
    // Own properties of Gtk-4.0.Gtk.ConstraintClass

    static name: string
  }

  interface ConstraintGuideClass {
    // Own fields of Gtk-4.0.Gtk.ConstraintGuideClass

    parentClass: GObject.ObjectClass
  }

  abstract class ConstraintGuideClass {
    // Own properties of Gtk-4.0.Gtk.ConstraintGuideClass

    static name: string
  }

  interface ConstraintLayoutChildClass {
    // Own fields of Gtk-4.0.Gtk.ConstraintLayoutChildClass

    parentClass: LayoutChildClass
  }

  abstract class ConstraintLayoutChildClass {
    // Own properties of Gtk-4.0.Gtk.ConstraintLayoutChildClass

    static name: string
  }

  interface ConstraintLayoutClass {
    // Own fields of Gtk-4.0.Gtk.ConstraintLayoutClass

    parentClass: LayoutManagerClass
  }

  abstract class ConstraintLayoutClass {
    // Own properties of Gtk-4.0.Gtk.ConstraintLayoutClass

    static name: string
  }

  interface ConstraintTargetInterface {}

  abstract class ConstraintTargetInterface {
    // Own properties of Gtk-4.0.Gtk.ConstraintTargetInterface

    static name: string
  }

  interface CssLocation {
    // Own fields of Gtk-4.0.Gtk.CssLocation

    bytes: number
    chars: number
    lines: number
    lineBytes: number
    lineChars: number
  }

  class CssLocation {
    // Own properties of Gtk-4.0.Gtk.CssLocation

    static name: string
  }

  interface CssProviderClass {}

  abstract class CssProviderClass {
    // Own properties of Gtk-4.0.Gtk.CssProviderClass

    static name: string
  }

  interface CssProviderPrivate {}

  class CssProviderPrivate {
    // Own properties of Gtk-4.0.Gtk.CssProviderPrivate

    static name: string
  }

  interface CssSection {
    // Owm methods of Gtk-4.0.Gtk.CssSection

    /**
     * Returns the location in the CSS document where this section ends.
     * @returns The end location of   this section
     */
    getEndLocation(): CssLocation
    /**
     * Gets the file that `section` was parsed from.
     *
     * If no such file exists, for example because the CSS was loaded via
     * [method`Gtk`.CssProvider.load_from_data], then `NULL` is returned.
     * @returns the `GFile` from which the `section`   was parsed
     */
    getFile(): Gio.File | null
    /**
     * Gets the parent section for the given `section`.
     *
     * The parent section is the section that contains this `section`. A special
     * case are sections of  type `GTK_CSS_SECTION_DOCUMEN`T. Their parent will
     * either be `NULL` if they are the original CSS document that was loaded by
     * [method`Gtk`.CssProvider.load_from_file] or a section of type
     * `GTK_CSS_SECTION_IMPORT` if it was loaded with an ``import`` rule from
     * a different file.
     * @returns the parent section
     */
    getParent(): CssSection | null
    /**
     * Returns the location in the CSS document where this section starts.
     * @returns The start location of   this section
     */
    getStartLocation(): CssLocation
    /**
     * Prints the `section` into `string` in a human-readable form.
     *
     * This is a form like `gtk.css:32:1-23` to denote line 32, characters
     * 1 to 23 in the file `gtk.css`.
     * @param string a `GString` to print to
     */
    print(string: GLib.String): void
    /**
     * Increments the reference count on `section`.
     * @returns the CSS section itself.
     */
    ref(): CssSection
    /**
     * Prints the section into a human-readable text form using
     * [method`Gtk`.CssSection.print].
     * @returns A new string.
     */
    toString(): string | null
    /**
     * Decrements the reference count on `section`, freeing the
     * structure if the reference count reaches 0.
     */
    unref(): void
  }

  /**
   * Defines a part of a CSS document.
   *
   * Because sections are nested into one another, you can use
   * [method`CssSection`.get_parent] to get the containing region.
   * @record
   */
  class CssSection {
    // Own properties of Gtk-4.0.Gtk.CssSection

    static name: string

    // Constructors of Gtk-4.0.Gtk.CssSection

    /**
     * Creates a new `GtkCssSection` referring to the section
     * in the given `file` from the `start` location to the
     * `end` location.
     * @constructor
     * @param file The file this section refers to
     * @param start The start location
     * @param end The end location
     * @returns a new `GtkCssSection`
     */
    constructor(file: Gio.File | null, start: CssLocation, end: CssLocation)
    /**
     * Creates a new `GtkCssSection` referring to the section
     * in the given `file` from the `start` location to the
     * `end` location.
     * @constructor
     * @param file The file this section refers to
     * @param start The start location
     * @param end The end location
     * @returns a new `GtkCssSection`
     */
    static new(
      file: Gio.File | null,
      start: CssLocation,
      end: CssLocation
    ): CssSection
  }

  interface CssStyleChange {}

  class CssStyleChange {
    // Own properties of Gtk-4.0.Gtk.CssStyleChange

    static name: string
  }

  interface CustomFilterClass {
    // Own fields of Gtk-4.0.Gtk.CustomFilterClass

    parentClass: FilterClass
  }

  abstract class CustomFilterClass {
    // Own properties of Gtk-4.0.Gtk.CustomFilterClass

    static name: string
  }

  interface CustomLayoutClass {
    // Own fields of Gtk-4.0.Gtk.CustomLayoutClass

    parentClass: LayoutManagerClass
  }

  abstract class CustomLayoutClass {
    // Own properties of Gtk-4.0.Gtk.CustomLayoutClass

    static name: string
  }

  interface CustomSorterClass {
    // Own fields of Gtk-4.0.Gtk.CustomSorterClass

    parentClass: SorterClass
  }

  abstract class CustomSorterClass {
    // Own properties of Gtk-4.0.Gtk.CustomSorterClass

    static name: string
  }

  interface DialogClass {
    // Own fields of Gtk-4.0.Gtk.DialogClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WindowClass
    /**
     * Signal emitted when an action widget is activated.
     * @field
     */
    response: (dialog: Dialog, responseId: number) => void
    /**
     * Signal emitted when the user uses a keybinding to close the dialog.
     * @field
     */
    close: (dialog: Dialog) => void
  }

  abstract class DialogClass {
    // Own properties of Gtk-4.0.Gtk.DialogClass

    static name: string
  }

  interface DirectoryListClass {
    // Own fields of Gtk-4.0.Gtk.DirectoryListClass

    parentClass: GObject.ObjectClass
  }

  abstract class DirectoryListClass {
    // Own properties of Gtk-4.0.Gtk.DirectoryListClass

    static name: string
  }

  interface DragIconClass {
    // Own fields of Gtk-4.0.Gtk.DragIconClass

    parentClass: WidgetClass
  }

  abstract class DragIconClass {
    // Own properties of Gtk-4.0.Gtk.DragIconClass

    static name: string
  }

  interface DragSourceClass {}

  abstract class DragSourceClass {
    // Own properties of Gtk-4.0.Gtk.DragSourceClass

    static name: string
  }

  interface DrawingAreaClass {
    // Own fields of Gtk-4.0.Gtk.DrawingAreaClass

    parentClass: WidgetClass
    resize: (area: DrawingArea, width: number, height: number) => void
  }

  abstract class DrawingAreaClass {
    // Own properties of Gtk-4.0.Gtk.DrawingAreaClass

    static name: string
  }

  interface DropControllerMotionClass {}

  abstract class DropControllerMotionClass {
    // Own properties of Gtk-4.0.Gtk.DropControllerMotionClass

    static name: string
  }

  interface DropDownClass {
    // Own fields of Gtk-4.0.Gtk.DropDownClass

    parentClass: WidgetClass
  }

  abstract class DropDownClass {
    // Own properties of Gtk-4.0.Gtk.DropDownClass

    static name: string
  }

  interface DropTargetAsyncClass {}

  abstract class DropTargetAsyncClass {
    // Own properties of Gtk-4.0.Gtk.DropTargetAsyncClass

    static name: string
  }

  interface DropTargetClass {}

  abstract class DropTargetClass {
    // Own properties of Gtk-4.0.Gtk.DropTargetClass

    static name: string
  }

  interface EditableInterface {
    // Own fields of Gtk-4.0.Gtk.EditableInterface

    baseIface: GObject.TypeInterface
    insertText: (
      editable: Editable,
      text: string,
      length: number,
      position: number
    ) => /* position */ number
    deleteText: (editable: Editable, startPos: number, endPos: number) => void
    changed: (editable: Editable) => void
    getText: (editable: Editable) => string
    doInsertText: (
      editable: Editable,
      text: string,
      length: number,
      position: number
    ) => /* position */ number
    doDeleteText: (editable: Editable, startPos: number, endPos: number) => void
    getSelectionBounds: (
      editable: Editable
    ) => [/* returnType */ boolean, /* startPos */ number, /* endPos */ number]
    setSelectionBounds: (
      editable: Editable,
      startPos: number,
      endPos: number
    ) => void
    getDelegate: (editable: Editable) => Editable | null
  }

  abstract class EditableInterface {
    // Own properties of Gtk-4.0.Gtk.EditableInterface

    static name: string
  }

  interface EditableLabelClass {
    // Own fields of Gtk-4.0.Gtk.EditableLabelClass

    parentClass: WidgetClass
  }

  abstract class EditableLabelClass {
    // Own properties of Gtk-4.0.Gtk.EditableLabelClass

    static name: string
  }

  interface EmojiChooserClass {}

  abstract class EmojiChooserClass {
    // Own properties of Gtk-4.0.Gtk.EmojiChooserClass

    static name: string
  }

  interface EntryBufferClass {
    // Own fields of Gtk-4.0.Gtk.EntryBufferClass

    parentClass: GObject.ObjectClass
    insertedText: (
      buffer: EntryBuffer,
      position: number,
      chars: string,
      nChars: number
    ) => void
    deletedText: (buffer: EntryBuffer, position: number, nChars: number) => void
    getText: (buffer: EntryBuffer, nBytes: number) => string
    getLength: (buffer: EntryBuffer) => number
    insertText: (
      buffer: EntryBuffer,
      position: number,
      chars: string,
      nChars: number
    ) => number
    deleteText: (
      buffer: EntryBuffer,
      position: number,
      nChars: number
    ) => number
  }

  abstract class EntryBufferClass {
    // Own properties of Gtk-4.0.Gtk.EntryBufferClass

    static name: string
  }

  interface EntryClass {
    // Own fields of Gtk-4.0.Gtk.EntryClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WidgetClass
    /**
     * Class handler for the `GtkEntry::activate` signal. The default
     *   implementation activates the gtk.activate-default action.
     * @field
     */
    activate: (entry: Entry) => void
  }

  /**
   * Class structure for `GtkEntry`. All virtual functions have a default
   * implementation. Derived classes may set the virtual function pointers for the
   * signal handlers to %NULL, but must keep `get_text_area_size` and
   * `get_frame_size` non-%NULL; either use the default implementation, or provide
   * a custom one.
   * @record
   */
  abstract class EntryClass {
    // Own properties of Gtk-4.0.Gtk.EntryClass

    static name: string
  }

  interface EventControllerClass {}

  abstract class EventControllerClass {
    // Own properties of Gtk-4.0.Gtk.EventControllerClass

    static name: string
  }

  interface EventControllerFocusClass {}

  abstract class EventControllerFocusClass {
    // Own properties of Gtk-4.0.Gtk.EventControllerFocusClass

    static name: string
  }

  interface EventControllerKeyClass {}

  abstract class EventControllerKeyClass {
    // Own properties of Gtk-4.0.Gtk.EventControllerKeyClass

    static name: string
  }

  interface EventControllerLegacyClass {}

  abstract class EventControllerLegacyClass {
    // Own properties of Gtk-4.0.Gtk.EventControllerLegacyClass

    static name: string
  }

  interface EventControllerMotionClass {}

  abstract class EventControllerMotionClass {
    // Own properties of Gtk-4.0.Gtk.EventControllerMotionClass

    static name: string
  }

  interface EventControllerScrollClass {}

  abstract class EventControllerScrollClass {
    // Own properties of Gtk-4.0.Gtk.EventControllerScrollClass

    static name: string
  }

  interface EveryFilterClass {}

  abstract class EveryFilterClass {
    // Own properties of Gtk-4.0.Gtk.EveryFilterClass

    static name: string
  }

  interface ExpressionWatch {
    // Owm methods of Gtk-4.0.Gtk.ExpressionWatch

    /**
     * Evaluates the watched expression and on success stores the result
     * in `value`.
     *
     * This is equivalent to calling [method`Gtk`.Expression.evaluate] with the
     * expression and this pointer originally used to create `watch`.
     * @param value an empty `GValue` to be set
     * @returns `TRUE` if the expression could be evaluated and `value` was set
     */
    evaluate(value: any): boolean
    /**
     * Acquires a reference on the given `GtkExpressionWatch`.
     * @returns the `GtkExpressionWatch` with an additional reference
     */
    ref(): ExpressionWatch
    /**
     * Releases a reference on the given `GtkExpressionWatch`.
     *
     * If the reference was the last, the resources associated to `self` are
     * freed.
     */
    unref(): void
    /**
     * Stops watching an expression.
     *
     * See [method`Gtk`.Expression.watch] for how the watch
     * was established.
     */
    unwatch(): void
  }

  /**
   * An opaque structure representing a watched `GtkExpression`.
   *
   * The contents of `GtkExpressionWatch` should only be accessed through the
   * provided API.
   * @record
   */
  class ExpressionWatch {
    // Own properties of Gtk-4.0.Gtk.ExpressionWatch

    static name: string
  }

  interface FileChooserNativeClass {
    // Own fields of Gtk-4.0.Gtk.FileChooserNativeClass

    parentClass: NativeDialogClass
  }

  abstract class FileChooserNativeClass {
    // Own properties of Gtk-4.0.Gtk.FileChooserNativeClass

    static name: string
  }

  interface FileDialogClass {
    // Own fields of Gtk-4.0.Gtk.FileDialogClass

    parentClass: GObject.ObjectClass
  }

  abstract class FileDialogClass {
    // Own properties of Gtk-4.0.Gtk.FileDialogClass

    static name: string
  }

  interface FileLauncherClass {
    // Own fields of Gtk-4.0.Gtk.FileLauncherClass

    parentClass: GObject.ObjectClass
  }

  abstract class FileLauncherClass {
    // Own properties of Gtk-4.0.Gtk.FileLauncherClass

    static name: string
  }

  interface FilterClass {
    // Own fields of Gtk-4.0.Gtk.FilterClass

    parentClass: GObject.ObjectClass
    match: (self: Filter, item: GObject.Object | null) => boolean
    getStrictness: (self: Filter) => FilterMatch
  }

  abstract class FilterClass {
    // Own properties of Gtk-4.0.Gtk.FilterClass

    static name: string
  }

  interface FilterListModelClass {
    // Own fields of Gtk-4.0.Gtk.FilterListModelClass

    parentClass: GObject.ObjectClass
  }

  abstract class FilterListModelClass {
    // Own properties of Gtk-4.0.Gtk.FilterListModelClass

    static name: string
  }

  interface FixedClass {
    // Own fields of Gtk-4.0.Gtk.FixedClass

    parentClass: WidgetClass
  }

  abstract class FixedClass {
    // Own properties of Gtk-4.0.Gtk.FixedClass

    static name: string
  }

  interface FixedLayoutChildClass {
    // Own fields of Gtk-4.0.Gtk.FixedLayoutChildClass

    parentClass: LayoutChildClass
  }

  abstract class FixedLayoutChildClass {
    // Own properties of Gtk-4.0.Gtk.FixedLayoutChildClass

    static name: string
  }

  interface FixedLayoutClass {
    // Own fields of Gtk-4.0.Gtk.FixedLayoutClass

    parentClass: LayoutManagerClass
  }

  abstract class FixedLayoutClass {
    // Own properties of Gtk-4.0.Gtk.FixedLayoutClass

    static name: string
  }

  interface FlattenListModelClass {
    // Own fields of Gtk-4.0.Gtk.FlattenListModelClass

    parentClass: GObject.ObjectClass
  }

  abstract class FlattenListModelClass {
    // Own properties of Gtk-4.0.Gtk.FlattenListModelClass

    static name: string
  }

  interface FlowBoxChildClass {
    // Own fields of Gtk-4.0.Gtk.FlowBoxChildClass

    activate: (child: FlowBoxChild) => void
  }

  abstract class FlowBoxChildClass {
    // Own properties of Gtk-4.0.Gtk.FlowBoxChildClass

    static name: string
  }

  interface FontChooserIface {
    // Own fields of Gtk-4.0.Gtk.FontChooserIface

    baseIface: GObject.TypeInterface
    getFontFamily: (fontchooser: FontChooser) => Pango.FontFamily | null
    getFontFace: (fontchooser: FontChooser) => Pango.FontFace | null
    getFontSize: (fontchooser: FontChooser) => number
    setFilterFunc: (
      fontchooser: FontChooser,
      filter: FontFilterFunc | null
    ) => void
    fontActivated: (chooser: FontChooser, fontname: string) => void
    setFontMap: (
      fontchooser: FontChooser,
      fontmap: Pango.FontMap | null
    ) => void
    getFontMap: (fontchooser: FontChooser) => Pango.FontMap | null
  }

  abstract class FontChooserIface {
    // Own properties of Gtk-4.0.Gtk.FontChooserIface

    static name: string
  }

  interface FontDialogButtonClass {
    // Own fields of Gtk-4.0.Gtk.FontDialogButtonClass

    parentClass: WidgetClass
  }

  abstract class FontDialogButtonClass {
    // Own properties of Gtk-4.0.Gtk.FontDialogButtonClass

    static name: string
  }

  interface FontDialogClass {
    // Own fields of Gtk-4.0.Gtk.FontDialogClass

    parentClass: GObject.ObjectClass
  }

  abstract class FontDialogClass {
    // Own properties of Gtk-4.0.Gtk.FontDialogClass

    static name: string
  }

  interface FrameClass {
    // Own fields of Gtk-4.0.Gtk.FrameClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WidgetClass
    computeChildAllocation: (frame: Frame, allocation: Allocation) => void
  }

  abstract class FrameClass {
    // Own properties of Gtk-4.0.Gtk.FrameClass

    static name: string
  }

  interface GLAreaClass {
    // Own fields of Gtk-4.0.Gtk.GLAreaClass

    /**
     * class closure for the `GtkGLArea::render` signal
     * @field
     */
    render: (area: GLArea, context: Gdk.GLContext) => boolean
    /**
     * class closeure for the `GtkGLArea::resize` signal
     * @field
     */
    resize: (area: GLArea, width: number, height: number) => void
  }

  /**
   * The `GtkGLAreaClass` structure contains only private data.
   * @record
   */
  abstract class GLAreaClass {
    // Own properties of Gtk-4.0.Gtk.GLAreaClass

    static name: string
  }

  interface GestureClass {}

  abstract class GestureClass {
    // Own properties of Gtk-4.0.Gtk.GestureClass

    static name: string
  }

  interface GestureClickClass {}

  abstract class GestureClickClass {
    // Own properties of Gtk-4.0.Gtk.GestureClickClass

    static name: string
  }

  interface GestureDragClass {}

  abstract class GestureDragClass {
    // Own properties of Gtk-4.0.Gtk.GestureDragClass

    static name: string
  }

  interface GestureLongPressClass {}

  abstract class GestureLongPressClass {
    // Own properties of Gtk-4.0.Gtk.GestureLongPressClass

    static name: string
  }

  interface GesturePanClass {}

  abstract class GesturePanClass {
    // Own properties of Gtk-4.0.Gtk.GesturePanClass

    static name: string
  }

  interface GestureRotateClass {}

  abstract class GestureRotateClass {
    // Own properties of Gtk-4.0.Gtk.GestureRotateClass

    static name: string
  }

  interface GestureSingleClass {}

  abstract class GestureSingleClass {
    // Own properties of Gtk-4.0.Gtk.GestureSingleClass

    static name: string
  }

  interface GestureStylusClass {}

  abstract class GestureStylusClass {
    // Own properties of Gtk-4.0.Gtk.GestureStylusClass

    static name: string
  }

  interface GestureSwipeClass {}

  abstract class GestureSwipeClass {
    // Own properties of Gtk-4.0.Gtk.GestureSwipeClass

    static name: string
  }

  interface GestureZoomClass {}

  abstract class GestureZoomClass {
    // Own properties of Gtk-4.0.Gtk.GestureZoomClass

    static name: string
  }

  interface GraphicsOffloadClass {
    // Own fields of Gtk-4.0.Gtk.GraphicsOffloadClass

    parentClass: WidgetClass
  }

  abstract class GraphicsOffloadClass {
    // Own properties of Gtk-4.0.Gtk.GraphicsOffloadClass

    static name: string
  }

  interface GridClass {
    // Own fields of Gtk-4.0.Gtk.GridClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WidgetClass
  }

  abstract class GridClass {
    // Own properties of Gtk-4.0.Gtk.GridClass

    static name: string
  }

  interface GridLayoutChildClass {
    // Own fields of Gtk-4.0.Gtk.GridLayoutChildClass

    parentClass: LayoutChildClass
  }

  abstract class GridLayoutChildClass {
    // Own properties of Gtk-4.0.Gtk.GridLayoutChildClass

    static name: string
  }

  interface GridLayoutClass {
    // Own fields of Gtk-4.0.Gtk.GridLayoutClass

    parentClass: LayoutManagerClass
  }

  abstract class GridLayoutClass {
    // Own properties of Gtk-4.0.Gtk.GridLayoutClass

    static name: string
  }

  interface GridViewClass {}

  abstract class GridViewClass {
    // Own properties of Gtk-4.0.Gtk.GridViewClass

    static name: string
  }

  interface IMContextClass {
    // Own fields of Gtk-4.0.Gtk.IMContextClass

    /**
     * Default handler of the [signal`Gtk`.IMContext::preedit-start] signal.
     * @field
     */
    preeditStart: (context: IMContext) => void
    /**
     * Default handler of the [signal`Gtk`.IMContext::preedit-end] signal.
     * @field
     */
    preeditEnd: (context: IMContext) => void
    /**
     * Default handler of the [signal`Gtk`.IMContext::preedit-changed]
     *   signal.
     * @field
     */
    preeditChanged: (context: IMContext) => void
    /**
     * Default handler of the [signal`Gtk`.IMContext::commit] signal.
     * @field
     */
    commit: (context: IMContext, str: string) => void
    /**
     * Default handler of the
     *   [signal`Gtk`.IMContext::retrieve-surrounding] signal.
     * @field
     */
    retrieveSurrounding: (context: IMContext) => boolean
    /**
     * Default handler of the
     *   [signal`Gtk`.IMContext::delete-surrounding] signal.
     * @field
     */
    deleteSurrounding: (
      context: IMContext,
      offset: number,
      nChars: number
    ) => boolean
    /**
     * Called via [method`Gtk`.IMContext.set_client_widget] when
     *   the input window where the entered text will appear changes. Override this
     *   to keep track of the current input window, for instance for the purpose of
     *   positioning a status display of your input method.
     * @field
     */
    setClientWidget: (context: IMContext, widget: Widget | null) => void
    /**
     * Called via [method`Gtk`.IMContext.get_preedit_string]
     *   to retrieve the text currently being preedited for display at the cursor
     *   position. Any input method which composes complex characters or any
     *   other compositions from multiple sequential key presses should override
     *   this method to provide feedback.
     * @field
     */
    getPreeditString: (
      context: IMContext
    ) => [
      /* str */ string | null,
      /* attrs */ Pango.AttrList,
      /* cursorPos */ number,
    ]
    /**
     * Called via [method`Gtk`.IMContext.filter_keypress] on every
     *   key press or release event. Every non-trivial input method needs to
     *   override this in order to implement the mapping from key events to text.
     *   A return value of %TRUE indicates to the caller that the event was
     *   consumed by the input method. In that case, the [signal`Gtk`.IMContext::commit]
     *   signal should be emitted upon completion of a key sequence to pass the
     *   resulting text back to the input widget. Alternatively, %FALSE may be
     *   returned to indicate that the event wasn’t handled by the input method.
     *   If a builtin mapping exists for the key, it is used to produce a
     *   character.
     * @field
     */
    filterKeypress: (context: IMContext, event: Gdk.Event) => boolean
    /**
     * Called via [method`Gtk`.IMContext.focus_in] when the input widget
     *   has gained focus. May be overridden to keep track of the current focus.
     * @field
     */
    focusIn: (context: IMContext) => void
    /**
     * Called via [method`Gtk`.IMContext.focus_out] when the input widget
     *   has lost focus. May be overridden to keep track of the current focus.
     * @field
     */
    focusOut: (context: IMContext) => void
    /**
     * Called via [method`Gtk`.IMContext.reset] to signal a change such as a
     *   change in cursor position. An input method that implements preediting
     *   should override this method to clear the preedit state on reset.
     * @field
     */
    reset: (context: IMContext) => void
    /**
     * Called via [method`Gtk`.IMContext.set_cursor_location]
     *   to inform the input method of the current cursor location relative to
     *   the client window. May be overridden to implement the display of popup
     *   windows at the cursor position.
     * @field
     */
    setCursorLocation: (context: IMContext, area: Gdk.Rectangle) => void
    /**
     * Called via [method`Gtk`.IMContext.set_use_preedit] to control
     *   the use of the preedit string. Override this to display feedback by some
     *   other means if turned off.
     * @field
     */
    setUsePreedit: (context: IMContext, usePreedit: boolean) => void
    /**
     * Called via [method`Gtk`.IMContext.set_surrounding] in
     *   response to [signal`Gtk`.IMContext::retrieve-surrounding] signal to update
     *   the input method’s idea of the context around the cursor. It is not necessary
     *   to override this method even with input methods which implement
     *   context-dependent behavior. The base implementation is sufficient for
     *   [method`Gtk`.IMContext.get_surrounding] to work.
     * @field
     */
    setSurrounding: (
      context: IMContext,
      text: string,
      len: number,
      cursorIndex: number
    ) => void
    /**
     * Called via [method`Gtk`.IMContext.get_surrounding] to update
     *   the context around the cursor location. It is not necessary to override this
     *   method even with input methods which implement context-dependent behavior.
     *   The base implementation emits [signal`Gtk`.IMContext::retrieve-surrounding]
     *   and records the context received by the subsequent invocation of
     *   [vfunc`Gtk`.IMContext.get_surrounding].
     * @field
     */
    getSurrounding: (
      context: IMContext
    ) => [
      /* returnType */ boolean,
      /* text */ string | null,
      /* cursorIndex */ number,
    ]
    /**
     * Called via
     *   [method`Gtk`.IMContext.set_surrounding_with_selection] in response to the
     *   [signal`Gtk`.IMContext::retrieve-surrounding] signal to update the input
     *   method’s idea of the context around the cursor. It is not necessary to
     *   override this method even with input methods which implement
     *   context-dependent behavior. The base implementation is sufficient for
     *   [method`Gtk`.IMContext.get_surrounding] to work.
     * @field
     */
    setSurroundingWithSelection: (
      context: IMContext,
      text: string,
      len: number,
      cursorIndex: number,
      anchorIndex: number
    ) => void
    /**
     * Called via
     *   [method`Gtk`.IMContext.get_surrounding_with_selection] to update the
     *   context around the cursor location. It is not necessary to override
     *   this method even with input methods which implement context-dependent
     *   behavior. The base implementation emits
     *   [signal`Gtk`.IMContext::retrieve-surrounding] and records the context
     *   received by the subsequent invocation of [vfunc`Gtk`.IMContext.get_surrounding].
     * @field
     */
    getSurroundingWithSelection: (
      context: IMContext
    ) => [
      /* returnType */ boolean,
      /* text */ string | null,
      /* cursorIndex */ number,
      /* anchorIndex */ number,
    ]
    activateOsk: (context: IMContext) => void
    activateOskWithEvent: (context: IMContext, event: Gdk.Event) => boolean
  }

  abstract class IMContextClass {
    // Own properties of Gtk-4.0.Gtk.IMContextClass

    static name: string
  }

  interface IMContextSimpleClass {
    // Own fields of Gtk-4.0.Gtk.IMContextSimpleClass

    parentClass: IMContextClass
  }

  abstract class IMContextSimpleClass {
    // Own properties of Gtk-4.0.Gtk.IMContextSimpleClass

    static name: string
  }

  interface IMContextSimplePrivate {}

  class IMContextSimplePrivate {
    // Own properties of Gtk-4.0.Gtk.IMContextSimplePrivate

    static name: string
  }

  interface IMMulticontextClass {
    // Own fields of Gtk-4.0.Gtk.IMMulticontextClass

    parentClass: IMContextClass
  }

  abstract class IMMulticontextClass {
    // Own properties of Gtk-4.0.Gtk.IMMulticontextClass

    static name: string
  }

  interface IMMulticontextPrivate {}

  class IMMulticontextPrivate {
    // Own properties of Gtk-4.0.Gtk.IMMulticontextPrivate

    static name: string
  }

  interface InscriptionClass {
    // Own fields of Gtk-4.0.Gtk.InscriptionClass

    parentClass: WidgetClass
  }

  abstract class InscriptionClass {
    // Own properties of Gtk-4.0.Gtk.InscriptionClass

    static name: string
  }

  interface KeyvalTriggerClass {}

  abstract class KeyvalTriggerClass {
    // Own properties of Gtk-4.0.Gtk.KeyvalTriggerClass

    static name: string
  }

  interface LayoutChildClass {}

  abstract class LayoutChildClass {
    // Own properties of Gtk-4.0.Gtk.LayoutChildClass

    static name: string
  }

  interface LayoutManagerClass {
    // Own fields of Gtk-4.0.Gtk.LayoutManagerClass

    /**
     * a virtual function, used to return the preferred
     *   request mode for the layout manager; for instance, "width for height"
     *   or "height for width"; see `GtkSizeRequestMode`
     * @field
     */
    getRequestMode: (manager: LayoutManager, widget: Widget) => SizeRequestMode
    /**
     * a virtual function, used to measure the minimum and preferred
     *   sizes of the widget using the layout manager for a given orientation
     * @field
     */
    measure: (
      manager: LayoutManager,
      widget: Widget,
      orientation: Orientation,
      forSize: number
    ) => [
      /* minimum */ number,
      /* natural */ number,
      /* minimumBaseline */ number,
      /* naturalBaseline */ number,
    ]
    /**
     * a virtual function, used to allocate the size of the widget
     *   using the layout manager
     * @field
     */
    allocate: (
      manager: LayoutManager,
      widget: Widget,
      width: number,
      height: number,
      baseline: number
    ) => void
    /**
     * the type of `GtkLayoutChild` used by this layout manager
     * @field
     */
    layoutChildType: GObject.GType
    /**
     * a virtual function, used to create a `GtkLayoutChild`
     *   meta object for the layout properties
     * @field
     */
    createLayoutChild: (
      manager: LayoutManager,
      widget: Widget,
      forChild: Widget
    ) => LayoutChild
    /**
     * a virtual function, called when the widget using the layout
     *   manager is attached to a `GtkRoot`
     * @field
     */
    root: (manager: LayoutManager) => void
    /**
     * a virtual function, called when the widget using the layout
     *   manager is detached from a `GtkRoot`
     * @field
     */
    unroot: (manager: LayoutManager) => void
  }

  /**
   * The `GtkLayoutManagerClass` structure contains only private data, and
   * should only be accessed through the provided API, or when subclassing
   * `GtkLayoutManager`.
   * @record
   */
  abstract class LayoutManagerClass {
    // Own properties of Gtk-4.0.Gtk.LayoutManagerClass

    static name: string
  }

  interface ListBaseClass {}

  abstract class ListBaseClass {
    // Own properties of Gtk-4.0.Gtk.ListBaseClass

    static name: string
  }

  interface ListBoxRowClass {
    // Own fields of Gtk-4.0.Gtk.ListBoxRowClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WidgetClass
    activate: (row: ListBoxRow) => void
  }

  abstract class ListBoxRowClass {
    // Own properties of Gtk-4.0.Gtk.ListBoxRowClass

    static name: string
  }

  interface ListHeaderClass {}

  abstract class ListHeaderClass {
    // Own properties of Gtk-4.0.Gtk.ListHeaderClass

    static name: string
  }

  interface ListItemClass {}

  abstract class ListItemClass {
    // Own properties of Gtk-4.0.Gtk.ListItemClass

    static name: string
  }

  interface ListItemFactoryClass {}

  abstract class ListItemFactoryClass {
    // Own properties of Gtk-4.0.Gtk.ListItemFactoryClass

    static name: string
  }

  interface ListStoreClass {
    // Own fields of Gtk-4.0.Gtk.ListStoreClass

    parentClass: GObject.ObjectClass
  }

  abstract class ListStoreClass {
    // Own properties of Gtk-4.0.Gtk.ListStoreClass

    static name: string
  }

  interface ListStorePrivate {}

  class ListStorePrivate {
    // Own properties of Gtk-4.0.Gtk.ListStorePrivate

    static name: string
  }

  interface ListViewClass {}

  abstract class ListViewClass {
    // Own properties of Gtk-4.0.Gtk.ListViewClass

    static name: string
  }

  interface MapListModelClass {
    // Own fields of Gtk-4.0.Gtk.MapListModelClass

    parentClass: GObject.ObjectClass
  }

  abstract class MapListModelClass {
    // Own properties of Gtk-4.0.Gtk.MapListModelClass

    static name: string
  }

  interface MediaControlsClass {
    // Own fields of Gtk-4.0.Gtk.MediaControlsClass

    parentClass: WidgetClass
  }

  abstract class MediaControlsClass {
    // Own properties of Gtk-4.0.Gtk.MediaControlsClass

    static name: string
  }

  interface MediaFileClass {
    // Own fields of Gtk-4.0.Gtk.MediaFileClass

    parentClass: MediaStreamClass
    open: (self: MediaFile) => void
    close: (self: MediaFile) => void
  }

  abstract class MediaFileClass {
    // Own properties of Gtk-4.0.Gtk.MediaFileClass

    static name: string
  }

  interface MediaStreamClass {
    // Own fields of Gtk-4.0.Gtk.MediaStreamClass

    parentClass: GObject.ObjectClass
    play: (self: MediaStream) => boolean
    pause: (self: MediaStream) => void
    seek: (self: MediaStream, timestamp: number) => void
    updateAudio: (self: MediaStream, muted: boolean, volume: number) => void
    realize: (self: MediaStream, surface: Gdk.Surface) => void
    unrealize: (self: MediaStream, surface: Gdk.Surface) => void
  }

  abstract class MediaStreamClass {
    // Own properties of Gtk-4.0.Gtk.MediaStreamClass

    static name: string
  }

  interface MessageDialogClass {}

  abstract class MessageDialogClass {
    // Own properties of Gtk-4.0.Gtk.MessageDialogClass

    static name: string
  }

  interface MnemonicActionClass {}

  abstract class MnemonicActionClass {
    // Own properties of Gtk-4.0.Gtk.MnemonicActionClass

    static name: string
  }

  interface MnemonicTriggerClass {}

  abstract class MnemonicTriggerClass {
    // Own properties of Gtk-4.0.Gtk.MnemonicTriggerClass

    static name: string
  }

  interface MountOperationClass {
    // Own fields of Gtk-4.0.Gtk.MountOperationClass

    /**
     * The parent class.
     * @field
     */
    parentClass: Gio.MountOperationClass
  }

  abstract class MountOperationClass {
    // Own properties of Gtk-4.0.Gtk.MountOperationClass

    static name: string
  }

  interface MountOperationPrivate {}

  class MountOperationPrivate {
    // Own properties of Gtk-4.0.Gtk.MountOperationPrivate

    static name: string
  }

  interface MultiFilterClass {}

  abstract class MultiFilterClass {
    // Own properties of Gtk-4.0.Gtk.MultiFilterClass

    static name: string
  }

  interface MultiSelectionClass {
    // Own fields of Gtk-4.0.Gtk.MultiSelectionClass

    parentClass: GObject.ObjectClass
  }

  abstract class MultiSelectionClass {
    // Own properties of Gtk-4.0.Gtk.MultiSelectionClass

    static name: string
  }

  interface MultiSorterClass {
    // Own fields of Gtk-4.0.Gtk.MultiSorterClass

    parentClass: SorterClass
  }

  abstract class MultiSorterClass {
    // Own properties of Gtk-4.0.Gtk.MultiSorterClass

    static name: string
  }

  interface NamedActionClass {}

  abstract class NamedActionClass {
    // Own properties of Gtk-4.0.Gtk.NamedActionClass

    static name: string
  }

  interface NativeDialogClass {
    // Own fields of Gtk-4.0.Gtk.NativeDialogClass

    /**
     * class handler for the `GtkNativeDialog::response` signal
     * @field
     */
    response: (self: NativeDialog, responseId: number) => void
    show: (self: NativeDialog) => void
    hide: (self: NativeDialog) => void
  }

  /**
   * Class structure for `GtkNativeDialog`.
   * @record
   */
  abstract class NativeDialogClass {
    // Own properties of Gtk-4.0.Gtk.NativeDialogClass

    static name: string
  }

  interface NativeInterface {}

  abstract class NativeInterface {
    // Own properties of Gtk-4.0.Gtk.NativeInterface

    static name: string
  }

  interface NeverTriggerClass {}

  abstract class NeverTriggerClass {
    // Own properties of Gtk-4.0.Gtk.NeverTriggerClass

    static name: string
  }

  interface NoSelectionClass {
    // Own fields of Gtk-4.0.Gtk.NoSelectionClass

    parentClass: GObject.ObjectClass
  }

  abstract class NoSelectionClass {
    // Own properties of Gtk-4.0.Gtk.NoSelectionClass

    static name: string
  }

  interface NothingActionClass {}

  abstract class NothingActionClass {
    // Own properties of Gtk-4.0.Gtk.NothingActionClass

    static name: string
  }

  interface NumericSorterClass {
    // Own fields of Gtk-4.0.Gtk.NumericSorterClass

    parentClass: SorterClass
  }

  abstract class NumericSorterClass {
    // Own properties of Gtk-4.0.Gtk.NumericSorterClass

    static name: string
  }

  interface OrientableIface {
    // Own fields of Gtk-4.0.Gtk.OrientableIface

    baseIface: GObject.TypeInterface
  }

  abstract class OrientableIface {
    // Own properties of Gtk-4.0.Gtk.OrientableIface

    static name: string
  }

  interface OverlayLayoutChildClass {
    // Own fields of Gtk-4.0.Gtk.OverlayLayoutChildClass

    parentClass: LayoutChildClass
  }

  abstract class OverlayLayoutChildClass {
    // Own properties of Gtk-4.0.Gtk.OverlayLayoutChildClass

    static name: string
  }

  interface OverlayLayoutClass {
    // Own fields of Gtk-4.0.Gtk.OverlayLayoutClass

    parentClass: LayoutManagerClass
  }

  abstract class OverlayLayoutClass {
    // Own properties of Gtk-4.0.Gtk.OverlayLayoutClass

    static name: string
  }

  interface PadActionEntry {
    // Own fields of Gtk-4.0.Gtk.PadActionEntry

    /**
     * the type of pad feature that will trigger this action entry.
     * @field
     */
    type: PadActionType
    /**
     * the 0-indexed button/ring/strip number that will trigger this action
     *   entry.
     * @field
     */
    index: number
    /**
     * the mode that will trigger this action entry, or -1 for all modes.
     * @field
     */
    mode: number
    /**
     * Human readable description of this action entry, this string should
     *   be deemed user-visible.
     * @field
     */
    label: string
    /**
     * action name that will be activated in the `GActionGroup`.
     * @field
     */
    actionName: string
  }

  /**
   * Struct defining a pad action entry.
   * @record
   */
  class PadActionEntry {
    // Own properties of Gtk-4.0.Gtk.PadActionEntry

    static name: string
  }

  interface PadControllerClass {}

  abstract class PadControllerClass {
    // Own properties of Gtk-4.0.Gtk.PadControllerClass

    static name: string
  }

  interface PageRange {
    // Own fields of Gtk-4.0.Gtk.PageRange

    /**
     * start of page range.
     * @field
     */
    start: number
    /**
     * end of page range.
     * @field
     */
    end: number
  }

  /**
   * A range of pages to print.
   *
   * See also [method`Gtk`.PrintSettings.set_page_ranges].
   * @record
   */
  class PageRange {
    // Own properties of Gtk-4.0.Gtk.PageRange

    static name: string
  }

  interface PaperSize {
    // Owm methods of Gtk-4.0.Gtk.PaperSize

    /**
     * Copies an existing `GtkPaperSize`.
     * @returns a copy of @other
     */
    copy(): PaperSize
    /**
     * Free the given `GtkPaperSize` object.
     */
    free(): void
    /**
     * Gets the default bottom margin for the `GtkPaperSize`.
     * @param unit the unit for the return value, not %GTK_UNIT_NONE
     * @returns the default bottom margin
     */
    getDefaultBottomMargin(unit: Unit): number
    /**
     * Gets the default left margin for the `GtkPaperSize`.
     * @param unit the unit for the return value, not %GTK_UNIT_NONE
     * @returns the default left margin
     */
    getDefaultLeftMargin(unit: Unit): number
    /**
     * Gets the default right margin for the `GtkPaperSize`.
     * @param unit the unit for the return value, not %GTK_UNIT_NONE
     * @returns the default right margin
     */
    getDefaultRightMargin(unit: Unit): number
    /**
     * Gets the default top margin for the `GtkPaperSize`.
     * @param unit the unit for the return value, not %GTK_UNIT_NONE
     * @returns the default top margin
     */
    getDefaultTopMargin(unit: Unit): number
    /**
     * Gets the human-readable name of the `GtkPaperSize`.
     * @returns the human-readable name of @size
     */
    getDisplayName(): string
    /**
     * Gets the paper height of the `GtkPaperSize`, in
     * units of `unit`.
     * @param unit the unit for the return value, not %GTK_UNIT_NONE
     * @returns the paper height
     */
    getHeight(unit: Unit): number
    /**
     * Gets the name of the `GtkPaperSize`.
     * @returns the name of @size
     */
    getName(): string
    /**
     * Gets the PPD name of the `GtkPaperSize`, which
     * may be %NULL.
     * @returns the PPD name of @size
     */
    getPpdName(): string
    /**
     * Gets the paper width of the `GtkPaperSize`, in
     * units of `unit`.
     * @param unit the unit for the return value, not %GTK_UNIT_NONE
     * @returns the paper width
     */
    getWidth(unit: Unit): number
    /**
     * Returns %TRUE if `size` is not a standard paper size.
     * @returns whether @size is a custom paper size.
     */
    isCustom(): boolean
    /**
     * Compares two `GtkPaperSize` objects.
     * @param size2 another `GtkPaperSize` object
     * @returns %TRUE, if @size1 and @size2 represent the same paper size
     */
    isEqual(size2: PaperSize): boolean
    /**
     * Returns %TRUE if `size` is an IPP standard paper size.
     * @returns whether @size is not an IPP custom paper size.
     */
    isIpp(): boolean
    /**
     * Changes the dimensions of a `size` to `width` x `height`.
     * @param width the new width in units of `unit`
     * @param height the new height in units of `unit`
     * @param unit the unit for `width` and `height`
     */
    setSize(width: number, height: number, unit: Unit): void
    /**
     * Serialize a paper size to an `a{sv}` variant.
     * @returns a new, floating, `GVariant`
     */
    toGvariant(): GLib.Variant
    /**
     * This function adds the paper size from `size` to `key_file`.
     * @param keyFile the `GKeyFile` to save the paper size to
     * @param groupName the group to add the settings to in `key_file`
     */
    toKeyFile(keyFile: GLib.KeyFile, groupName: string): void
  }

  /**
   * `GtkPaperSize` handles paper sizes.
   *
   * It uses the standard called
   * [PWG 5101.1-2002 PWG: Standard for Media Standardized Names](http://www.pwg.org/standards.html)
   * to name the paper sizes (and to get the data for the page sizes).
   * In addition to standard paper sizes, `GtkPaperSize` allows to
   * construct custom paper sizes with arbitrary dimensions.
   *
   * The `GtkPaperSize` object stores not only the dimensions (width
   * and height) of a paper size and its name, it also provides
   * default print margins.
   * @record
   */
  class PaperSize {
    // Own properties of Gtk-4.0.Gtk.PaperSize

    static name: string

    // Constructors of Gtk-4.0.Gtk.PaperSize

    /**
     * Creates a new `GtkPaperSize` object by parsing a
     * [PWG 5101.1-2002](ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf)
     * paper name.
     *
     * If `name` is %NULL, the default paper size is returned,
     * see [func`Gtk`.PaperSize.get_default].
     * @constructor
     * @param name a paper size name
     * @returns a new `GtkPaperSize`, use [method@Gtk.PaperSize.free] to free it
     */
    constructor(name: string | null)
    /**
     * Creates a new `GtkPaperSize` object by parsing a
     * [PWG 5101.1-2002](ftp://ftp.pwg.org/pub/pwg/candidates/cs-pwgmsn10-20020226-5101.1.pdf)
     * paper name.
     *
     * If `name` is %NULL, the default paper size is returned,
     * see [func`Gtk`.PaperSize.get_default].
     * @constructor
     * @param name a paper size name
     * @returns a new `GtkPaperSize`, use [method@Gtk.PaperSize.free] to free it
     */
    static new(name: string | null): PaperSize
    /**
     * Creates a new `GtkPaperSize` object with the
     * given parameters.
     * @constructor
     * @param name the paper name
     * @param displayName the human-readable name
     * @param width the paper width, in units of `unit`
     * @param height the paper height, in units of `unit`
     * @param unit the unit for `width` and `height`. not %GTK_UNIT_NONE.
     * @returns a new `GtkPaperSize` object, use [method@Gtk.PaperSize.free] to free it
     */
    static newCustom(
      name: string,
      displayName: string,
      width: number,
      height: number,
      unit: Unit
    ): PaperSize
    /**
     * Deserialize a paper size from a `GVariant`.
     *
     * The `GVariant must be in the format produced by
     * [method`Gtk`.PaperSize.to_gvariant].
     * @constructor
     * @param variant an a{sv} `GVariant`
     * @returns a new `GtkPaperSize` object
     */
    static newFromGvariant(variant: GLib.Variant): PaperSize
    /**
     * Creates a new `GtkPaperSize` object by using
     * IPP information.
     *
     * If `ipp_name` is not a recognized paper name,
     * `width` and `height` are used to
     * construct a custom `GtkPaperSize` object.
     * @constructor
     * @param ippName an IPP paper name
     * @param width the paper width, in points
     * @param height the paper height in points
     * @returns a new `GtkPaperSize`, use [method@Gtk.PaperSize.free] to free it
     */
    static newFromIpp(ippName: string, width: number, height: number): PaperSize
    /**
     * Reads a paper size from the group `group_name` in the key file
     * `key_file`.
     * @constructor
     * @param keyFile the `GKeyFile` to retrieve the papersize from
     * @param groupName the name of the group in the key file to read,   or %NULL to read the first group
     * @returns a new `GtkPaperSize` object with the restored paper size
     */
    static newFromKeyFile(
      keyFile: GLib.KeyFile,
      groupName: string | null
    ): PaperSize
    /**
     * Creates a new `GtkPaperSize` object by using
     * PPD information.
     *
     * If `ppd_name` is not a recognized PPD paper name,
     * `ppd_display_name,` `width` and `height` are used to
     * construct a custom `GtkPaperSize` object.
     * @constructor
     * @param ppdName a PPD paper name
     * @param ppdDisplayName the corresponding human-readable name
     * @param width the paper width, in points
     * @param height the paper height in points
     * @returns a new `GtkPaperSize`, use [method@Gtk.PaperSize.free] to free it
     */
    static newFromPpd(
      ppdName: string,
      ppdDisplayName: string,
      width: number,
      height: number
    ): PaperSize
    /**
     * Returns the name of the default paper size, which
     * depends on the current locale.
     * @returns the name of the default paper size. The string is owned by GTK and should not be modified.
     */
    static getDefault(): string
    /**
     * Creates a list of known paper sizes.
     * @param includeCustom whether to include custom paper sizes   as defined in the page setup dialog
     * @returns a newly allocated list of newly    allocated `GtkPaperSize` objects
     */
    static getPaperSizes(includeCustom: boolean): PaperSize[]
  }

  interface PasswordEntryBufferClass {
    // Own fields of Gtk-4.0.Gtk.PasswordEntryBufferClass

    parentClass: EntryBufferClass
  }

  abstract class PasswordEntryBufferClass {
    // Own properties of Gtk-4.0.Gtk.PasswordEntryBufferClass

    static name: string
  }

  interface PasswordEntryClass {}

  abstract class PasswordEntryClass {
    // Own properties of Gtk-4.0.Gtk.PasswordEntryClass

    static name: string
  }

  interface PictureClass {
    // Own fields of Gtk-4.0.Gtk.PictureClass

    parentClass: WidgetClass
  }

  abstract class PictureClass {
    // Own properties of Gtk-4.0.Gtk.PictureClass

    static name: string
  }

  interface PopoverClass {
    // Own fields of Gtk-4.0.Gtk.PopoverClass

    parentClass: WidgetClass
    closed: (popover: Popover) => void
    activateDefault: (popover: Popover) => void
  }

  abstract class PopoverClass {
    // Own properties of Gtk-4.0.Gtk.PopoverClass

    static name: string
  }

  interface PrintBackend {}

  class PrintBackend {
    // Own properties of Gtk-4.0.Gtk.PrintBackend

    static name: string
  }

  interface PrintDialogClass {
    // Own fields of Gtk-4.0.Gtk.PrintDialogClass

    parentClass: GObject.ObjectClass
  }

  abstract class PrintDialogClass {
    // Own properties of Gtk-4.0.Gtk.PrintDialogClass

    static name: string
  }

  interface PrintOperationClass {
    // Own fields of Gtk-4.0.Gtk.PrintOperationClass

    /**
     * The parent class.
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * Signal emitted when the print operation run has finished
     *    doing everything required for printing.
     * @field
     */
    done: (operation: PrintOperation, result: PrintOperationResult) => void
    /**
     * Signal emitted after the user has finished changing
     *    print settings in the dialog, before the actual rendering starts.
     * @field
     */
    beginPrint: (operation: PrintOperation, context: PrintContext) => void
    /**
     * Signal emitted after the “begin-print” signal, but
     *    before the actual rendering starts.
     * @field
     */
    paginate: (operation: PrintOperation, context: PrintContext) => boolean
    /**
     * Emitted once for every page that is printed,
     *    to give the application a chance to modify the page setup.
     * @field
     */
    requestPageSetup: (
      operation: PrintOperation,
      context: PrintContext,
      pageNr: number,
      setup: PageSetup
    ) => void
    /**
     * Signal emitted for every page that is printed.
     * @field
     */
    drawPage: (
      operation: PrintOperation,
      context: PrintContext,
      pageNr: number
    ) => void
    /**
     * Signal emitted after all pages have been rendered.
     * @field
     */
    endPrint: (operation: PrintOperation, context: PrintContext) => void
    /**
     * Emitted at between the various phases of the print
     *    operation.
     * @field
     */
    statusChanged: (operation: PrintOperation) => void
    /**
     * Signal emitted right before “begin-print” if
     *    you added a custom widget in the “create-custom-widget” handler.
     * @field
     */
    customWidgetApply: (operation: PrintOperation, widget: Widget) => void
    /**
     * Signal emitted when a preview is requested from the
     *    native dialog.
     * @field
     */
    preview: (
      operation: PrintOperation,
      preview: PrintOperationPreview,
      context: PrintContext,
      parent: Window
    ) => boolean
    /**
     * Emitted after change of selected printer.
     * @field
     */
    updateCustomWidget: (
      operation: PrintOperation,
      widget: Widget,
      setup: PageSetup,
      settings: PrintSettings
    ) => void
  }

  abstract class PrintOperationClass {
    // Own properties of Gtk-4.0.Gtk.PrintOperationClass

    static name: string
  }

  interface PrintOperationPreviewIface {
    // Own fields of Gtk-4.0.Gtk.PrintOperationPreviewIface

    gIface: GObject.TypeInterface
    ready: (preview: PrintOperationPreview, context: PrintContext) => void
    gotPageSize: (
      preview: PrintOperationPreview,
      context: PrintContext,
      pageSetup: PageSetup
    ) => void
    renderPage: (preview: PrintOperationPreview, pageNr: number) => void
    isSelected: (preview: PrintOperationPreview, pageNr: number) => boolean
    endPreview: (preview: PrintOperationPreview) => void
  }

  abstract class PrintOperationPreviewIface {
    // Own properties of Gtk-4.0.Gtk.PrintOperationPreviewIface

    static name: string
  }

  interface PrintOperationPrivate {}

  class PrintOperationPrivate {
    // Own properties of Gtk-4.0.Gtk.PrintOperationPrivate

    static name: string
  }

  interface PrintSetup {
    // Owm methods of Gtk-4.0.Gtk.PrintSetup

    /**
     * Returns the page setup of `setup`.
     *
     * It may be different from the `GtkPrintDialog`'s page setup
     * if the user changed it during the setup process.
     * @returns the page setup, or `NULL`
     */
    getPageSetup(): PageSetup | null
    /**
     * Returns the print settings of `setup`.
     *
     * They may be different from the `GtkPrintDialog`'s settings
     * if the user changed them during the setup process.
     * @returns the print settings, or `NULL`
     */
    getPrintSettings(): PrintSettings | null
    /**
     * Increase the reference count of `setup`.
     * @returns the print setup
     */
    ref(): PrintSetup
    /**
     * Decrease the reference count of `setup`.
     *
     * If the reference count reaches zero,
     * the object is freed.
     */
    unref(): void
  }

  /**
   * A `GtkPrintSetup` is an auxiliary object for printing that allows decoupling
   * the setup from the printing.
   *
   * A print setup is obtained by calling [method`Gtk`.PrintDialog.setup],
   * and can later be passed to print functions such as [method`Gtk`.PrintDialog.print].
   *
   * Print setups can be reused for multiple print calls.
   *
   * Applications may wish to store the page_setup and print_settings from the print setup
   * and copy them to the PrintDialog if they want to keep using them.
   * @record
   */
  class PrintSetup {
    // Own properties of Gtk-4.0.Gtk.PrintSetup

    static name: string
  }

  interface RangeClass {
    // Own fields of Gtk-4.0.Gtk.RangeClass

    parentClass: WidgetClass
    valueChanged: (range: Range) => void
    adjustBounds: (range: Range, newValue: number) => void
    moveSlider: (range: Range, scroll: ScrollType) => void
    getRangeBorder: (range: Range, border: Border) => void
    changeValue: (range: Range, scroll: ScrollType, newValue: number) => boolean
  }

  abstract class RangeClass {
    // Own properties of Gtk-4.0.Gtk.RangeClass

    static name: string
  }

  interface RecentData {
    // Own fields of Gtk-4.0.Gtk.RecentData

    /**
     * a UTF-8 encoded string, containing the name of the recently
     *   used resource to be displayed, or %NULL;
     * @field
     */
    displayName: string | null
    /**
     * a UTF-8 encoded string, containing a short description of
     *   the resource, or %NULL;
     * @field
     */
    description: string | null
    /**
     * the MIME type of the resource;
     * @field
     */
    mimeType: string | null
    /**
     * the name of the application that is registering this recently
     *   used resource;
     * @field
     */
    appName: string | null
    /**
     * command line used to launch this resource; may contain the
     *   “\%f” and “\%u” escape characters which will be expanded
     *   to the resource file path and URI respectively when the command line
     *   is retrieved;
     * @field
     */
    appExec: string | null
    /**
     * a vector of strings containing
     *   groups names;
     * @field
     */
    groups: string[]
    /**
     * whether this resource should be displayed only by the
     *   applications that have registered it or not.
     * @field
     */
    isPrivate: boolean
  }

  /**
   * Meta-data to be passed to gtk_recent_manager_add_full() when
   * registering a recently used resource.
   * @record
   */
  class RecentData {
    // Own properties of Gtk-4.0.Gtk.RecentData

    static name: string
  }

  interface RecentInfo {
    // Owm methods of Gtk-4.0.Gtk.RecentInfo

    /**
     * Creates a `GAppInfo` for the specified `GtkRecentInfo`
     *
     * In case of error, `error` will be set either with a
     * %GTK_RECENT_MANAGER_ERROR or a %G_IO_ERROR
     * @param appName the name of the application that should   be mapped to a `GAppInfo`; if %NULL is used then the default   application for the MIME type is used
     * @returns the newly created `GAppInfo`
     */
    createAppInfo(appName: string | null): Gio.AppInfo | null
    /**
     * Checks whether the resource pointed by `info` still exists.
     * At the moment this check is done only on resources pointing
     * to local files.
     * @returns %TRUE if the resource exists
     */
    exists(): boolean
    /**
     * Gets the time when the resource
     * was added to the recently used resources list.
     * @returns a `GDateTime` for the time    when the resource was added
     */
    getAdded(): GLib.DateTime
    /**
     * Gets the number of days elapsed since the last update
     * of the resource pointed by `info`.
     * @returns a positive integer containing the number of days   elapsed since the time this resource was last modified
     */
    getAge(): number
    /**
     * Gets the data regarding the application that has registered the resource
     * pointed by `info`.
     *
     * If the command line contains any escape characters defined inside the
     * storage specification, they will be expanded.
     * @param appName the name of the application that has registered this item
     * @returns %TRUE if an application with @app_name has registered this   resource inside the recently used list, or %FALSE otherwise. The   @app_exec string is owned by the `GtkRecentInfo` and should not be   modified or freed
     */
    getApplicationInfo(
      appName: string
    ): [
      /* returnType */ boolean,
      /* appExec */ string,
      /* count */ number,
      /* stamp */ GLib.DateTime,
    ]
    /**
     * Retrieves the list of applications that have registered this resource.
     * @returns a newly   allocated %NULL-terminated array of strings. Use g_strfreev() to free it.
     */
    getApplications(): string[]
    /**
     * Gets the (short) description of the resource.
     * @returns the description of the resource. The returned string   is owned by the recent manager, and should not be freed.
     */
    getDescription(): string
    /**
     * Gets the name of the resource.
     *
     * If none has been defined, the basename
     * of the resource is obtained.
     * @returns the display name of the resource. The returned string   is owned by the recent manager, and should not be freed.
     */
    getDisplayName(): string
    /**
     * Retrieves the icon associated to the resource MIME type.
     * @returns a `GIcon` containing the icon
     */
    getGicon(): Gio.Icon | null
    /**
     * Returns all groups registered for the recently used item `info`.
     *
     * The array of returned group names will be %NULL terminated, so
     * length might optionally be %NULL.
     * @returns a newly allocated %NULL terminated array of strings.   Use g_strfreev() to free it.
     */
    getGroups(): string[]
    /**
     * Gets the MIME type of the resource.
     * @returns the MIME type of the resource. The returned string   is owned by the recent manager, and should not be freed.
     */
    getMimeType(): string
    /**
     * Gets the time when the meta-data
     * for the resource was last modified.
     * @returns a `GDateTime` for the time   when the resource was last modified
     */
    getModified(): GLib.DateTime
    /**
     * Gets the value of the “private” flag.
     *
     * Resources in the recently used list that have this flag
     * set to %TRUE should only be displayed by the applications
     * that have registered them.
     * @returns %TRUE if the private flag was found, %FALSE otherwise
     */
    getPrivateHint(): boolean
    /**
     * Computes a valid UTF-8 string that can be used as the
     * name of the item in a menu or list.
     *
     * For example, calling this function on an item that refers
     * to “file:///foo/bar.txt” will yield “bar.txt”.
     * @returns A newly-allocated string in UTF-8 encoding   free it with g_free()
     */
    getShortName(): string | null
    /**
     * Gets the URI of the resource.
     * @returns the URI of the resource. The returned string is   owned by the recent manager, and should not be freed.
     */
    getUri(): string
    /**
     * Gets a displayable version of the resource’s URI.
     *
     * If the resource is local, it returns a local path; if the
     * resource is not local, it returns the UTF-8 encoded content
     * of [method`Gtk`.RecentInfo.get_uri].
     * @returns a newly allocated UTF-8 string containing the   resource’s URI or %NULL. Use g_free() when done using it.
     */
    getUriDisplay(): string | null
    /**
     * Gets the time when the meta-data
     * for the resource was last visited.
     * @returns a `GDateTime` for the time    when the resource was last visited
     */
    getVisited(): GLib.DateTime
    /**
     * Checks whether an application registered this resource using `app_name`.
     * @param appName a string containing an application name
     * @returns %TRUE if an application with name @app_name was found,   %FALSE otherwise
     */
    hasApplication(appName: string): boolean
    /**
     * Checks whether `group_name` appears inside the groups
     * registered for the recently used item `info`.
     * @param groupName name of a group
     * @returns %TRUE if the group was found
     */
    hasGroup(groupName: string): boolean
    /**
     * Checks whether the resource is local or not by looking at the
     * scheme of its URI.
     * @returns %TRUE if the resource is local
     */
    isLocal(): boolean
    /**
     * Gets the name of the last application that have registered the
     * recently used resource represented by `info`.
     * @returns an application name. Use g_free() to free it.
     */
    lastApplication(): string | null
    /**
     * Checks whether two `GtkRecentInfo` point to the same resource.
     * @param infoB a `GtkRecentInfo`
     * @returns %TRUE if both `GtkRecentInfo` point to the same   resource, %FALSE otherwise
     */
    match(infoB: RecentInfo): boolean
    /**
     * Increases the reference count of `recent_info` by one.
     * @returns the recent info object with its reference count   increased by one
     */
    ref(): RecentInfo
    /**
     * Decreases the reference count of `info` by one.
     *
     * If the reference count reaches zero, `info` is
     * deallocated, and the memory freed.
     */
    unref(): void
  }

  /**
   * `GtkRecentInfo` contains the metadata associated with an item in the
   * recently used files list.
   * @record
   */
  class RecentInfo {
    // Own properties of Gtk-4.0.Gtk.RecentInfo

    static name: string
  }

  interface RecentManagerClass {
    // Own fields of Gtk-4.0.Gtk.RecentManagerClass

    changed: (manager: RecentManager) => void
  }

  /**
   * `GtkRecentManagerClass` contains only private data.
   * @record
   */
  abstract class RecentManagerClass {
    // Own properties of Gtk-4.0.Gtk.RecentManagerClass

    static name: string
  }

  interface RecentManagerPrivate {}

  class RecentManagerPrivate {
    // Own properties of Gtk-4.0.Gtk.RecentManagerPrivate

    static name: string
  }

  interface RequestedSize {
    // Own fields of Gtk-4.0.Gtk.RequestedSize

    /**
     * A client pointer
     * @field
     */
    data: any
    /**
     * The minimum size needed for allocation in a given orientation
     * @field
     */
    minimumSize: number
    /**
     * The natural size for allocation in a given orientation
     * @field
     */
    naturalSize: number
  }

  /**
   * Represents a request of a screen object in a given orientation. These
   * are primarily used in container implementations when allocating a natural
   * size for children calling. See [func`distribute_natural_allocation]`.
   * @record
   */
  class RequestedSize {
    // Own properties of Gtk-4.0.Gtk.RequestedSize

    static name: string
  }

  interface Requisition {
    // Own fields of Gtk-4.0.Gtk.Requisition

    /**
     * the widget’s desired width
     * @field
     */
    width: number
    /**
     * the widget’s desired height
     * @field
     */
    height: number

    // Owm methods of Gtk-4.0.Gtk.Requisition

    /**
     * Copies a `GtkRequisition`.
     * @returns a copy of @requisition
     */
    copy(): Requisition
    /**
     * Frees a `GtkRequisition`.
     */
    free(): void
  }

  /**
   * A `GtkRequisition` represents the desired size of a widget. See
   * [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
   * more information.
   * @record
   */
  class Requisition {
    // Own properties of Gtk-4.0.Gtk.Requisition

    static name: string

    // Constructors of Gtk-4.0.Gtk.Requisition

    /**
     * Allocates a new `GtkRequisition`.
     *
     * The struct is initialized to zero.
     * @constructor
     * @returns a new empty `GtkRequisition`. The newly   allocated `GtkRequisition` should be freed with   [method@Gtk.Requisition.free]
     */
    constructor()
    /**
     * Allocates a new `GtkRequisition`.
     *
     * The struct is initialized to zero.
     * @constructor
     * @returns a new empty `GtkRequisition`. The newly   allocated `GtkRequisition` should be freed with   [method@Gtk.Requisition.free]
     */
    static new(): Requisition
  }

  interface RootInterface {}

  abstract class RootInterface {
    // Own properties of Gtk-4.0.Gtk.RootInterface

    static name: string
  }

  interface ScaleButtonClass {
    // Own fields of Gtk-4.0.Gtk.ScaleButtonClass

    parentClass: WidgetClass
    valueChanged: (button: ScaleButton, value: number) => void
  }

  abstract class ScaleButtonClass {
    // Own properties of Gtk-4.0.Gtk.ScaleButtonClass

    static name: string
  }

  interface ScaleClass {
    // Own fields of Gtk-4.0.Gtk.ScaleClass

    parentClass: RangeClass
    getLayoutOffsets: (scale: Scale) => [/* x */ number, /* y */ number]
  }

  abstract class ScaleClass {
    // Own properties of Gtk-4.0.Gtk.ScaleClass

    static name: string
  }

  interface ScrollInfo {
    // Owm methods of Gtk-4.0.Gtk.ScrollInfo

    /**
     * Checks if horizontal scrolling is enabled.
     * @returns %TRUE if horizontal scrolling is enabled.
     */
    getEnableHorizontal(): boolean
    /**
     * Checks if vertical scrolling is enabled.
     * @returns %TRUE if vertical scrolling is enabled.
     */
    getEnableVertical(): boolean
    /**
     * Increases the reference count of a `GtkScrollInfo` by one.
     * @returns the passed in `GtkScrollInfo`.
     */
    ref(): ScrollInfo
    /**
     * Turns horizontal scrolling on or off.
     * @param horizontal if scrolling in the horizontal direction     should happen
     */
    setEnableHorizontal(horizontal: boolean): void
    /**
     * Turns vertical scrolling on or off.
     * @param vertical if scrolling in the vertical direction     should happen
     */
    setEnableVertical(vertical: boolean): void
    /**
     * Decreases the reference count of a `GtkScrollInfo` by one.
     *
     * If the resulting reference count is zero, frees the self.
     */
    unref(): void
  }

  /**
   * The `GtkScrollInfo` can be used to provide more accurate data on how a scroll
   * operation should be performed.
   *
   * Scrolling functions usually allow passing a %NULL scroll info which will cause
   * the default values to be used and just scroll the element into view.
   * @record
   */
  class ScrollInfo {
    // Own properties of Gtk-4.0.Gtk.ScrollInfo

    static name: string

    // Constructors of Gtk-4.0.Gtk.ScrollInfo

    /**
     * Creates a new scroll info for scrolling an element into view.
     * @constructor
     * @returns A new scroll info
     */
    constructor()
    /**
     * Creates a new scroll info for scrolling an element into view.
     * @constructor
     * @returns A new scroll info
     */
    static new(): ScrollInfo
  }

  interface ScrollableInterface {
    // Own fields of Gtk-4.0.Gtk.ScrollableInterface

    baseIface: GObject.TypeInterface
    getBorder: (
      scrollable: Scrollable
    ) => [/* returnType */ boolean, /* border */ Border]
  }

  abstract class ScrollableInterface {
    // Own properties of Gtk-4.0.Gtk.ScrollableInterface

    static name: string
  }

  interface SectionModelInterface {
    // Own fields of Gtk-4.0.Gtk.SectionModelInterface

    /**
     * Return the section that covers the given position. If
     *   the position is outside the number of items, returns a single range from
     *   n_items to G_MAXUINT
     * @field
     */
    getSection: (
      self: SectionModel,
      position: number
    ) => [/* outStart */ number, /* outEnd */ number]
  }

  /**
   * The list of virtual functions for the `GtkSectionModel` interface.
   * No function must be implemented, but unless `GtkSectionModel::get_section()`
   * is implemented, the whole model will just be a single section.
   * @record
   */
  abstract class SectionModelInterface {
    // Own properties of Gtk-4.0.Gtk.SectionModelInterface

    static name: string
  }

  interface SelectionFilterModelClass {
    // Own fields of Gtk-4.0.Gtk.SelectionFilterModelClass

    parentClass: GObject.ObjectClass
  }

  abstract class SelectionFilterModelClass {
    // Own properties of Gtk-4.0.Gtk.SelectionFilterModelClass

    static name: string
  }

  interface SelectionModelInterface {
    // Own fields of Gtk-4.0.Gtk.SelectionModelInterface

    /**
     * Return if the item at the given position is selected.
     * @field
     */
    isSelected: (model: SelectionModel, position: number) => boolean
    /**
     * Return a bitset with all currently selected
     *   items in the given range. By default, this function will call
     *   `GtkSelectionModel::is_selected()` on all items in the given range.
     * @field
     */
    getSelectionInRange: (
      model: SelectionModel,
      position: number,
      nItems: number
    ) => Bitset
    /**
     * Select the item in the given position. If the operation
     *   is known to fail, return %FALSE.
     * @field
     */
    selectItem: (
      model: SelectionModel,
      position: number,
      unselectRest: boolean
    ) => boolean
    /**
     * Unselect the item in the given position. If the
     *   operation is known to fail, return %FALSE.
     * @field
     */
    unselectItem: (model: SelectionModel, position: number) => boolean
    /**
     * Select all items in the given range. If the operation
     *   is unsupported or known to fail for all items, return %FALSE.
     * @field
     */
    selectRange: (
      model: SelectionModel,
      position: number,
      nItems: number,
      unselectRest: boolean
    ) => boolean
    /**
     * Unselect all items in the given range. If the
     *   operation is unsupported or known to fail for all items, return
     *   %FALSE.
     * @field
     */
    unselectRange: (
      model: SelectionModel,
      position: number,
      nItems: number
    ) => boolean
    /**
     * Select all items in the model. If the operation is
     *   unsupported or known to fail for all items, return %FALSE.
     * @field
     */
    selectAll: (model: SelectionModel) => boolean
    /**
     * Unselect all items in the model. If the operation is
     *   unsupported or known to fail for all items, return %FALSE.
     * @field
     */
    unselectAll: (model: SelectionModel) => boolean
    /**
     * Set selection state of all items in mask to selected.
     *   See gtk_selection_model_set_selection() for a detailed explanation
     *   of this function.
     * @field
     */
    setSelection: (
      model: SelectionModel,
      selected: Bitset,
      mask: Bitset
    ) => boolean
  }

  /**
   * The list of virtual functions for the `GtkSelectionModel` interface.
   * No function must be implemented, but unless `GtkSelectionModel::is_selected()`
   * is implemented, it will not be possible to select items in the set.
   *
   * The model does not need to implement any functions to support either
   * selecting or unselecting items. Of course, if the model does not do that,
   * it means that users cannot select or unselect items in a list widget
   * using the model.
   *
   * All selection functions fall back to `GtkSelectionModel::set_selection()`
   * so it is sufficient to implement just that function for full selection
   * support.
   * @record
   */
  abstract class SelectionModelInterface {
    // Own properties of Gtk-4.0.Gtk.SelectionModelInterface

    static name: string
  }

  interface ShortcutActionClass {}

  abstract class ShortcutActionClass {
    // Own properties of Gtk-4.0.Gtk.ShortcutActionClass

    static name: string
  }

  interface ShortcutClass {
    // Own fields of Gtk-4.0.Gtk.ShortcutClass

    parentClass: GObject.ObjectClass
  }

  abstract class ShortcutClass {
    // Own properties of Gtk-4.0.Gtk.ShortcutClass

    static name: string
  }

  interface ShortcutControllerClass {}

  abstract class ShortcutControllerClass {
    // Own properties of Gtk-4.0.Gtk.ShortcutControllerClass

    static name: string
  }

  interface ShortcutLabelClass {}

  abstract class ShortcutLabelClass {
    // Own properties of Gtk-4.0.Gtk.ShortcutLabelClass

    static name: string
  }

  interface ShortcutManagerInterface {
    // Own fields of Gtk-4.0.Gtk.ShortcutManagerInterface

    /**
     * Add a `GtkShortcutController` to be managed.
     * @field
     */
    addController: (
      self: ShortcutManager,
      controller: ShortcutController
    ) => void
    /**
     * Remove a `GtkShortcutController` that had previously
     *   been added
     * @field
     */
    removeController: (
      self: ShortcutManager,
      controller: ShortcutController
    ) => void
  }

  /**
   * The list of functions that can be implemented for the `GtkShortcutManager`
   * interface.
   *
   * Note that no function is mandatory to implement, the default implementation
   * will work fine.
   * @record
   */
  abstract class ShortcutManagerInterface {
    // Own properties of Gtk-4.0.Gtk.ShortcutManagerInterface

    static name: string
  }

  interface ShortcutTriggerClass {}

  abstract class ShortcutTriggerClass {
    // Own properties of Gtk-4.0.Gtk.ShortcutTriggerClass

    static name: string
  }

  interface ShortcutsGroupClass {}

  abstract class ShortcutsGroupClass {
    // Own properties of Gtk-4.0.Gtk.ShortcutsGroupClass

    static name: string
  }

  interface ShortcutsSectionClass {}

  abstract class ShortcutsSectionClass {
    // Own properties of Gtk-4.0.Gtk.ShortcutsSectionClass

    static name: string
  }

  interface ShortcutsShortcutClass {}

  abstract class ShortcutsShortcutClass {
    // Own properties of Gtk-4.0.Gtk.ShortcutsShortcutClass

    static name: string
  }

  interface SignalActionClass {}

  abstract class SignalActionClass {
    // Own properties of Gtk-4.0.Gtk.SignalActionClass

    static name: string
  }

  interface SignalListItemFactoryClass {}

  abstract class SignalListItemFactoryClass {
    // Own properties of Gtk-4.0.Gtk.SignalListItemFactoryClass

    static name: string
  }

  interface SingleSelectionClass {
    // Own fields of Gtk-4.0.Gtk.SingleSelectionClass

    parentClass: GObject.ObjectClass
  }

  abstract class SingleSelectionClass {
    // Own properties of Gtk-4.0.Gtk.SingleSelectionClass

    static name: string
  }

  interface SliceListModelClass {
    // Own fields of Gtk-4.0.Gtk.SliceListModelClass

    parentClass: GObject.ObjectClass
  }

  abstract class SliceListModelClass {
    // Own properties of Gtk-4.0.Gtk.SliceListModelClass

    static name: string
  }

  interface SnapshotClass {}

  abstract class SnapshotClass {
    // Own properties of Gtk-4.0.Gtk.SnapshotClass

    static name: string
  }

  interface SortListModelClass {
    // Own fields of Gtk-4.0.Gtk.SortListModelClass

    parentClass: GObject.ObjectClass
  }

  abstract class SortListModelClass {
    // Own properties of Gtk-4.0.Gtk.SortListModelClass

    static name: string
  }

  interface SorterClass {
    // Own fields of Gtk-4.0.Gtk.SorterClass

    parentClass: GObject.ObjectClass
    /**
     * Compare two items. See gtk_sorter_compare() for details.
     * @field
     */
    compare: (
      self: Sorter,
      item1: GObject.Object | null,
      item2: GObject.Object | null
    ) => Ordering
    /**
     * Get the `GtkSorderOrder` that applies to the current sorter.
     *   If unimplemented, it returns %GTK_SORTER_ORDER_PARTIAL.
     * @field
     */
    getOrder: (self: Sorter) => SorterOrder
  }

  /**
   * The virtual table for `GtkSorter`.
   * @record
   */
  abstract class SorterClass {
    // Own properties of Gtk-4.0.Gtk.SorterClass

    static name: string
  }

  interface StringFilterClass {
    // Own fields of Gtk-4.0.Gtk.StringFilterClass

    parentClass: FilterClass
  }

  abstract class StringFilterClass {
    // Own properties of Gtk-4.0.Gtk.StringFilterClass

    static name: string
  }

  interface StringListClass {
    // Own fields of Gtk-4.0.Gtk.StringListClass

    parentClass: GObject.ObjectClass
  }

  abstract class StringListClass {
    // Own properties of Gtk-4.0.Gtk.StringListClass

    static name: string
  }

  interface StringObjectClass {
    // Own fields of Gtk-4.0.Gtk.StringObjectClass

    parentClass: GObject.ObjectClass
  }

  abstract class StringObjectClass {
    // Own properties of Gtk-4.0.Gtk.StringObjectClass

    static name: string
  }

  interface StringSorterClass {
    // Own fields of Gtk-4.0.Gtk.StringSorterClass

    parentClass: SorterClass
  }

  abstract class StringSorterClass {
    // Own properties of Gtk-4.0.Gtk.StringSorterClass

    static name: string
  }

  interface StyleContextClass {
    // Own fields of Gtk-4.0.Gtk.StyleContextClass

    parentClass: GObject.ObjectClass
    changed: (context: StyleContext) => void
  }

  abstract class StyleContextClass {
    // Own properties of Gtk-4.0.Gtk.StyleContextClass

    static name: string
  }

  interface SymbolicPaintableInterface {
    // Own fields of Gtk-4.0.Gtk.SymbolicPaintableInterface

    /**
     * Snapshot the paintable using the given colors.
     *   See `GtkSymbolicPaintable::snapshot_symbolic()` for details.
     *   If this function is not implemented, [vfunc`Gdk`.Paintable.snapshot]
     *   will be called.
     * @field
     */
    snapshotSymbolic: (
      paintable: SymbolicPaintable,
      snapshot: Gdk.Snapshot,
      width: number,
      height: number,
      colors: Gdk.RGBA[]
    ) => void
  }

  /**
   * The list of virtual functions for the `GtkSymbolicPaintable` interface.
   * No function must be implemented, default implementations exist for each one.
   * @record
   */
  abstract class SymbolicPaintableInterface {
    // Own properties of Gtk-4.0.Gtk.SymbolicPaintableInterface

    static name: string
  }

  interface TextBufferClass {
    // Own fields of Gtk-4.0.Gtk.TextBufferClass

    /**
     * The object class structure needs to be the first.
     * @field
     */
    parentClass: GObject.ObjectClass
    /**
     * The class handler for the `GtkTextBuffer::insert-text` signal.
     * @field
     */
    insertText: (
      buffer: TextBuffer,
      pos: TextIter,
      newText: string,
      newTextLength: number
    ) => void
    /**
     * The class handler for the `GtkTextBuffer::insert-paintable` signal.
     * @field
     */
    insertPaintable: (
      buffer: TextBuffer,
      iter: TextIter,
      paintable: Gdk.Paintable
    ) => void
    /**
     * The class handler for the `GtkTextBuffer::insert-child-anchor` signal.
     * @field
     */
    insertChildAnchor: (
      buffer: TextBuffer,
      iter: TextIter,
      anchor: TextChildAnchor
    ) => void
    /**
     * The class handler for the `GtkTextBuffer::delete-range` signal.
     * @field
     */
    deleteRange: (buffer: TextBuffer, start: TextIter, end: TextIter) => void
    /**
     * The class handler for the `GtkTextBuffer::changed` signal.
     * @field
     */
    changed: (buffer: TextBuffer) => void
    /**
     * The class handler for the `GtkTextBuffer::modified-changed` signal.
     * @field
     */
    modifiedChanged: (buffer: TextBuffer) => void
    /**
     * The class handler for the `GtkTextBuffer::mark-set` signal.
     * @field
     */
    markSet: (buffer: TextBuffer, location: TextIter, mark: TextMark) => void
    /**
     * The class handler for the `GtkTextBuffer::mark-deleted` signal.
     * @field
     */
    markDeleted: (buffer: TextBuffer, mark: TextMark) => void
    /**
     * The class handler for the `GtkTextBuffer::apply-tag` signal.
     * @field
     */
    applyTag: (
      buffer: TextBuffer,
      tag: TextTag,
      start: TextIter,
      end: TextIter
    ) => void
    /**
     * The class handler for the `GtkTextBuffer::remove-tag` signal.
     * @field
     */
    removeTag: (
      buffer: TextBuffer,
      tag: TextTag,
      start: TextIter,
      end: TextIter
    ) => void
    /**
     * The class handler for the `GtkTextBuffer::begin-user-action` signal.
     * @field
     */
    beginUserAction: (buffer: TextBuffer) => void
    /**
     * The class handler for the `GtkTextBuffer::end-user-action` signal.
     * @field
     */
    endUserAction: (buffer: TextBuffer) => void
    /**
     * The class handler for the `GtkTextBuffer::paste-done` signal.
     * @field
     */
    pasteDone: (buffer: TextBuffer, clipboard: Gdk.Clipboard) => void
    /**
     * The class handler for the `GtkTextBuffer::undo` signal
     * @field
     */
    undo: (buffer: TextBuffer) => void
    /**
     * The class handler for the `GtkTextBuffer::redo` signal
     * @field
     */
    redo: (buffer: TextBuffer) => void
  }

  /**
   * The class structure for `GtkTextBuffer`.
   * @record
   */
  abstract class TextBufferClass {
    // Own properties of Gtk-4.0.Gtk.TextBufferClass

    static name: string
  }

  interface TextBufferPrivate {}

  class TextBufferPrivate {
    // Own properties of Gtk-4.0.Gtk.TextBufferPrivate

    static name: string
  }

  interface TextChildAnchorClass {
    // Own fields of Gtk-4.0.Gtk.TextChildAnchorClass

    parentClass: GObject.ObjectClass
  }

  abstract class TextChildAnchorClass {
    // Own properties of Gtk-4.0.Gtk.TextChildAnchorClass

    static name: string
  }

  interface TextIter {
    // Owm methods of Gtk-4.0.Gtk.TextIter

    /**
     * Assigns the value of `other` to `iter`.
     *
     * This function is not useful in applications, because
     * iterators can be assigned with `GtkTextIter i = j;`.
     *
     * The function is used by language bindings.
     * @param other another `GtkTextIter`
     */
    assign(other: TextIter): void
    /**
     * Moves backward by one character offset.
     *
     * Returns %TRUE if movement was possible; if `iter` was the first
     * in the buffer (character offset 0), this function returns %FALSE
     * for convenience when writing loops.
     * @returns whether movement was possible
     */
    backwardChar(): boolean
    /**
     * Moves `count` characters backward, if possible.
     *
     * If `count` would move past the start or end of the buffer, moves
     * to the start or end of the buffer.
     *
     * The return value indicates whether the iterator moved
     * onto a dereferenceable position; if the iterator didn’t move, or
     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
     * the function does nothing and returns %FALSE.
     * @param count number of characters to move
     * @returns whether @iter moved and is dereferenceable
     */
    backwardChars(count: number): boolean
    /**
     * Like [method`Gtk`.TextIter.forward_cursor_position], but moves backward.
     * @returns %TRUE if we moved
     */
    backwardCursorPosition(): boolean
    /**
     * Moves up to `count` cursor positions.
     *
     * See [method`Gtk`.TextIter.forward_cursor_position] for details.
     * @param count number of positions to move
     * @returns %TRUE if we moved and the new position is dereferenceable
     */
    backwardCursorPositions(count: number): boolean
    /**
     * Same as [method`Gtk`.TextIter.forward_find_char],
     * but goes backward from `iter`.
     * @param pred function to be called on each character
     * @param limit search limit
     * @returns whether a match was found
     */
    backwardFindChar(pred: TextCharPredicate, limit: TextIter | null): boolean
    /**
     * Moves `iter` to the start of the previous line.
     *
     * Returns %TRUE if `iter` could be moved; i.e. if `iter` was at
     * character offset 0, this function returns %FALSE. Therefore,
     * if `iter` was already on line 0, but not at the start of the line,
     * `iter` is snapped to the start of the line and the function returns
     * %TRUE. (Note that this implies that
     * in a loop calling this function, the line number may not change on
     * every iteration, if your first iteration is on line 0.)
     * @returns whether @iter moved
     */
    backwardLine(): boolean
    /**
     * Moves `count` lines backward, if possible.
     *
     * If `count` would move past the start or end of the buffer, moves to
     * the start or end of the buffer.
     *
     * The return value indicates whether the iterator moved
     * onto a dereferenceable position; if the iterator didn’t move, or
     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
     * the function does nothing and returns %FALSE. If `count` is negative,
     * moves forward by 0 - `count` lines.
     * @param count number of lines to move backward
     * @returns whether @iter moved and is dereferenceable
     */
    backwardLines(count: number): boolean
    /**
     * Same as [method`Gtk`.TextIter.forward_search], but moves backward.
     *
     * `match_end` will never be set to a `GtkTextIter` located after `iter,`
     * even if there is a possible `match_start` before or at `iter`.
     * @param str search string
     * @param flags bitmask of flags affecting the search
     * @param limit location of last possible `match_start,` or %NULL for start of buffer
     * @returns whether a match was found
     */
    backwardSearch(
      str: string,
      flags: TextSearchFlags,
      limit: TextIter | null
    ): [
      /* returnType */ boolean,
      /* matchStart */ TextIter,
      /* matchEnd */ TextIter,
    ]
    /**
     * Moves backward to the previous sentence start.
     *
     * If `iter` is already at the start of a sentence, moves backward
     * to the next one.
     *
     * Sentence boundaries are determined by Pango and should
     * be correct for nearly any language.
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    backwardSentenceStart(): boolean
    /**
     * Calls [method`Gtk`.TextIter.backward_sentence_start] up to `count` times.
     *
     * If `count` is negative, moves forward instead of backward.
     * @param count number of sentences to move
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    backwardSentenceStarts(count: number): boolean
    /**
     * Moves backward to the next toggle (on or off) of the
     * `tag,` or to the next toggle of any tag if
     * `tag` is %NULL.
     *
     * If no matching tag toggles are found,
     * returns %FALSE, otherwise %TRUE. Does not return toggles
     * located at `iter,` only toggles before `iter`. Sets `iter`
     * to the location of the toggle, or the start of the buffer
     * if no toggle is found.
     * @param tag a `GtkTextTag`
     * @returns whether we found a tag toggle before @iter
     */
    backwardToTagToggle(tag: TextTag | null): boolean
    /**
     * Moves `iter` backward to the previous visible cursor position.
     *
     * See [method`Gtk`.TextIter.backward_cursor_position] for details.
     * @returns %TRUE if we moved and the new position is dereferenceable
     */
    backwardVisibleCursorPosition(): boolean
    /**
     * Moves up to `count` visible cursor positions.
     *
     * See [method`Gtk`.TextIter.backward_cursor_position] for details.
     * @param count number of positions to move
     * @returns %TRUE if we moved and the new position is dereferenceable
     */
    backwardVisibleCursorPositions(count: number): boolean
    /**
     * Moves `iter` to the start of the previous visible line.
     *
     * Returns %TRUE if
     * `iter` could be moved; i.e. if `iter` was at character offset 0, this
     * function returns %FALSE. Therefore if `iter` was already on line 0,
     * but not at the start of the line, `iter` is snapped to the start of
     * the line and the function returns %TRUE. (Note that this implies that
     * in a loop calling this function, the line number may not change on
     * every iteration, if your first iteration is on line 0.)
     * @returns whether @iter moved
     */
    backwardVisibleLine(): boolean
    /**
     * Moves `count` visible lines backward, if possible.
     *
     * If `count` would move past the start or end of the buffer, moves to
     * the start or end of the buffer.
     *
     * The return value indicates whether the iterator moved
     * onto a dereferenceable position; if the iterator didn’t move, or
     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
     * the function does nothing and returns %FALSE. If `count` is negative,
     * moves forward by 0 - `count` lines.
     * @param count number of lines to move backward
     * @returns whether @iter moved and is dereferenceable
     */
    backwardVisibleLines(count: number): boolean
    /**
     * Moves backward to the previous visible word start.
     *
     * If `iter` is currently on a word start, moves backward to the
     * next one after that.
     *
     * Word breaks are determined by Pango and should be correct
     * for nearly any language.
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    backwardVisibleWordStart(): boolean
    /**
     * Calls [method`Gtk`.TextIter.backward_visible_word_start] up to `count` times.
     * @param count number of times to move
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    backwardVisibleWordStarts(count: number): boolean
    /**
     * Moves backward to the previous word start.
     *
     * If `iter` is currently on a word start, moves backward to the
     * next one after that.
     *
     * Word breaks are determined by Pango and should be correct
     * for nearly any language
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    backwardWordStart(): boolean
    /**
     * Calls [method`Gtk`.TextIter.backward_word_start] up to `count` times.
     * @param count number of times to move
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    backwardWordStarts(count: number): boolean
    /**
     * Considering the default editability of the buffer, and tags that
     * affect editability, determines whether text inserted at `iter` would
     * be editable.
     *
     * If text inserted at `iter` would be editable then the
     * user should be allowed to insert text at `iter`.
     * [method`Gtk`.TextBuffer.insert_interactive] uses this function
     * to decide whether insertions are allowed at a given position.
     * @param defaultEditability %TRUE if text is editable by default
     * @returns whether text inserted at @iter would be editable
     */
    canInsert(defaultEditability: boolean): boolean
    /**
     * A qsort()-style function that returns negative if `lhs` is less than
     * `rhs,` positive if `lhs` is greater than `rhs,` and 0 if they’re equal.
     *
     * Ordering is in character offset order, i.e. the first character
     * in the buffer is less than the second character in the buffer.
     * @param rhs another `GtkTextIter`
     * @returns -1 if @lhs is less than @rhs, 1 if @lhs is greater, 0 if they are equal
     */
    compare(rhs: TextIter): number
    /**
     * Creates a dynamically-allocated copy of an iterator.
     *
     * This function is not useful in applications, because
     * iterators can be copied with a simple assignment
     * (`GtkTextIter i = j;`).
     *
     * The function is used by language bindings.
     * @returns a copy of the @iter, free with [method@Gtk.TextIter.free]
     */
    copy(): TextIter
    /**
     * Returns whether the character at `iter` is within an editable region
     * of text.
     *
     * Non-editable text is “locked” and can’t be changed by the
     * user via `GtkTextView`. If no tags applied to this text affect
     * editability, `default_setting` will be returned.
     *
     * You don’t want to use this function to decide whether text can be
     * inserted at `iter,` because for insertion you don’t want to know
     * whether the char at `iter` is inside an editable range, you want to
     * know whether a new character inserted at `iter` would be inside an
     * editable range. Use [method`Gtk`.TextIter.can_insert] to handle this
     * case.
     * @param defaultSetting %TRUE if text is editable by default
     * @returns whether @iter is inside an editable range
     */
    editable(defaultSetting: boolean): boolean
    /**
     * Returns %TRUE if `iter` points to the start of the paragraph
     * delimiter characters for a line.
     *
     * Delimiters will be either a newline, a carriage return, a carriage
     * return followed by a newline, or a Unicode paragraph separator
     * character.
     *
     * Note that an iterator pointing to the \n of a \r\n pair will not be
     * counted as the end of a line, the line ends before the \r. The end
     * iterator is considered to be at the end of a line, even though there
     * are no paragraph delimiter chars there.
     * @returns whether @iter is at the end of a line
     */
    endsLine(): boolean
    /**
     * Determines whether `iter` ends a sentence.
     *
     * Sentence boundaries are determined by Pango and should
     * be correct for nearly any language.
     * @returns %TRUE if @iter is at the end of a sentence.
     */
    endsSentence(): boolean
    /**
     * Returns %TRUE if `tag` is toggled off at exactly this point.
     *
     * If `tag` is %NULL, returns %TRUE if any tag is toggled off at this point.
     *
     * Note that if this function returns %TRUE, it means that
     * `iter` is at the end of the tagged range, but that the character
     * at `iter` is outside the tagged range. In other words,
     * unlike [method`Gtk`.TextIter.starts_tag], if this function
     * returns %TRUE, [method`Gtk`.TextIter.has_tag] will return
     * %FALSE for the same parameters.
     * @param tag a `GtkTextTag`
     * @returns whether @iter is the end of a range tagged with @tag
     */
    endsTag(tag: TextTag | null): boolean
    /**
     * Determines whether `iter` ends a natural-language word.
     *
     * Word breaks are determined by Pango and should be correct
     * for nearly any language.
     * @returns %TRUE if @iter is at the end of a word
     */
    endsWord(): boolean
    /**
     * Tests whether two iterators are equal, using the fastest possible
     * mechanism.
     *
     * This function is very fast; you can expect it to perform
     * better than e.g. getting the character offset for each
     * iterator and comparing the offsets yourself. Also, it’s a
     * bit faster than [method`Gtk`.TextIter.compare].
     * @param rhs another `GtkTextIter`
     * @returns %TRUE if the iterators point to the same place in the buffer
     */
    equal(rhs: TextIter): boolean
    /**
     * Moves `iter` forward by one character offset.
     *
     * Note that images embedded in the buffer occupy 1 character slot, so
     * this function may actually move onto an image instead of a character,
     * if you have images in your buffer. If `iter` is the end iterator or
     * one character before it, `iter` will now point at the end iterator,
     * and this function returns %FALSE for convenience when writing loops.
     * @returns whether @iter moved and is dereferenceable
     */
    forwardChar(): boolean
    /**
     * Moves `count` characters if possible.
     *
     * If `count` would move past the start or end of the buffer,
     * moves to the start or end of the buffer.
     *
     * The return value indicates whether the new position of
     * `iter` is different from its original position, and dereferenceable
     * (the last iterator in the buffer is not dereferenceable). If `count`
     * is 0, the function does nothing and returns %FALSE.
     * @param count number of characters to move, may be negative
     * @returns whether @iter moved and is dereferenceable
     */
    forwardChars(count: number): boolean
    /**
     * Moves `iter` forward by a single cursor position.
     *
     * Cursor positions are (unsurprisingly) positions where the
     * cursor can appear. Perhaps surprisingly, there may not be
     * a cursor position between all characters. The most common
     * example for European languages would be a carriage return/newline
     * sequence.
     *
     * For some Unicode characters, the equivalent of say the letter “a”
     * with an accent mark will be represented as two characters, first
     * the letter then a "combining mark" that causes the accent to be
     * rendered; so the cursor can’t go between those two characters.
     *
     * See also the [struct`Pango`.LogAttr] struct and the [func`Pango`.break]
     * function.
     * @returns %TRUE if we moved and the new position is dereferenceable
     */
    forwardCursorPosition(): boolean
    /**
     * Moves up to `count` cursor positions.
     *
     * See [method`Gtk`.TextIter.forward_cursor_position] for details.
     * @param count number of positions to move
     * @returns %TRUE if we moved and the new position is dereferenceable
     */
    forwardCursorPositions(count: number): boolean
    /**
     * Advances `iter,` calling `pred` on each character.
     *
     * If `pred` returns %TRUE, returns %TRUE and stops scanning.
     * If `pred` never returns %TRUE, `iter` is set to `limit` if
     * `limit` is non-%NULL, otherwise to the end iterator.
     * @param pred a function to be called on each character
     * @param limit search limit
     * @returns whether a match was found
     */
    forwardFindChar(pred: TextCharPredicate, limit: TextIter | null): boolean
    /**
     * Moves `iter` to the start of the next line.
     *
     * If the iter is already on the last line of the buffer,
     * moves the iter to the end of the current line. If after
     * the operation, the iter is at the end of the buffer and not
     * dereferenceable, returns %FALSE. Otherwise, returns %TRUE.
     * @returns whether @iter can be dereferenced
     */
    forwardLine(): boolean
    /**
     * Moves `count` lines forward, if possible.
     *
     * If `count` would move past the start or end of the buffer, moves to
     * the start or end of the buffer.
     *
     * The return value indicates whether the iterator moved
     * onto a dereferenceable position; if the iterator didn’t move, or
     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
     * the function does nothing and returns %FALSE. If `count` is negative,
     * moves backward by 0 - `count` lines.
     * @param count number of lines to move forward
     * @returns whether @iter moved and is dereferenceable
     */
    forwardLines(count: number): boolean
    /**
     * Searches forward for `str`.
     *
     * Any match is returned by setting `match_start` to the first character
     * of the match and `match_end` to the first character after the match.
     * The search will not continue past `limit`. Note that a search is a
     * linear or O(n) operation, so you may wish to use `limit` to avoid
     * locking up your UI on large buffers.
     *
     * `match_start` will never be set to a `GtkTextIter` located before `iter,`
     * even if there is a possible `match_end` after or at `iter`.
     * @param str a search string
     * @param flags flags affecting how the search is done
     * @param limit location of last possible `match_end,` or %NULL for the end of the buffer
     * @returns whether a match was found
     */
    forwardSearch(
      str: string,
      flags: TextSearchFlags,
      limit: TextIter | null
    ): [
      /* returnType */ boolean,
      /* matchStart */ TextIter,
      /* matchEnd */ TextIter,
    ]
    /**
     * Moves forward to the next sentence end.
     *
     * If `iter` is at the end of a sentence, moves to the next
     * end of sentence.
     *
     * Sentence boundaries are determined by Pango and should
     * be correct for nearly any language.
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    forwardSentenceEnd(): boolean
    /**
     * Calls [method`Gtk`.TextIter.forward_sentence_end] `count` times.
     *
     * If `count` is negative, moves backward instead of forward.
     * @param count number of sentences to move
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    forwardSentenceEnds(count: number): boolean
    /**
     * Moves `iter` forward to the “end iterator”, which points
     * one past the last valid character in the buffer.
     *
     * [method`Gtk`.TextIter.get_char] called on the end iterator
     * returns 0, which is convenient for writing loops.
     */
    forwardToEnd(): void
    /**
     * Moves the iterator to point to the paragraph delimiter characters.
     *
     * The possible characters are either a newline, a carriage return,
     * a carriage return/newline in sequence, or the Unicode paragraph
     * separator character.
     *
     * If the iterator is already at the paragraph delimiter
     * characters, moves to the paragraph delimiter characters for the
     * next line. If `iter` is on the last line in the buffer, which does
     * not end in paragraph delimiters, moves to the end iterator (end of
     * the last line), and returns %FALSE.
     * @returns %TRUE if we moved and the new location is not the end iterator
     */
    forwardToLineEnd(): boolean
    /**
     * Moves forward to the next toggle (on or off) of the
     * `tag,` or to the next toggle of any tag if
     * `tag` is %NULL.
     *
     * If no matching tag toggles are found,
     * returns %FALSE, otherwise %TRUE. Does not return toggles
     * located at `iter,` only toggles after `iter`. Sets `iter` to
     * the location of the toggle, or to the end of the buffer
     * if no toggle is found.
     * @param tag a `GtkTextTag`
     * @returns whether we found a tag toggle after @iter
     */
    forwardToTagToggle(tag: TextTag | null): boolean
    /**
     * Moves `iter` forward to the next visible cursor position.
     *
     * See [method`Gtk`.TextIter.forward_cursor_position] for details.
     * @returns %TRUE if we moved and the new position is dereferenceable
     */
    forwardVisibleCursorPosition(): boolean
    /**
     * Moves up to `count` visible cursor positions.
     *
     * See [method`Gtk`.TextIter.forward_cursor_position] for details.
     * @param count number of positions to move
     * @returns %TRUE if we moved and the new position is dereferenceable
     */
    forwardVisibleCursorPositions(count: number): boolean
    /**
     * Moves `iter` to the start of the next visible line.
     *
     * Returns %TRUE if there
     * was a next line to move to, and %FALSE if `iter` was simply moved to
     * the end of the buffer and is now not dereferenceable, or if `iter` was
     * already at the end of the buffer.
     * @returns whether @iter can be dereferenced
     */
    forwardVisibleLine(): boolean
    /**
     * Moves `count` visible lines forward, if possible.
     *
     * If `count` would move past the start or end of the buffer, moves to
     * the start or end of the buffer.
     *
     * The return value indicates whether the iterator moved
     * onto a dereferenceable position; if the iterator didn’t move, or
     * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
     * the function does nothing and returns %FALSE. If `count` is negative,
     * moves backward by 0 - `count` lines.
     * @param count number of lines to move forward
     * @returns whether @iter moved and is dereferenceable
     */
    forwardVisibleLines(count: number): boolean
    /**
     * Moves forward to the next visible word end.
     *
     * If `iter` is currently on a word end, moves forward to the
     * next one after that.
     *
     * Word breaks are determined by Pango and should be correct
     * for nearly any language
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    forwardVisibleWordEnd(): boolean
    /**
     * Calls [method`Gtk`.TextIter.forward_visible_word_end] up to `count` times.
     * @param count number of times to move
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    forwardVisibleWordEnds(count: number): boolean
    /**
     * Moves forward to the next word end.
     *
     * If `iter` is currently on a word end, moves forward to the
     * next one after that.
     *
     * Word breaks are determined by Pango and should be correct
     * for nearly any language.
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    forwardWordEnd(): boolean
    /**
     * Calls [method`Gtk`.TextIter.forward_word_end] up to `count` times.
     * @param count number of times to move
     * @returns %TRUE if @iter moved and is not the end iterator
     */
    forwardWordEnds(count: number): boolean
    /**
     * Free an iterator allocated on the heap.
     *
     * This function is intended for use in language bindings,
     * and is not especially useful for applications, because
     * iterators can simply be allocated on the stack.
     */
    free(): void
    /**
     * Returns the `GtkTextBuffer` this iterator is associated with.
     * @returns the buffer
     */
    getBuffer(): TextBuffer
    /**
     * Returns the number of bytes in the line containing `iter,`
     * including the paragraph delimiters.
     * @returns number of bytes in the line
     */
    getBytesInLine(): number
    /**
     * The Unicode character at this iterator is returned.
     *
     * Equivalent to operator* on a C++ iterator. If the element at
     * this iterator is a non-character element, such as an image
     * embedded in the buffer, the Unicode “unknown” character 0xFFFC
     * is returned. If invoked on the end iterator, zero is returned;
     * zero is not a valid Unicode character.
     *
     * So you can write a loop which ends when this function returns 0.
     * @returns a Unicode character, or 0 if @iter is not dereferenceable
     */
    getChar(): string
    /**
     * Returns the number of characters in the line containing `iter,`
     * including the paragraph delimiters.
     * @returns number of characters in the line
     */
    getCharsInLine(): number
    /**
     * If the location at `iter` contains a child anchor, the
     * anchor is returned.
     *
     * Otherwise, %NULL is returned.
     * @returns the anchor at @iter
     */
    getChildAnchor(): TextChildAnchor | null
    /**
     * Returns the language in effect at `iter`.
     *
     * If no tags affecting language apply to `iter,` the return
     * value is identical to that of [func`Gtk`.get_default_language].
     * @returns language in effect at @iter
     */
    getLanguage(): Pango.Language
    /**
     * Returns the line number containing the iterator.
     *
     * Lines in a `GtkTextBuffer` are numbered beginning
     * with 0 for the first line in the buffer.
     * @returns a line number
     */
    getLine(): number
    /**
     * Returns the byte index of the iterator, counting
     * from the start of a newline-terminated line.
     *
     * Remember that `GtkTextBuffer` encodes text in
     * UTF-8, and that characters can require a variable
     * number of bytes to represent.
     * @returns distance from start of line, in bytes
     */
    getLineIndex(): number
    /**
     * Returns the character offset of the iterator,
     * counting from the start of a newline-terminated line.
     *
     * The first character on the line has offset 0.
     * @returns offset from start of line
     */
    getLineOffset(): number
    /**
     * Returns a list of all `GtkTextMark` at this location.
     *
     * Because marks are not iterable (they don’t take up any "space"
     * in the buffer, they are just marks in between iterable locations),
     * multiple marks can exist in the same place.
     *
     * The returned list is not in any meaningful order.
     * @returns list of `GtkTextMark`
     */
    getMarks(): TextMark[]
    /**
     * Returns the character offset of an iterator.
     *
     * Each character in a `GtkTextBuffer` has an offset,
     * starting with 0 for the first character in the buffer.
     * Use [method`Gtk`.TextBuffer.get_iter_at_offset] to convert
     * an offset back into an iterator.
     * @returns a character offset
     */
    getOffset(): number
    /**
     * If the element at `iter` is a paintable, the paintable is returned.
     *
     * Otherwise, %NULL is returned.
     * @returns the paintable at @iter
     */
    getPaintable(): Gdk.Paintable | null
    /**
     * Returns the text in the given range.
     *
     * A “slice” is an array of characters encoded in UTF-8 format,
     * including the Unicode “unknown” character 0xFFFC for iterable
     * non-character elements in the buffer, such as images.
     * Because images are encoded in the slice, byte and
     * character offsets in the returned array will correspond to byte
     * offsets in the text buffer. Note that 0xFFFC can occur in normal
     * text as well, so it is not a reliable indicator that a paintable or
     * widget is in the buffer.
     * @param end iterator at end of a range
     * @returns slice of text from the buffer
     */
    getSlice(end: TextIter): string | null
    /**
     * Returns a list of tags that apply to `iter,` in ascending order of
     * priority.
     *
     * The highest-priority tags are last.
     *
     * The `GtkTextTag`s in the list don’t have a reference added,
     * but you have to free the list itself.
     * @returns list of   `GtkTextTag`
     */
    getTags(): TextTag[]
    /**
     * Returns text in the given range.
     *
     * If the range
     * contains non-text elements such as images, the character and byte
     * offsets in the returned string will not correspond to character and
     * byte offsets in the buffer. If you want offsets to correspond, see
     * [method`Gtk`.TextIter.get_slice].
     * @param end iterator at end of a range
     * @returns array of characters from the buffer
     */
    getText(end: TextIter): string | null
    /**
     * Returns a list of `GtkTextTag` that are toggled on or off at this
     * point.
     *
     * If `toggled_on` is %TRUE, the list contains tags that are
     * toggled on. If a tag is toggled on at `iter,` then some non-empty
     * range of characters following `iter` has that tag applied to it.  If
     * a tag is toggled off, then some non-empty range following `iter`
     * does not have the tag applied to it.
     * @param toggledOn %TRUE to get toggled-on tags
     * @returns tags   toggled at this point
     */
    getToggledTags(toggledOn: boolean): TextTag[]
    /**
     * Returns the number of bytes from the start of the
     * line to the given `iter,` not counting bytes that
     * are invisible due to tags with the “invisible” flag
     * toggled on.
     * @returns byte index of @iter with respect to the start of the line
     */
    getVisibleLineIndex(): number
    /**
     * Returns the offset in characters from the start of the
     * line to the given `iter,` not counting characters that
     * are invisible due to tags with the “invisible” flag
     * toggled on.
     * @returns offset in visible characters from the start of the line
     */
    getVisibleLineOffset(): number
    /**
     * Returns visible text in the given range.
     *
     * Like [method`Gtk`.TextIter.get_slice], but invisible text
     * is not included. Invisible text is usually invisible because
     * a `GtkTextTag` with the “invisible” attribute turned on has
     * been applied to it.
     * @param end iterator at end of range
     * @returns slice of text from the buffer
     */
    getVisibleSlice(end: TextIter): string | null
    /**
     * Returns visible text in the given range.
     *
     * Like [method`Gtk`.TextIter.get_text], but invisible text
     * is not included. Invisible text is usually invisible because
     * a `GtkTextTag` with the “invisible” attribute turned on has
     * been applied to it.
     * @param end iterator at end of range
     * @returns string containing visible text in the range
     */
    getVisibleText(end: TextIter): string | null
    /**
     * Returns %TRUE if `iter` points to a character that is part
     * of a range tagged with `tag`.
     *
     * See also [method`Gtk`.TextIter.starts_tag] and
     * [method`Gtk`.TextIter.ends_tag].
     * @param tag a `GtkTextTag`
     * @returns whether @iter is tagged with @tag
     */
    hasTag(tag: TextTag): boolean
    /**
     * Checks whether `iter` falls in the range [`start,` `end)`.
     *
     * `start` and `end` must be in ascending order.
     * @param start start of range
     * @param end end of range
     * @returns %TRUE if @iter is in the range
     */
    inRange(start: TextIter, end: TextIter): boolean
    /**
     * Determines whether `iter` is inside a sentence (as opposed to in
     * between two sentences, e.g. after a period and before the first
     * letter of the next sentence).
     *
     * Sentence boundaries are determined by Pango and should be correct
     * for nearly any language.
     * @returns %TRUE if @iter is inside a sentence.
     */
    insideSentence(): boolean
    /**
     * Determines whether the character pointed by `iter` is part of a
     * natural-language word (as opposed to say inside some whitespace).
     *
     * Word breaks are determined by Pango and should be correct
     * for nearly any language.
     *
     * Note that if [method`Gtk`.TextIter.starts_word] returns %TRUE,
     * then this function returns %TRUE too, since `iter` points to
     * the first character of the word.
     * @returns %TRUE if @iter is inside a word
     */
    insideWord(): boolean
    /**
     * Determine if `iter` is at a cursor position.
     *
     * See [method`Gtk`.TextIter.forward_cursor_position] or
     * [struct`Pango`.LogAttr] or [func`Pango`.break] for details
     * on what a cursor position is.
     * @returns %TRUE if the cursor can be placed at @iter
     */
    isCursorPosition(): boolean
    /**
     * Returns %TRUE if `iter` is the end iterator.
     *
     * This means it is one past the last dereferenceable iterator
     * in the buffer. [method`Gtk`.TextIter.is_end] is the most efficient
     * way to check whether an iterator is the end iterator.
     * @returns whether @iter is the end iterator
     */
    isEnd(): boolean
    /**
     * Returns %TRUE if `iter` is the first iterator in the buffer.
     * @returns whether @iter is the first in the buffer
     */
    isStart(): boolean
    /**
     * Swaps the value of `first` and `second` if `second` comes before
     * `first` in the buffer.
     *
     * That is, ensures that `first` and `second` are in sequence.
     * Most text buffer functions that take a range call this
     * automatically on your behalf, so there’s no real reason to
     * call it yourself in those cases. There are some exceptions,
     * such as [method`Gtk`.TextIter.in_range], that expect a
     * pre-sorted range.
     * @param second another `GtkTextIter`
     */
    order(second: TextIter): void
    /**
     * Moves iterator `iter` to the start of the line `line_number`.
     *
     * If `line_number` is negative or larger than or equal to the number of lines
     * in the buffer, moves `iter` to the start of the last line in the buffer.
     * @param lineNumber line number (counted from 0)
     */
    setLine(lineNumber: number): void
    /**
     * Same as [method`Gtk`.TextIter.set_line_offset], but works with a
     * byte index. The given byte index must be at
     * the start of a character, it can’t be in the middle of a UTF-8
     * encoded character.
     * @param byteOnLine a byte index relative to the start of `iter’`s current line
     */
    setLineIndex(byteOnLine: number): void
    /**
     * Moves `iter` within a line, to a new character (not byte) offset.
     *
     * The given character offset must be less than or equal to the number
     * of characters in the line; if equal, `iter` moves to the start of the
     * next line. See [method`Gtk`.TextIter.set_line_index] if you have a byte
     * index rather than a character offset.
     * @param charOnLine a character offset relative to the start of `iter’`s current line
     */
    setLineOffset(charOnLine: number): void
    /**
     * Sets `iter` to point to `char_offset`.
     *
     * `char_offset` counts from the start
     * of the entire text buffer, starting with 0.
     * @param charOffset a character number
     */
    setOffset(charOffset: number): void
    /**
     * Like [method`Gtk`.TextIter.set_line_index], but the index is in visible
     * bytes, i.e. text with a tag making it invisible is not counted
     * in the index.
     * @param byteOnLine a byte index
     */
    setVisibleLineIndex(byteOnLine: number): void
    /**
     * Like [method`Gtk`.TextIter.set_line_offset], but the offset is in visible
     * characters, i.e. text with a tag making it invisible is not
     * counted in the offset.
     * @param charOnLine a character offset
     */
    setVisibleLineOffset(charOnLine: number): void
    /**
     * Returns %TRUE if `iter` begins a paragraph.
     *
     * This is the case if [method`Gtk`.TextIter.get_line_offset]
     * would return 0. However this function is potentially more
     * efficient than [method`Gtk`.TextIter.get_line_offset], because
     * it doesn’t have to compute the offset, it just has to see
     * whether it’s 0.
     * @returns whether @iter begins a line
     */
    startsLine(): boolean
    /**
     * Determines whether `iter` begins a sentence.
     *
     * Sentence boundaries are determined by Pango and
     * should be correct for nearly any language.
     * @returns %TRUE if @iter is at the start of a sentence.
     */
    startsSentence(): boolean
    /**
     * Returns %TRUE if `tag` is toggled on at exactly this point.
     *
     * If `tag` is %NULL, returns %TRUE if any tag is toggled on at this point.
     *
     * Note that if this function returns %TRUE, it means that
     * `iter` is at the beginning of the tagged range, and that the
     * character at `iter` is inside the tagged range. In other
     * words, unlike [method`Gtk`.TextIter.ends_tag], if
     * this function returns %TRUE, [method`Gtk`.TextIter.has_tag]
     * will also return %TRUE for the same parameters.
     * @param tag a `GtkTextTag`
     * @returns whether @iter is the start of a range tagged with @tag
     */
    startsTag(tag: TextTag | null): boolean
    /**
     * Determines whether `iter` begins a natural-language word.
     *
     * Word breaks are determined by Pango and should be correct
     * for nearly any language.
     * @returns %TRUE if @iter is at the start of a word
     */
    startsWord(): boolean
    /**
     * Gets whether a range with `tag` applied to it begins
     * or ends at `iter`.
     *
     * This is equivalent to (gtk_text_iter_starts_tag() ||
     * gtk_text_iter_ends_tag())
     * @param tag a `GtkTextTag`
     * @returns whether @tag is toggled on or off at @iter
     */
    togglesTag(tag: TextTag | null): boolean
  }

  /**
   * An iterator for the contents of a `GtkTextBuffer`.
   *
   * You may wish to begin by reading the
   * [text widget conceptual overview](section-text-widget.html),
   * which gives an overview of all the objects and data types
   * related to the text widget and how they work together.
   * @record
   */
  class TextIter {
    // Own properties of Gtk-4.0.Gtk.TextIter

    static name: string
  }

  interface TextMarkClass {
    // Own fields of Gtk-4.0.Gtk.TextMarkClass

    parentClass: GObject.ObjectClass
  }

  abstract class TextMarkClass {
    // Own properties of Gtk-4.0.Gtk.TextMarkClass

    static name: string
  }

  interface TextTagClass {
    // Own fields of Gtk-4.0.Gtk.TextTagClass

    parentClass: GObject.ObjectClass
  }

  abstract class TextTagClass {
    // Own properties of Gtk-4.0.Gtk.TextTagClass

    static name: string
  }

  interface TextTagPrivate {}

  class TextTagPrivate {
    // Own properties of Gtk-4.0.Gtk.TextTagPrivate

    static name: string
  }

  interface TextViewClass {
    // Own fields of Gtk-4.0.Gtk.TextViewClass

    /**
     * The object class structure needs to be the first
     * @field
     */
    parentClass: WidgetClass
    /**
     * The class handler for the `GtkTextView::move-cursor`
     *   keybinding signal.
     * @field
     */
    moveCursor: (
      textView: TextView,
      step: MovementStep,
      count: number,
      extendSelection: boolean
    ) => void
    /**
     * The class handler for the `GtkTextView::set-anchor`
     *   keybinding signal.
     * @field
     */
    setAnchor: (textView: TextView) => void
    /**
     * The class handler for the `GtkTextView::insert-at-cursor`
     *   keybinding signal.
     * @field
     */
    insertAtCursor: (textView: TextView, str: string) => void
    /**
     * The class handler for the `GtkTextView::delete-from-cursor`
     *   keybinding signal.
     * @field
     */
    deleteFromCursor: (
      textView: TextView,
      type: DeleteType,
      count: number
    ) => void
    /**
     * The class handler for the `GtkTextView::backspace`
     *   keybinding signal.
     * @field
     */
    backspace: (textView: TextView) => void
    /**
     * The class handler for the `GtkTextView::cut-clipboard`
     *   keybinding signal
     * @field
     */
    cutClipboard: (textView: TextView) => void
    /**
     * The class handler for the `GtkTextView::copy-clipboard`
     *   keybinding signal.
     * @field
     */
    copyClipboard: (textView: TextView) => void
    /**
     * The class handler for the `GtkTextView::paste-clipboard`
     *   keybinding signal.
     * @field
     */
    pasteClipboard: (textView: TextView) => void
    /**
     * The class handler for the `GtkTextView::toggle-overwrite`
     *   keybinding signal.
     * @field
     */
    toggleOverwrite: (textView: TextView) => void
    /**
     * The snapshot_layer vfunc is called before and after the text
     *   view is drawing its own text. Applications can override this vfunc
     *   in a subclass to draw customized content underneath or above the
     *   text. In the %GTK_TEXT_VIEW_LAYER_BELOW_TEXT and %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT
     *   layers the drawing is done in the buffer coordinate space.
     * @field
     */
    snapshotLayer: (
      textView: TextView,
      layer: TextViewLayer,
      snapshot: Snapshot
    ) => void
    /**
     * The class handler for the `GtkTextView::extend-selection` signal.
     * @field
     */
    extendSelection: (
      textView: TextView,
      granularity: TextExtendSelection,
      location: TextIter,
      start: TextIter,
      end: TextIter
    ) => boolean
    /**
     * The class handler for the `GtkTextView::insert-emoji` signal.
     * @field
     */
    insertEmoji: (textView: TextView) => void
  }

  abstract class TextViewClass {
    // Own properties of Gtk-4.0.Gtk.TextViewClass

    static name: string
  }

  interface TextViewPrivate {}

  class TextViewPrivate {
    // Own properties of Gtk-4.0.Gtk.TextViewPrivate

    static name: string
  }

  interface ToggleButtonClass {
    // Own fields of Gtk-4.0.Gtk.ToggleButtonClass

    parentClass: ButtonClass
    toggled: (toggleButton: ToggleButton) => void
  }

  abstract class ToggleButtonClass {
    // Own properties of Gtk-4.0.Gtk.ToggleButtonClass

    static name: string
  }

  interface TreeDragDestIface {
    // Own fields of Gtk-4.0.Gtk.TreeDragDestIface

    /**
     * Asks the `GtkTreeDragDest` to insert a row
     *    before the path dest, deriving the contents of the row from
     *    selection_data.
     * @field
     */
    dragDataReceived: (
      dragDest: TreeDragDest,
      dest: TreePath,
      value: any
    ) => boolean
    /**
     * Determines whether a drop is possible before
     *    the given dest_path, at the same depth as dest_path.
     * @field
     */
    rowDropPossible: (
      dragDest: TreeDragDest,
      destPath: TreePath,
      value: any
    ) => boolean
  }

  abstract class TreeDragDestIface {
    // Own properties of Gtk-4.0.Gtk.TreeDragDestIface

    static name: string
  }

  interface TreeDragSourceIface {
    // Own fields of Gtk-4.0.Gtk.TreeDragSourceIface

    /**
     * Asks the `GtkTreeDragSource` whether a particular
     *    row can be used as the source of a DND operation.
     * @field
     */
    rowDraggable: (dragSource: TreeDragSource, path: TreePath) => boolean
    /**
     * Asks the `GtkTreeDragSource` to fill in
     *    selection_data with a representation of the row at path.
     * @field
     */
    dragDataGet: (
      dragSource: TreeDragSource,
      path: TreePath
    ) => Gdk.ContentProvider | null
    /**
     * Asks the `GtkTreeDragSource` to delete the row at
     *    path, because it was moved somewhere else via drag-and-drop.
     * @field
     */
    dragDataDelete: (dragSource: TreeDragSource, path: TreePath) => boolean
  }

  abstract class TreeDragSourceIface {
    // Own properties of Gtk-4.0.Gtk.TreeDragSourceIface

    static name: string
  }

  interface TreeExpanderClass {
    // Own fields of Gtk-4.0.Gtk.TreeExpanderClass

    parentClass: WidgetClass
  }

  abstract class TreeExpanderClass {
    // Own properties of Gtk-4.0.Gtk.TreeExpanderClass

    static name: string
  }

  interface TreeIter {
    // Own fields of Gtk-4.0.Gtk.TreeIter

    /**
     * a unique stamp to catch invalid iterators
     * @field
     */
    stamp: number
    /**
     * model-specific data
     * @field
     */
    userData: any
    /**
     * model-specific data
     * @field
     */
    userData2: any
    /**
     * model-specific data
     * @field
     */
    userData3: any

    // Owm methods of Gtk-4.0.Gtk.TreeIter

    /**
     * Creates a dynamically allocated tree iterator as a copy of `iter`.
     *
     * This function is not intended for use in applications,
     * because you can just copy the structs by value
     * (`GtkTreeIter new_iter = iter;`).
     * You must free this iter with gtk_tree_iter_free().
     * @returns a newly-allocated copy of @iter
     */
    copy(): TreeIter
    /**
     * Frees an iterator that has been allocated by gtk_tree_iter_copy().
     *
     * This function is mainly used for language bindings.
     */
    free(): void
  }

  /**
   * The `GtkTreeIter` is the primary structure
   * for accessing a `GtkTreeModel`. Models are expected to put a unique
   * integer in the `stamp` member, and put
   * model-specific data in the three `user_data`
   * members.
   * @record
   */
  class TreeIter {
    // Own properties of Gtk-4.0.Gtk.TreeIter

    static name: string
  }

  interface TreeListModelClass {
    // Own fields of Gtk-4.0.Gtk.TreeListModelClass

    parentClass: GObject.ObjectClass
  }

  abstract class TreeListModelClass {
    // Own properties of Gtk-4.0.Gtk.TreeListModelClass

    static name: string
  }

  interface TreeListRowClass {
    // Own fields of Gtk-4.0.Gtk.TreeListRowClass

    parentClass: GObject.ObjectClass
  }

  abstract class TreeListRowClass {
    // Own properties of Gtk-4.0.Gtk.TreeListRowClass

    static name: string
  }

  interface TreeListRowSorterClass {
    // Own fields of Gtk-4.0.Gtk.TreeListRowSorterClass

    parentClass: SorterClass
  }

  abstract class TreeListRowSorterClass {
    // Own properties of Gtk-4.0.Gtk.TreeListRowSorterClass

    static name: string
  }

  interface TreeModelFilterClass {
    // Own fields of Gtk-4.0.Gtk.TreeModelFilterClass

    parentClass: GObject.ObjectClass
    visible: (
      self: TreeModelFilter,
      childModel: TreeModel,
      iter: TreeIter
    ) => boolean
    modify: (
      self: TreeModelFilter,
      childModel: TreeModel,
      iter: TreeIter,
      value: any,
      column: number
    ) => void
  }

  abstract class TreeModelFilterClass {
    // Own properties of Gtk-4.0.Gtk.TreeModelFilterClass

    static name: string
  }

  interface TreeModelFilterPrivate {}

  class TreeModelFilterPrivate {
    // Own properties of Gtk-4.0.Gtk.TreeModelFilterPrivate

    static name: string
  }

  interface TreeModelIface {
    // Own fields of Gtk-4.0.Gtk.TreeModelIface

    /**
     * Signal emitted when a row in the model has changed.
     * @field
     */
    rowChanged: (treeModel: TreeModel, path: TreePath, iter: TreeIter) => void
    /**
     * Signal emitted when a new row has been inserted in
     *    the model.
     * @field
     */
    rowInserted: (treeModel: TreeModel, path: TreePath, iter: TreeIter) => void
    /**
     * Signal emitted when a row has gotten the
     *    first child row or lost its last child row.
     * @field
     */
    rowHasChildToggled: (
      treeModel: TreeModel,
      path: TreePath,
      iter: TreeIter
    ) => void
    /**
     * Signal emitted when a row has been deleted.
     * @field
     */
    rowDeleted: (treeModel: TreeModel, path: TreePath) => void
    /**
     * Signal emitted when the children of a node in the
     *    GtkTreeModel have been reordered.
     * @field
     */
    rowsReordered: (
      treeModel: TreeModel,
      path: TreePath,
      iter: TreeIter,
      newOrder: number
    ) => void
    /**
     * Get `GtkTreeModelFlags` supported by this interface.
     * @field
     */
    getFlags: (treeModel: TreeModel) => TreeModelFlags
    /**
     * Get the number of columns supported by the model.
     * @field
     */
    getNColumns: (treeModel: TreeModel) => number
    /**
     * Get the type of the column.
     * @field
     */
    getColumnType: (treeModel: TreeModel, index: number) => GObject.GType
    /**
     * Sets iter to a valid iterator pointing to path.
     * @field
     */
    getIter: (
      treeModel: TreeModel,
      path: TreePath
    ) => [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Gets a newly-created `GtkTreePath` referenced by iter.
     * @field
     */
    getPath: (treeModel: TreeModel, iter: TreeIter) => TreePath
    /**
     * Initializes and sets value to that at column.
     * @field
     */
    getValue: (
      treeModel: TreeModel,
      iter: TreeIter,
      column: number
    ) => /* value */ any
    /**
     * Sets iter to point to the node following it at the
     *    current level.
     * @field
     */
    iterNext: (treeModel: TreeModel, iter: TreeIter) => boolean
    /**
     * Sets iter to point to the previous node at the
     *    current level.
     * @field
     */
    iterPrevious: (treeModel: TreeModel, iter: TreeIter) => boolean
    /**
     * Sets iter to point to the first child of parent.
     * @field
     */
    iterChildren: (
      treeModel: TreeModel,
      parent: TreeIter | null
    ) => [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * %TRUE if iter has children, %FALSE otherwise.
     * @field
     */
    iterHasChild: (treeModel: TreeModel, iter: TreeIter) => boolean
    /**
     * Gets the number of children that iter has.
     * @field
     */
    iterNChildren: (treeModel: TreeModel, iter: TreeIter | null) => number
    /**
     * Sets iter to be the child of parent, using the
     *    given index.
     * @field
     */
    iterNthChild: (
      treeModel: TreeModel,
      parent: TreeIter | null,
      n: number
    ) => [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Sets iter to be the parent of child.
     * @field
     */
    iterParent: (
      treeModel: TreeModel,
      child: TreeIter
    ) => [/* returnType */ boolean, /* iter */ TreeIter]
    /**
     * Lets the tree ref the node.
     * @field
     */
    refNode: (treeModel: TreeModel, iter: TreeIter) => void
    /**
     * Lets the tree unref the node.
     * @field
     */
    unrefNode: (treeModel: TreeModel, iter: TreeIter) => void
  }

  abstract class TreeModelIface {
    // Own properties of Gtk-4.0.Gtk.TreeModelIface

    static name: string
  }

  interface TreeModelSortClass {
    // Own fields of Gtk-4.0.Gtk.TreeModelSortClass

    parentClass: GObject.ObjectClass
  }

  abstract class TreeModelSortClass {
    // Own properties of Gtk-4.0.Gtk.TreeModelSortClass

    static name: string
  }

  interface TreeModelSortPrivate {}

  class TreeModelSortPrivate {
    // Own properties of Gtk-4.0.Gtk.TreeModelSortPrivate

    static name: string
  }

  interface TreePath {
    // Owm methods of Gtk-4.0.Gtk.TreePath

    /**
     * Appends a new index to a path.
     *
     * As a result, the depth of the path is increased.
     * @param index the index
     */
    appendIndex(index: number): void
    /**
     * Compares two paths.
     *
     * If `a` appears before `b` in a tree, then -1 is returned.
     * If `b` appears before `a,` then 1 is returned.
     * If the two nodes are equal, then 0 is returned.
     * @param b a `GtkTreePath` to compare with
     * @returns the relative positions of @a and @b
     */
    compare(b: TreePath): number
    /**
     * Creates a new `GtkTreePath` as a copy of `path`.
     * @returns a new `GtkTreePath`
     */
    copy(): TreePath
    /**
     * Moves `path` to point to the first child of the current path.
     */
    down(): void
    /**
     * Frees `path`. If `path` is %NULL, it simply returns.
     */
    free(): void
    /**
     * Returns the current depth of `path`.
     * @returns The depth of @path
     */
    getDepth(): number
    /**
     * Returns the current indices of `path`.
     *
     * This is an array of integers, each representing a node in a tree.
     * It also returns the number of elements in the array.
     * The array should not be freed.
     * @returns The current   indices
     */
    getIndices(): number[] | null
    /**
     * Returns %TRUE if `descendant` is a descendant of `path`.
     * @param descendant another `GtkTreePath`
     * @returns %TRUE if @descendant is contained inside @path
     */
    isAncestor(descendant: TreePath): boolean
    /**
     * Returns %TRUE if `path` is a descendant of `ancestor`.
     * @param ancestor another `GtkTreePath`
     * @returns %TRUE if @ancestor contains @path somewhere below it
     */
    isDescendant(ancestor: TreePath): boolean
    /**
     * Moves the `path` to point to the next node at the current depth.
     */
    next(): void
    /**
     * Prepends a new index to a path.
     *
     * As a result, the depth of the path is increased.
     * @param index the index
     */
    prependIndex(index: number): void
    /**
     * Moves the `path` to point to the previous node at the
     * current depth, if it exists.
     * @returns %TRUE if @path has a previous node, and   the move was made
     */
    prev(): boolean
    /**
     * Generates a string representation of the path.
     *
     * This string is a “:” separated list of numbers.
     * For example, “4:10:0:3” would be an acceptable
     * return value for this string. If the path has
     * depth 0, %NULL is returned.
     * @returns A newly-allocated string
     */
    toString(): string | null
    /**
     * Moves the `path` to point to its parent node, if it has a parent.
     * @returns %TRUE if @path has a parent, and the move was made
     */
    up(): boolean
  }

  /**
   * An opaque structure representing a path to a row in a model.
   * @record
   */
  class TreePath {
    // Own properties of Gtk-4.0.Gtk.TreePath

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreePath

    /**
     * Creates a new `GtkTreePath`
     * This refers to a row.
     * @constructor
     * @returns A newly created `GtkTreePath`.
     */
    constructor()
    /**
     * Creates a new `GtkTreePath`
     * This refers to a row.
     * @constructor
     * @returns A newly created `GtkTreePath`.
     */
    static new(): TreePath
    /**
     * Creates a new `GtkTreePath`.
     *
     * The string representation of this path is “0”.
     * @constructor
     * @returns A new `GtkTreePath`
     */
    static newFirst(): TreePath
    /**
     * Creates a new path with the given `indices` array of `length`.
     * @constructor
     * @param indices array of indices
     * @returns A newly created `GtkTreePath`
     */
    static newFromIndices(indices: number[]): TreePath
    /**
     * Creates a new `GtkTreePath` initialized to `path`.
     *
     * `path` is expected to be a colon separated list of numbers.
     * For example, the string “10:4:0” would create a path of depth
     * 3 pointing to the 11th child of the root node, the 5th
     * child of that 11th child, and the 1st child of that 5th child.
     * If an invalid path string is passed in, %NULL is returned.
     * @constructor
     * @param path The string representation of a path
     * @returns A newly-created `GtkTreePath`
     */
    static newFromString(path: string): TreePath
  }

  interface TreeRowReference {
    // Owm methods of Gtk-4.0.Gtk.TreeRowReference

    /**
     * Copies a `GtkTreeRowReference`.
     * @returns a copy of @reference
     */
    copy(): TreeRowReference
    /**
     * Free’s `reference`. `reference` may be %NULL
     */
    free(): void
    /**
     * Returns the model that the row reference is monitoring.
     * @returns the model
     */
    getModel(): TreeModel
    /**
     * Returns a path that the row reference currently points to,
     * or %NULL if the path pointed to is no longer valid.
     * @returns a current path
     */
    getPath(): TreePath | null
    /**
     * Returns %TRUE if the `reference` is non-%NULL and refers to
     * a current valid path.
     * @returns %TRUE if @reference points to a valid path
     */
    valid(): boolean
  }

  /**
   * A GtkTreeRowReference tracks model changes so that it always refers to the
   * same row (a `GtkTreePath` refers to a position, not a fixed row). Create a
   * new GtkTreeRowReference with gtk_tree_row_reference_new().
   * @record
   */
  class TreeRowReference {
    // Own properties of Gtk-4.0.Gtk.TreeRowReference

    static name: string

    // Constructors of Gtk-4.0.Gtk.TreeRowReference

    /**
     * Creates a row reference based on `path`.
     *
     * This reference will keep pointing to the node pointed to
     * by `path,` so long as it exists. Any changes that occur on `model` are
     * propagated, and the path is updated appropriately. If
     * `path` isn’t a valid path in `model,` then %NULL is returned.
     * @constructor
     * @param model a `GtkTreeModel`
     * @param path a valid `GtkTreePath` to monitor
     * @returns a newly allocated `GtkTreeRowReference`
     */
    constructor(model: TreeModel, path: TreePath)
    /**
     * Creates a row reference based on `path`.
     *
     * This reference will keep pointing to the node pointed to
     * by `path,` so long as it exists. Any changes that occur on `model` are
     * propagated, and the path is updated appropriately. If
     * `path` isn’t a valid path in `model,` then %NULL is returned.
     * @constructor
     * @param model a `GtkTreeModel`
     * @param path a valid `GtkTreePath` to monitor
     * @returns a newly allocated `GtkTreeRowReference`
     */
    static new(model: TreeModel, path: TreePath): TreeRowReference
    /**
     * You do not need to use this function.
     *
     * Creates a row reference based on `path`.
     *
     * This reference will keep pointing to the node pointed to
     * by `path,` so long as it exists. If `path` isn’t a valid
     * path in `model,` then %NULL is returned. However, unlike
     * references created with gtk_tree_row_reference_new(), it
     * does not listen to the model for changes. The creator of
     * the row reference must do this explicitly using
     * gtk_tree_row_reference_inserted(), gtk_tree_row_reference_deleted(),
     * gtk_tree_row_reference_reordered().
     *
     * These functions must be called exactly once per proxy when the
     * corresponding signal on the model is emitted. This single call
     * updates all row references for that proxy. Since built-in GTK
     * objects like `GtkTreeView` already use this mechanism internally,
     * using them as the proxy object will produce unpredictable results.
     * Further more, passing the same object as `model` and `proxy`
     * doesn’t work for reasons of internal implementation.
     *
     * This type of row reference is primarily meant by structures that
     * need to carefully monitor exactly when a row reference updates
     * itself, and is not generally needed by most applications.
     * @constructor
     * @param proxy a proxy `GObject`
     * @param model a `GtkTreeModel`
     * @param path a valid `GtkTreePath` to monitor
     * @returns a newly allocated `GtkTreeRowReference`
     */
    static newProxy(
      proxy: GObject.Object,
      model: TreeModel,
      path: TreePath
    ): TreeRowReference
    /**
     * Lets a set of row reference created by
     * gtk_tree_row_reference_new_proxy() know that the
     * model emitted the ::row-deleted signal.
     * @param proxy a `GObject`
     * @param path the path position that was deleted
     */
    static deleted(proxy: GObject.Object, path: TreePath): void
    /**
     * Lets a set of row reference created by
     * gtk_tree_row_reference_new_proxy() know that the
     * model emitted the ::row-inserted signal.
     * @param proxy a `GObject`
     * @param path the row position that was inserted
     */
    static inserted(proxy: GObject.Object, path: TreePath): void
  }

  interface TreeSortableIface {
    // Own fields of Gtk-4.0.Gtk.TreeSortableIface

    /**
     * Signal emitted when the sort column or sort
     *    order of sortable is changed.
     * @field
     */
    sortColumnChanged: (sortable: TreeSortable) => void
    /**
     * Fills in sort_column_id and order with the
     *    current sort column and the order.
     * @field
     */
    getSortColumnId: (
      sortable: TreeSortable
    ) => [
      /* returnType */ boolean,
      /* sortColumnId */ number,
      /* order */ SortType,
    ]
    /**
     * Sets the current sort column to be
     *    sort_column_id.
     * @field
     */
    setSortColumnId: (
      sortable: TreeSortable,
      sortColumnId: number,
      order: SortType
    ) => void
    /**
     * Sets the comparison function used when sorting to
     *    be sort_func.
     * @field
     */
    setSortFunc: (
      sortable: TreeSortable,
      sortColumnId: number,
      sortFunc: TreeIterCompareFunc
    ) => void
    /**
     * Sets the default comparison function used
     *    when sorting to be sort_func.
     * @field
     */
    setDefaultSortFunc: (
      sortable: TreeSortable,
      sortFunc: TreeIterCompareFunc
    ) => void
    /**
     * %TRUE if the model has a default sort
     * function.
     * @field
     */
    hasDefaultSortFunc: (sortable: TreeSortable) => boolean
  }

  abstract class TreeSortableIface {
    // Own properties of Gtk-4.0.Gtk.TreeSortableIface

    static name: string
  }

  interface TreeStoreClass {
    // Own fields of Gtk-4.0.Gtk.TreeStoreClass

    parentClass: GObject.ObjectClass
  }

  abstract class TreeStoreClass {
    // Own properties of Gtk-4.0.Gtk.TreeStoreClass

    static name: string
  }

  interface TreeStorePrivate {}

  class TreeStorePrivate {
    // Own properties of Gtk-4.0.Gtk.TreeStorePrivate

    static name: string
  }

  interface TreeViewClass {
    // Own fields of Gtk-4.0.Gtk.TreeViewClass

    parentClass: WidgetClass
    rowActivated: (
      treeView: TreeView,
      path: TreePath,
      column: TreeViewColumn | null
    ) => void
    testExpandRow: (
      treeView: TreeView,
      iter: TreeIter,
      path: TreePath
    ) => boolean
    testCollapseRow: (
      treeView: TreeView,
      iter: TreeIter,
      path: TreePath
    ) => boolean
    rowExpanded: (treeView: TreeView, iter: TreeIter, path: TreePath) => void
    rowCollapsed: (treeView: TreeView, iter: TreeIter, path: TreePath) => void
    columnsChanged: (treeView: TreeView) => void
    cursorChanged: (treeView: TreeView) => void
    moveCursor: (
      treeView: TreeView,
      step: MovementStep,
      count: number,
      extend: boolean,
      modify: boolean
    ) => boolean
    selectAll: (treeView: TreeView) => boolean
    unselectAll: (treeView: TreeView) => boolean
    selectCursorRow: (treeView: TreeView, startEditing: boolean) => boolean
    toggleCursorRow: (treeView: TreeView) => boolean
    expandCollapseCursorRow: (
      treeView: TreeView,
      logical: boolean,
      expand: boolean,
      openAll: boolean
    ) => boolean
    selectCursorParent: (treeView: TreeView) => boolean
    startInteractiveSearch: (treeView: TreeView) => boolean
  }

  abstract class TreeViewClass {
    // Own properties of Gtk-4.0.Gtk.TreeViewClass

    static name: string
  }

  interface UriLauncherClass {
    // Own fields of Gtk-4.0.Gtk.UriLauncherClass

    parentClass: GObject.ObjectClass
  }

  abstract class UriLauncherClass {
    // Own properties of Gtk-4.0.Gtk.UriLauncherClass

    static name: string
  }

  interface VideoClass {
    // Own fields of Gtk-4.0.Gtk.VideoClass

    parentClass: WidgetClass
  }

  abstract class VideoClass {
    // Own properties of Gtk-4.0.Gtk.VideoClass

    static name: string
  }

  interface WidgetClass {
    // Own fields of Gtk-4.0.Gtk.WidgetClass

    /**
     * The object class structure needs to be the first
     *   element in the widget class structure in order for the class mechanism
     *   to work correctly. This allows a GtkWidgetClass pointer to be cast to
     *   a GObjectClass pointer.
     * @field
     */
    parentClass: GObject.InitiallyUnownedClass
    /**
     * Signal emitted when widget is shown
     * @field
     */
    show: (widget: Widget) => void
    /**
     * Signal emitted when widget is hidden.
     * @field
     */
    hide: (widget: Widget) => void
    /**
     * Signal emitted when widget is going to be mapped, that is
     *   when the widget is visible (which is controlled with
     *   gtk_widget_set_visible()) and all its parents up to the toplevel
     *   widget are also visible.
     * @field
     */
    map: (widget: Widget) => void
    /**
     * Signal emitted when widget is going to be unmapped, which
     *   means that either it or any of its parents up to the toplevel
     *   widget have been set as hidden.
     * @field
     */
    unmap: (widget: Widget) => void
    /**
     * Signal emitted when widget is associated with a
     *   `GdkSurface`, which means that gtk_widget_realize() has been called or
     *   the widget has been mapped (that is, it is going to be drawn).
     * @field
     */
    realize: (widget: Widget) => void
    /**
     * Signal emitted when the GdkSurface associated with
     *   widget is destroyed, which means that gtk_widget_unrealize() has
     *   been called or the widget has been unmapped (that is, it is going
     *   to be hidden).
     * @field
     */
    unrealize: (widget: Widget) => void
    /**
     * Called when the widget gets added to a `GtkRoot` widget. Must
     *   chain up
     * @field
     */
    root: (widget: Widget) => void
    /**
     * Called when the widget is about to be removed from its
     *   `GtkRoot` widget. Must chain up
     * @field
     */
    unroot: (widget: Widget) => void
    /**
     * Called to set the allocation, if the widget does
     *   not have a layout manager.
     * @field
     */
    sizeAllocate: (
      widget: Widget,
      width: number,
      height: number,
      baseline: number
    ) => void
    /**
     * Signal emitted when the widget state changes,
     *   see gtk_widget_get_state_flags().
     * @field
     */
    stateFlagsChanged: (widget: Widget, previousStateFlags: StateFlags) => void
    /**
     * Signal emitted when the text direction of a
     *   widget changes.
     * @field
     */
    directionChanged: (widget: Widget, previousDirection: TextDirection) => void
    /**
     * Called to get the request mode, if the widget
     *   does not have a layout manager.
     *   This allows a widget to tell its parent container whether
     *   it prefers to be allocated in %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or
     *   %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT mode.
     *   %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH means the widget prefers to have
     *   `GtkWidgetClass.measure()` called first to get the default width (passing
     *   a for_size of -1), then again to get the height for said default width.
     *   %GTK_SIZE_REQUEST_CONSTANT_SIZE disables any height-for-width or
     *   width-for-height geometry management for said widget and is the
     *   default return.
     *   It’s important to note that any widget
     *   which trades height-for-width or width-for-height must respond properly
     *   to a for_size value >= -1 passed to `GtkWidgetClass.measure`, for both
     *   possible orientations.
     * @field
     */
    getRequestMode: (widget: Widget) => SizeRequestMode
    /**
     * Called to obtain the minimum and natural size of the widget,
     *   if the widget does not have a layout manager.
     *   Depending on the orientation parameter, the passed for_size can be
     *   interpreted as width or height. A widget will never be allocated less
     *   than its minimum size.
     * @field
     */
    measure: (
      widget: Widget,
      orientation: Orientation,
      forSize: number
    ) => [
      /* minimum */ number,
      /* natural */ number,
      /* minimumBaseline */ number,
      /* naturalBaseline */ number,
    ]
    /**
     * Activates the `widget` if `group_cycling` is
     *   %FALSE, and just grabs the focus if `group_cycling` is %TRUE.
     * @field
     */
    mnemonicActivate: (widget: Widget, groupCycling: boolean) => boolean
    /**
     * Causes `widget` to have the keyboard focus for the
     *   `GtkWindow` it’s inside.
     * @field
     */
    grabFocus: (widget: Widget) => boolean
    /**
     * Vfunc for gtk_widget_child_focus()
     * @field
     */
    focus: (widget: Widget, direction: DirectionType) => boolean
    /**
     * Sets the focused child of a widget. Must chain up
     * @field
     */
    setFocusChild: (widget: Widget, child: Widget | null) => void
    /**
     * Signal emitted when a change of focus is requested
     * @field
     */
    moveFocus: (widget: Widget, direction: DirectionType) => void
    /**
     * Signal emitted if keyboard navigation fails.
     * @field
     */
    keynavFailed: (widget: Widget, direction: DirectionType) => boolean
    /**
     * Signal emitted when “has-tooltip” is %TRUE and the
     *   hover timeout has expired with the cursor hovering “above”
     *   widget; or emitted when widget got focus in keyboard mode.
     * @field
     */
    queryTooltip: (
      widget: Widget,
      x: number,
      y: number,
      keyboardTooltip: boolean,
      tooltip: Tooltip
    ) => boolean
    /**
     * Computes whether a container should give this
     *   widget extra space when possible.
     * @field
     */
    computeExpand: (
      widget: Widget,
      hexpandP: boolean,
      vexpandP: boolean
    ) => void
    /**
     * Vfunc called when the CSS used by widget was changed. Widgets
     *   should then discard their caches that depend on CSS and queue resizes or
     *   redraws accordingly. The default implementation will take care of this for
     *   all the default CSS properties, so implementations must chain up.
     * @field
     */
    cssChanged: (widget: Widget, change: CssStyleChange) => void
    /**
     * Emitted when a system setting was changed. Must chain up.
     * @field
     */
    systemSettingChanged: (widget: Widget, settings: SystemSetting) => void
    /**
     * Vfunc called when a new snapshot of the widget has to be taken.
     * @field
     */
    snapshot: (widget: Widget, snapshot: Snapshot) => void
    /**
     * Vfunc for gtk_widget_contains().
     * @field
     */
    contains: (widget: Widget, x: number, y: number) => boolean
  }

  abstract class WidgetClass {
    // Own properties of Gtk-4.0.Gtk.WidgetClass

    static name: string

    // Owm static methods of Gtk-4.0.Gtk.WidgetClass

    /**
     * Installs a shortcut in `widget_class`.
     *
     * Every instance created for `widget_class` or its subclasses will
     * inherit this shortcut and trigger it.
     *
     * Shortcuts added this way will be triggered in the %GTK_PHASE_BUBBLE
     * phase, which means they may also trigger if child widgets have focus.
     *
     * This function must only be used in class initialization functions
     * otherwise it is not guaranteed that the shortcut will be installed.
     * @param shortcut the `GtkShortcut` to add
     */
    static addShortcut(
      widget_class: Widget | Function | GObject.GType,
      shortcut: Shortcut
    ): void
    /**
     * Declares a `callback_symbol` to handle `callback_name` from
     * the template XML defined for `widget_type`.
     *
     * This function is not supported after [method`Gtk`.WidgetClass.set_template_scope]
     * has been used on `widget_class`. See [method`Gtk`.BuilderCScope.add_callback_symbol].
     *
     * Note that this must be called from a composite widget classes
     * class initializer after calling [method`Gtk`.WidgetClass.set_template].
     * @param callbackName The name of the callback as expected in the template XML
     * @param callbackSymbol The callback symbol
     */
    static bindTemplateCallbackFull(
      widget_class: Widget | Function | GObject.GType,
      callbackName: string,
      callbackSymbol: GObject.Callback
    ): void
    /**
     * Automatically assign an object declared in the class template XML to
     * be set to a location on a freshly built instance’s private data, or
     * alternatively accessible via [method`Gtk`.Widget.get_template_child].
     *
     * The struct can point either into the public instance, then you should
     * use `G_STRUCT_OFFSET(WidgetType, member)` for `struct_offset,` or in the
     * private struct, then you should use `G_PRIVATE_OFFSET(WidgetType, member)`.
     *
     * An explicit strong reference will be held automatically for the duration
     * of your instance’s life cycle, it will be released automatically when
     * `GObjectClass.dispose()` runs on your instance and if a `struct_offset`
     * that is `!= 0` is specified, then the automatic location in your instance
     * public or private data will be set to %NULL. You can however access an
     * automated child pointer the first time your classes `GObjectClass.dispose()`
     * runs, or alternatively in [signal`Gtk`.Widget::destroy].
     *
     * If `internal_child` is specified, [vfunc`Gtk`.Buildable.get_internal_child]
     * will be automatically implemented by the `GtkWidget` class so there is no
     * need to implement it manually.
     *
     * The wrapper macros [func`Gtk`.widget_class_bind_template_child],
     * [func`Gtk`.widget_class_bind_template_child_internal],
     * [func`Gtk`.widget_class_bind_template_child_private] and
     * [func`Gtk`.widget_class_bind_template_child_internal_private]
     * might be more convenient to use.
     *
     * Note that this must be called from a composite widget classes class
     * initializer after calling [method`Gtk`.WidgetClass.set_template].
     * @param name The “id” of the child defined in the template XML
     * @param internalChild Whether the child should be accessible as an “internal-child”   when this class is used in GtkBuilder XML
     * @param structOffset The structure offset into the composite widget’s instance   public or private structure where the automated child pointer should be set,   or 0 to not assign the pointer.
     */
    static bindTemplateChildFull(
      widget_class: Widget | Function | GObject.GType,
      name: string,
      internalChild: boolean,
      structOffset: number
    ): void
    /**
     * Retrieves the accessible role used by the given `GtkWidget` class.
     *
     * Different accessible roles have different states, and are rendered
     * differently by assistive technologies.
     *
     * See also: [method`Gtk`.Accessible.get_accessible_role].
     * @returns the accessible role for the widget class
     */
    static getAccessibleRole(
      widget_class: Widget | Function | GObject.GType
    ): AccessibleRole
    /**
     * Retrieves the signal id for the activation signal.
     *
     * the activation signal is set using
     * [method`Gtk`.WidgetClass.set_activate_signal].
     * @returns a signal id, or 0 if the widget class does not   specify an activation signal
     */
    static getActivateSignal(
      widget_class: Widget | Function | GObject.GType
    ): number
    /**
     * Gets the name used by this class for matching in CSS code.
     *
     * See [method`Gtk`.WidgetClass.set_css_name] for details.
     * @returns the CSS name of the given class
     */
    static getCssName(widget_class: Widget | Function | GObject.GType): string
    /**
     * Retrieves the type of the [class`Gtk`.LayoutManager]
     * used by widgets of class `widget_class`.
     *
     * See also: [method`Gtk`.WidgetClass.set_layout_manager_type].
     * @returns type of a `GtkLayoutManager` subclass, or %G_TYPE_INVALID
     */
    static getLayoutManagerType(
      widget_class: Widget | Function | GObject.GType
    ): GObject.GType
    /**
     * This should be called at class initialization time to specify
     * actions to be added for all instances of this class.
     *
     * Actions installed by this function are stateless. The only state
     * they have is whether they are enabled or not (which can be changed with
     * [method`Gtk`.Widget.action_set_enabled]).
     * @param actionName a prefixed action name, such as "clipboard.paste"
     * @param parameterType the parameter type
     * @param activate callback to use when the action is activated
     */
    static installAction(
      widget_class: Widget | Function | GObject.GType,
      actionName: string,
      parameterType: string | null,
      activate: WidgetActionActivateFunc
    ): void
    /**
     * Installs an action called `action_name` on `widget_class` and
     * binds its state to the value of the `property_name` property.
     *
     * This function will perform a few sanity checks on the property selected
     * via `property_name`. Namely, the property must exist, must be readable,
     * writable and must not be construct-only. There are also restrictions
     * on the type of the given property, it must be boolean, int, unsigned int,
     * double or string. If any of these conditions are not met, a critical
     * warning will be printed and no action will be added.
     *
     * The state type of the action matches the property type.
     *
     * If the property is boolean, the action will have no parameter and
     * toggle the property value. Otherwise, the action will have a parameter
     * of the same type as the property.
     * @param actionName name of the action
     * @param propertyName name of the property in instances of `widget_class`   or any parent class.
     */
    static installPropertyAction(
      widget_class: Widget | Function | GObject.GType,
      actionName: string,
      propertyName: string
    ): void
    /**
     * Returns details about the `index_-th` action that has been
     * installed for `widget_class` during class initialization.
     *
     * See [method`Gtk`.WidgetClass.install_action] for details on
     * how to install actions.
     *
     * Note that this function will also return actions defined
     * by parent classes. You can identify those by looking
     * at `owner`.
     * @param index position of the action to query
     * @returns %TRUE if the action was found, %FALSE if @index_   is out of range
     */
    static queryAction(
      widget_class: Widget | Function | GObject.GType,
      index: number
    ): [
      /* returnType */ boolean,
      /* owner */ GObject.GType,
      /* actionName */ string,
      /* parameterType */ GLib.VariantType | null,
      /* propertyName */ string | null,
    ]
    /**
     * Sets the accessible role used by the given `GtkWidget` class.
     *
     * Different accessible roles have different states, and are
     * rendered differently by assistive technologies.
     * @param accessibleRole the `GtkAccessibleRole` used by the `widget_class`
     */
    static setAccessibleRole(
      widget_class: Widget | Function | GObject.GType,
      accessibleRole: AccessibleRole
    ): void
    /**
     * Sets the `GtkWidgetClass.activate_signal` field with the
     * given `signal_id`.
     *
     * The signal will be emitted when calling [method`Gtk`.Widget.activate].
     *
     * The `signal_id` must have been registered with `g_signal_new()`
     * or g_signal_newv() before calling this function.
     * @param signalId the id for the activate signal
     */
    static setActivateSignal(
      widget_class: Widget | Function | GObject.GType,
      signalId: number
    ): void
    /**
     * Sets the `GtkWidgetClass.activate_signal` field with the signal id for
     * the given `signal_name`.
     *
     * The signal will be emitted when calling [method`Gtk`.Widget.activate].
     *
     * The `signal_name` of `widget_type` must have been registered with
     * g_signal_new() or g_signal_newv() before calling this function.
     * @param signalName the name of the activate signal of `widget_type`
     */
    static setActivateSignalFromName(
      widget_class: Widget | Function | GObject.GType,
      signalName: string
    ): void
    /**
     * Sets the name to be used for CSS matching of widgets.
     *
     * If this function is not called for a given class, the name
     * set on the parent class is used. By default, `GtkWidget`
     * uses the name "widget".
     * @param name name to use
     */
    static setCssName(
      widget_class: Widget | Function | GObject.GType,
      name: string
    ): void
    /**
     * Sets the type to be used for creating layout managers for
     * widgets of `widget_class`.
     *
     * The given `type` must be a subtype of [class`Gtk`.LayoutManager].
     *
     * This function should only be called from class init functions
     * of widgets.
     * @param type The object type that implements the `GtkLayoutManager`   for `widget_class`
     */
    static setLayoutManagerType(
      widget_class: Widget | Function | GObject.GType,
      type: GObject.GType
    ): void
    /**
     * This should be called at class initialization time to specify
     * the `GtkBuilder` XML to be used to extend a widget.
     *
     * For convenience, [method`Gtk`.WidgetClass.set_template_from_resource]
     * is also provided.
     *
     * Note that any class that installs templates must call
     * [method`Gtk`.Widget.init_template] in the widget’s instance initializer.
     * @param templateBytes A `GBytes` holding the `GtkBuilder` XML
     */
    static setTemplate(
      widget_class: Widget | Function | GObject.GType,
      templateBytes: any
    ): void
    /**
     * A convenience function that calls [method`Gtk`.WidgetClass.set_template]
     * with the contents of a `GResource`.
     *
     * Note that any class that installs templates must call
     * [method`Gtk`.Widget.init_template] in the widget’s instance
     * initializer.
     * @param resourceName The name of the resource to load the template from
     */
    static setTemplateFromResource(
      widget_class: Widget | Function | GObject.GType,
      resourceName: string
    ): void
    /**
     * For use in language bindings, this will override the default
     * `GtkBuilderScope` to be used when parsing GtkBuilder XML from
     * this class’s template data.
     *
     * Note that this must be called from a composite widget classes class
     * initializer after calling [method`Gtk`.WidgetClass.set_template].
     * @param scope The `GtkBuilderScope` to use when loading   the class template
     */
    static setTemplateScope(
      widget_class: Widget | Function | GObject.GType,
      scope: BuilderScope
    ): void
  }

  interface WidgetClassPrivate {}

  class WidgetClassPrivate {
    // Own properties of Gtk-4.0.Gtk.WidgetClassPrivate

    static name: string
  }

  interface WidgetPaintableClass {
    // Own fields of Gtk-4.0.Gtk.WidgetPaintableClass

    parentClass: GObject.ObjectClass
  }

  abstract class WidgetPaintableClass {
    // Own properties of Gtk-4.0.Gtk.WidgetPaintableClass

    static name: string
  }

  interface WidgetPrivate {}

  class WidgetPrivate {
    // Own properties of Gtk-4.0.Gtk.WidgetPrivate

    static name: string
  }

  interface WindowClass {
    // Own fields of Gtk-4.0.Gtk.WindowClass

    /**
     * The parent class.
     * @field
     */
    parentClass: WidgetClass
    /**
     * Activates the current focused widget within the window.
     * @field
     */
    activateFocus: (window: Window) => void
    /**
     * Activates the default widget for the window.
     * @field
     */
    activateDefault: (window: Window) => void
    /**
     * Signal gets emitted when the set of accelerators or
     *   mnemonics that are associated with window changes.
     * @field
     */
    keysChanged: (window: Window) => void
    /**
     * Class handler for the `GtkWindow::enable-debugging`
     *   keybinding signal.
     * @field
     */
    enableDebugging: (window: Window, toggle: boolean) => boolean
    /**
     * Class handler for the `GtkWindow::close-request` signal.
     * @field
     */
    closeRequest: (window: Window) => boolean
  }

  abstract class WindowClass {
    // Own properties of Gtk-4.0.Gtk.WindowClass

    static name: string
  }

  interface WindowControlsClass {
    // Own fields of Gtk-4.0.Gtk.WindowControlsClass

    parentClass: WidgetClass
  }

  abstract class WindowControlsClass {
    // Own properties of Gtk-4.0.Gtk.WindowControlsClass

    static name: string
  }

  interface WindowGroupClass {
    // Own fields of Gtk-4.0.Gtk.WindowGroupClass

    parentClass: GObject.ObjectClass
  }

  abstract class WindowGroupClass {
    // Own properties of Gtk-4.0.Gtk.WindowGroupClass

    static name: string
  }

  interface WindowGroupPrivate {}

  class WindowGroupPrivate {
    // Own properties of Gtk-4.0.Gtk.WindowGroupPrivate

    static name: string
  }

  interface WindowHandleClass {
    // Own fields of Gtk-4.0.Gtk.WindowHandleClass

    parentClass: WidgetClass
  }

  abstract class WindowHandleClass {
    // Own properties of Gtk-4.0.Gtk.WindowHandleClass

    static name: string
  }

  type Allocation = Gdk.Rectangle
}

interface ApplicationContext {
    quit(): boolean;
    application: Gtk.Application;
}
declare const ApplicationContext: React$1.Context<ApplicationContext | null>;

declare class Node<T = any> {
    children: Node[];
    parent: Node | null;
    node: T;
    constructor(node: T);
    appendChild(child: Node): void;
    removeChild(child: Node): void;
    insertBefore(child: Node, beforeChild: Node): void;
    getClosestParentOfType<T>(type: new () => T): T | null;
}

declare class Application extends Node<Gtk.Application> {
    context: ApplicationContext;
    private loop;
    private timeout?;
    constructor(node: Gtk.Application);
    run(callback: () => void): void;
    appendChild(child: Node): void;
    insertBefore(child: Node, beforeChild: Node): void;
    private afterInsert;
}

declare abstract class AbstractWidget<T extends Gtk.Widget = Gtk.Widget> extends Node<T> {
    handlers: Record<string, any>;
    props: Record<string, any>;
    abstract set(propName: string, newValue: any): void;
    abstract commitMount(): void;
    constructor(props: Record<string, any> | undefined, node: T);
    setHandler(handlerName: string, handler: any): void;
}

declare class Widget$1<T extends Gtk.Widget = Gtk.Widget> extends AbstractWidget<T> {
    static createNode(): Gtk.Widget;
    commitMount(): void;
    set(propName: string, newValue: any): void;
}

declare const ROOT_NODE_KEY: unique symbol;
type RootNode<T> = T extends Gtk.Application ? Application : T extends Gtk.Widget ? Widget$1<T> : Node<T>;
type WithRootNode<T> = T & {
    [ROOT_NODE_KEY]?: RootNode<T>;
};
declare function createRootNode<T>(node: WithRootNode<T>): RootNode<T>;

declare function createReconciler(): Reconciler;
type Reconciler = ReturnType<typeof ReactReconciler>;
declare const Reconciler: ReactReconciler.Reconciler<unknown, unknown, unknown, unknown, unknown>;

declare global {
    namespace JSX {
        interface IntrinsicElements {
            AboutDialog: JSX.IntrinsicElements["Window"] & {
                ref?: React$1.Ref<Gtk.AboutDialog>;
                artists?: string[];
                authors?: string[];
                comments?: string | null;
                copyright?: string | null;
                documenters?: string[];
                license?: string | null;
                licenseType?: Gtk.License;
                logo?: Gdk.Paintable | null;
                logoIconName?: string | null;
                programName?: string | null;
                systemInformation?: string | null;
                translatorCredits?: string | null;
                version?: string | null;
                website?: string | null;
                websiteLabel?: string | null;
                wrapLicense?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivateLink?: (node: Gtk.AboutDialog, uri: string | null) => boolean;
                onNotifyArtists?: (node: Gtk.AboutDialog) => void;
                onNotifyAuthors?: (node: Gtk.AboutDialog) => void;
                onNotifyComments?: (node: Gtk.AboutDialog) => void;
                onNotifyCopyright?: (node: Gtk.AboutDialog) => void;
                onNotifyDocumenters?: (node: Gtk.AboutDialog) => void;
                onNotifyLicense?: (node: Gtk.AboutDialog) => void;
                onNotifyLicenseType?: (node: Gtk.AboutDialog) => void;
                onNotifyLogo?: (node: Gtk.AboutDialog) => void;
                onNotifyLogoIconName?: (node: Gtk.AboutDialog) => void;
                onNotifyProgramName?: (node: Gtk.AboutDialog) => void;
                onNotifySystemInformation?: (node: Gtk.AboutDialog) => void;
                onNotifyTranslatorCredits?: (node: Gtk.AboutDialog) => void;
                onNotifyVersion?: (node: Gtk.AboutDialog) => void;
                onNotifyWebsite?: (node: Gtk.AboutDialog) => void;
                onNotifyWebsiteLabel?: (node: Gtk.AboutDialog) => void;
                onNotifyWrapLicense?: (node: Gtk.AboutDialog) => void;
                onNotifyName?: (node: Gtk.AboutDialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.AboutDialog) => void;
            };
            ActionBar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ActionBar>;
                revealed?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyRevealed?: (node: Gtk.ActionBar) => void;
                onNotifyName?: (node: Gtk.ActionBar) => void;
                onNotifyAccessibleRole?: (node: Gtk.ActionBar) => void;
            };
            AppChooserButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.AppChooserButton>;
                heading?: string | null;
                modal?: boolean;
                showDefaultItem?: boolean;
                showDialogItem?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivate?: (node: Gtk.AppChooserButton) => void;
                onChanged?: (node: Gtk.AppChooserButton) => void;
                onCustomItemActivated?: (node: Gtk.AppChooserButton, itemName: string | null) => void;
                onNotifyHeading?: (node: Gtk.AppChooserButton) => void;
                onNotifyModal?: (node: Gtk.AppChooserButton) => void;
                onNotifyShowDefaultItem?: (node: Gtk.AppChooserButton) => void;
                onNotifyShowDialogItem?: (node: Gtk.AppChooserButton) => void;
                onNotifyName?: (node: Gtk.AppChooserButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.AppChooserButton) => void;
                onNotifyContentType?: (node: Gtk.AppChooserButton) => void;
            };
            AppChooserDialog: JSX.IntrinsicElements["Dialog"] & {
                ref?: React$1.Ref<Gtk.AppChooserDialog>;
                heading?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyGfile?: (node: Gtk.AppChooserDialog) => void;
                onNotifyHeading?: (node: Gtk.AppChooserDialog) => void;
                onNotifyName?: (node: Gtk.AppChooserDialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.AppChooserDialog) => void;
                onNotifyContentType?: (node: Gtk.AppChooserDialog) => void;
            };
            AppChooserWidget: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.AppChooserWidget>;
                defaultText?: string | null;
                showAll?: boolean;
                showDefault?: boolean;
                showFallback?: boolean;
                showOther?: boolean;
                showRecommended?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onApplicationActivated?: (node: Gtk.AppChooserWidget, application: Gio.AppInfo) => void;
                onApplicationSelected?: (node: Gtk.AppChooserWidget, application: Gio.AppInfo) => void;
                onNotifyDefaultText?: (node: Gtk.AppChooserWidget) => void;
                onNotifyShowAll?: (node: Gtk.AppChooserWidget) => void;
                onNotifyShowDefault?: (node: Gtk.AppChooserWidget) => void;
                onNotifyShowFallback?: (node: Gtk.AppChooserWidget) => void;
                onNotifyShowOther?: (node: Gtk.AppChooserWidget) => void;
                onNotifyShowRecommended?: (node: Gtk.AppChooserWidget) => void;
                onNotifyName?: (node: Gtk.AppChooserWidget) => void;
                onNotifyAccessibleRole?: (node: Gtk.AppChooserWidget) => void;
                onNotifyContentType?: (node: Gtk.AppChooserWidget) => void;
            };
            ApplicationWindow: JSX.IntrinsicElements["Window"] & {
                ref?: React$1.Ref<Gtk.ApplicationWindow>;
                showMenubar?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActionAdded?: (node: Gtk.ApplicationWindow, actionName: string | null) => void;
                onActionEnabledChanged?: (node: Gtk.ApplicationWindow, actionName: string | null, enabled: boolean) => void;
                onActionRemoved?: (node: Gtk.ApplicationWindow, actionName: string | null) => void;
                onActionStateChanged?: (node: Gtk.ApplicationWindow, actionName: string | null, value: GLib.Variant) => void;
                onNotifyShowMenubar?: (node: Gtk.ApplicationWindow) => void;
                onNotifyName?: (node: Gtk.ApplicationWindow) => void;
                onNotifyAccessibleRole?: (node: Gtk.ApplicationWindow) => void;
            };
            AspectFrame: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.AspectFrame>;
                obeyChild?: boolean;
                ratio?: number;
                xalign?: number;
                yalign?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyChild?: (node: Gtk.AspectFrame) => void;
                onNotifyObeyChild?: (node: Gtk.AspectFrame) => void;
                onNotifyRatio?: (node: Gtk.AspectFrame) => void;
                onNotifyXalign?: (node: Gtk.AspectFrame) => void;
                onNotifyYalign?: (node: Gtk.AspectFrame) => void;
                onNotifyName?: (node: Gtk.AspectFrame) => void;
                onNotifyAccessibleRole?: (node: Gtk.AspectFrame) => void;
            };
            Assistant: JSX.IntrinsicElements["Window"] & {
                ref?: React$1.Ref<Gtk.Assistant>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onApply?: (node: Gtk.Assistant) => void;
                onCancel?: (node: Gtk.Assistant) => void;
                onClose?: (node: Gtk.Assistant) => void;
                onEscape?: (node: Gtk.Assistant) => void;
                onPrepare?: (node: Gtk.Assistant, page: Gtk.Widget) => void;
                onNotifyPages?: (node: Gtk.Assistant) => void;
                onNotifyUseHeaderBar?: (node: Gtk.Assistant) => void;
                onNotifyName?: (node: Gtk.Assistant) => void;
                onNotifyAccessibleRole?: (node: Gtk.Assistant) => void;
            };
            Box: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Box>;
                baselineChild?: number;
                baselinePosition?: Gtk.BaselinePosition;
                homogeneous?: boolean;
                spacing?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyBaselineChild?: (node: Gtk.Box) => void;
                onNotifyBaselinePosition?: (node: Gtk.Box) => void;
                onNotifyHomogeneous?: (node: Gtk.Box) => void;
                onNotifySpacing?: (node: Gtk.Box) => void;
                onNotifyName?: (node: Gtk.Box) => void;
                onNotifyAccessibleRole?: (node: Gtk.Box) => void;
                onNotifyOrientation?: (node: Gtk.Box) => void;
            };
            Button: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Button>;
                canShrink?: boolean;
                hasFrame?: boolean;
                iconName?: string | null;
                label?: string | null;
                useUnderline?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                actionName?: string | null;
                actionTarget?: GLib.Variant;
                onActivate?: (node: Gtk.Button) => void;
                onClicked?: (node: Gtk.Button) => void;
                onNotifyCanShrink?: (node: Gtk.Button) => void;
                onNotifyChild?: (node: Gtk.Button) => void;
                onNotifyHasFrame?: (node: Gtk.Button) => void;
                onNotifyIconName?: (node: Gtk.Button) => void;
                onNotifyLabel?: (node: Gtk.Button) => void;
                onNotifyUseUnderline?: (node: Gtk.Button) => void;
                onNotifyName?: (node: Gtk.Button) => void;
                onNotifyAccessibleRole?: (node: Gtk.Button) => void;
                onNotifyActionName?: (node: Gtk.Button) => void;
                onNotifyActionTarget?: (node: Gtk.Button) => void;
            };
            Calendar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Calendar>;
                day?: number;
                month?: number;
                showDayNames?: boolean;
                showHeading?: boolean;
                showWeekNumbers?: boolean;
                year?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onDaySelected?: (node: Gtk.Calendar) => void;
                onNextMonth?: (node: Gtk.Calendar) => void;
                onNextYear?: (node: Gtk.Calendar) => void;
                onPrevMonth?: (node: Gtk.Calendar) => void;
                onPrevYear?: (node: Gtk.Calendar) => void;
                onNotifyDay?: (node: Gtk.Calendar) => void;
                onNotifyMonth?: (node: Gtk.Calendar) => void;
                onNotifyShowDayNames?: (node: Gtk.Calendar) => void;
                onNotifyShowHeading?: (node: Gtk.Calendar) => void;
                onNotifyShowWeekNumbers?: (node: Gtk.Calendar) => void;
                onNotifyYear?: (node: Gtk.Calendar) => void;
                onNotifyName?: (node: Gtk.Calendar) => void;
                onNotifyAccessibleRole?: (node: Gtk.Calendar) => void;
            };
            CellView: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.CellView>;
                drawSensitive?: boolean;
                fitModel?: boolean;
                model?: Gtk.TreeModel | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyCellArea?: (node: Gtk.CellView) => void;
                onNotifyCellAreaContext?: (node: Gtk.CellView) => void;
                onNotifyDrawSensitive?: (node: Gtk.CellView) => void;
                onNotifyFitModel?: (node: Gtk.CellView) => void;
                onNotifyModel?: (node: Gtk.CellView) => void;
                onNotifyName?: (node: Gtk.CellView) => void;
                onNotifyAccessibleRole?: (node: Gtk.CellView) => void;
                onNotifyOrientation?: (node: Gtk.CellView) => void;
            };
            CenterBox: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.CenterBox>;
                baselinePosition?: Gtk.BaselinePosition;
                centerWidget?: Gtk.Widget | null;
                endWidget?: Gtk.Widget | null;
                shrinkCenterLast?: boolean;
                startWidget?: Gtk.Widget | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyBaselinePosition?: (node: Gtk.CenterBox) => void;
                onNotifyCenterWidget?: (node: Gtk.CenterBox) => void;
                onNotifyEndWidget?: (node: Gtk.CenterBox) => void;
                onNotifyShrinkCenterLast?: (node: Gtk.CenterBox) => void;
                onNotifyStartWidget?: (node: Gtk.CenterBox) => void;
                onNotifyName?: (node: Gtk.CenterBox) => void;
                onNotifyAccessibleRole?: (node: Gtk.CenterBox) => void;
                onNotifyOrientation?: (node: Gtk.CenterBox) => void;
            };
            CheckButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.CheckButton>;
                active?: boolean;
                group?: Gtk.CheckButton | null;
                inconsistent?: boolean;
                label?: string | null;
                useUnderline?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                actionName?: string | null;
                actionTarget?: GLib.Variant;
                onActivate?: (node: Gtk.CheckButton) => void;
                onToggled?: (node: Gtk.CheckButton) => void;
                onNotifyActive?: (node: Gtk.CheckButton) => void;
                onNotifyChild?: (node: Gtk.CheckButton) => void;
                onNotifyGroup?: (node: Gtk.CheckButton) => void;
                onNotifyInconsistent?: (node: Gtk.CheckButton) => void;
                onNotifyLabel?: (node: Gtk.CheckButton) => void;
                onNotifyUseUnderline?: (node: Gtk.CheckButton) => void;
                onNotifyName?: (node: Gtk.CheckButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.CheckButton) => void;
                onNotifyActionName?: (node: Gtk.CheckButton) => void;
                onNotifyActionTarget?: (node: Gtk.CheckButton) => void;
            };
            ColorButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ColorButton>;
                modal?: boolean;
                showEditor?: boolean;
                title?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                rgba?: Gdk.RGBA;
                useAlpha?: boolean;
                onActivate?: (node: Gtk.ColorButton) => void;
                onColorSet?: (node: Gtk.ColorButton) => void;
                onColorActivated?: (node: Gtk.ColorButton, color: Gdk.RGBA) => void;
                onNotifyModal?: (node: Gtk.ColorButton) => void;
                onNotifyShowEditor?: (node: Gtk.ColorButton) => void;
                onNotifyTitle?: (node: Gtk.ColorButton) => void;
                onNotifyName?: (node: Gtk.ColorButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.ColorButton) => void;
                onNotifyRgba?: (node: Gtk.ColorButton) => void;
                onNotifyUseAlpha?: (node: Gtk.ColorButton) => void;
            };
            ColorChooserDialog: JSX.IntrinsicElements["Dialog"] & {
                ref?: React$1.Ref<Gtk.ColorChooserDialog>;
                showEditor?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                rgba?: Gdk.RGBA;
                useAlpha?: boolean;
                onColorActivated?: (node: Gtk.ColorChooserDialog, color: Gdk.RGBA) => void;
                onNotifyShowEditor?: (node: Gtk.ColorChooserDialog) => void;
                onNotifyName?: (node: Gtk.ColorChooserDialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.ColorChooserDialog) => void;
                onNotifyRgba?: (node: Gtk.ColorChooserDialog) => void;
                onNotifyUseAlpha?: (node: Gtk.ColorChooserDialog) => void;
            };
            ColorChooserWidget: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ColorChooserWidget>;
                showEditor?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                rgba?: Gdk.RGBA;
                useAlpha?: boolean;
                onColorActivated?: (node: Gtk.ColorChooserWidget, color: Gdk.RGBA) => void;
                onNotifyShowEditor?: (node: Gtk.ColorChooserWidget) => void;
                onNotifyName?: (node: Gtk.ColorChooserWidget) => void;
                onNotifyAccessibleRole?: (node: Gtk.ColorChooserWidget) => void;
                onNotifyRgba?: (node: Gtk.ColorChooserWidget) => void;
                onNotifyUseAlpha?: (node: Gtk.ColorChooserWidget) => void;
            };
            ColorDialogButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ColorDialogButton>;
                dialog?: Gtk.ColorDialog;
                rgba?: Gdk.RGBA;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivate?: (node: Gtk.ColorDialogButton) => void;
                onNotifyDialog?: (node: Gtk.ColorDialogButton) => void;
                onNotifyRgba?: (node: Gtk.ColorDialogButton) => void;
                onNotifyName?: (node: Gtk.ColorDialogButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.ColorDialogButton) => void;
            };
            ColumnView: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ColumnView>;
                enableRubberband?: boolean;
                headerFactory?: Gtk.ListItemFactory | null;
                model?: Gtk.SelectionModel | null;
                reorderable?: boolean;
                rowFactory?: Gtk.ListItemFactory | null;
                showColumnSeparators?: boolean;
                showRowSeparators?: boolean;
                singleClickActivate?: boolean;
                tabBehavior?: Gtk.ListTabBehavior;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                hadjustment?: Gtk.Adjustment | null;
                hscrollPolicy?: Gtk.ScrollablePolicy;
                vadjustment?: Gtk.Adjustment | null;
                vscrollPolicy?: Gtk.ScrollablePolicy;
                onActivate?: (node: Gtk.ColumnView, position: number) => void;
                onNotifyColumns?: (node: Gtk.ColumnView) => void;
                onNotifyEnableRubberband?: (node: Gtk.ColumnView) => void;
                onNotifyHeaderFactory?: (node: Gtk.ColumnView) => void;
                onNotifyModel?: (node: Gtk.ColumnView) => void;
                onNotifyReorderable?: (node: Gtk.ColumnView) => void;
                onNotifyRowFactory?: (node: Gtk.ColumnView) => void;
                onNotifyShowColumnSeparators?: (node: Gtk.ColumnView) => void;
                onNotifyShowRowSeparators?: (node: Gtk.ColumnView) => void;
                onNotifySingleClickActivate?: (node: Gtk.ColumnView) => void;
                onNotifySorter?: (node: Gtk.ColumnView) => void;
                onNotifyTabBehavior?: (node: Gtk.ColumnView) => void;
                onNotifyName?: (node: Gtk.ColumnView) => void;
                onNotifyAccessibleRole?: (node: Gtk.ColumnView) => void;
                onNotifyHadjustment?: (node: Gtk.ColumnView) => void;
                onNotifyHscrollPolicy?: (node: Gtk.ColumnView) => void;
                onNotifyVadjustment?: (node: Gtk.ColumnView) => void;
                onNotifyVscrollPolicy?: (node: Gtk.ColumnView) => void;
            };
            ComboBox: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ComboBox>;
                active?: number;
                activeId?: string | null;
                buttonSensitivity?: Gtk.SensitivityType;
                entryTextColumn?: number;
                hasFrame?: boolean;
                idColumn?: number;
                model?: Gtk.TreeModel | null;
                popupFixedWidth?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                editingCanceled?: boolean;
                onActivate?: (node: Gtk.ComboBox) => void;
                onChanged?: (node: Gtk.ComboBox) => void;
                onFormatEntryText?: (node: Gtk.ComboBox, path: string | null) => string;
                onMoveActive?: (node: Gtk.ComboBox, scrollType: Gtk.ScrollType) => void;
                onPopdown?: (node: Gtk.ComboBox) => boolean;
                onPopup?: (node: Gtk.ComboBox) => void;
                onEditingDone?: (node: Gtk.ComboBox) => void;
                onRemoveWidget?: (node: Gtk.ComboBox) => void;
                onNotifyActive?: (node: Gtk.ComboBox) => void;
                onNotifyActiveId?: (node: Gtk.ComboBox) => void;
                onNotifyButtonSensitivity?: (node: Gtk.ComboBox) => void;
                onNotifyChild?: (node: Gtk.ComboBox) => void;
                onNotifyEntryTextColumn?: (node: Gtk.ComboBox) => void;
                onNotifyHasEntry?: (node: Gtk.ComboBox) => void;
                onNotifyHasFrame?: (node: Gtk.ComboBox) => void;
                onNotifyIdColumn?: (node: Gtk.ComboBox) => void;
                onNotifyModel?: (node: Gtk.ComboBox) => void;
                onNotifyPopupFixedWidth?: (node: Gtk.ComboBox) => void;
                onNotifyPopupShown?: (node: Gtk.ComboBox) => void;
                onNotifyName?: (node: Gtk.ComboBox) => void;
                onNotifyAccessibleRole?: (node: Gtk.ComboBox) => void;
                onNotifyEditingCanceled?: (node: Gtk.ComboBox) => void;
            };
            ComboBoxText: JSX.IntrinsicElements["ComboBox"] & {
                ref?: React$1.Ref<Gtk.ComboBoxText>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                editingCanceled?: boolean;
                onEditingDone?: (node: Gtk.ComboBoxText) => void;
                onRemoveWidget?: (node: Gtk.ComboBoxText) => void;
                onNotifyName?: (node: Gtk.ComboBoxText) => void;
                onNotifyAccessibleRole?: (node: Gtk.ComboBoxText) => void;
                onNotifyEditingCanceled?: (node: Gtk.ComboBoxText) => void;
            };
            Dialog: JSX.IntrinsicElements["Window"] & {
                ref?: React$1.Ref<Gtk.Dialog>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onClose?: (node: Gtk.Dialog) => void;
                onResponse?: (node: Gtk.Dialog, responseId: number) => void;
                onNotifyUseHeaderBar?: (node: Gtk.Dialog) => void;
                onNotifyName?: (node: Gtk.Dialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.Dialog) => void;
            };
            DragIcon: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.DragIcon>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyChild?: (node: Gtk.DragIcon) => void;
                onNotifyName?: (node: Gtk.DragIcon) => void;
                onNotifyAccessibleRole?: (node: Gtk.DragIcon) => void;
            };
            DrawingArea: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.DrawingArea>;
                contentHeight?: number;
                contentWidth?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onResize?: (node: Gtk.DrawingArea, width: number, height: number) => void;
                onNotifyContentHeight?: (node: Gtk.DrawingArea) => void;
                onNotifyContentWidth?: (node: Gtk.DrawingArea) => void;
                onNotifyName?: (node: Gtk.DrawingArea) => void;
                onNotifyAccessibleRole?: (node: Gtk.DrawingArea) => void;
            };
            DropDown: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.DropDown>;
                enableSearch?: boolean;
                expression?: Gtk.Expression | null;
                factory?: Gtk.ListItemFactory | null;
                headerFactory?: Gtk.ListItemFactory | null;
                listFactory?: Gtk.ListItemFactory | null;
                model?: Gio.ListModel | null;
                searchMatchMode?: Gtk.StringFilterMatchMode;
                selected?: number;
                showArrow?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivate?: (node: Gtk.DropDown) => void;
                onNotifyEnableSearch?: (node: Gtk.DropDown) => void;
                onNotifyExpression?: (node: Gtk.DropDown) => void;
                onNotifyFactory?: (node: Gtk.DropDown) => void;
                onNotifyHeaderFactory?: (node: Gtk.DropDown) => void;
                onNotifyListFactory?: (node: Gtk.DropDown) => void;
                onNotifyModel?: (node: Gtk.DropDown) => void;
                onNotifySearchMatchMode?: (node: Gtk.DropDown) => void;
                onNotifySelected?: (node: Gtk.DropDown) => void;
                onNotifySelectedItem?: (node: Gtk.DropDown) => void;
                onNotifyShowArrow?: (node: Gtk.DropDown) => void;
                onNotifyName?: (node: Gtk.DropDown) => void;
                onNotifyAccessibleRole?: (node: Gtk.DropDown) => void;
            };
            EditableLabel: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.EditableLabel>;
                editing?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                editable?: boolean;
                enableUndo?: boolean;
                maxWidthChars?: number;
                text?: string | null;
                widthChars?: number;
                xalign?: number;
                onChanged?: (node: Gtk.EditableLabel) => void;
                onDeleteText?: (node: Gtk.EditableLabel, startPos: number, endPos: number) => void;
                onInsertText?: (node: Gtk.EditableLabel, text: string | null, length: number, position: number) => void;
                onNotifyEditing?: (node: Gtk.EditableLabel) => void;
                onNotifyName?: (node: Gtk.EditableLabel) => void;
                onNotifyAccessibleRole?: (node: Gtk.EditableLabel) => void;
                onNotifyCursorPosition?: (node: Gtk.EditableLabel) => void;
                onNotifyEditable?: (node: Gtk.EditableLabel) => void;
                onNotifyEnableUndo?: (node: Gtk.EditableLabel) => void;
                onNotifyMaxWidthChars?: (node: Gtk.EditableLabel) => void;
                onNotifySelectionBound?: (node: Gtk.EditableLabel) => void;
                onNotifyText?: (node: Gtk.EditableLabel) => void;
                onNotifyWidthChars?: (node: Gtk.EditableLabel) => void;
                onNotifyXalign?: (node: Gtk.EditableLabel) => void;
            };
            EmojiChooser: JSX.IntrinsicElements["Popover"] & {
                ref?: React$1.Ref<Gtk.EmojiChooser>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onEmojiPicked?: (node: Gtk.EmojiChooser, text: string | null) => void;
                onNotifyName?: (node: Gtk.EmojiChooser) => void;
                onNotifyAccessibleRole?: (node: Gtk.EmojiChooser) => void;
            };
            Entry: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Entry>;
                activatesDefault?: boolean;
                attributes?: Pango.AttrList;
                buffer?: Gtk.EntryBuffer;
                completion?: Gtk.EntryCompletion | null;
                enableEmojiCompletion?: boolean;
                extraMenu?: Gio.MenuModel | null;
                hasFrame?: boolean;
                imModule?: string | null;
                inputHints?: Gtk.InputHints;
                inputPurpose?: Gtk.InputPurpose;
                invisibleChar?: number;
                invisibleCharSet?: boolean;
                maxLength?: number;
                overwriteMode?: boolean;
                placeholderText?: string | null;
                primaryIconActivatable?: boolean;
                primaryIconGicon?: Gio.Icon;
                primaryIconName?: string | null;
                primaryIconPaintable?: Gdk.Paintable;
                primaryIconSensitive?: boolean;
                primaryIconTooltipMarkup?: string | null;
                primaryIconTooltipText?: string | null;
                progressFraction?: number;
                progressPulseStep?: number;
                secondaryIconActivatable?: boolean;
                secondaryIconGicon?: Gio.Icon;
                secondaryIconName?: string | null;
                secondaryIconPaintable?: Gdk.Paintable;
                secondaryIconSensitive?: boolean;
                secondaryIconTooltipMarkup?: string | null;
                secondaryIconTooltipText?: string | null;
                showEmojiIcon?: boolean;
                tabs?: Pango.TabArray | null;
                truncateMultiline?: boolean;
                visibility?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                editingCanceled?: boolean;
                editable?: boolean;
                enableUndo?: boolean;
                maxWidthChars?: number;
                text?: string | null;
                widthChars?: number;
                xalign?: number;
                onActivate?: (node: Gtk.Entry) => void;
                onIconPress?: (node: Gtk.Entry, iconPos: Gtk.EntryIconPosition) => void;
                onIconRelease?: (node: Gtk.Entry, iconPos: Gtk.EntryIconPosition) => void;
                onEditingDone?: (node: Gtk.Entry) => void;
                onRemoveWidget?: (node: Gtk.Entry) => void;
                onChanged?: (node: Gtk.Entry) => void;
                onDeleteText?: (node: Gtk.Entry, startPos: number, endPos: number) => void;
                onInsertText?: (node: Gtk.Entry, text: string | null, length: number, position: number) => void;
                onNotifyActivatesDefault?: (node: Gtk.Entry) => void;
                onNotifyAttributes?: (node: Gtk.Entry) => void;
                onNotifyBuffer?: (node: Gtk.Entry) => void;
                onNotifyCompletion?: (node: Gtk.Entry) => void;
                onNotifyEnableEmojiCompletion?: (node: Gtk.Entry) => void;
                onNotifyExtraMenu?: (node: Gtk.Entry) => void;
                onNotifyHasFrame?: (node: Gtk.Entry) => void;
                onNotifyImModule?: (node: Gtk.Entry) => void;
                onNotifyInputHints?: (node: Gtk.Entry) => void;
                onNotifyInputPurpose?: (node: Gtk.Entry) => void;
                onNotifyInvisibleChar?: (node: Gtk.Entry) => void;
                onNotifyInvisibleCharSet?: (node: Gtk.Entry) => void;
                onNotifyMaxLength?: (node: Gtk.Entry) => void;
                onNotifyOverwriteMode?: (node: Gtk.Entry) => void;
                onNotifyPlaceholderText?: (node: Gtk.Entry) => void;
                onNotifyPrimaryIconActivatable?: (node: Gtk.Entry) => void;
                onNotifyPrimaryIconGicon?: (node: Gtk.Entry) => void;
                onNotifyPrimaryIconName?: (node: Gtk.Entry) => void;
                onNotifyPrimaryIconPaintable?: (node: Gtk.Entry) => void;
                onNotifyPrimaryIconSensitive?: (node: Gtk.Entry) => void;
                onNotifyPrimaryIconStorageType?: (node: Gtk.Entry) => void;
                onNotifyPrimaryIconTooltipMarkup?: (node: Gtk.Entry) => void;
                onNotifyPrimaryIconTooltipText?: (node: Gtk.Entry) => void;
                onNotifyProgressFraction?: (node: Gtk.Entry) => void;
                onNotifyProgressPulseStep?: (node: Gtk.Entry) => void;
                onNotifyScrollOffset?: (node: Gtk.Entry) => void;
                onNotifySecondaryIconActivatable?: (node: Gtk.Entry) => void;
                onNotifySecondaryIconGicon?: (node: Gtk.Entry) => void;
                onNotifySecondaryIconName?: (node: Gtk.Entry) => void;
                onNotifySecondaryIconPaintable?: (node: Gtk.Entry) => void;
                onNotifySecondaryIconSensitive?: (node: Gtk.Entry) => void;
                onNotifySecondaryIconStorageType?: (node: Gtk.Entry) => void;
                onNotifySecondaryIconTooltipMarkup?: (node: Gtk.Entry) => void;
                onNotifySecondaryIconTooltipText?: (node: Gtk.Entry) => void;
                onNotifyShowEmojiIcon?: (node: Gtk.Entry) => void;
                onNotifyTabs?: (node: Gtk.Entry) => void;
                onNotifyTextLength?: (node: Gtk.Entry) => void;
                onNotifyTruncateMultiline?: (node: Gtk.Entry) => void;
                onNotifyVisibility?: (node: Gtk.Entry) => void;
                onNotifyName?: (node: Gtk.Entry) => void;
                onNotifyAccessibleRole?: (node: Gtk.Entry) => void;
                onNotifyEditingCanceled?: (node: Gtk.Entry) => void;
                onNotifyCursorPosition?: (node: Gtk.Entry) => void;
                onNotifyEditable?: (node: Gtk.Entry) => void;
                onNotifyEnableUndo?: (node: Gtk.Entry) => void;
                onNotifyMaxWidthChars?: (node: Gtk.Entry) => void;
                onNotifySelectionBound?: (node: Gtk.Entry) => void;
                onNotifyText?: (node: Gtk.Entry) => void;
                onNotifyWidthChars?: (node: Gtk.Entry) => void;
                onNotifyXalign?: (node: Gtk.Entry) => void;
            };
            Expander: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Expander>;
                expanded?: boolean;
                label?: string | null;
                labelWidget?: Gtk.Widget | null;
                resizeToplevel?: boolean;
                useMarkup?: boolean;
                useUnderline?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivate?: (node: Gtk.Expander) => void;
                onNotifyChild?: (node: Gtk.Expander) => void;
                onNotifyExpanded?: (node: Gtk.Expander) => void;
                onNotifyLabel?: (node: Gtk.Expander) => void;
                onNotifyLabelWidget?: (node: Gtk.Expander) => void;
                onNotifyResizeToplevel?: (node: Gtk.Expander) => void;
                onNotifyUseMarkup?: (node: Gtk.Expander) => void;
                onNotifyUseUnderline?: (node: Gtk.Expander) => void;
                onNotifyName?: (node: Gtk.Expander) => void;
                onNotifyAccessibleRole?: (node: Gtk.Expander) => void;
            };
            FileChooserDialog: JSX.IntrinsicElements["Dialog"] & {
                ref?: React$1.Ref<Gtk.FileChooserDialog>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                action?: Gtk.FileChooserAction;
                createFolders?: boolean;
                filter?: Gtk.FileFilter;
                selectMultiple?: boolean;
                onNotifyName?: (node: Gtk.FileChooserDialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.FileChooserDialog) => void;
                onNotifyAction?: (node: Gtk.FileChooserDialog) => void;
                onNotifyCreateFolders?: (node: Gtk.FileChooserDialog) => void;
                onNotifyFilter?: (node: Gtk.FileChooserDialog) => void;
                onNotifyFilters?: (node: Gtk.FileChooserDialog) => void;
                onNotifySelectMultiple?: (node: Gtk.FileChooserDialog) => void;
                onNotifyShortcutFolders?: (node: Gtk.FileChooserDialog) => void;
            };
            FileChooserWidget: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.FileChooserWidget>;
                searchMode?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                action?: Gtk.FileChooserAction;
                createFolders?: boolean;
                filter?: Gtk.FileFilter;
                selectMultiple?: boolean;
                onDesktopFolder?: (node: Gtk.FileChooserWidget) => void;
                onDownFolder?: (node: Gtk.FileChooserWidget) => void;
                onHomeFolder?: (node: Gtk.FileChooserWidget) => void;
                onLocationPopup?: (node: Gtk.FileChooserWidget, path: string | null) => void;
                onLocationPopupOnPaste?: (node: Gtk.FileChooserWidget) => void;
                onLocationTogglePopup?: (node: Gtk.FileChooserWidget) => void;
                onPlacesShortcut?: (node: Gtk.FileChooserWidget) => void;
                onQuickBookmark?: (node: Gtk.FileChooserWidget, bookmarkIndex: number) => void;
                onRecentShortcut?: (node: Gtk.FileChooserWidget) => void;
                onSearchShortcut?: (node: Gtk.FileChooserWidget) => void;
                onShowHidden?: (node: Gtk.FileChooserWidget) => void;
                onUpFolder?: (node: Gtk.FileChooserWidget) => void;
                onNotifySearchMode?: (node: Gtk.FileChooserWidget) => void;
                onNotifyShowTime?: (node: Gtk.FileChooserWidget) => void;
                onNotifySubtitle?: (node: Gtk.FileChooserWidget) => void;
                onNotifyName?: (node: Gtk.FileChooserWidget) => void;
                onNotifyAccessibleRole?: (node: Gtk.FileChooserWidget) => void;
                onNotifyAction?: (node: Gtk.FileChooserWidget) => void;
                onNotifyCreateFolders?: (node: Gtk.FileChooserWidget) => void;
                onNotifyFilter?: (node: Gtk.FileChooserWidget) => void;
                onNotifyFilters?: (node: Gtk.FileChooserWidget) => void;
                onNotifySelectMultiple?: (node: Gtk.FileChooserWidget) => void;
                onNotifyShortcutFolders?: (node: Gtk.FileChooserWidget) => void;
            };
            Fixed: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Fixed>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyName?: (node: Gtk.Fixed) => void;
                onNotifyAccessibleRole?: (node: Gtk.Fixed) => void;
            };
            FlowBox: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.FlowBox>;
                acceptUnpairedRelease?: boolean;
                activateOnSingleClick?: boolean;
                columnSpacing?: number;
                homogeneous?: boolean;
                maxChildrenPerLine?: number;
                minChildrenPerLine?: number;
                rowSpacing?: number;
                selectionMode?: Gtk.SelectionMode;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onActivateCursorChild?: (node: Gtk.FlowBox) => void;
                onChildActivated?: (node: Gtk.FlowBox, child: Gtk.FlowBoxChild) => void;
                onMoveCursor?: (node: Gtk.FlowBox, step: Gtk.MovementStep, count: number, extend: boolean, modify: boolean) => boolean;
                onSelectAll?: (node: Gtk.FlowBox) => void;
                onSelectedChildrenChanged?: (node: Gtk.FlowBox) => void;
                onToggleCursorChild?: (node: Gtk.FlowBox) => void;
                onUnselectAll?: (node: Gtk.FlowBox) => void;
                onNotifyAcceptUnpairedRelease?: (node: Gtk.FlowBox) => void;
                onNotifyActivateOnSingleClick?: (node: Gtk.FlowBox) => void;
                onNotifyColumnSpacing?: (node: Gtk.FlowBox) => void;
                onNotifyHomogeneous?: (node: Gtk.FlowBox) => void;
                onNotifyMaxChildrenPerLine?: (node: Gtk.FlowBox) => void;
                onNotifyMinChildrenPerLine?: (node: Gtk.FlowBox) => void;
                onNotifyRowSpacing?: (node: Gtk.FlowBox) => void;
                onNotifySelectionMode?: (node: Gtk.FlowBox) => void;
                onNotifyName?: (node: Gtk.FlowBox) => void;
                onNotifyAccessibleRole?: (node: Gtk.FlowBox) => void;
                onNotifyOrientation?: (node: Gtk.FlowBox) => void;
            };
            FlowBoxChild: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.FlowBoxChild>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivate?: (node: Gtk.FlowBoxChild) => void;
                onNotifyChild?: (node: Gtk.FlowBoxChild) => void;
                onNotifyName?: (node: Gtk.FlowBoxChild) => void;
                onNotifyAccessibleRole?: (node: Gtk.FlowBoxChild) => void;
            };
            FontButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.FontButton>;
                modal?: boolean;
                title?: string | null;
                useFont?: boolean;
                useSize?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                font?: string | null;
                fontDesc?: Pango.FontDescription;
                language?: string | null;
                level?: Gtk.FontChooserLevel;
                previewText?: string | null;
                showPreviewEntry?: boolean;
                onActivate?: (node: Gtk.FontButton) => void;
                onFontSet?: (node: Gtk.FontButton) => void;
                onFontActivated?: (node: Gtk.FontButton, fontname: string | null) => void;
                onNotifyModal?: (node: Gtk.FontButton) => void;
                onNotifyTitle?: (node: Gtk.FontButton) => void;
                onNotifyUseFont?: (node: Gtk.FontButton) => void;
                onNotifyUseSize?: (node: Gtk.FontButton) => void;
                onNotifyName?: (node: Gtk.FontButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.FontButton) => void;
                onNotifyFont?: (node: Gtk.FontButton) => void;
                onNotifyFontDesc?: (node: Gtk.FontButton) => void;
                onNotifyFontFeatures?: (node: Gtk.FontButton) => void;
                onNotifyLanguage?: (node: Gtk.FontButton) => void;
                onNotifyLevel?: (node: Gtk.FontButton) => void;
                onNotifyPreviewText?: (node: Gtk.FontButton) => void;
                onNotifyShowPreviewEntry?: (node: Gtk.FontButton) => void;
            };
            FontChooserDialog: JSX.IntrinsicElements["Dialog"] & {
                ref?: React$1.Ref<Gtk.FontChooserDialog>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                font?: string | null;
                fontDesc?: Pango.FontDescription;
                language?: string | null;
                level?: Gtk.FontChooserLevel;
                previewText?: string | null;
                showPreviewEntry?: boolean;
                onFontActivated?: (node: Gtk.FontChooserDialog, fontname: string | null) => void;
                onNotifyName?: (node: Gtk.FontChooserDialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.FontChooserDialog) => void;
                onNotifyFont?: (node: Gtk.FontChooserDialog) => void;
                onNotifyFontDesc?: (node: Gtk.FontChooserDialog) => void;
                onNotifyFontFeatures?: (node: Gtk.FontChooserDialog) => void;
                onNotifyLanguage?: (node: Gtk.FontChooserDialog) => void;
                onNotifyLevel?: (node: Gtk.FontChooserDialog) => void;
                onNotifyPreviewText?: (node: Gtk.FontChooserDialog) => void;
                onNotifyShowPreviewEntry?: (node: Gtk.FontChooserDialog) => void;
            };
            FontChooserWidget: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.FontChooserWidget>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                font?: string | null;
                fontDesc?: Pango.FontDescription;
                language?: string | null;
                level?: Gtk.FontChooserLevel;
                previewText?: string | null;
                showPreviewEntry?: boolean;
                onFontActivated?: (node: Gtk.FontChooserWidget, fontname: string | null) => void;
                onNotifyTweakAction?: (node: Gtk.FontChooserWidget) => void;
                onNotifyName?: (node: Gtk.FontChooserWidget) => void;
                onNotifyAccessibleRole?: (node: Gtk.FontChooserWidget) => void;
                onNotifyFont?: (node: Gtk.FontChooserWidget) => void;
                onNotifyFontDesc?: (node: Gtk.FontChooserWidget) => void;
                onNotifyFontFeatures?: (node: Gtk.FontChooserWidget) => void;
                onNotifyLanguage?: (node: Gtk.FontChooserWidget) => void;
                onNotifyLevel?: (node: Gtk.FontChooserWidget) => void;
                onNotifyPreviewText?: (node: Gtk.FontChooserWidget) => void;
                onNotifyShowPreviewEntry?: (node: Gtk.FontChooserWidget) => void;
            };
            FontDialogButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.FontDialogButton>;
                dialog?: Gtk.FontDialog;
                fontDesc?: Pango.FontDescription;
                fontFeatures?: string | null;
                language?: Pango.Language | null;
                level?: Gtk.FontLevel;
                useFont?: boolean;
                useSize?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivate?: (node: Gtk.FontDialogButton) => void;
                onNotifyDialog?: (node: Gtk.FontDialogButton) => void;
                onNotifyFontDesc?: (node: Gtk.FontDialogButton) => void;
                onNotifyFontFeatures?: (node: Gtk.FontDialogButton) => void;
                onNotifyLanguage?: (node: Gtk.FontDialogButton) => void;
                onNotifyLevel?: (node: Gtk.FontDialogButton) => void;
                onNotifyUseFont?: (node: Gtk.FontDialogButton) => void;
                onNotifyUseSize?: (node: Gtk.FontDialogButton) => void;
                onNotifyName?: (node: Gtk.FontDialogButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.FontDialogButton) => void;
            };
            Frame: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Frame>;
                label?: string | null;
                labelWidget?: Gtk.Widget | null;
                labelXalign?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyChild?: (node: Gtk.Frame) => void;
                onNotifyLabel?: (node: Gtk.Frame) => void;
                onNotifyLabelWidget?: (node: Gtk.Frame) => void;
                onNotifyLabelXalign?: (node: Gtk.Frame) => void;
                onNotifyName?: (node: Gtk.Frame) => void;
                onNotifyAccessibleRole?: (node: Gtk.Frame) => void;
            };
            GLArea: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.GLArea>;
                allowedApis?: Gdk.GLAPI;
                autoRender?: boolean;
                hasDepthBuffer?: boolean;
                hasStencilBuffer?: boolean;
                useEs?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onCreateContext?: (node: Gtk.GLArea) => Gdk.GLContext;
                onRender?: (node: Gtk.GLArea, context: Gdk.GLContext) => boolean;
                onResize?: (node: Gtk.GLArea, width: number, height: number) => void;
                onNotifyAllowedApis?: (node: Gtk.GLArea) => void;
                onNotifyApi?: (node: Gtk.GLArea) => void;
                onNotifyAutoRender?: (node: Gtk.GLArea) => void;
                onNotifyContext?: (node: Gtk.GLArea) => void;
                onNotifyHasDepthBuffer?: (node: Gtk.GLArea) => void;
                onNotifyHasStencilBuffer?: (node: Gtk.GLArea) => void;
                onNotifyUseEs?: (node: Gtk.GLArea) => void;
                onNotifyName?: (node: Gtk.GLArea) => void;
                onNotifyAccessibleRole?: (node: Gtk.GLArea) => void;
            };
            GraphicsOffload: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.GraphicsOffload>;
                enabled?: Gtk.GraphicsOffloadEnabled;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyChild?: (node: Gtk.GraphicsOffload) => void;
                onNotifyEnabled?: (node: Gtk.GraphicsOffload) => void;
                onNotifyName?: (node: Gtk.GraphicsOffload) => void;
                onNotifyAccessibleRole?: (node: Gtk.GraphicsOffload) => void;
            };
            Grid: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Grid>;
                baselineRow?: number;
                columnHomogeneous?: boolean;
                columnSpacing?: number;
                rowHomogeneous?: boolean;
                rowSpacing?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyBaselineRow?: (node: Gtk.Grid) => void;
                onNotifyColumnHomogeneous?: (node: Gtk.Grid) => void;
                onNotifyColumnSpacing?: (node: Gtk.Grid) => void;
                onNotifyRowHomogeneous?: (node: Gtk.Grid) => void;
                onNotifyRowSpacing?: (node: Gtk.Grid) => void;
                onNotifyName?: (node: Gtk.Grid) => void;
                onNotifyAccessibleRole?: (node: Gtk.Grid) => void;
                onNotifyOrientation?: (node: Gtk.Grid) => void;
            };
            GridView: JSX.IntrinsicElements["ListBase"] & {
                ref?: React$1.Ref<Gtk.GridView>;
                enableRubberband?: boolean;
                factory?: Gtk.ListItemFactory | null;
                maxColumns?: number;
                minColumns?: number;
                model?: Gtk.SelectionModel | null;
                singleClickActivate?: boolean;
                tabBehavior?: Gtk.ListTabBehavior;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                hadjustment?: Gtk.Adjustment | null;
                hscrollPolicy?: Gtk.ScrollablePolicy;
                vadjustment?: Gtk.Adjustment | null;
                vscrollPolicy?: Gtk.ScrollablePolicy;
                onActivate?: (node: Gtk.GridView, position: number) => void;
                onNotifyEnableRubberband?: (node: Gtk.GridView) => void;
                onNotifyFactory?: (node: Gtk.GridView) => void;
                onNotifyMaxColumns?: (node: Gtk.GridView) => void;
                onNotifyMinColumns?: (node: Gtk.GridView) => void;
                onNotifyModel?: (node: Gtk.GridView) => void;
                onNotifySingleClickActivate?: (node: Gtk.GridView) => void;
                onNotifyTabBehavior?: (node: Gtk.GridView) => void;
                onNotifyName?: (node: Gtk.GridView) => void;
                onNotifyAccessibleRole?: (node: Gtk.GridView) => void;
                onNotifyOrientation?: (node: Gtk.GridView) => void;
                onNotifyHadjustment?: (node: Gtk.GridView) => void;
                onNotifyHscrollPolicy?: (node: Gtk.GridView) => void;
                onNotifyVadjustment?: (node: Gtk.GridView) => void;
                onNotifyVscrollPolicy?: (node: Gtk.GridView) => void;
            };
            HeaderBar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.HeaderBar>;
                decorationLayout?: string | null;
                showTitleButtons?: boolean;
                titleWidget?: Gtk.Widget | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyDecorationLayout?: (node: Gtk.HeaderBar) => void;
                onNotifyShowTitleButtons?: (node: Gtk.HeaderBar) => void;
                onNotifyTitleWidget?: (node: Gtk.HeaderBar) => void;
                onNotifyName?: (node: Gtk.HeaderBar) => void;
                onNotifyAccessibleRole?: (node: Gtk.HeaderBar) => void;
            };
            IconView: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.IconView>;
                activateOnSingleClick?: boolean;
                columnSpacing?: number;
                columns?: number;
                itemOrientation?: Gtk.Orientation;
                itemPadding?: number;
                itemWidth?: number;
                margin?: number;
                markupColumn?: number;
                model?: Gtk.TreeModel | null;
                pixbufColumn?: number;
                reorderable?: boolean;
                rowSpacing?: number;
                selectionMode?: Gtk.SelectionMode;
                spacing?: number;
                textColumn?: number;
                tooltipColumn?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                hadjustment?: Gtk.Adjustment | null;
                hscrollPolicy?: Gtk.ScrollablePolicy;
                vadjustment?: Gtk.Adjustment | null;
                vscrollPolicy?: Gtk.ScrollablePolicy;
                onActivateCursorItem?: (node: Gtk.IconView) => boolean;
                onItemActivated?: (node: Gtk.IconView, path: Gtk.TreePath) => void;
                onMoveCursor?: (node: Gtk.IconView, step: Gtk.MovementStep, count: number, extend: boolean, modify: boolean) => boolean;
                onSelectAll?: (node: Gtk.IconView) => void;
                onSelectCursorItem?: (node: Gtk.IconView) => void;
                onSelectionChanged?: (node: Gtk.IconView) => void;
                onToggleCursorItem?: (node: Gtk.IconView) => void;
                onUnselectAll?: (node: Gtk.IconView) => void;
                onNotifyActivateOnSingleClick?: (node: Gtk.IconView) => void;
                onNotifyCellArea?: (node: Gtk.IconView) => void;
                onNotifyColumnSpacing?: (node: Gtk.IconView) => void;
                onNotifyColumns?: (node: Gtk.IconView) => void;
                onNotifyItemOrientation?: (node: Gtk.IconView) => void;
                onNotifyItemPadding?: (node: Gtk.IconView) => void;
                onNotifyItemWidth?: (node: Gtk.IconView) => void;
                onNotifyMargin?: (node: Gtk.IconView) => void;
                onNotifyMarkupColumn?: (node: Gtk.IconView) => void;
                onNotifyModel?: (node: Gtk.IconView) => void;
                onNotifyPixbufColumn?: (node: Gtk.IconView) => void;
                onNotifyReorderable?: (node: Gtk.IconView) => void;
                onNotifyRowSpacing?: (node: Gtk.IconView) => void;
                onNotifySelectionMode?: (node: Gtk.IconView) => void;
                onNotifySpacing?: (node: Gtk.IconView) => void;
                onNotifyTextColumn?: (node: Gtk.IconView) => void;
                onNotifyTooltipColumn?: (node: Gtk.IconView) => void;
                onNotifyName?: (node: Gtk.IconView) => void;
                onNotifyAccessibleRole?: (node: Gtk.IconView) => void;
                onNotifyHadjustment?: (node: Gtk.IconView) => void;
                onNotifyHscrollPolicy?: (node: Gtk.IconView) => void;
                onNotifyVadjustment?: (node: Gtk.IconView) => void;
                onNotifyVscrollPolicy?: (node: Gtk.IconView) => void;
            };
            Image: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Image>;
                file?: string | null;
                gicon?: Gio.Icon;
                iconName?: string | null;
                iconSize?: Gtk.IconSize;
                paintable?: Gdk.Paintable;
                pixelSize?: number;
                resource?: string | null;
                useFallback?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyFile?: (node: Gtk.Image) => void;
                onNotifyGicon?: (node: Gtk.Image) => void;
                onNotifyIconName?: (node: Gtk.Image) => void;
                onNotifyIconSize?: (node: Gtk.Image) => void;
                onNotifyPaintable?: (node: Gtk.Image) => void;
                onNotifyPixelSize?: (node: Gtk.Image) => void;
                onNotifyResource?: (node: Gtk.Image) => void;
                onNotifyStorageType?: (node: Gtk.Image) => void;
                onNotifyUseFallback?: (node: Gtk.Image) => void;
                onNotifyName?: (node: Gtk.Image) => void;
                onNotifyAccessibleRole?: (node: Gtk.Image) => void;
            };
            InfoBar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.InfoBar>;
                messageType?: Gtk.MessageType;
                revealed?: boolean;
                showCloseButton?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onClose?: (node: Gtk.InfoBar) => void;
                onResponse?: (node: Gtk.InfoBar, responseId: number) => void;
                onNotifyMessageType?: (node: Gtk.InfoBar) => void;
                onNotifyRevealed?: (node: Gtk.InfoBar) => void;
                onNotifyShowCloseButton?: (node: Gtk.InfoBar) => void;
                onNotifyName?: (node: Gtk.InfoBar) => void;
                onNotifyAccessibleRole?: (node: Gtk.InfoBar) => void;
            };
            Inscription: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Inscription>;
                attributes?: Pango.AttrList | null;
                markup?: string | null;
                minChars?: number;
                minLines?: number;
                natChars?: number;
                natLines?: number;
                text?: string | null;
                textOverflow?: Gtk.InscriptionOverflow;
                wrapMode?: Pango.WrapMode;
                xalign?: number;
                yalign?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyAttributes?: (node: Gtk.Inscription) => void;
                onNotifyMarkup?: (node: Gtk.Inscription) => void;
                onNotifyMinChars?: (node: Gtk.Inscription) => void;
                onNotifyMinLines?: (node: Gtk.Inscription) => void;
                onNotifyNatChars?: (node: Gtk.Inscription) => void;
                onNotifyNatLines?: (node: Gtk.Inscription) => void;
                onNotifyText?: (node: Gtk.Inscription) => void;
                onNotifyTextOverflow?: (node: Gtk.Inscription) => void;
                onNotifyWrapMode?: (node: Gtk.Inscription) => void;
                onNotifyXalign?: (node: Gtk.Inscription) => void;
                onNotifyYalign?: (node: Gtk.Inscription) => void;
                onNotifyName?: (node: Gtk.Inscription) => void;
                onNotifyAccessibleRole?: (node: Gtk.Inscription) => void;
            };
            Label: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Label>;
                attributes?: Pango.AttrList | null;
                ellipsize?: Pango.EllipsizeMode;
                extraMenu?: Gio.MenuModel | null;
                justify?: Gtk.Justification;
                label?: string | null;
                lines?: number;
                maxWidthChars?: number;
                mnemonicWidget?: Gtk.Widget | null;
                naturalWrapMode?: Gtk.NaturalWrapMode;
                selectable?: boolean;
                singleLineMode?: boolean;
                tabs?: Pango.TabArray | null;
                useMarkup?: boolean;
                useUnderline?: boolean;
                widthChars?: number;
                wrap?: boolean;
                wrapMode?: Pango.WrapMode;
                xalign?: number;
                yalign?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivateCurrentLink?: (node: Gtk.Label) => void;
                onActivateLink?: (node: Gtk.Label, uri: string | null) => boolean;
                onCopyClipboard?: (node: Gtk.Label) => void;
                onMoveCursor?: (node: Gtk.Label, step: Gtk.MovementStep, count: number, extendSelection: boolean) => void;
                onNotifyAttributes?: (node: Gtk.Label) => void;
                onNotifyEllipsize?: (node: Gtk.Label) => void;
                onNotifyExtraMenu?: (node: Gtk.Label) => void;
                onNotifyJustify?: (node: Gtk.Label) => void;
                onNotifyLabel?: (node: Gtk.Label) => void;
                onNotifyLines?: (node: Gtk.Label) => void;
                onNotifyMaxWidthChars?: (node: Gtk.Label) => void;
                onNotifyMnemonicKeyval?: (node: Gtk.Label) => void;
                onNotifyMnemonicWidget?: (node: Gtk.Label) => void;
                onNotifyNaturalWrapMode?: (node: Gtk.Label) => void;
                onNotifySelectable?: (node: Gtk.Label) => void;
                onNotifySingleLineMode?: (node: Gtk.Label) => void;
                onNotifyTabs?: (node: Gtk.Label) => void;
                onNotifyUseMarkup?: (node: Gtk.Label) => void;
                onNotifyUseUnderline?: (node: Gtk.Label) => void;
                onNotifyWidthChars?: (node: Gtk.Label) => void;
                onNotifyWrap?: (node: Gtk.Label) => void;
                onNotifyWrapMode?: (node: Gtk.Label) => void;
                onNotifyXalign?: (node: Gtk.Label) => void;
                onNotifyYalign?: (node: Gtk.Label) => void;
                onNotifyName?: (node: Gtk.Label) => void;
                onNotifyAccessibleRole?: (node: Gtk.Label) => void;
            };
            LevelBar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.LevelBar>;
                inverted?: boolean;
                maxValue?: number;
                minValue?: number;
                mode?: Gtk.LevelBarMode;
                value?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onOffsetChanged?: (node: Gtk.LevelBar, name: string | null) => void;
                onNotifyInverted?: (node: Gtk.LevelBar) => void;
                onNotifyMaxValue?: (node: Gtk.LevelBar) => void;
                onNotifyMinValue?: (node: Gtk.LevelBar) => void;
                onNotifyMode?: (node: Gtk.LevelBar) => void;
                onNotifyValue?: (node: Gtk.LevelBar) => void;
                onNotifyName?: (node: Gtk.LevelBar) => void;
                onNotifyAccessibleRole?: (node: Gtk.LevelBar) => void;
                onNotifyOrientation?: (node: Gtk.LevelBar) => void;
            };
            LinkButton: JSX.IntrinsicElements["Button"] & {
                ref?: React$1.Ref<Gtk.LinkButton>;
                uri?: string | null;
                visited?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                actionName?: string | null;
                actionTarget?: GLib.Variant;
                onActivateLink?: (node: Gtk.LinkButton) => boolean;
                onNotifyUri?: (node: Gtk.LinkButton) => void;
                onNotifyVisited?: (node: Gtk.LinkButton) => void;
                onNotifyName?: (node: Gtk.LinkButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.LinkButton) => void;
                onNotifyActionName?: (node: Gtk.LinkButton) => void;
                onNotifyActionTarget?: (node: Gtk.LinkButton) => void;
            };
            ListBase: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ListBase>;
                orientation?: Gtk.Orientation;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                hadjustment?: Gtk.Adjustment | null;
                hscrollPolicy?: Gtk.ScrollablePolicy;
                vadjustment?: Gtk.Adjustment | null;
                vscrollPolicy?: Gtk.ScrollablePolicy;
                onNotifyOrientation?: (node: Gtk.ListBase) => void;
                onNotifyName?: (node: Gtk.ListBase) => void;
                onNotifyAccessibleRole?: (node: Gtk.ListBase) => void;
                onNotifyHadjustment?: (node: Gtk.ListBase) => void;
                onNotifyHscrollPolicy?: (node: Gtk.ListBase) => void;
                onNotifyVadjustment?: (node: Gtk.ListBase) => void;
                onNotifyVscrollPolicy?: (node: Gtk.ListBase) => void;
            };
            ListBox: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ListBox>;
                acceptUnpairedRelease?: boolean;
                activateOnSingleClick?: boolean;
                selectionMode?: Gtk.SelectionMode;
                showSeparators?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivateCursorRow?: (node: Gtk.ListBox) => void;
                onMoveCursor?: (node: Gtk.ListBox, object: Gtk.MovementStep, p0: number, p1: boolean, p2: boolean) => void;
                onRowActivated?: (node: Gtk.ListBox, row: Gtk.ListBoxRow) => void;
                onRowSelected?: (node: Gtk.ListBox, row: Gtk.ListBoxRow | null) => void;
                onSelectAll?: (node: Gtk.ListBox) => void;
                onSelectedRowsChanged?: (node: Gtk.ListBox) => void;
                onToggleCursorRow?: (node: Gtk.ListBox) => void;
                onUnselectAll?: (node: Gtk.ListBox) => void;
                onNotifyAcceptUnpairedRelease?: (node: Gtk.ListBox) => void;
                onNotifyActivateOnSingleClick?: (node: Gtk.ListBox) => void;
                onNotifySelectionMode?: (node: Gtk.ListBox) => void;
                onNotifyShowSeparators?: (node: Gtk.ListBox) => void;
                onNotifyName?: (node: Gtk.ListBox) => void;
                onNotifyAccessibleRole?: (node: Gtk.ListBox) => void;
            };
            ListBoxRow: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ListBoxRow>;
                activatable?: boolean;
                selectable?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                actionName?: string | null;
                actionTarget?: GLib.Variant;
                onActivate?: (node: Gtk.ListBoxRow) => void;
                onNotifyActivatable?: (node: Gtk.ListBoxRow) => void;
                onNotifyChild?: (node: Gtk.ListBoxRow) => void;
                onNotifySelectable?: (node: Gtk.ListBoxRow) => void;
                onNotifyName?: (node: Gtk.ListBoxRow) => void;
                onNotifyAccessibleRole?: (node: Gtk.ListBoxRow) => void;
                onNotifyActionName?: (node: Gtk.ListBoxRow) => void;
                onNotifyActionTarget?: (node: Gtk.ListBoxRow) => void;
            };
            ListView: JSX.IntrinsicElements["ListBase"] & {
                ref?: React$1.Ref<Gtk.ListView>;
                enableRubberband?: boolean;
                factory?: Gtk.ListItemFactory | null;
                headerFactory?: Gtk.ListItemFactory | null;
                model?: Gtk.SelectionModel | null;
                showSeparators?: boolean;
                singleClickActivate?: boolean;
                tabBehavior?: Gtk.ListTabBehavior;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                hadjustment?: Gtk.Adjustment | null;
                hscrollPolicy?: Gtk.ScrollablePolicy;
                vadjustment?: Gtk.Adjustment | null;
                vscrollPolicy?: Gtk.ScrollablePolicy;
                onActivate?: (node: Gtk.ListView, position: number) => void;
                onNotifyEnableRubberband?: (node: Gtk.ListView) => void;
                onNotifyFactory?: (node: Gtk.ListView) => void;
                onNotifyHeaderFactory?: (node: Gtk.ListView) => void;
                onNotifyModel?: (node: Gtk.ListView) => void;
                onNotifyShowSeparators?: (node: Gtk.ListView) => void;
                onNotifySingleClickActivate?: (node: Gtk.ListView) => void;
                onNotifyTabBehavior?: (node: Gtk.ListView) => void;
                onNotifyName?: (node: Gtk.ListView) => void;
                onNotifyAccessibleRole?: (node: Gtk.ListView) => void;
                onNotifyOrientation?: (node: Gtk.ListView) => void;
                onNotifyHadjustment?: (node: Gtk.ListView) => void;
                onNotifyHscrollPolicy?: (node: Gtk.ListView) => void;
                onNotifyVadjustment?: (node: Gtk.ListView) => void;
                onNotifyVscrollPolicy?: (node: Gtk.ListView) => void;
            };
            LockButton: JSX.IntrinsicElements["Button"] & {
                ref?: React$1.Ref<Gtk.LockButton>;
                permission?: Gio.Permission | null;
                textLock?: string | null;
                textUnlock?: string | null;
                tooltipLock?: string | null;
                tooltipNotAuthorized?: string | null;
                tooltipUnlock?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                actionName?: string | null;
                actionTarget?: GLib.Variant;
                onNotifyPermission?: (node: Gtk.LockButton) => void;
                onNotifyTextLock?: (node: Gtk.LockButton) => void;
                onNotifyTextUnlock?: (node: Gtk.LockButton) => void;
                onNotifyTooltipLock?: (node: Gtk.LockButton) => void;
                onNotifyTooltipNotAuthorized?: (node: Gtk.LockButton) => void;
                onNotifyTooltipUnlock?: (node: Gtk.LockButton) => void;
                onNotifyName?: (node: Gtk.LockButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.LockButton) => void;
                onNotifyActionName?: (node: Gtk.LockButton) => void;
                onNotifyActionTarget?: (node: Gtk.LockButton) => void;
            };
            MediaControls: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.MediaControls>;
                mediaStream?: Gtk.MediaStream | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyMediaStream?: (node: Gtk.MediaControls) => void;
                onNotifyName?: (node: Gtk.MediaControls) => void;
                onNotifyAccessibleRole?: (node: Gtk.MediaControls) => void;
            };
            MenuButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.MenuButton>;
                active?: boolean;
                alwaysShowArrow?: boolean;
                canShrink?: boolean;
                direction?: Gtk.ArrowType;
                hasFrame?: boolean;
                iconName?: string | null;
                label?: string | null;
                menuModel?: Gio.MenuModel | null;
                popover?: Gtk.Popover | null;
                primary?: boolean;
                useUnderline?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivate?: (node: Gtk.MenuButton) => void;
                onNotifyActive?: (node: Gtk.MenuButton) => void;
                onNotifyAlwaysShowArrow?: (node: Gtk.MenuButton) => void;
                onNotifyCanShrink?: (node: Gtk.MenuButton) => void;
                onNotifyChild?: (node: Gtk.MenuButton) => void;
                onNotifyDirection?: (node: Gtk.MenuButton) => void;
                onNotifyHasFrame?: (node: Gtk.MenuButton) => void;
                onNotifyIconName?: (node: Gtk.MenuButton) => void;
                onNotifyLabel?: (node: Gtk.MenuButton) => void;
                onNotifyMenuModel?: (node: Gtk.MenuButton) => void;
                onNotifyPopover?: (node: Gtk.MenuButton) => void;
                onNotifyPrimary?: (node: Gtk.MenuButton) => void;
                onNotifyUseUnderline?: (node: Gtk.MenuButton) => void;
                onNotifyName?: (node: Gtk.MenuButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.MenuButton) => void;
            };
            MessageDialog: JSX.IntrinsicElements["Dialog"] & {
                ref?: React$1.Ref<Gtk.MessageDialog>;
                messageType?: Gtk.MessageType;
                secondaryText?: string | null;
                secondaryUseMarkup?: boolean;
                text?: string | null;
                useMarkup?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyButtons?: (node: Gtk.MessageDialog) => void;
                onNotifyMessageArea?: (node: Gtk.MessageDialog) => void;
                onNotifyMessageType?: (node: Gtk.MessageDialog) => void;
                onNotifySecondaryText?: (node: Gtk.MessageDialog) => void;
                onNotifySecondaryUseMarkup?: (node: Gtk.MessageDialog) => void;
                onNotifyText?: (node: Gtk.MessageDialog) => void;
                onNotifyUseMarkup?: (node: Gtk.MessageDialog) => void;
                onNotifyName?: (node: Gtk.MessageDialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.MessageDialog) => void;
            };
            Notebook: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Notebook>;
                enablePopup?: boolean;
                groupName?: string | null;
                page?: number;
                scrollable?: boolean;
                showBorder?: boolean;
                showTabs?: boolean;
                tabPos?: Gtk.PositionType;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onChangeCurrentPage?: (node: Gtk.Notebook, object: number) => boolean;
                onCreateWindow?: (node: Gtk.Notebook, page: Gtk.Widget) => Gtk.Notebook;
                onFocusTab?: (node: Gtk.Notebook, object: Gtk.NotebookTab) => boolean;
                onMoveFocusOut?: (node: Gtk.Notebook, object: Gtk.DirectionType) => void;
                onPageAdded?: (node: Gtk.Notebook, child: Gtk.Widget, pageNum: number) => void;
                onPageRemoved?: (node: Gtk.Notebook, child: Gtk.Widget, pageNum: number) => void;
                onPageReordered?: (node: Gtk.Notebook, child: Gtk.Widget, pageNum: number) => void;
                onReorderTab?: (node: Gtk.Notebook, object: Gtk.DirectionType, p0: boolean) => boolean;
                onSelectPage?: (node: Gtk.Notebook, object: boolean) => boolean;
                onSwitchPage?: (node: Gtk.Notebook, page: Gtk.Widget, pageNum: number) => void;
                onNotifyEnablePopup?: (node: Gtk.Notebook) => void;
                onNotifyGroupName?: (node: Gtk.Notebook) => void;
                onNotifyPage?: (node: Gtk.Notebook) => void;
                onNotifyPages?: (node: Gtk.Notebook) => void;
                onNotifyScrollable?: (node: Gtk.Notebook) => void;
                onNotifyShowBorder?: (node: Gtk.Notebook) => void;
                onNotifyShowTabs?: (node: Gtk.Notebook) => void;
                onNotifyTabPos?: (node: Gtk.Notebook) => void;
                onNotifyName?: (node: Gtk.Notebook) => void;
                onNotifyAccessibleRole?: (node: Gtk.Notebook) => void;
            };
            Overlay: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Overlay>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onGetChildPosition?: (node: Gtk.Overlay, widget: Gtk.Widget) => boolean;
                onNotifyChild?: (node: Gtk.Overlay) => void;
                onNotifyName?: (node: Gtk.Overlay) => void;
                onNotifyAccessibleRole?: (node: Gtk.Overlay) => void;
            };
            PageSetupUnixDialog: JSX.IntrinsicElements["Dialog"] & {
                ref?: React$1.Ref<Gtk.PageSetupUnixDialog>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyName?: (node: Gtk.PageSetupUnixDialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.PageSetupUnixDialog) => void;
            };
            Paned: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Paned>;
                endChild?: Gtk.Widget | null;
                position?: number;
                positionSet?: boolean;
                resizeEndChild?: boolean;
                resizeStartChild?: boolean;
                shrinkEndChild?: boolean;
                shrinkStartChild?: boolean;
                startChild?: Gtk.Widget | null;
                wideHandle?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onAcceptPosition?: (node: Gtk.Paned) => boolean;
                onCancelPosition?: (node: Gtk.Paned) => boolean;
                onCycleChildFocus?: (node: Gtk.Paned, reversed: boolean) => boolean;
                onCycleHandleFocus?: (node: Gtk.Paned, reversed: boolean) => boolean;
                onMoveHandle?: (node: Gtk.Paned, scrollType: Gtk.ScrollType) => boolean;
                onToggleHandleFocus?: (node: Gtk.Paned) => boolean;
                onNotifyEndChild?: (node: Gtk.Paned) => void;
                onNotifyMaxPosition?: (node: Gtk.Paned) => void;
                onNotifyMinPosition?: (node: Gtk.Paned) => void;
                onNotifyPosition?: (node: Gtk.Paned) => void;
                onNotifyPositionSet?: (node: Gtk.Paned) => void;
                onNotifyResizeEndChild?: (node: Gtk.Paned) => void;
                onNotifyResizeStartChild?: (node: Gtk.Paned) => void;
                onNotifyShrinkEndChild?: (node: Gtk.Paned) => void;
                onNotifyShrinkStartChild?: (node: Gtk.Paned) => void;
                onNotifyStartChild?: (node: Gtk.Paned) => void;
                onNotifyWideHandle?: (node: Gtk.Paned) => void;
                onNotifyName?: (node: Gtk.Paned) => void;
                onNotifyAccessibleRole?: (node: Gtk.Paned) => void;
                onNotifyOrientation?: (node: Gtk.Paned) => void;
            };
            PasswordEntry: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.PasswordEntry>;
                activatesDefault?: boolean;
                extraMenu?: Gio.MenuModel | null;
                placeholderText?: string | null;
                showPeekIcon?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                editable?: boolean;
                enableUndo?: boolean;
                maxWidthChars?: number;
                text?: string | null;
                widthChars?: number;
                xalign?: number;
                onActivate?: (node: Gtk.PasswordEntry) => void;
                onChanged?: (node: Gtk.PasswordEntry) => void;
                onDeleteText?: (node: Gtk.PasswordEntry, startPos: number, endPos: number) => void;
                onInsertText?: (node: Gtk.PasswordEntry, text: string | null, length: number, position: number) => void;
                onNotifyActivatesDefault?: (node: Gtk.PasswordEntry) => void;
                onNotifyExtraMenu?: (node: Gtk.PasswordEntry) => void;
                onNotifyPlaceholderText?: (node: Gtk.PasswordEntry) => void;
                onNotifyShowPeekIcon?: (node: Gtk.PasswordEntry) => void;
                onNotifyName?: (node: Gtk.PasswordEntry) => void;
                onNotifyAccessibleRole?: (node: Gtk.PasswordEntry) => void;
                onNotifyCursorPosition?: (node: Gtk.PasswordEntry) => void;
                onNotifyEditable?: (node: Gtk.PasswordEntry) => void;
                onNotifyEnableUndo?: (node: Gtk.PasswordEntry) => void;
                onNotifyMaxWidthChars?: (node: Gtk.PasswordEntry) => void;
                onNotifySelectionBound?: (node: Gtk.PasswordEntry) => void;
                onNotifyText?: (node: Gtk.PasswordEntry) => void;
                onNotifyWidthChars?: (node: Gtk.PasswordEntry) => void;
                onNotifyXalign?: (node: Gtk.PasswordEntry) => void;
            };
            Picture: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Picture>;
                alternativeText?: string | null;
                canShrink?: boolean;
                contentFit?: Gtk.ContentFit;
                file?: Gio.File | null;
                keepAspectRatio?: boolean;
                paintable?: Gdk.Paintable | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyAlternativeText?: (node: Gtk.Picture) => void;
                onNotifyCanShrink?: (node: Gtk.Picture) => void;
                onNotifyContentFit?: (node: Gtk.Picture) => void;
                onNotifyFile?: (node: Gtk.Picture) => void;
                onNotifyKeepAspectRatio?: (node: Gtk.Picture) => void;
                onNotifyPaintable?: (node: Gtk.Picture) => void;
                onNotifyName?: (node: Gtk.Picture) => void;
                onNotifyAccessibleRole?: (node: Gtk.Picture) => void;
            };
            Popover: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Popover>;
                autohide?: boolean;
                cascadePopdown?: boolean;
                defaultWidget?: Gtk.Widget | null;
                hasArrow?: boolean;
                mnemonicsVisible?: boolean;
                pointingTo?: Gdk.Rectangle | null;
                position?: Gtk.PositionType;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivateDefault?: (node: Gtk.Popover) => void;
                onClosed?: (node: Gtk.Popover) => void;
                onNotifyAutohide?: (node: Gtk.Popover) => void;
                onNotifyCascadePopdown?: (node: Gtk.Popover) => void;
                onNotifyChild?: (node: Gtk.Popover) => void;
                onNotifyDefaultWidget?: (node: Gtk.Popover) => void;
                onNotifyHasArrow?: (node: Gtk.Popover) => void;
                onNotifyMnemonicsVisible?: (node: Gtk.Popover) => void;
                onNotifyPointingTo?: (node: Gtk.Popover) => void;
                onNotifyPosition?: (node: Gtk.Popover) => void;
                onNotifyName?: (node: Gtk.Popover) => void;
                onNotifyAccessibleRole?: (node: Gtk.Popover) => void;
            };
            PopoverMenu: JSX.IntrinsicElements["Popover"] & {
                ref?: React$1.Ref<Gtk.PopoverMenu>;
                flags?: Gtk.PopoverMenuFlags;
                menuModel?: Gio.MenuModel | null;
                visibleSubmenu?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyFlags?: (node: Gtk.PopoverMenu) => void;
                onNotifyMenuModel?: (node: Gtk.PopoverMenu) => void;
                onNotifyVisibleSubmenu?: (node: Gtk.PopoverMenu) => void;
                onNotifyName?: (node: Gtk.PopoverMenu) => void;
                onNotifyAccessibleRole?: (node: Gtk.PopoverMenu) => void;
            };
            PopoverMenuBar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.PopoverMenuBar>;
                menuModel?: Gio.MenuModel | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyMenuModel?: (node: Gtk.PopoverMenuBar) => void;
                onNotifyName?: (node: Gtk.PopoverMenuBar) => void;
                onNotifyAccessibleRole?: (node: Gtk.PopoverMenuBar) => void;
            };
            PrintUnixDialog: JSX.IntrinsicElements["Dialog"] & {
                ref?: React$1.Ref<Gtk.PrintUnixDialog>;
                currentPage?: number;
                embedPageSetup?: boolean;
                hasSelection?: boolean;
                manualCapabilities?: Gtk.PrintCapabilities;
                pageSetup?: Gtk.PageSetup;
                printSettings?: Gtk.PrintSettings;
                supportSelection?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyCurrentPage?: (node: Gtk.PrintUnixDialog) => void;
                onNotifyEmbedPageSetup?: (node: Gtk.PrintUnixDialog) => void;
                onNotifyHasSelection?: (node: Gtk.PrintUnixDialog) => void;
                onNotifyManualCapabilities?: (node: Gtk.PrintUnixDialog) => void;
                onNotifyPageSetup?: (node: Gtk.PrintUnixDialog) => void;
                onNotifyPrintSettings?: (node: Gtk.PrintUnixDialog) => void;
                onNotifySelectedPrinter?: (node: Gtk.PrintUnixDialog) => void;
                onNotifySupportSelection?: (node: Gtk.PrintUnixDialog) => void;
                onNotifyName?: (node: Gtk.PrintUnixDialog) => void;
                onNotifyAccessibleRole?: (node: Gtk.PrintUnixDialog) => void;
            };
            ProgressBar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ProgressBar>;
                ellipsize?: Pango.EllipsizeMode;
                fraction?: number;
                inverted?: boolean;
                pulseStep?: number;
                showText?: boolean;
                text?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyEllipsize?: (node: Gtk.ProgressBar) => void;
                onNotifyFraction?: (node: Gtk.ProgressBar) => void;
                onNotifyInverted?: (node: Gtk.ProgressBar) => void;
                onNotifyPulseStep?: (node: Gtk.ProgressBar) => void;
                onNotifyShowText?: (node: Gtk.ProgressBar) => void;
                onNotifyText?: (node: Gtk.ProgressBar) => void;
                onNotifyName?: (node: Gtk.ProgressBar) => void;
                onNotifyAccessibleRole?: (node: Gtk.ProgressBar) => void;
                onNotifyOrientation?: (node: Gtk.ProgressBar) => void;
            };
            Range: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Range>;
                adjustment?: Gtk.Adjustment;
                fillLevel?: number;
                inverted?: boolean;
                restrictToFillLevel?: boolean;
                roundDigits?: number;
                showFillLevel?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onAdjustBounds?: (node: Gtk.Range, value: number) => void;
                onChangeValue?: (node: Gtk.Range, scroll: Gtk.ScrollType, value: number) => boolean;
                onMoveSlider?: (node: Gtk.Range, step: Gtk.ScrollType) => void;
                onValueChanged?: (node: Gtk.Range) => void;
                onNotifyAdjustment?: (node: Gtk.Range) => void;
                onNotifyFillLevel?: (node: Gtk.Range) => void;
                onNotifyInverted?: (node: Gtk.Range) => void;
                onNotifyRestrictToFillLevel?: (node: Gtk.Range) => void;
                onNotifyRoundDigits?: (node: Gtk.Range) => void;
                onNotifyShowFillLevel?: (node: Gtk.Range) => void;
                onNotifyName?: (node: Gtk.Range) => void;
                onNotifyAccessibleRole?: (node: Gtk.Range) => void;
                onNotifyOrientation?: (node: Gtk.Range) => void;
            };
            Revealer: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Revealer>;
                revealChild?: boolean;
                transitionDuration?: number;
                transitionType?: Gtk.RevealerTransitionType;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyChild?: (node: Gtk.Revealer) => void;
                onNotifyChildRevealed?: (node: Gtk.Revealer) => void;
                onNotifyRevealChild?: (node: Gtk.Revealer) => void;
                onNotifyTransitionDuration?: (node: Gtk.Revealer) => void;
                onNotifyTransitionType?: (node: Gtk.Revealer) => void;
                onNotifyName?: (node: Gtk.Revealer) => void;
                onNotifyAccessibleRole?: (node: Gtk.Revealer) => void;
            };
            Scale: JSX.IntrinsicElements["Range"] & {
                ref?: React$1.Ref<Gtk.Scale>;
                digits?: number;
                drawValue?: boolean;
                hasOrigin?: boolean;
                valuePos?: Gtk.PositionType;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyDigits?: (node: Gtk.Scale) => void;
                onNotifyDrawValue?: (node: Gtk.Scale) => void;
                onNotifyHasOrigin?: (node: Gtk.Scale) => void;
                onNotifyValuePos?: (node: Gtk.Scale) => void;
                onNotifyName?: (node: Gtk.Scale) => void;
                onNotifyAccessibleRole?: (node: Gtk.Scale) => void;
                onNotifyOrientation?: (node: Gtk.Scale) => void;
            };
            ScaleButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ScaleButton>;
                adjustment?: Gtk.Adjustment;
                hasFrame?: boolean;
                icons?: string[];
                value?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onPopdown?: (node: Gtk.ScaleButton) => void;
                onPopup?: (node: Gtk.ScaleButton) => void;
                onValueChanged?: (node: Gtk.ScaleButton, value: number) => void;
                onNotifyActive?: (node: Gtk.ScaleButton) => void;
                onNotifyAdjustment?: (node: Gtk.ScaleButton) => void;
                onNotifyHasFrame?: (node: Gtk.ScaleButton) => void;
                onNotifyIcons?: (node: Gtk.ScaleButton) => void;
                onNotifyValue?: (node: Gtk.ScaleButton) => void;
                onNotifyName?: (node: Gtk.ScaleButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.ScaleButton) => void;
                onNotifyOrientation?: (node: Gtk.ScaleButton) => void;
            };
            Scrollbar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Scrollbar>;
                adjustment?: Gtk.Adjustment | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyAdjustment?: (node: Gtk.Scrollbar) => void;
                onNotifyName?: (node: Gtk.Scrollbar) => void;
                onNotifyAccessibleRole?: (node: Gtk.Scrollbar) => void;
                onNotifyOrientation?: (node: Gtk.Scrollbar) => void;
            };
            ScrolledWindow: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ScrolledWindow>;
                hadjustment?: Gtk.Adjustment | null;
                hasFrame?: boolean;
                hscrollbarPolicy?: Gtk.PolicyType;
                kineticScrolling?: boolean;
                maxContentHeight?: number;
                maxContentWidth?: number;
                minContentHeight?: number;
                minContentWidth?: number;
                overlayScrolling?: boolean;
                propagateNaturalHeight?: boolean;
                propagateNaturalWidth?: boolean;
                vadjustment?: Gtk.Adjustment | null;
                vscrollbarPolicy?: Gtk.PolicyType;
                windowPlacement?: Gtk.CornerType;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onEdgeOvershot?: (node: Gtk.ScrolledWindow, pos: Gtk.PositionType) => void;
                onEdgeReached?: (node: Gtk.ScrolledWindow, pos: Gtk.PositionType) => void;
                onMoveFocusOut?: (node: Gtk.ScrolledWindow, directionType: Gtk.DirectionType) => void;
                onScrollChild?: (node: Gtk.ScrolledWindow, scroll: Gtk.ScrollType, horizontal: boolean) => boolean;
                onNotifyChild?: (node: Gtk.ScrolledWindow) => void;
                onNotifyHadjustment?: (node: Gtk.ScrolledWindow) => void;
                onNotifyHasFrame?: (node: Gtk.ScrolledWindow) => void;
                onNotifyHscrollbarPolicy?: (node: Gtk.ScrolledWindow) => void;
                onNotifyKineticScrolling?: (node: Gtk.ScrolledWindow) => void;
                onNotifyMaxContentHeight?: (node: Gtk.ScrolledWindow) => void;
                onNotifyMaxContentWidth?: (node: Gtk.ScrolledWindow) => void;
                onNotifyMinContentHeight?: (node: Gtk.ScrolledWindow) => void;
                onNotifyMinContentWidth?: (node: Gtk.ScrolledWindow) => void;
                onNotifyOverlayScrolling?: (node: Gtk.ScrolledWindow) => void;
                onNotifyPropagateNaturalHeight?: (node: Gtk.ScrolledWindow) => void;
                onNotifyPropagateNaturalWidth?: (node: Gtk.ScrolledWindow) => void;
                onNotifyVadjustment?: (node: Gtk.ScrolledWindow) => void;
                onNotifyVscrollbarPolicy?: (node: Gtk.ScrolledWindow) => void;
                onNotifyWindowPlacement?: (node: Gtk.ScrolledWindow) => void;
                onNotifyName?: (node: Gtk.ScrolledWindow) => void;
                onNotifyAccessibleRole?: (node: Gtk.ScrolledWindow) => void;
            };
            SearchBar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.SearchBar>;
                keyCaptureWidget?: Gtk.Widget | null;
                searchModeEnabled?: boolean;
                showCloseButton?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyChild?: (node: Gtk.SearchBar) => void;
                onNotifyKeyCaptureWidget?: (node: Gtk.SearchBar) => void;
                onNotifySearchModeEnabled?: (node: Gtk.SearchBar) => void;
                onNotifyShowCloseButton?: (node: Gtk.SearchBar) => void;
                onNotifyName?: (node: Gtk.SearchBar) => void;
                onNotifyAccessibleRole?: (node: Gtk.SearchBar) => void;
            };
            SearchEntry: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.SearchEntry>;
                activatesDefault?: boolean;
                inputHints?: Gtk.InputHints;
                inputPurpose?: Gtk.InputPurpose;
                placeholderText?: string | null;
                searchDelay?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                editable?: boolean;
                enableUndo?: boolean;
                maxWidthChars?: number;
                text?: string | null;
                widthChars?: number;
                xalign?: number;
                onActivate?: (node: Gtk.SearchEntry) => void;
                onNextMatch?: (node: Gtk.SearchEntry) => void;
                onPreviousMatch?: (node: Gtk.SearchEntry) => void;
                onSearchChanged?: (node: Gtk.SearchEntry) => void;
                onSearchStarted?: (node: Gtk.SearchEntry) => void;
                onStopSearch?: (node: Gtk.SearchEntry) => void;
                onChanged?: (node: Gtk.SearchEntry) => void;
                onDeleteText?: (node: Gtk.SearchEntry, startPos: number, endPos: number) => void;
                onInsertText?: (node: Gtk.SearchEntry, text: string | null, length: number, position: number) => void;
                onNotifyActivatesDefault?: (node: Gtk.SearchEntry) => void;
                onNotifyInputHints?: (node: Gtk.SearchEntry) => void;
                onNotifyInputPurpose?: (node: Gtk.SearchEntry) => void;
                onNotifyPlaceholderText?: (node: Gtk.SearchEntry) => void;
                onNotifySearchDelay?: (node: Gtk.SearchEntry) => void;
                onNotifyName?: (node: Gtk.SearchEntry) => void;
                onNotifyAccessibleRole?: (node: Gtk.SearchEntry) => void;
                onNotifyCursorPosition?: (node: Gtk.SearchEntry) => void;
                onNotifyEditable?: (node: Gtk.SearchEntry) => void;
                onNotifyEnableUndo?: (node: Gtk.SearchEntry) => void;
                onNotifyMaxWidthChars?: (node: Gtk.SearchEntry) => void;
                onNotifySelectionBound?: (node: Gtk.SearchEntry) => void;
                onNotifyText?: (node: Gtk.SearchEntry) => void;
                onNotifyWidthChars?: (node: Gtk.SearchEntry) => void;
                onNotifyXalign?: (node: Gtk.SearchEntry) => void;
            };
            Separator: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Separator>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyName?: (node: Gtk.Separator) => void;
                onNotifyAccessibleRole?: (node: Gtk.Separator) => void;
                onNotifyOrientation?: (node: Gtk.Separator) => void;
            };
            ShortcutLabel: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ShortcutLabel>;
                accelerator?: string | null;
                disabledText?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyAccelerator?: (node: Gtk.ShortcutLabel) => void;
                onNotifyDisabledText?: (node: Gtk.ShortcutLabel) => void;
                onNotifyName?: (node: Gtk.ShortcutLabel) => void;
                onNotifyAccessibleRole?: (node: Gtk.ShortcutLabel) => void;
            };
            ShortcutsGroup: JSX.IntrinsicElements["Box"] & {
                ref?: React$1.Ref<Gtk.ShortcutsGroup>;
                accelSizeGroup?: Gtk.SizeGroup;
                title?: string | null;
                titleSizeGroup?: Gtk.SizeGroup;
                view?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyAccelSizeGroup?: (node: Gtk.ShortcutsGroup) => void;
                onNotifyHeight?: (node: Gtk.ShortcutsGroup) => void;
                onNotifyTitle?: (node: Gtk.ShortcutsGroup) => void;
                onNotifyTitleSizeGroup?: (node: Gtk.ShortcutsGroup) => void;
                onNotifyView?: (node: Gtk.ShortcutsGroup) => void;
                onNotifyName?: (node: Gtk.ShortcutsGroup) => void;
                onNotifyAccessibleRole?: (node: Gtk.ShortcutsGroup) => void;
                onNotifyOrientation?: (node: Gtk.ShortcutsGroup) => void;
            };
            ShortcutsSection: JSX.IntrinsicElements["Box"] & {
                ref?: React$1.Ref<Gtk.ShortcutsSection>;
                maxHeight?: number;
                sectionName?: string | null;
                title?: string | null;
                viewName?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onChangeCurrentPage?: (node: Gtk.ShortcutsSection, object: number) => boolean;
                onNotifyMaxHeight?: (node: Gtk.ShortcutsSection) => void;
                onNotifySectionName?: (node: Gtk.ShortcutsSection) => void;
                onNotifyTitle?: (node: Gtk.ShortcutsSection) => void;
                onNotifyViewName?: (node: Gtk.ShortcutsSection) => void;
                onNotifyName?: (node: Gtk.ShortcutsSection) => void;
                onNotifyAccessibleRole?: (node: Gtk.ShortcutsSection) => void;
                onNotifyOrientation?: (node: Gtk.ShortcutsSection) => void;
            };
            ShortcutsShortcut: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.ShortcutsShortcut>;
                accelSizeGroup?: Gtk.SizeGroup;
                accelerator?: string | null;
                actionName?: string | null;
                direction?: Gtk.TextDirection;
                icon?: Gio.Icon;
                iconSet?: boolean;
                shortcutType?: Gtk.ShortcutType;
                subtitle?: string | null;
                subtitleSet?: boolean;
                title?: string | null;
                titleSizeGroup?: Gtk.SizeGroup;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyAccelSizeGroup?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyAccelerator?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyActionName?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyDirection?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyIcon?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyIconSet?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyShortcutType?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifySubtitle?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifySubtitleSet?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyTitle?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyTitleSizeGroup?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyName?: (node: Gtk.ShortcutsShortcut) => void;
                onNotifyAccessibleRole?: (node: Gtk.ShortcutsShortcut) => void;
            };
            ShortcutsWindow: JSX.IntrinsicElements["Window"] & {
                ref?: React$1.Ref<Gtk.ShortcutsWindow>;
                sectionName?: string | null;
                viewName?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onClose?: (node: Gtk.ShortcutsWindow) => void;
                onSearch?: (node: Gtk.ShortcutsWindow) => void;
                onNotifySectionName?: (node: Gtk.ShortcutsWindow) => void;
                onNotifyViewName?: (node: Gtk.ShortcutsWindow) => void;
                onNotifyName?: (node: Gtk.ShortcutsWindow) => void;
                onNotifyAccessibleRole?: (node: Gtk.ShortcutsWindow) => void;
            };
            SpinButton: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.SpinButton>;
                activatesDefault?: boolean;
                adjustment?: Gtk.Adjustment;
                climbRate?: number;
                digits?: number;
                numeric?: boolean;
                snapToTicks?: boolean;
                updatePolicy?: Gtk.SpinButtonUpdatePolicy;
                value?: number;
                wrap?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                editingCanceled?: boolean;
                editable?: boolean;
                enableUndo?: boolean;
                maxWidthChars?: number;
                text?: string | null;
                widthChars?: number;
                xalign?: number;
                orientation?: Gtk.Orientation;
                onActivate?: (node: Gtk.SpinButton) => void;
                onChangeValue?: (node: Gtk.SpinButton, scroll: Gtk.ScrollType) => void;
                onInput?: (node: Gtk.SpinButton) => number;
                onOutput?: (node: Gtk.SpinButton) => boolean;
                onValueChanged?: (node: Gtk.SpinButton) => void;
                onWrapped?: (node: Gtk.SpinButton) => void;
                onEditingDone?: (node: Gtk.SpinButton) => void;
                onRemoveWidget?: (node: Gtk.SpinButton) => void;
                onChanged?: (node: Gtk.SpinButton) => void;
                onDeleteText?: (node: Gtk.SpinButton, startPos: number, endPos: number) => void;
                onInsertText?: (node: Gtk.SpinButton, text: string | null, length: number, position: number) => void;
                onNotifyActivatesDefault?: (node: Gtk.SpinButton) => void;
                onNotifyAdjustment?: (node: Gtk.SpinButton) => void;
                onNotifyClimbRate?: (node: Gtk.SpinButton) => void;
                onNotifyDigits?: (node: Gtk.SpinButton) => void;
                onNotifyNumeric?: (node: Gtk.SpinButton) => void;
                onNotifySnapToTicks?: (node: Gtk.SpinButton) => void;
                onNotifyUpdatePolicy?: (node: Gtk.SpinButton) => void;
                onNotifyValue?: (node: Gtk.SpinButton) => void;
                onNotifyWrap?: (node: Gtk.SpinButton) => void;
                onNotifyName?: (node: Gtk.SpinButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.SpinButton) => void;
                onNotifyEditingCanceled?: (node: Gtk.SpinButton) => void;
                onNotifyCursorPosition?: (node: Gtk.SpinButton) => void;
                onNotifyEditable?: (node: Gtk.SpinButton) => void;
                onNotifyEnableUndo?: (node: Gtk.SpinButton) => void;
                onNotifyMaxWidthChars?: (node: Gtk.SpinButton) => void;
                onNotifySelectionBound?: (node: Gtk.SpinButton) => void;
                onNotifyText?: (node: Gtk.SpinButton) => void;
                onNotifyWidthChars?: (node: Gtk.SpinButton) => void;
                onNotifyXalign?: (node: Gtk.SpinButton) => void;
                onNotifyOrientation?: (node: Gtk.SpinButton) => void;
            };
            Spinner: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Spinner>;
                spinning?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifySpinning?: (node: Gtk.Spinner) => void;
                onNotifyName?: (node: Gtk.Spinner) => void;
                onNotifyAccessibleRole?: (node: Gtk.Spinner) => void;
            };
            Stack: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Stack>;
                hhomogeneous?: boolean;
                interpolateSize?: boolean;
                transitionDuration?: number;
                transitionType?: Gtk.StackTransitionType;
                vhomogeneous?: boolean;
                visibleChild?: Gtk.Widget;
                visibleChildName?: string | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyHhomogeneous?: (node: Gtk.Stack) => void;
                onNotifyInterpolateSize?: (node: Gtk.Stack) => void;
                onNotifyPages?: (node: Gtk.Stack) => void;
                onNotifyTransitionDuration?: (node: Gtk.Stack) => void;
                onNotifyTransitionRunning?: (node: Gtk.Stack) => void;
                onNotifyTransitionType?: (node: Gtk.Stack) => void;
                onNotifyVhomogeneous?: (node: Gtk.Stack) => void;
                onNotifyVisibleChild?: (node: Gtk.Stack) => void;
                onNotifyVisibleChildName?: (node: Gtk.Stack) => void;
                onNotifyName?: (node: Gtk.Stack) => void;
                onNotifyAccessibleRole?: (node: Gtk.Stack) => void;
            };
            StackSidebar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.StackSidebar>;
                stack?: Gtk.Stack;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyStack?: (node: Gtk.StackSidebar) => void;
                onNotifyName?: (node: Gtk.StackSidebar) => void;
                onNotifyAccessibleRole?: (node: Gtk.StackSidebar) => void;
            };
            StackSwitcher: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.StackSwitcher>;
                stack?: Gtk.Stack | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyStack?: (node: Gtk.StackSwitcher) => void;
                onNotifyName?: (node: Gtk.StackSwitcher) => void;
                onNotifyAccessibleRole?: (node: Gtk.StackSwitcher) => void;
                onNotifyOrientation?: (node: Gtk.StackSwitcher) => void;
            };
            Statusbar: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Statusbar>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onTextPopped?: (node: Gtk.Statusbar, contextId: number, text: string | null) => void;
                onTextPushed?: (node: Gtk.Statusbar, contextId: number, text: string | null) => void;
                onNotifyName?: (node: Gtk.Statusbar) => void;
                onNotifyAccessibleRole?: (node: Gtk.Statusbar) => void;
            };
            Switch: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Switch>;
                active?: boolean;
                state?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                actionName?: string | null;
                actionTarget?: GLib.Variant;
                onActivate?: (node: Gtk.Switch) => void;
                onStateSet?: (node: Gtk.Switch, state: boolean) => boolean;
                onNotifyActive?: (node: Gtk.Switch) => void;
                onNotifyState?: (node: Gtk.Switch) => void;
                onNotifyName?: (node: Gtk.Switch) => void;
                onNotifyAccessibleRole?: (node: Gtk.Switch) => void;
                onNotifyActionName?: (node: Gtk.Switch) => void;
                onNotifyActionTarget?: (node: Gtk.Switch) => void;
            };
            Text: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Text>;
                activatesDefault?: boolean;
                attributes?: Pango.AttrList | null;
                buffer?: Gtk.EntryBuffer;
                enableEmojiCompletion?: boolean;
                extraMenu?: Gio.MenuModel | null;
                imModule?: string | null;
                inputHints?: Gtk.InputHints;
                inputPurpose?: Gtk.InputPurpose;
                invisibleChar?: number;
                invisibleCharSet?: boolean;
                maxLength?: number;
                overwriteMode?: boolean;
                placeholderText?: string | null;
                propagateTextWidth?: boolean;
                tabs?: Pango.TabArray | null;
                truncateMultiline?: boolean;
                visibility?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                editable?: boolean;
                enableUndo?: boolean;
                maxWidthChars?: number;
                text?: string | null;
                widthChars?: number;
                xalign?: number;
                onActivate?: (node: Gtk.Text) => void;
                onBackspace?: (node: Gtk.Text) => void;
                onCopyClipboard?: (node: Gtk.Text) => void;
                onCutClipboard?: (node: Gtk.Text) => void;
                onDeleteFromCursor?: (node: Gtk.Text, type: Gtk.DeleteType, count: number) => void;
                onInsertAtCursor?: (node: Gtk.Text, string: string | null) => void;
                onInsertEmoji?: (node: Gtk.Text) => void;
                onMoveCursor?: (node: Gtk.Text, step: Gtk.MovementStep, count: number, extend: boolean) => void;
                onPasteClipboard?: (node: Gtk.Text) => void;
                onPreeditChanged?: (node: Gtk.Text, preedit: string | null) => void;
                onToggleOverwrite?: (node: Gtk.Text) => void;
                onChanged?: (node: Gtk.Text) => void;
                onDeleteText?: (node: Gtk.Text, startPos: number, endPos: number) => void;
                onInsertText?: (node: Gtk.Text, text: string | null, length: number, position: number) => void;
                onNotifyActivatesDefault?: (node: Gtk.Text) => void;
                onNotifyAttributes?: (node: Gtk.Text) => void;
                onNotifyBuffer?: (node: Gtk.Text) => void;
                onNotifyEnableEmojiCompletion?: (node: Gtk.Text) => void;
                onNotifyExtraMenu?: (node: Gtk.Text) => void;
                onNotifyImModule?: (node: Gtk.Text) => void;
                onNotifyInputHints?: (node: Gtk.Text) => void;
                onNotifyInputPurpose?: (node: Gtk.Text) => void;
                onNotifyInvisibleChar?: (node: Gtk.Text) => void;
                onNotifyInvisibleCharSet?: (node: Gtk.Text) => void;
                onNotifyMaxLength?: (node: Gtk.Text) => void;
                onNotifyOverwriteMode?: (node: Gtk.Text) => void;
                onNotifyPlaceholderText?: (node: Gtk.Text) => void;
                onNotifyPropagateTextWidth?: (node: Gtk.Text) => void;
                onNotifyScrollOffset?: (node: Gtk.Text) => void;
                onNotifyTabs?: (node: Gtk.Text) => void;
                onNotifyTruncateMultiline?: (node: Gtk.Text) => void;
                onNotifyVisibility?: (node: Gtk.Text) => void;
                onNotifyName?: (node: Gtk.Text) => void;
                onNotifyAccessibleRole?: (node: Gtk.Text) => void;
                onNotifyCursorPosition?: (node: Gtk.Text) => void;
                onNotifyEditable?: (node: Gtk.Text) => void;
                onNotifyEnableUndo?: (node: Gtk.Text) => void;
                onNotifyMaxWidthChars?: (node: Gtk.Text) => void;
                onNotifySelectionBound?: (node: Gtk.Text) => void;
                onNotifyText?: (node: Gtk.Text) => void;
                onNotifyWidthChars?: (node: Gtk.Text) => void;
                onNotifyXalign?: (node: Gtk.Text) => void;
            };
            TextView: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.TextView>;
                acceptsTab?: boolean;
                bottomMargin?: number;
                buffer?: Gtk.TextBuffer | null;
                cursorVisible?: boolean;
                editable?: boolean;
                extraMenu?: Gio.MenuModel | null;
                imModule?: string | null;
                indent?: number;
                inputHints?: Gtk.InputHints;
                inputPurpose?: Gtk.InputPurpose;
                justification?: Gtk.Justification;
                leftMargin?: number;
                monospace?: boolean;
                overwrite?: boolean;
                pixelsAboveLines?: number;
                pixelsBelowLines?: number;
                pixelsInsideWrap?: number;
                rightMargin?: number;
                tabs?: Pango.TabArray;
                topMargin?: number;
                wrapMode?: Gtk.WrapMode;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                hadjustment?: Gtk.Adjustment | null;
                hscrollPolicy?: Gtk.ScrollablePolicy;
                vadjustment?: Gtk.Adjustment | null;
                vscrollPolicy?: Gtk.ScrollablePolicy;
                onBackspace?: (node: Gtk.TextView) => void;
                onCopyClipboard?: (node: Gtk.TextView) => void;
                onCutClipboard?: (node: Gtk.TextView) => void;
                onDeleteFromCursor?: (node: Gtk.TextView, type: Gtk.DeleteType, count: number) => void;
                onExtendSelection?: (node: Gtk.TextView, granularity: Gtk.TextExtendSelection, location: Gtk.TextIter, start: Gtk.TextIter, end: Gtk.TextIter) => boolean;
                onInsertAtCursor?: (node: Gtk.TextView, string: string | null) => void;
                onInsertEmoji?: (node: Gtk.TextView) => void;
                onMoveCursor?: (node: Gtk.TextView, step: Gtk.MovementStep, count: number, extendSelection: boolean) => void;
                onMoveViewport?: (node: Gtk.TextView, step: Gtk.ScrollStep, count: number) => void;
                onPasteClipboard?: (node: Gtk.TextView) => void;
                onPreeditChanged?: (node: Gtk.TextView, preedit: string | null) => void;
                onSelectAll?: (node: Gtk.TextView, select: boolean) => void;
                onSetAnchor?: (node: Gtk.TextView) => void;
                onToggleCursorVisible?: (node: Gtk.TextView) => void;
                onToggleOverwrite?: (node: Gtk.TextView) => void;
                onNotifyAcceptsTab?: (node: Gtk.TextView) => void;
                onNotifyBottomMargin?: (node: Gtk.TextView) => void;
                onNotifyBuffer?: (node: Gtk.TextView) => void;
                onNotifyCursorVisible?: (node: Gtk.TextView) => void;
                onNotifyEditable?: (node: Gtk.TextView) => void;
                onNotifyExtraMenu?: (node: Gtk.TextView) => void;
                onNotifyImModule?: (node: Gtk.TextView) => void;
                onNotifyIndent?: (node: Gtk.TextView) => void;
                onNotifyInputHints?: (node: Gtk.TextView) => void;
                onNotifyInputPurpose?: (node: Gtk.TextView) => void;
                onNotifyJustification?: (node: Gtk.TextView) => void;
                onNotifyLeftMargin?: (node: Gtk.TextView) => void;
                onNotifyMonospace?: (node: Gtk.TextView) => void;
                onNotifyOverwrite?: (node: Gtk.TextView) => void;
                onNotifyPixelsAboveLines?: (node: Gtk.TextView) => void;
                onNotifyPixelsBelowLines?: (node: Gtk.TextView) => void;
                onNotifyPixelsInsideWrap?: (node: Gtk.TextView) => void;
                onNotifyRightMargin?: (node: Gtk.TextView) => void;
                onNotifyTabs?: (node: Gtk.TextView) => void;
                onNotifyTopMargin?: (node: Gtk.TextView) => void;
                onNotifyWrapMode?: (node: Gtk.TextView) => void;
                onNotifyName?: (node: Gtk.TextView) => void;
                onNotifyAccessibleRole?: (node: Gtk.TextView) => void;
                onNotifyHadjustment?: (node: Gtk.TextView) => void;
                onNotifyHscrollPolicy?: (node: Gtk.TextView) => void;
                onNotifyVadjustment?: (node: Gtk.TextView) => void;
                onNotifyVscrollPolicy?: (node: Gtk.TextView) => void;
            };
            ToggleButton: JSX.IntrinsicElements["Button"] & {
                ref?: React$1.Ref<Gtk.ToggleButton>;
                active?: boolean;
                group?: Gtk.ToggleButton | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                actionName?: string | null;
                actionTarget?: GLib.Variant;
                onToggled?: (node: Gtk.ToggleButton) => void;
                onNotifyActive?: (node: Gtk.ToggleButton) => void;
                onNotifyGroup?: (node: Gtk.ToggleButton) => void;
                onNotifyName?: (node: Gtk.ToggleButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.ToggleButton) => void;
                onNotifyActionName?: (node: Gtk.ToggleButton) => void;
                onNotifyActionTarget?: (node: Gtk.ToggleButton) => void;
            };
            TreeExpander: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.TreeExpander>;
                hideExpander?: boolean;
                indentForDepth?: boolean;
                indentForIcon?: boolean;
                listRow?: Gtk.TreeListRow | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyChild?: (node: Gtk.TreeExpander) => void;
                onNotifyHideExpander?: (node: Gtk.TreeExpander) => void;
                onNotifyIndentForDepth?: (node: Gtk.TreeExpander) => void;
                onNotifyIndentForIcon?: (node: Gtk.TreeExpander) => void;
                onNotifyItem?: (node: Gtk.TreeExpander) => void;
                onNotifyListRow?: (node: Gtk.TreeExpander) => void;
                onNotifyName?: (node: Gtk.TreeExpander) => void;
                onNotifyAccessibleRole?: (node: Gtk.TreeExpander) => void;
            };
            TreeView: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.TreeView>;
                activateOnSingleClick?: boolean;
                enableGridLines?: Gtk.TreeViewGridLines;
                enableSearch?: boolean;
                enableTreeLines?: boolean;
                expanderColumn?: Gtk.TreeViewColumn | null;
                fixedHeightMode?: boolean;
                headersClickable?: boolean;
                headersVisible?: boolean;
                hoverExpand?: boolean;
                hoverSelection?: boolean;
                levelIndentation?: number;
                model?: Gtk.TreeModel | null;
                reorderable?: boolean;
                rubberBanding?: boolean;
                searchColumn?: number;
                showExpanders?: boolean;
                tooltipColumn?: number;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                hadjustment?: Gtk.Adjustment | null;
                hscrollPolicy?: Gtk.ScrollablePolicy;
                vadjustment?: Gtk.Adjustment | null;
                vscrollPolicy?: Gtk.ScrollablePolicy;
                onColumnsChanged?: (node: Gtk.TreeView) => void;
                onCursorChanged?: (node: Gtk.TreeView) => void;
                onExpandCollapseCursorRow?: (node: Gtk.TreeView, object: boolean, p0: boolean, p1: boolean) => boolean;
                onMoveCursor?: (node: Gtk.TreeView, step: Gtk.MovementStep, direction: number, extend: boolean, modify: boolean) => boolean;
                onRowActivated?: (node: Gtk.TreeView, path: Gtk.TreePath, column: Gtk.TreeViewColumn | null) => void;
                onRowCollapsed?: (node: Gtk.TreeView, iter: Gtk.TreeIter, path: Gtk.TreePath) => void;
                onRowExpanded?: (node: Gtk.TreeView, iter: Gtk.TreeIter, path: Gtk.TreePath) => void;
                onSelectAll?: (node: Gtk.TreeView) => boolean;
                onSelectCursorParent?: (node: Gtk.TreeView) => boolean;
                onSelectCursorRow?: (node: Gtk.TreeView, object: boolean) => boolean;
                onStartInteractiveSearch?: (node: Gtk.TreeView) => boolean;
                onTestCollapseRow?: (node: Gtk.TreeView, iter: Gtk.TreeIter, path: Gtk.TreePath) => boolean;
                onTestExpandRow?: (node: Gtk.TreeView, iter: Gtk.TreeIter, path: Gtk.TreePath) => boolean;
                onToggleCursorRow?: (node: Gtk.TreeView) => boolean;
                onUnselectAll?: (node: Gtk.TreeView) => boolean;
                onNotifyActivateOnSingleClick?: (node: Gtk.TreeView) => void;
                onNotifyEnableGridLines?: (node: Gtk.TreeView) => void;
                onNotifyEnableSearch?: (node: Gtk.TreeView) => void;
                onNotifyEnableTreeLines?: (node: Gtk.TreeView) => void;
                onNotifyExpanderColumn?: (node: Gtk.TreeView) => void;
                onNotifyFixedHeightMode?: (node: Gtk.TreeView) => void;
                onNotifyHeadersClickable?: (node: Gtk.TreeView) => void;
                onNotifyHeadersVisible?: (node: Gtk.TreeView) => void;
                onNotifyHoverExpand?: (node: Gtk.TreeView) => void;
                onNotifyHoverSelection?: (node: Gtk.TreeView) => void;
                onNotifyLevelIndentation?: (node: Gtk.TreeView) => void;
                onNotifyModel?: (node: Gtk.TreeView) => void;
                onNotifyReorderable?: (node: Gtk.TreeView) => void;
                onNotifyRubberBanding?: (node: Gtk.TreeView) => void;
                onNotifySearchColumn?: (node: Gtk.TreeView) => void;
                onNotifyShowExpanders?: (node: Gtk.TreeView) => void;
                onNotifyTooltipColumn?: (node: Gtk.TreeView) => void;
                onNotifyName?: (node: Gtk.TreeView) => void;
                onNotifyAccessibleRole?: (node: Gtk.TreeView) => void;
                onNotifyHadjustment?: (node: Gtk.TreeView) => void;
                onNotifyHscrollPolicy?: (node: Gtk.TreeView) => void;
                onNotifyVadjustment?: (node: Gtk.TreeView) => void;
                onNotifyVscrollPolicy?: (node: Gtk.TreeView) => void;
            };
            Video: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Video>;
                autoplay?: boolean;
                file?: Gio.File | null;
                graphicsOffload?: Gtk.GraphicsOffloadEnabled;
                loop?: boolean;
                mediaStream?: Gtk.MediaStream | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyAutoplay?: (node: Gtk.Video) => void;
                onNotifyFile?: (node: Gtk.Video) => void;
                onNotifyGraphicsOffload?: (node: Gtk.Video) => void;
                onNotifyLoop?: (node: Gtk.Video) => void;
                onNotifyMediaStream?: (node: Gtk.Video) => void;
                onNotifyName?: (node: Gtk.Video) => void;
                onNotifyAccessibleRole?: (node: Gtk.Video) => void;
            };
            Viewport: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Viewport>;
                scrollToFocus?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                hadjustment?: Gtk.Adjustment | null;
                hscrollPolicy?: Gtk.ScrollablePolicy;
                vadjustment?: Gtk.Adjustment | null;
                vscrollPolicy?: Gtk.ScrollablePolicy;
                onNotifyChild?: (node: Gtk.Viewport) => void;
                onNotifyScrollToFocus?: (node: Gtk.Viewport) => void;
                onNotifyName?: (node: Gtk.Viewport) => void;
                onNotifyAccessibleRole?: (node: Gtk.Viewport) => void;
                onNotifyHadjustment?: (node: Gtk.Viewport) => void;
                onNotifyHscrollPolicy?: (node: Gtk.Viewport) => void;
                onNotifyVadjustment?: (node: Gtk.Viewport) => void;
                onNotifyVscrollPolicy?: (node: Gtk.Viewport) => void;
            };
            VolumeButton: JSX.IntrinsicElements["ScaleButton"] & {
                ref?: React$1.Ref<Gtk.VolumeButton>;
                useSymbolic?: boolean;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                orientation?: Gtk.Orientation;
                onNotifyUseSymbolic?: (node: Gtk.VolumeButton) => void;
                onNotifyName?: (node: Gtk.VolumeButton) => void;
                onNotifyAccessibleRole?: (node: Gtk.VolumeButton) => void;
                onNotifyOrientation?: (node: Gtk.VolumeButton) => void;
            };
            Widget: {
                ref?: React$1.Ref<Gtk.Widget>;
                children?: React$1.ReactNode;
                canFocus?: boolean;
                canTarget?: boolean;
                cssClasses?: string[];
                cursor?: Gdk.Cursor | null;
                focusOnClick?: boolean;
                focusable?: boolean;
                halign?: Gtk.Align;
                hasTooltip?: boolean;
                heightRequest?: number;
                hexpand?: boolean;
                hexpandSet?: boolean;
                layoutManager?: Gtk.LayoutManager | null;
                marginBottom?: number;
                marginEnd?: number;
                marginStart?: number;
                marginTop?: number;
                name?: string | null;
                opacity?: number;
                overflow?: Gtk.Overflow;
                receivesDefault?: boolean;
                sensitive?: boolean;
                tooltipMarkup?: string | null;
                tooltipText?: string | null;
                valign?: Gtk.Align;
                vexpand?: boolean;
                vexpandSet?: boolean;
                visible?: boolean;
                widthRequest?: number;
                accessibleRole?: Gtk.AccessibleRole;
                onDestroy?: (node: Gtk.Widget) => void;
                onDirectionChanged?: (node: Gtk.Widget, previousDirection: Gtk.TextDirection) => void;
                onHide?: (node: Gtk.Widget) => void;
                onKeynavFailed?: (node: Gtk.Widget, direction: Gtk.DirectionType) => boolean;
                onMap?: (node: Gtk.Widget) => void;
                onMnemonicActivate?: (node: Gtk.Widget, groupCycling: boolean) => boolean;
                onMoveFocus?: (node: Gtk.Widget, direction: Gtk.DirectionType) => void;
                onQueryTooltip?: (node: Gtk.Widget, x: number, y: number, keyboardMode: boolean, tooltip: Gtk.Tooltip) => boolean;
                onRealize?: (node: Gtk.Widget) => void;
                onShow?: (node: Gtk.Widget) => void;
                onStateFlagsChanged?: (node: Gtk.Widget, flags: Gtk.StateFlags) => void;
                onUnmap?: (node: Gtk.Widget) => void;
                onUnrealize?: (node: Gtk.Widget) => void;
                onNotifyCanFocus?: (node: Gtk.Widget) => void;
                onNotifyCanTarget?: (node: Gtk.Widget) => void;
                onNotifyCssClasses?: (node: Gtk.Widget) => void;
                onNotifyCssName?: (node: Gtk.Widget) => void;
                onNotifyCursor?: (node: Gtk.Widget) => void;
                onNotifyFocusOnClick?: (node: Gtk.Widget) => void;
                onNotifyFocusable?: (node: Gtk.Widget) => void;
                onNotifyHalign?: (node: Gtk.Widget) => void;
                onNotifyHasDefault?: (node: Gtk.Widget) => void;
                onNotifyHasFocus?: (node: Gtk.Widget) => void;
                onNotifyHasTooltip?: (node: Gtk.Widget) => void;
                onNotifyHeightRequest?: (node: Gtk.Widget) => void;
                onNotifyHexpand?: (node: Gtk.Widget) => void;
                onNotifyHexpandSet?: (node: Gtk.Widget) => void;
                onNotifyLayoutManager?: (node: Gtk.Widget) => void;
                onNotifyMarginBottom?: (node: Gtk.Widget) => void;
                onNotifyMarginEnd?: (node: Gtk.Widget) => void;
                onNotifyMarginStart?: (node: Gtk.Widget) => void;
                onNotifyMarginTop?: (node: Gtk.Widget) => void;
                onNotifyName?: (node: Gtk.Widget) => void;
                onNotifyOpacity?: (node: Gtk.Widget) => void;
                onNotifyOverflow?: (node: Gtk.Widget) => void;
                onNotifyParent?: (node: Gtk.Widget) => void;
                onNotifyReceivesDefault?: (node: Gtk.Widget) => void;
                onNotifyRoot?: (node: Gtk.Widget) => void;
                onNotifyScaleFactor?: (node: Gtk.Widget) => void;
                onNotifySensitive?: (node: Gtk.Widget) => void;
                onNotifyTooltipMarkup?: (node: Gtk.Widget) => void;
                onNotifyTooltipText?: (node: Gtk.Widget) => void;
                onNotifyValign?: (node: Gtk.Widget) => void;
                onNotifyVexpand?: (node: Gtk.Widget) => void;
                onNotifyVexpandSet?: (node: Gtk.Widget) => void;
                onNotifyVisible?: (node: Gtk.Widget) => void;
                onNotifyWidthRequest?: (node: Gtk.Widget) => void;
                onNotifyAccessibleRole?: (node: Gtk.Widget) => void;
            };
            Window: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.Window>;
                application?: Gtk.Application | null;
                decorated?: boolean;
                defaultHeight?: number;
                defaultWidget?: Gtk.Widget | null;
                defaultWidth?: number;
                deletable?: boolean;
                destroyWithParent?: boolean;
                display?: Gdk.Display;
                focusVisible?: boolean;
                focusWidget?: Gtk.Widget;
                fullscreened?: boolean;
                handleMenubarAccel?: boolean;
                hideOnClose?: boolean;
                iconName?: string | null;
                maximized?: boolean;
                mnemonicsVisible?: boolean;
                modal?: boolean;
                resizable?: boolean;
                startupId?: string | null;
                title?: string | null;
                titlebar?: Gtk.Widget | null;
                transientFor?: Gtk.Window | null;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onActivateDefault?: (node: Gtk.Window) => void;
                onActivateFocus?: (node: Gtk.Window) => void;
                onCloseRequest?: (node: Gtk.Window) => boolean;
                onEnableDebugging?: (node: Gtk.Window, toggle: boolean) => boolean;
                onKeysChanged?: (node: Gtk.Window) => void;
                onNotifyApplication?: (node: Gtk.Window) => void;
                onNotifyChild?: (node: Gtk.Window) => void;
                onNotifyDecorated?: (node: Gtk.Window) => void;
                onNotifyDefaultHeight?: (node: Gtk.Window) => void;
                onNotifyDefaultWidget?: (node: Gtk.Window) => void;
                onNotifyDefaultWidth?: (node: Gtk.Window) => void;
                onNotifyDeletable?: (node: Gtk.Window) => void;
                onNotifyDestroyWithParent?: (node: Gtk.Window) => void;
                onNotifyDisplay?: (node: Gtk.Window) => void;
                onNotifyFocusVisible?: (node: Gtk.Window) => void;
                onNotifyFocusWidget?: (node: Gtk.Window) => void;
                onNotifyFullscreened?: (node: Gtk.Window) => void;
                onNotifyHandleMenubarAccel?: (node: Gtk.Window) => void;
                onNotifyHideOnClose?: (node: Gtk.Window) => void;
                onNotifyIconName?: (node: Gtk.Window) => void;
                onNotifyIsActive?: (node: Gtk.Window) => void;
                onNotifyMaximized?: (node: Gtk.Window) => void;
                onNotifyMnemonicsVisible?: (node: Gtk.Window) => void;
                onNotifyModal?: (node: Gtk.Window) => void;
                onNotifyResizable?: (node: Gtk.Window) => void;
                onNotifyStartupId?: (node: Gtk.Window) => void;
                onNotifySuspended?: (node: Gtk.Window) => void;
                onNotifyTitle?: (node: Gtk.Window) => void;
                onNotifyTitlebar?: (node: Gtk.Window) => void;
                onNotifyTransientFor?: (node: Gtk.Window) => void;
                onNotifyName?: (node: Gtk.Window) => void;
                onNotifyAccessibleRole?: (node: Gtk.Window) => void;
            };
            WindowControls: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.WindowControls>;
                decorationLayout?: string | null;
                side?: Gtk.PackType;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyDecorationLayout?: (node: Gtk.WindowControls) => void;
                onNotifyEmpty?: (node: Gtk.WindowControls) => void;
                onNotifySide?: (node: Gtk.WindowControls) => void;
                onNotifyName?: (node: Gtk.WindowControls) => void;
                onNotifyAccessibleRole?: (node: Gtk.WindowControls) => void;
            };
            WindowHandle: JSX.IntrinsicElements["Widget"] & {
                ref?: React$1.Ref<Gtk.WindowHandle>;
                name?: string;
                accessibleRole?: Gtk.AccessibleRole;
                onNotifyChild?: (node: Gtk.WindowHandle) => void;
                onNotifyName?: (node: Gtk.WindowHandle) => void;
                onNotifyAccessibleRole?: (node: Gtk.WindowHandle) => void;
            };
        }
    }
}

declare const AppChooserButton = "AppChooserButton";
declare const AppChooserDialog = "AppChooserDialog";
declare const AppChooserWidget = "AppChooserWidget";
declare const AspectFrame = "AspectFrame";
declare const Assistant = "Assistant";
declare const Box = "Box";
declare const Button = "Button";
declare const CellView = "CellView";
declare const ColorButton = "ColorButton";
declare const ColorChooserDialog = "ColorChooserDialog";
declare const ColorChooserWidget = "ColorChooserWidget";
declare const ComboBox = "ComboBox";
declare const ComboBoxText = "ComboBoxText";
declare const Dialog = "Dialog";
declare const DragIcon = "DragIcon";
declare const DrawingArea = "DrawingArea";
declare const EditableLabel = "EditableLabel";
declare const Entry = "Entry";
declare const FileChooserDialog = "FileChooserDialog";
declare const FileChooserWidget = "FileChooserWidget";
declare const Fixed = "Fixed";
declare const FlowBox = "FlowBox";
declare const FlowBoxChild = "FlowBoxChild";
declare const FontButton = "FontButton";
declare const FontChooserDialog = "FontChooserDialog";
declare const FontChooserWidget = "FontChooserWidget";
declare const GLArea = "GLArea";
declare const GraphicsOffload = "GraphicsOffload";
declare const GridView = "GridView";
declare const IconView = "IconView";
declare const Image = "Image";
declare const InfoBar = "InfoBar";
declare const Inscription = "Inscription";
declare const Label = "Label";
declare const LinkButton = "LinkButton";
declare const ListBase = "ListBase";
declare const ListBox = "ListBox";
declare const ListBoxRow = "ListBoxRow";
declare const LockButton = "LockButton";
declare const MediaControls = "MediaControls";
declare const MessageDialog = "MessageDialog";
declare const PasswordEntry = "PasswordEntry";
declare const Picture = "Picture";
declare const ProgressBar = "ProgressBar";
declare const Range = "Range";
declare const Revealer = "Revealer";
declare const ScaleButton = "ScaleButton";
declare const Scrollbar = "Scrollbar";
declare const ScrolledWindow = "ScrolledWindow";
declare const SearchBar = "SearchBar";
declare const SearchEntry = "SearchEntry";
declare const Separator = "Separator";
declare const ShortcutLabel = "ShortcutLabel";
declare const ShortcutsGroup = "ShortcutsGroup";
declare const ShortcutsSection = "ShortcutsSection";
declare const ShortcutsShortcut = "ShortcutsShortcut";
declare const ShortcutsWindow = "ShortcutsWindow";
declare const Spinner = "Spinner";
declare const StackSidebar = "StackSidebar";
declare const StackSwitcher = "StackSwitcher";
declare const Statusbar = "Statusbar";
declare const Switch = "Switch";
declare const Text = "Text";
declare const ToggleButton = "ToggleButton";
declare const TreeExpander = "TreeExpander";
declare const TreeView = "TreeView";
declare const Video = "Video";
declare const Viewport = "Viewport";
declare const VolumeButton = "VolumeButton";
declare const Widget = "Widget";
declare const Window = "Window";
declare const WindowControls = "WindowControls";
declare const WindowHandle = "WindowHandle";

declare function useApplication(): ApplicationContext;

declare function useActionGroup(actions: Record<string, () => void>, deps: React.DependencyList): Gio.SimpleActionGroup;

interface ListModelContext {
    items: Record<string, unknown>;
    setItems: React$1.Dispatch<React$1.SetStateAction<Record<string, unknown>>>;
    model: Gio.ListModel;
}
declare const ListModelContext: React$1.Context<ListModelContext | null>;
interface ContainerProps$2 {
    children: React$1.ReactNode;
    model: Gio.ListModel;
}
declare function ListModelProvider({ children, model }: ContainerProps$2): React$1.JSX.Element;

declare function useListModel(): ListModelContext;

type ListItemFactoryRenderFunction<T> = (value: T | null, listItem: Gtk.ListItem) => React$1.ReactElement & React$1.RefAttributes<Gtk.Widget>;
declare function useListItemFactory<T>(render?: ListItemFactoryRenderFunction<T> | null): Gtk.SignalListItemFactory | null | undefined;

interface MenuItem {
    label?: string;
    icon?: string;
    action?: string;
    section?: boolean;
    attributes?: Record<string, GLib.Variant>;
    children?: MenuItem[];
}
declare function useMenu(items: MenuItem[], deps: React.DependencyList): Gio.Menu;

declare function useInlineStylesheet(content: string): Gtk.CssProvider;
declare function useStylesheet(path: string): Gtk.CssProvider;

type OnSelectionChanged = (selection: number[], values: unknown[]) => void;
interface Props$p {
    selectionMode: Gtk.SelectionMode;
    onSelectionChanged?: OnSelectionChanged;
    selection: number[];
}
declare function useSelection({ selectionMode, selection, onSelectionChanged, }: Props$p): Gtk.SelectionModel | null;

declare const REACT_PORTAL_TYPE: unique symbol;
declare function createPortal<T = Gtk.Application>(children: React.ReactNode, rootNode?: T | null, key?: string | null): ReactPortal;

interface AboutDialogCreditSection {
    name: string;
    people: string[];
}
type Props$o = JSX.IntrinsicElements["AboutDialog"] & {
    creditSections?: AboutDialogCreditSection[];
};
declare const _default$v: React$1.ForwardRefExoticComponent<Omit<Props$o, "ref"> & React$1.RefAttributes<Gtk.AboutDialog>>;

type Position$1 = "start" | "center" | "end";
interface ItemProps$6 {
    children: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
}
interface SectionProps$1 {
    children: React$1.ReactElement;
    position?: Position$1;
}
declare const _default$u: {
    Container: React$1.ForwardRefExoticComponent<Omit<Omit<{
        ref?: React$1.Ref<Gtk.Widget>;
        children?: React$1.ReactNode;
        canFocus?: boolean;
        canTarget?: boolean;
        cssClasses?: string[];
        cursor?: Gdk.Cursor | null;
        focusOnClick?: boolean;
        focusable?: boolean;
        halign?: Gtk.Align;
        hasTooltip?: boolean;
        heightRequest?: number;
        hexpand?: boolean;
        hexpandSet?: boolean;
        layoutManager?: Gtk.LayoutManager | null;
        marginBottom?: number;
        marginEnd?: number;
        marginStart?: number;
        marginTop?: number;
        name?: string | null;
        opacity?: number;
        overflow?: Gtk.Overflow;
        receivesDefault?: boolean;
        sensitive?: boolean;
        tooltipMarkup?: string | null;
        tooltipText?: string | null;
        valign?: Gtk.Align;
        vexpand?: boolean;
        vexpandSet?: boolean;
        visible?: boolean;
        widthRequest?: number;
        accessibleRole?: Gtk.AccessibleRole;
        onDestroy?: (node: Gtk.Widget) => void;
        onDirectionChanged?: (node: Gtk.Widget, previousDirection: Gtk.TextDirection) => void;
        onHide?: (node: Gtk.Widget) => void;
        onKeynavFailed?: (node: Gtk.Widget, direction: Gtk.DirectionType) => boolean;
        onMap?: (node: Gtk.Widget) => void;
        onMnemonicActivate?: (node: Gtk.Widget, groupCycling: boolean) => boolean;
        onMoveFocus?: (node: Gtk.Widget, direction: Gtk.DirectionType) => void;
        onQueryTooltip?: (node: Gtk.Widget, x: number, y: number, keyboardMode: boolean, tooltip: Gtk.Tooltip) => boolean;
        onRealize?: (node: Gtk.Widget) => void;
        onShow?: (node: Gtk.Widget) => void;
        onStateFlagsChanged?: (node: Gtk.Widget, flags: Gtk.StateFlags) => void;
        onUnmap?: (node: Gtk.Widget) => void;
        onUnrealize?: (node: Gtk.Widget) => void;
        onNotifyCanFocus?: (node: Gtk.Widget) => void;
        onNotifyCanTarget?: (node: Gtk.Widget) => void;
        onNotifyCssClasses?: (node: Gtk.Widget) => void;
        onNotifyCssName?: (node: Gtk.Widget) => void;
        onNotifyCursor?: (node: Gtk.Widget) => void;
        onNotifyFocusOnClick?: (node: Gtk.Widget) => void;
        onNotifyFocusable?: (node: Gtk.Widget) => void;
        onNotifyHalign?: (node: Gtk.Widget) => void;
        onNotifyHasDefault?: (node: Gtk.Widget) => void;
        onNotifyHasFocus?: (node: Gtk.Widget) => void;
        onNotifyHasTooltip?: (node: Gtk.Widget) => void;
        onNotifyHeightRequest?: (node: Gtk.Widget) => void;
        onNotifyHexpand?: (node: Gtk.Widget) => void;
        onNotifyHexpandSet?: (node: Gtk.Widget) => void;
        onNotifyLayoutManager?: (node: Gtk.Widget) => void;
        onNotifyMarginBottom?: (node: Gtk.Widget) => void;
        onNotifyMarginEnd?: (node: Gtk.Widget) => void;
        onNotifyMarginStart?: (node: Gtk.Widget) => void;
        onNotifyMarginTop?: (node: Gtk.Widget) => void;
        onNotifyName?: (node: Gtk.Widget) => void;
        onNotifyOpacity?: (node: Gtk.Widget) => void;
        onNotifyOverflow?: (node: Gtk.Widget) => void;
        onNotifyParent?: (node: Gtk.Widget) => void;
        onNotifyReceivesDefault?: (node: Gtk.Widget) => void;
        onNotifyRoot?: (node: Gtk.Widget) => void;
        onNotifyScaleFactor?: (node: Gtk.Widget) => void;
        onNotifySensitive?: (node: Gtk.Widget) => void;
        onNotifyTooltipMarkup?: (node: Gtk.Widget) => void;
        onNotifyTooltipText?: (node: Gtk.Widget) => void;
        onNotifyValign?: (node: Gtk.Widget) => void;
        onNotifyVexpand?: (node: Gtk.Widget) => void;
        onNotifyVexpandSet?: (node: Gtk.Widget) => void;
        onNotifyVisible?: (node: Gtk.Widget) => void;
        onNotifyWidthRequest?: (node: Gtk.Widget) => void;
        onNotifyAccessibleRole?: (node: Gtk.Widget) => void;
    } & {
        ref?: React$1.Ref<Gtk.ActionBar>;
        revealed?: boolean;
        name?: string;
        accessibleRole?: Gtk.AccessibleRole;
        onNotifyRevealed?: (node: Gtk.ActionBar) => void;
        onNotifyName?: (node: Gtk.ActionBar) => void;
        onNotifyAccessibleRole?: (node: Gtk.ActionBar) => void;
    }, "centerWidget">, "ref"> & React$1.RefAttributes<Gtk.ActionBar>>;
    Section: ({ children, position, }: SectionProps$1) => React$1.JSX.Element;
    Item: ({ children }: ItemProps$6) => React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
};

type Props$n = Omit<JSX.IntrinsicElements["ApplicationWindow"], "titlebar"> & {
    titlebar?: (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
};
declare const _default$t: React$1.ForwardRefExoticComponent<Omit<Props$n, "ref"> & React$1.RefAttributes<Gtk.ApplicationWindow>>;

type Props$m = JSX.IntrinsicElements["Calendar"] & {
    markedDays?: number[];
};
declare const _default$s: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<Props$m, "ref"> & React$1.RefAttributes<Gtk.Calendar>>>;

type Props$l = Omit<JSX.IntrinsicElements["CenterBox"], "startWidget" | "endWidget" | "centerWidget" | "children"> & {
    start?: (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
    end?: (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
    children?: (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
};
declare const _default$r: React$1.ForwardRefExoticComponent<Omit<Props$l, "ref"> & React$1.RefAttributes<Gtk.CenterBox>>;

type Props$k = Omit<JSX.IntrinsicElements["CheckButton"], "group"> & {
    radio?: boolean;
};
declare const _default$q: React$1.ForwardRefExoticComponent<Omit<Props$k, "ref"> & React$1.RefAttributes<Gtk.CheckButton>>;

type ColorDialog = Pick<Gtk.ColorDialog, "title" | "modal">;
type Props$j = Omit<JSX.IntrinsicElements["ColorDialogButton"], "dialog"> & Partial<ColorDialog>;
declare const _default$p: React$1.ForwardRefExoticComponent<Omit<Props$j, "ref"> & React$1.RefAttributes<Gtk.ColorDialogButton>>;

type RenderCellFunction<T> = (item: T | null, column: number, listItem: Gtk.ListItem) => React$1.ReactElement & React$1.RefAttributes<Gtk.Widget>;
type Props$i<T> = Omit<JSX.IntrinsicElements["ColumnView"], "model"> & {
    columns: Column[];
    selectionMode?: Gtk.SelectionMode;
    selection?: number[];
    onSelectionChanged?: (indexes: number[], selection: T[]) => void;
    renderCell: RenderCellFunction<T>;
};
interface ColumnProps<T> {
    index: number;
    column: Column;
    view: Gtk.ColumnView;
    renderCell: RenderCellFunction<T>;
}
type Column = Omit<Gtk.ColumnViewColumn.ConstructorProperties, "model" | "id">;
declare const Column: React$1.MemoExoticComponent<(<T>({ index, column, renderCell, view, }: ColumnProps<T>) => null)>;
declare const _default$o: React$1.ForwardRefExoticComponent<Omit<Props$i<any>, "ref"> & React$1.RefAttributes<Gtk.ColumnView>>;

type Props$h<T> = Omit<JSX.IntrinsicElements["DropDown"], "itemFactory" | "popoverItemFactory" | "model" | "selectedItem" | "selected" | "onNotifySelectedItem" | "onNotifySelectedItemChanged"> & {
    renderPopoverItem?: ListItemFactoryRenderFunction<T> | null;
    renderItem?: ListItemFactoryRenderFunction<T> | null;
    onSelectedItemChanged?: (index: number, item: T) => void;
    selectedItem?: number;
};
declare const _default$n: React$1.ForwardRefExoticComponent<Omit<Props$h<any>, "ref"> & React$1.RefAttributes<Gtk.DropDown>>;

type ElementType = "Popover" | "PopoverMenu" | "EmojiChooser";
type AbstractPopoverProps<T extends ElementType> = Omit<JSX.IntrinsicElements[T], "children"> & {
    elementType: T;
    children?: (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
    content?: (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
    open?: boolean;
};

type Props$g = Omit<AbstractPopoverProps<"EmojiChooser">, "elementType">;
declare const _default$m: React$1.ForwardRefExoticComponent<Omit<Props$g, "ref"> & React$1.RefAttributes<Gtk.EmojiChooser>>;

type Props$f = Omit<JSX.IntrinsicElements["Expander"], "labelWidget" | "label"> & {
    label?: string | (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
};
declare const _default$l: React$1.ForwardRefExoticComponent<Omit<Props$f, "ref"> & React$1.RefAttributes<Gtk.Expander>>;

type FileDialogProps = Partial<Pick<Gtk.FileDialog, "acceptLabel" | "defaultFilter" | "filters" | "initialFile" | "initialFolder" | "initialName" | "modal" | "title">>;
type Props$e = FileDialogProps & {
    onCancelled?: () => void;
};
type SingleSelectionDialogProps = Props$e & {
    selectionType?: "file" | "folder" | "save";
    onFinished?: (selection: Gio.File | null) => void;
};
type MultipleSelectionDialogProps = Props$e & {
    selectionType?: "file" | "folder";
    onFinished?: (selection: Gio.ListModel | null) => void;
};
declare function SingleFileDialog({ selectionType, onFinished, onCancelled, ...props }: SingleSelectionDialogProps): null;
declare function MultipleFileDialog({ selectionType, onFinished, onCancelled, ...props }: MultipleSelectionDialogProps): null;

type Props$d = Omit<JSX.IntrinsicElements["FontDialogButton"], "dialog"> & Partial<Gtk.FontDialog>;
declare const _default$k: React$1.ForwardRefExoticComponent<Omit<Props$d, "ref"> & React$1.RefAttributes<Gtk.FontDialogButton>>;

type Props$c = Omit<JSX.IntrinsicElements["Frame"], "labelWidget" | "label"> & {
    label?: string | (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
};
declare const _default$j: React$1.ForwardRefExoticComponent<Omit<Props$c, "ref"> & React$1.RefAttributes<Gtk.Frame>>;

interface ItemProps$5 {
    children: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
    col?: number;
    row?: number;
    width?: number;
    height?: number;
}
declare const _default$i: {
    Container: React$1.ForwardRefExoticComponent<Omit<{
        ref?: React$1.Ref<Gtk.Widget>;
        children?: React$1.ReactNode;
        canFocus?: boolean;
        canTarget?: boolean;
        cssClasses?: string[];
        cursor?: Gdk.Cursor | null;
        focusOnClick?: boolean;
        focusable?: boolean;
        halign?: Gtk.Align;
        hasTooltip?: boolean;
        heightRequest?: number;
        hexpand?: boolean;
        hexpandSet?: boolean;
        layoutManager?: Gtk.LayoutManager | null;
        marginBottom?: number;
        marginEnd?: number;
        marginStart?: number;
        marginTop?: number;
        name?: string | null;
        opacity?: number;
        overflow?: Gtk.Overflow;
        receivesDefault?: boolean;
        sensitive?: boolean;
        tooltipMarkup?: string | null;
        tooltipText?: string | null;
        valign?: Gtk.Align;
        vexpand?: boolean;
        vexpandSet?: boolean;
        visible?: boolean;
        widthRequest?: number;
        accessibleRole?: Gtk.AccessibleRole;
        onDestroy?: (node: Gtk.Widget) => void;
        onDirectionChanged?: (node: Gtk.Widget, previousDirection: Gtk.TextDirection) => void;
        onHide?: (node: Gtk.Widget) => void;
        onKeynavFailed?: (node: Gtk.Widget, direction: Gtk.DirectionType) => boolean;
        onMap?: (node: Gtk.Widget) => void;
        onMnemonicActivate?: (node: Gtk.Widget, groupCycling: boolean) => boolean;
        onMoveFocus?: (node: Gtk.Widget, direction: Gtk.DirectionType) => void;
        onQueryTooltip?: (node: Gtk.Widget, x: number, y: number, keyboardMode: boolean, tooltip: Gtk.Tooltip) => boolean;
        onRealize?: (node: Gtk.Widget) => void;
        onShow?: (node: Gtk.Widget) => void;
        onStateFlagsChanged?: (node: Gtk.Widget, flags: Gtk.StateFlags) => void;
        onUnmap?: (node: Gtk.Widget) => void;
        onUnrealize?: (node: Gtk.Widget) => void;
        onNotifyCanFocus?: (node: Gtk.Widget) => void;
        onNotifyCanTarget?: (node: Gtk.Widget) => void;
        onNotifyCssClasses?: (node: Gtk.Widget) => void;
        onNotifyCssName?: (node: Gtk.Widget) => void;
        onNotifyCursor?: (node: Gtk.Widget) => void;
        onNotifyFocusOnClick?: (node: Gtk.Widget) => void;
        onNotifyFocusable?: (node: Gtk.Widget) => void;
        onNotifyHalign?: (node: Gtk.Widget) => void;
        onNotifyHasDefault?: (node: Gtk.Widget) => void;
        onNotifyHasFocus?: (node: Gtk.Widget) => void;
        onNotifyHasTooltip?: (node: Gtk.Widget) => void;
        onNotifyHeightRequest?: (node: Gtk.Widget) => void;
        onNotifyHexpand?: (node: Gtk.Widget) => void;
        onNotifyHexpandSet?: (node: Gtk.Widget) => void;
        onNotifyLayoutManager?: (node: Gtk.Widget) => void;
        onNotifyMarginBottom?: (node: Gtk.Widget) => void;
        onNotifyMarginEnd?: (node: Gtk.Widget) => void;
        onNotifyMarginStart?: (node: Gtk.Widget) => void;
        onNotifyMarginTop?: (node: Gtk.Widget) => void;
        onNotifyName?: (node: Gtk.Widget) => void;
        onNotifyOpacity?: (node: Gtk.Widget) => void;
        onNotifyOverflow?: (node: Gtk.Widget) => void;
        onNotifyParent?: (node: Gtk.Widget) => void;
        onNotifyReceivesDefault?: (node: Gtk.Widget) => void;
        onNotifyRoot?: (node: Gtk.Widget) => void;
        onNotifyScaleFactor?: (node: Gtk.Widget) => void;
        onNotifySensitive?: (node: Gtk.Widget) => void;
        onNotifyTooltipMarkup?: (node: Gtk.Widget) => void;
        onNotifyTooltipText?: (node: Gtk.Widget) => void;
        onNotifyValign?: (node: Gtk.Widget) => void;
        onNotifyVexpand?: (node: Gtk.Widget) => void;
        onNotifyVexpandSet?: (node: Gtk.Widget) => void;
        onNotifyVisible?: (node: Gtk.Widget) => void;
        onNotifyWidthRequest?: (node: Gtk.Widget) => void;
        onNotifyAccessibleRole?: (node: Gtk.Widget) => void;
    } & {
        ref?: React$1.Ref<Gtk.Grid>;
        baselineRow?: number;
        columnHomogeneous?: boolean;
        columnSpacing?: number;
        rowHomogeneous?: boolean;
        rowSpacing?: number;
        name?: string;
        accessibleRole?: Gtk.AccessibleRole;
        orientation?: Gtk.Orientation;
        onNotifyBaselineRow?: (node: Gtk.Grid) => void;
        onNotifyColumnHomogeneous?: (node: Gtk.Grid) => void;
        onNotifyColumnSpacing?: (node: Gtk.Grid) => void;
        onNotifyRowHomogeneous?: (node: Gtk.Grid) => void;
        onNotifyRowSpacing?: (node: Gtk.Grid) => void;
        onNotifyName?: (node: Gtk.Grid) => void;
        onNotifyAccessibleRole?: (node: Gtk.Grid) => void;
        onNotifyOrientation?: (node: Gtk.Grid) => void;
    }, "ref"> & React$1.RefAttributes<Gtk.Grid>>;
    Item: ({ children, col, row, width, height, }: ItemProps$5) => React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
};

type Position = "start" | "end";
type Props$b = Omit<JSX.IntrinsicElements["HeaderBar"], "titleWidget"> & {
    title?: (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    }) | null;
};
interface SectionProps {
    children: React$1.ReactNode;
    position?: Position;
}
interface ItemProps$4 {
    children: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
}
declare const _default$h: {
    Container: React$1.ForwardRefExoticComponent<Omit<Props$b, "ref"> & React$1.RefAttributes<Gtk.HeaderBar>>;
    Section: ({ children, position, }: SectionProps) => React$1.JSX.Element;
    Item: ({ children }: ItemProps$4) => React$1.ReactPortal;
};

type Props$a = JSX.IntrinsicElements["LevelBar"] & {
    offsets?: Record<string, number>;
};
declare const _default$g: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<Props$a, "ref"> & React$1.RefAttributes<Gtk.LevelBar | null>>>;

interface ContainerProps$1 {
    children: React$1.ReactNode;
}
interface ListProps$1 {
    children: React$1.ReactNode;
}
interface ItemProps$3<T> {
    value: T;
}
declare const _default$f: {
    Container: ({ children }: ContainerProps$1) => React$1.JSX.Element;
    Item: <T>({ value }: ItemProps$3<T>) => null;
    List: ({ children }: ListProps$1) => (string | number | Iterable<React$1.ReactNode> | React$1.JSX.Element)[] | null | undefined;
};

type Props$9<T> = Omit<JSX.IntrinsicElements["ListView"], "factory" | "headerFactory" | "model"> & {
    selectionMode?: Gtk.SelectionMode;
    selection?: number[];
    onSelectionChanged?: (indexes: number[], selection: unknown[]) => void;
    renderItem?: ListItemFactoryRenderFunction<T> | null;
};
declare const _default$e: React$1.ForwardRefExoticComponent<Omit<Props$9<any>, "ref"> & React$1.RefAttributes<Gtk.ListView>>;

type Props$8 = Omit<JSX.IntrinsicElements["MenuButton"], "popover"> & {
    actionGroup?: Gio.ActionGroup;
    actionPrefix: string;
    popover?: (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Popover>;
    }) | null;
};
declare const _default$d: React$1.ForwardRefExoticComponent<Omit<Props$8, "ref"> & React$1.RefAttributes<Gtk.MenuButton>>;

type Props$7 = JSX.IntrinsicElements["Notebook"] & {
    children: React$1.ReactNode;
};
interface TabProps {
    children: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
    label?: string | (React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    });
}
declare const _default$c: {
    Container: React$1.ForwardRefExoticComponent<Omit<Props$7, "ref"> & React$1.RefAttributes<Gtk.Notebook>>;
    Tab: ({ children, label }: TabProps) => React$1.JSX.Element;
};

type Props$6 = JSX.IntrinsicElements["Overlay"] & {
    content: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
};
declare const _default$b: React$1.ForwardRefExoticComponent<Omit<Props$6, "ref"> & React$1.RefAttributes<Gtk.Overlay>>;

declare const _default$a: React$1.ForwardRefExoticComponent<Omit<{
    ref?: React$1.Ref<Gtk.Widget>;
    children?: React$1.ReactNode;
    canFocus?: boolean;
    canTarget?: boolean;
    cssClasses?: string[];
    cursor?: Gdk.Cursor | null;
    focusOnClick?: boolean;
    focusable?: boolean;
    halign?: Gtk.Align;
    hasTooltip?: boolean;
    heightRequest?: number;
    hexpand?: boolean;
    hexpandSet?: boolean;
    layoutManager?: Gtk.LayoutManager | null;
    marginBottom?: number;
    marginEnd?: number;
    marginStart?: number;
    marginTop?: number;
    name?: string | null;
    opacity?: number;
    overflow?: Gtk.Overflow;
    receivesDefault?: boolean;
    sensitive?: boolean;
    tooltipMarkup?: string | null;
    tooltipText?: string | null;
    valign?: Gtk.Align;
    vexpand?: boolean;
    vexpandSet?: boolean;
    visible?: boolean;
    widthRequest?: number;
    accessibleRole?: Gtk.AccessibleRole;
    onDestroy?: (node: Gtk.Widget) => void;
    onDirectionChanged?: (node: Gtk.Widget, previousDirection: Gtk.TextDirection) => void;
    onHide?: (node: Gtk.Widget) => void;
    onKeynavFailed?: (node: Gtk.Widget, direction: Gtk.DirectionType) => boolean;
    onMap?: (node: Gtk.Widget) => void;
    onMnemonicActivate?: (node: Gtk.Widget, groupCycling: boolean) => boolean;
    onMoveFocus?: (node: Gtk.Widget, direction: Gtk.DirectionType) => void;
    onQueryTooltip?: (node: Gtk.Widget, x: number, y: number, keyboardMode: boolean, tooltip: Gtk.Tooltip) => boolean;
    onRealize?: (node: Gtk.Widget) => void;
    onShow?: (node: Gtk.Widget) => void;
    onStateFlagsChanged?: (node: Gtk.Widget, flags: Gtk.StateFlags) => void;
    onUnmap?: (node: Gtk.Widget) => void;
    onUnrealize?: (node: Gtk.Widget) => void;
    onNotifyCanFocus?: (node: Gtk.Widget) => void;
    onNotifyCanTarget?: (node: Gtk.Widget) => void;
    onNotifyCssClasses?: (node: Gtk.Widget) => void;
    onNotifyCssName?: (node: Gtk.Widget) => void;
    onNotifyCursor?: (node: Gtk.Widget) => void;
    onNotifyFocusOnClick?: (node: Gtk.Widget) => void;
    onNotifyFocusable?: (node: Gtk.Widget) => void;
    onNotifyHalign?: (node: Gtk.Widget) => void;
    onNotifyHasDefault?: (node: Gtk.Widget) => void;
    onNotifyHasFocus?: (node: Gtk.Widget) => void;
    onNotifyHasTooltip?: (node: Gtk.Widget) => void;
    onNotifyHeightRequest?: (node: Gtk.Widget) => void;
    onNotifyHexpand?: (node: Gtk.Widget) => void;
    onNotifyHexpandSet?: (node: Gtk.Widget) => void;
    onNotifyLayoutManager?: (node: Gtk.Widget) => void;
    onNotifyMarginBottom?: (node: Gtk.Widget) => void;
    onNotifyMarginEnd?: (node: Gtk.Widget) => void;
    onNotifyMarginStart?: (node: Gtk.Widget) => void;
    onNotifyMarginTop?: (node: Gtk.Widget) => void;
    onNotifyName?: (node: Gtk.Widget) => void;
    onNotifyOpacity?: (node: Gtk.Widget) => void;
    onNotifyOverflow?: (node: Gtk.Widget) => void;
    onNotifyParent?: (node: Gtk.Widget) => void;
    onNotifyReceivesDefault?: (node: Gtk.Widget) => void;
    onNotifyRoot?: (node: Gtk.Widget) => void;
    onNotifyScaleFactor?: (node: Gtk.Widget) => void;
    onNotifySensitive?: (node: Gtk.Widget) => void;
    onNotifyTooltipMarkup?: (node: Gtk.Widget) => void;
    onNotifyTooltipText?: (node: Gtk.Widget) => void;
    onNotifyValign?: (node: Gtk.Widget) => void;
    onNotifyVexpand?: (node: Gtk.Widget) => void;
    onNotifyVexpandSet?: (node: Gtk.Widget) => void;
    onNotifyVisible?: (node: Gtk.Widget) => void;
    onNotifyWidthRequest?: (node: Gtk.Widget) => void;
    onNotifyAccessibleRole?: (node: Gtk.Widget) => void;
} & {
    ref?: React$1.Ref<Gtk.Window>;
    application?: Gtk.Application | null;
    decorated?: boolean;
    defaultHeight?: number;
    defaultWidget?: Gtk.Widget | null;
    defaultWidth?: number;
    deletable?: boolean;
    destroyWithParent?: boolean;
    display?: Gdk.Display;
    focusVisible?: boolean;
    focusWidget?: Gtk.Widget;
    fullscreened?: boolean;
    handleMenubarAccel?: boolean;
    hideOnClose?: boolean;
    iconName?: string | null;
    maximized?: boolean;
    mnemonicsVisible?: boolean;
    modal?: boolean;
    resizable?: boolean;
    startupId?: string | null;
    title?: string | null;
    titlebar?: Gtk.Widget | null;
    transientFor?: Gtk.Window | null;
    name?: string;
    accessibleRole?: Gtk.AccessibleRole;
    onActivateDefault?: (node: Gtk.Window) => void;
    onActivateFocus?: (node: Gtk.Window) => void;
    onCloseRequest?: (node: Gtk.Window) => boolean;
    onEnableDebugging?: (node: Gtk.Window, toggle: boolean) => boolean;
    onKeysChanged?: (node: Gtk.Window) => void;
    onNotifyApplication?: (node: Gtk.Window) => void;
    onNotifyChild?: (node: Gtk.Window) => void;
    onNotifyDecorated?: (node: Gtk.Window) => void;
    onNotifyDefaultHeight?: (node: Gtk.Window) => void;
    onNotifyDefaultWidget?: (node: Gtk.Window) => void;
    onNotifyDefaultWidth?: (node: Gtk.Window) => void;
    onNotifyDeletable?: (node: Gtk.Window) => void;
    onNotifyDestroyWithParent?: (node: Gtk.Window) => void;
    onNotifyDisplay?: (node: Gtk.Window) => void;
    onNotifyFocusVisible?: (node: Gtk.Window) => void;
    onNotifyFocusWidget?: (node: Gtk.Window) => void;
    onNotifyFullscreened?: (node: Gtk.Window) => void;
    onNotifyHandleMenubarAccel?: (node: Gtk.Window) => void;
    onNotifyHideOnClose?: (node: Gtk.Window) => void;
    onNotifyIconName?: (node: Gtk.Window) => void;
    onNotifyIsActive?: (node: Gtk.Window) => void;
    onNotifyMaximized?: (node: Gtk.Window) => void;
    onNotifyMnemonicsVisible?: (node: Gtk.Window) => void;
    onNotifyModal?: (node: Gtk.Window) => void;
    onNotifyResizable?: (node: Gtk.Window) => void;
    onNotifyStartupId?: (node: Gtk.Window) => void;
    onNotifySuspended?: (node: Gtk.Window) => void;
    onNotifyTitle?: (node: Gtk.Window) => void;
    onNotifyTitlebar?: (node: Gtk.Window) => void;
    onNotifyTransientFor?: (node: Gtk.Window) => void;
    onNotifyName?: (node: Gtk.Window) => void;
    onNotifyAccessibleRole?: (node: Gtk.Window) => void;
} & {
    ref?: React$1.Ref<Gtk.Dialog>;
    name?: string;
    accessibleRole?: Gtk.AccessibleRole;
    onClose?: (node: Gtk.Dialog) => void;
    onResponse?: (node: Gtk.Dialog, responseId: number) => void;
    onNotifyUseHeaderBar?: (node: Gtk.Dialog) => void;
    onNotifyName?: (node: Gtk.Dialog) => void;
    onNotifyAccessibleRole?: (node: Gtk.Dialog) => void;
} & {
    ref?: React$1.Ref<Gtk.PageSetupUnixDialog>;
    name?: string;
    accessibleRole?: Gtk.AccessibleRole;
    onNotifyName?: (node: Gtk.PageSetupUnixDialog) => void;
    onNotifyAccessibleRole?: (node: Gtk.PageSetupUnixDialog) => void;
}, "ref"> & React$1.RefAttributes<Gtk.PageSetupUnixDialog>>;

type Props$5 = Omit<JSX.IntrinsicElements["Paned"], "children" | "startChild" | "endChild"> & {
    children: [
        React$1.ReactElement & {
            ref?: React$1.Ref<Gtk.Widget>;
        },
        React$1.ReactElement & {
            ref?: React$1.Ref<Gtk.Widget>;
        }
    ];
};
declare const _default$9: React$1.ForwardRefExoticComponent<Omit<Props$5, "ref"> & React$1.RefAttributes<Gtk.Paned>>;

type Props$4 = Omit<AbstractPopoverProps<"Popover">, "elementType">;
declare const _default$8: React$1.ForwardRefExoticComponent<Omit<Props$4, "ref"> & React$1.RefAttributes<Gtk.Popover>>;

type Props$3 = Omit<AbstractPopoverProps<"PopoverMenu">, "elementType">;
declare const _default$7: React$1.ForwardRefExoticComponent<Omit<Props$3, "ref"> & React$1.RefAttributes<Gtk.PopoverMenu>>;

type Props$2 = Omit<JSX.IntrinsicElements["PopoverMenuBar"], "children"> & {
    children?: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
};
interface ItemProps$2 {
    id: string;
    children: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
}
declare const _default$6: {
    Container: React$1.ForwardRefExoticComponent<Omit<Props$2, "ref"> & React$1.RefAttributes<Gtk.PopoverMenuBar>>;
    Item: ({ children, id, ...props }: ItemProps$2) => React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
};

declare const _default$5: React$1.ForwardRefExoticComponent<Omit<{
    ref?: React$1.Ref<Gtk.Widget>;
    children?: React$1.ReactNode;
    canFocus?: boolean;
    canTarget?: boolean;
    cssClasses?: string[];
    cursor?: Gdk.Cursor | null;
    focusOnClick?: boolean;
    focusable?: boolean;
    halign?: Gtk.Align;
    hasTooltip?: boolean;
    heightRequest?: number;
    hexpand?: boolean;
    hexpandSet?: boolean;
    layoutManager?: Gtk.LayoutManager | null;
    marginBottom?: number;
    marginEnd?: number;
    marginStart?: number;
    marginTop?: number;
    name?: string | null;
    opacity?: number;
    overflow?: Gtk.Overflow;
    receivesDefault?: boolean;
    sensitive?: boolean;
    tooltipMarkup?: string | null;
    tooltipText?: string | null;
    valign?: Gtk.Align;
    vexpand?: boolean;
    vexpandSet?: boolean;
    visible?: boolean;
    widthRequest?: number;
    accessibleRole?: Gtk.AccessibleRole;
    onDestroy?: (node: Gtk.Widget) => void;
    onDirectionChanged?: (node: Gtk.Widget, previousDirection: Gtk.TextDirection) => void;
    onHide?: (node: Gtk.Widget) => void;
    onKeynavFailed?: (node: Gtk.Widget, direction: Gtk.DirectionType) => boolean;
    onMap?: (node: Gtk.Widget) => void;
    onMnemonicActivate?: (node: Gtk.Widget, groupCycling: boolean) => boolean;
    onMoveFocus?: (node: Gtk.Widget, direction: Gtk.DirectionType) => void;
    onQueryTooltip?: (node: Gtk.Widget, x: number, y: number, keyboardMode: boolean, tooltip: Gtk.Tooltip) => boolean;
    onRealize?: (node: Gtk.Widget) => void;
    onShow?: (node: Gtk.Widget) => void;
    onStateFlagsChanged?: (node: Gtk.Widget, flags: Gtk.StateFlags) => void;
    onUnmap?: (node: Gtk.Widget) => void;
    onUnrealize?: (node: Gtk.Widget) => void;
    onNotifyCanFocus?: (node: Gtk.Widget) => void;
    onNotifyCanTarget?: (node: Gtk.Widget) => void;
    onNotifyCssClasses?: (node: Gtk.Widget) => void;
    onNotifyCssName?: (node: Gtk.Widget) => void;
    onNotifyCursor?: (node: Gtk.Widget) => void;
    onNotifyFocusOnClick?: (node: Gtk.Widget) => void;
    onNotifyFocusable?: (node: Gtk.Widget) => void;
    onNotifyHalign?: (node: Gtk.Widget) => void;
    onNotifyHasDefault?: (node: Gtk.Widget) => void;
    onNotifyHasFocus?: (node: Gtk.Widget) => void;
    onNotifyHasTooltip?: (node: Gtk.Widget) => void;
    onNotifyHeightRequest?: (node: Gtk.Widget) => void;
    onNotifyHexpand?: (node: Gtk.Widget) => void;
    onNotifyHexpandSet?: (node: Gtk.Widget) => void;
    onNotifyLayoutManager?: (node: Gtk.Widget) => void;
    onNotifyMarginBottom?: (node: Gtk.Widget) => void;
    onNotifyMarginEnd?: (node: Gtk.Widget) => void;
    onNotifyMarginStart?: (node: Gtk.Widget) => void;
    onNotifyMarginTop?: (node: Gtk.Widget) => void;
    onNotifyName?: (node: Gtk.Widget) => void;
    onNotifyOpacity?: (node: Gtk.Widget) => void;
    onNotifyOverflow?: (node: Gtk.Widget) => void;
    onNotifyParent?: (node: Gtk.Widget) => void;
    onNotifyReceivesDefault?: (node: Gtk.Widget) => void;
    onNotifyRoot?: (node: Gtk.Widget) => void;
    onNotifyScaleFactor?: (node: Gtk.Widget) => void;
    onNotifySensitive?: (node: Gtk.Widget) => void;
    onNotifyTooltipMarkup?: (node: Gtk.Widget) => void;
    onNotifyTooltipText?: (node: Gtk.Widget) => void;
    onNotifyValign?: (node: Gtk.Widget) => void;
    onNotifyVexpand?: (node: Gtk.Widget) => void;
    onNotifyVexpandSet?: (node: Gtk.Widget) => void;
    onNotifyVisible?: (node: Gtk.Widget) => void;
    onNotifyWidthRequest?: (node: Gtk.Widget) => void;
    onNotifyAccessibleRole?: (node: Gtk.Widget) => void;
} & {
    ref?: React$1.Ref<Gtk.Window>;
    application?: Gtk.Application | null;
    decorated?: boolean;
    defaultHeight?: number;
    defaultWidget?: Gtk.Widget | null;
    defaultWidth?: number;
    deletable?: boolean;
    destroyWithParent?: boolean;
    display?: Gdk.Display;
    focusVisible?: boolean;
    focusWidget?: Gtk.Widget;
    fullscreened?: boolean;
    handleMenubarAccel?: boolean;
    hideOnClose?: boolean;
    iconName?: string | null;
    maximized?: boolean;
    mnemonicsVisible?: boolean;
    modal?: boolean;
    resizable?: boolean;
    startupId?: string | null;
    title?: string | null;
    titlebar?: Gtk.Widget | null;
    transientFor?: Gtk.Window | null;
    name?: string;
    accessibleRole?: Gtk.AccessibleRole;
    onActivateDefault?: (node: Gtk.Window) => void;
    onActivateFocus?: (node: Gtk.Window) => void;
    onCloseRequest?: (node: Gtk.Window) => boolean;
    onEnableDebugging?: (node: Gtk.Window, toggle: boolean) => boolean;
    onKeysChanged?: (node: Gtk.Window) => void;
    onNotifyApplication?: (node: Gtk.Window) => void;
    onNotifyChild?: (node: Gtk.Window) => void;
    onNotifyDecorated?: (node: Gtk.Window) => void;
    onNotifyDefaultHeight?: (node: Gtk.Window) => void;
    onNotifyDefaultWidget?: (node: Gtk.Window) => void;
    onNotifyDefaultWidth?: (node: Gtk.Window) => void;
    onNotifyDeletable?: (node: Gtk.Window) => void;
    onNotifyDestroyWithParent?: (node: Gtk.Window) => void;
    onNotifyDisplay?: (node: Gtk.Window) => void;
    onNotifyFocusVisible?: (node: Gtk.Window) => void;
    onNotifyFocusWidget?: (node: Gtk.Window) => void;
    onNotifyFullscreened?: (node: Gtk.Window) => void;
    onNotifyHandleMenubarAccel?: (node: Gtk.Window) => void;
    onNotifyHideOnClose?: (node: Gtk.Window) => void;
    onNotifyIconName?: (node: Gtk.Window) => void;
    onNotifyIsActive?: (node: Gtk.Window) => void;
    onNotifyMaximized?: (node: Gtk.Window) => void;
    onNotifyMnemonicsVisible?: (node: Gtk.Window) => void;
    onNotifyModal?: (node: Gtk.Window) => void;
    onNotifyResizable?: (node: Gtk.Window) => void;
    onNotifyStartupId?: (node: Gtk.Window) => void;
    onNotifySuspended?: (node: Gtk.Window) => void;
    onNotifyTitle?: (node: Gtk.Window) => void;
    onNotifyTitlebar?: (node: Gtk.Window) => void;
    onNotifyTransientFor?: (node: Gtk.Window) => void;
    onNotifyName?: (node: Gtk.Window) => void;
    onNotifyAccessibleRole?: (node: Gtk.Window) => void;
} & {
    ref?: React$1.Ref<Gtk.Dialog>;
    name?: string;
    accessibleRole?: Gtk.AccessibleRole;
    onClose?: (node: Gtk.Dialog) => void;
    onResponse?: (node: Gtk.Dialog, responseId: number) => void;
    onNotifyUseHeaderBar?: (node: Gtk.Dialog) => void;
    onNotifyName?: (node: Gtk.Dialog) => void;
    onNotifyAccessibleRole?: (node: Gtk.Dialog) => void;
} & {
    ref?: React$1.Ref<Gtk.PrintUnixDialog>;
    currentPage?: number;
    embedPageSetup?: boolean;
    hasSelection?: boolean;
    manualCapabilities?: Gtk.PrintCapabilities;
    pageSetup?: Gtk.PageSetup;
    printSettings?: Gtk.PrintSettings;
    supportSelection?: boolean;
    name?: string;
    accessibleRole?: Gtk.AccessibleRole;
    onNotifyCurrentPage?: (node: Gtk.PrintUnixDialog) => void;
    onNotifyEmbedPageSetup?: (node: Gtk.PrintUnixDialog) => void;
    onNotifyHasSelection?: (node: Gtk.PrintUnixDialog) => void;
    onNotifyManualCapabilities?: (node: Gtk.PrintUnixDialog) => void;
    onNotifyPageSetup?: (node: Gtk.PrintUnixDialog) => void;
    onNotifyPrintSettings?: (node: Gtk.PrintUnixDialog) => void;
    onNotifySelectedPrinter?: (node: Gtk.PrintUnixDialog) => void;
    onNotifySupportSelection?: (node: Gtk.PrintUnixDialog) => void;
    onNotifyName?: (node: Gtk.PrintUnixDialog) => void;
    onNotifyAccessibleRole?: (node: Gtk.PrintUnixDialog) => void;
}, "ref"> & React$1.RefAttributes<Gtk.PrintUnixDialog>>;

interface ScaleMark {
    label: string;
    value: number;
    position?: Gtk.PositionType;
}
type Props$1 = Omit<JSX.IntrinsicElements["Scale"], "children"> & {
    marks?: ScaleMark[];
    value?: number;
    range: [number, number];
};
declare const _default$4: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<Props$1, "ref"> & React$1.RefAttributes<Gtk.Scale | null>>>;

type Props = JSX.IntrinsicElements["SpinButton"] & {
    range?: [number, number];
};
declare const _default$3: React$1.MemoExoticComponent<React$1.ForwardRefExoticComponent<Omit<Props, "ref"> & React$1.RefAttributes<Gtk.SpinButton>>>;

interface ItemProps$1 {
    children: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
    name: string;
    title?: string;
}
type SidebarProps = Omit<JSX.IntrinsicElements["StackSidebar"], "stack">;
type SwitcherProps = Omit<JSX.IntrinsicElements["StackSwitcher"], "stack">;
declare const _default$2: {
    Container: React$1.ForwardRefExoticComponent<Omit<{
        ref?: React$1.Ref<Gtk.Widget>;
        children?: React$1.ReactNode;
        canFocus?: boolean;
        canTarget?: boolean;
        cssClasses?: string[];
        cursor?: Gdk.Cursor | null;
        focusOnClick?: boolean;
        focusable?: boolean;
        halign?: Gtk.Align;
        hasTooltip?: boolean;
        heightRequest?: number;
        hexpand?: boolean;
        hexpandSet?: boolean;
        layoutManager?: Gtk.LayoutManager | null;
        marginBottom?: number;
        marginEnd?: number;
        marginStart?: number;
        marginTop?: number;
        name?: string | null;
        opacity?: number;
        overflow?: Gtk.Overflow;
        receivesDefault?: boolean;
        sensitive?: boolean;
        tooltipMarkup?: string | null;
        tooltipText?: string | null;
        valign?: Gtk.Align;
        vexpand?: boolean;
        vexpandSet?: boolean;
        visible?: boolean;
        widthRequest?: number;
        accessibleRole?: Gtk.AccessibleRole;
        onDestroy?: (node: Gtk.Widget) => void;
        onDirectionChanged?: (node: Gtk.Widget, previousDirection: Gtk.TextDirection) => void;
        onHide?: (node: Gtk.Widget) => void;
        onKeynavFailed?: (node: Gtk.Widget, direction: Gtk.DirectionType) => boolean;
        onMap?: (node: Gtk.Widget) => void;
        onMnemonicActivate?: (node: Gtk.Widget, groupCycling: boolean) => boolean;
        onMoveFocus?: (node: Gtk.Widget, direction: Gtk.DirectionType) => void;
        onQueryTooltip?: (node: Gtk.Widget, x: number, y: number, keyboardMode: boolean, tooltip: Gtk.Tooltip) => boolean;
        onRealize?: (node: Gtk.Widget) => void;
        onShow?: (node: Gtk.Widget) => void;
        onStateFlagsChanged?: (node: Gtk.Widget, flags: Gtk.StateFlags) => void;
        onUnmap?: (node: Gtk.Widget) => void;
        onUnrealize?: (node: Gtk.Widget) => void;
        onNotifyCanFocus?: (node: Gtk.Widget) => void;
        onNotifyCanTarget?: (node: Gtk.Widget) => void;
        onNotifyCssClasses?: (node: Gtk.Widget) => void;
        onNotifyCssName?: (node: Gtk.Widget) => void;
        onNotifyCursor?: (node: Gtk.Widget) => void;
        onNotifyFocusOnClick?: (node: Gtk.Widget) => void;
        onNotifyFocusable?: (node: Gtk.Widget) => void;
        onNotifyHalign?: (node: Gtk.Widget) => void;
        onNotifyHasDefault?: (node: Gtk.Widget) => void;
        onNotifyHasFocus?: (node: Gtk.Widget) => void;
        onNotifyHasTooltip?: (node: Gtk.Widget) => void;
        onNotifyHeightRequest?: (node: Gtk.Widget) => void;
        onNotifyHexpand?: (node: Gtk.Widget) => void;
        onNotifyHexpandSet?: (node: Gtk.Widget) => void;
        onNotifyLayoutManager?: (node: Gtk.Widget) => void;
        onNotifyMarginBottom?: (node: Gtk.Widget) => void;
        onNotifyMarginEnd?: (node: Gtk.Widget) => void;
        onNotifyMarginStart?: (node: Gtk.Widget) => void;
        onNotifyMarginTop?: (node: Gtk.Widget) => void;
        onNotifyName?: (node: Gtk.Widget) => void;
        onNotifyOpacity?: (node: Gtk.Widget) => void;
        onNotifyOverflow?: (node: Gtk.Widget) => void;
        onNotifyParent?: (node: Gtk.Widget) => void;
        onNotifyReceivesDefault?: (node: Gtk.Widget) => void;
        onNotifyRoot?: (node: Gtk.Widget) => void;
        onNotifyScaleFactor?: (node: Gtk.Widget) => void;
        onNotifySensitive?: (node: Gtk.Widget) => void;
        onNotifyTooltipMarkup?: (node: Gtk.Widget) => void;
        onNotifyTooltipText?: (node: Gtk.Widget) => void;
        onNotifyValign?: (node: Gtk.Widget) => void;
        onNotifyVexpand?: (node: Gtk.Widget) => void;
        onNotifyVexpandSet?: (node: Gtk.Widget) => void;
        onNotifyVisible?: (node: Gtk.Widget) => void;
        onNotifyWidthRequest?: (node: Gtk.Widget) => void;
        onNotifyAccessibleRole?: (node: Gtk.Widget) => void;
    } & {
        ref?: React$1.Ref<Gtk.Stack>;
        hhomogeneous?: boolean;
        interpolateSize?: boolean;
        transitionDuration?: number;
        transitionType?: Gtk.StackTransitionType;
        vhomogeneous?: boolean;
        visibleChild?: Gtk.Widget;
        visibleChildName?: string | null;
        name?: string;
        accessibleRole?: Gtk.AccessibleRole;
        onNotifyHhomogeneous?: (node: Gtk.Stack) => void;
        onNotifyInterpolateSize?: (node: Gtk.Stack) => void;
        onNotifyPages?: (node: Gtk.Stack) => void;
        onNotifyTransitionDuration?: (node: Gtk.Stack) => void;
        onNotifyTransitionRunning?: (node: Gtk.Stack) => void;
        onNotifyTransitionType?: (node: Gtk.Stack) => void;
        onNotifyVhomogeneous?: (node: Gtk.Stack) => void;
        onNotifyVisibleChild?: (node: Gtk.Stack) => void;
        onNotifyVisibleChildName?: (node: Gtk.Stack) => void;
        onNotifyName?: (node: Gtk.Stack) => void;
        onNotifyAccessibleRole?: (node: Gtk.Stack) => void;
    }, "ref"> & React$1.RefAttributes<Gtk.Stack>>;
    Item: ({ children, name, title }: ItemProps$1) => React$1.ReactPortal;
    Sidebar: React$1.ForwardRefExoticComponent<Omit<SidebarProps, "ref"> & React$1.RefAttributes<Gtk.StackSidebar>>;
    Switcher: React$1.ForwardRefExoticComponent<Omit<SwitcherProps, "ref"> & React$1.RefAttributes<Gtk.StackSwitcher>>;
};

interface OverlayProps {
    children: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
    x?: number;
    y?: number;
}
interface AnchorProps {
    children: React$1.ReactElement & {
        ref?: React$1.Ref<Gtk.Widget>;
    };
    anchor: Gtk.TextChildAnchor;
}
declare const _default$1: {
    Container: React$1.ForwardRefExoticComponent<Omit<{
        ref?: React$1.Ref<Gtk.Widget>;
        children?: React$1.ReactNode;
        canFocus?: boolean;
        canTarget?: boolean;
        cssClasses?: string[];
        cursor?: Gdk.Cursor | null;
        focusOnClick?: boolean;
        focusable?: boolean;
        halign?: Gtk.Align;
        hasTooltip?: boolean;
        heightRequest?: number;
        hexpand?: boolean;
        hexpandSet?: boolean;
        layoutManager?: Gtk.LayoutManager | null;
        marginBottom?: number;
        marginEnd?: number;
        marginStart?: number;
        marginTop?: number;
        name?: string | null;
        opacity?: number;
        overflow?: Gtk.Overflow;
        receivesDefault?: boolean;
        sensitive?: boolean;
        tooltipMarkup?: string | null;
        tooltipText?: string | null;
        valign?: Gtk.Align;
        vexpand?: boolean;
        vexpandSet?: boolean;
        visible?: boolean;
        widthRequest?: number;
        accessibleRole?: Gtk.AccessibleRole;
        onDestroy?: (node: Gtk.Widget) => void;
        onDirectionChanged?: (node: Gtk.Widget, previousDirection: Gtk.TextDirection) => void;
        onHide?: (node: Gtk.Widget) => void;
        onKeynavFailed?: (node: Gtk.Widget, direction: Gtk.DirectionType) => boolean;
        onMap?: (node: Gtk.Widget) => void;
        onMnemonicActivate?: (node: Gtk.Widget, groupCycling: boolean) => boolean;
        onMoveFocus?: (node: Gtk.Widget, direction: Gtk.DirectionType) => void;
        onQueryTooltip?: (node: Gtk.Widget, x: number, y: number, keyboardMode: boolean, tooltip: Gtk.Tooltip) => boolean;
        onRealize?: (node: Gtk.Widget) => void;
        onShow?: (node: Gtk.Widget) => void;
        onStateFlagsChanged?: (node: Gtk.Widget, flags: Gtk.StateFlags) => void;
        onUnmap?: (node: Gtk.Widget) => void;
        onUnrealize?: (node: Gtk.Widget) => void;
        onNotifyCanFocus?: (node: Gtk.Widget) => void;
        onNotifyCanTarget?: (node: Gtk.Widget) => void;
        onNotifyCssClasses?: (node: Gtk.Widget) => void;
        onNotifyCssName?: (node: Gtk.Widget) => void;
        onNotifyCursor?: (node: Gtk.Widget) => void;
        onNotifyFocusOnClick?: (node: Gtk.Widget) => void;
        onNotifyFocusable?: (node: Gtk.Widget) => void;
        onNotifyHalign?: (node: Gtk.Widget) => void;
        onNotifyHasDefault?: (node: Gtk.Widget) => void;
        onNotifyHasFocus?: (node: Gtk.Widget) => void;
        onNotifyHasTooltip?: (node: Gtk.Widget) => void;
        onNotifyHeightRequest?: (node: Gtk.Widget) => void;
        onNotifyHexpand?: (node: Gtk.Widget) => void;
        onNotifyHexpandSet?: (node: Gtk.Widget) => void;
        onNotifyLayoutManager?: (node: Gtk.Widget) => void;
        onNotifyMarginBottom?: (node: Gtk.Widget) => void;
        onNotifyMarginEnd?: (node: Gtk.Widget) => void;
        onNotifyMarginStart?: (node: Gtk.Widget) => void;
        onNotifyMarginTop?: (node: Gtk.Widget) => void;
        onNotifyName?: (node: Gtk.Widget) => void;
        onNotifyOpacity?: (node: Gtk.Widget) => void;
        onNotifyOverflow?: (node: Gtk.Widget) => void;
        onNotifyParent?: (node: Gtk.Widget) => void;
        onNotifyReceivesDefault?: (node: Gtk.Widget) => void;
        onNotifyRoot?: (node: Gtk.Widget) => void;
        onNotifyScaleFactor?: (node: Gtk.Widget) => void;
        onNotifySensitive?: (node: Gtk.Widget) => void;
        onNotifyTooltipMarkup?: (node: Gtk.Widget) => void;
        onNotifyTooltipText?: (node: Gtk.Widget) => void;
        onNotifyValign?: (node: Gtk.Widget) => void;
        onNotifyVexpand?: (node: Gtk.Widget) => void;
        onNotifyVexpandSet?: (node: Gtk.Widget) => void;
        onNotifyVisible?: (node: Gtk.Widget) => void;
        onNotifyWidthRequest?: (node: Gtk.Widget) => void;
        onNotifyAccessibleRole?: (node: Gtk.Widget) => void;
    } & {
        ref?: React$1.Ref<Gtk.TextView>;
        acceptsTab?: boolean;
        bottomMargin?: number;
        buffer?: Gtk.TextBuffer | null;
        cursorVisible?: boolean;
        editable?: boolean;
        extraMenu?: Gio.MenuModel | null;
        imModule?: string | null;
        indent?: number;
        inputHints?: Gtk.InputHints;
        inputPurpose?: Gtk.InputPurpose;
        justification?: Gtk.Justification;
        leftMargin?: number;
        monospace?: boolean;
        overwrite?: boolean;
        pixelsAboveLines?: number;
        pixelsBelowLines?: number;
        pixelsInsideWrap?: number;
        rightMargin?: number;
        tabs?: Pango.TabArray;
        topMargin?: number;
        wrapMode?: Gtk.WrapMode;
        name?: string;
        accessibleRole?: Gtk.AccessibleRole;
        hadjustment?: Gtk.Adjustment | null;
        hscrollPolicy?: Gtk.ScrollablePolicy;
        vadjustment?: Gtk.Adjustment | null;
        vscrollPolicy?: Gtk.ScrollablePolicy;
        onBackspace?: (node: Gtk.TextView) => void;
        onCopyClipboard?: (node: Gtk.TextView) => void;
        onCutClipboard?: (node: Gtk.TextView) => void;
        onDeleteFromCursor?: (node: Gtk.TextView, type: Gtk.DeleteType, count: number) => void;
        onExtendSelection?: (node: Gtk.TextView, granularity: Gtk.TextExtendSelection, location: Gtk.TextIter, start: Gtk.TextIter, end: Gtk.TextIter) => boolean;
        onInsertAtCursor?: (node: Gtk.TextView, string: string | null) => void;
        onInsertEmoji?: (node: Gtk.TextView) => void;
        onMoveCursor?: (node: Gtk.TextView, step: Gtk.MovementStep, count: number, extendSelection: boolean) => void;
        onMoveViewport?: (node: Gtk.TextView, step: Gtk.ScrollStep, count: number) => void;
        onPasteClipboard?: (node: Gtk.TextView) => void;
        onPreeditChanged?: (node: Gtk.TextView, preedit: string | null) => void;
        onSelectAll?: (node: Gtk.TextView, select: boolean) => void;
        onSetAnchor?: (node: Gtk.TextView) => void;
        onToggleCursorVisible?: (node: Gtk.TextView) => void;
        onToggleOverwrite?: (node: Gtk.TextView) => void;
        onNotifyAcceptsTab?: (node: Gtk.TextView) => void;
        onNotifyBottomMargin?: (node: Gtk.TextView) => void;
        onNotifyBuffer?: (node: Gtk.TextView) => void;
        onNotifyCursorVisible?: (node: Gtk.TextView) => void;
        onNotifyEditable?: (node: Gtk.TextView) => void;
        onNotifyExtraMenu?: (node: Gtk.TextView) => void;
        onNotifyImModule?: (node: Gtk.TextView) => void;
        onNotifyIndent?: (node: Gtk.TextView) => void;
        onNotifyInputHints?: (node: Gtk.TextView) => void;
        onNotifyInputPurpose?: (node: Gtk.TextView) => void;
        onNotifyJustification?: (node: Gtk.TextView) => void;
        onNotifyLeftMargin?: (node: Gtk.TextView) => void;
        onNotifyMonospace?: (node: Gtk.TextView) => void;
        onNotifyOverwrite?: (node: Gtk.TextView) => void;
        onNotifyPixelsAboveLines?: (node: Gtk.TextView) => void;
        onNotifyPixelsBelowLines?: (node: Gtk.TextView) => void;
        onNotifyPixelsInsideWrap?: (node: Gtk.TextView) => void;
        onNotifyRightMargin?: (node: Gtk.TextView) => void;
        onNotifyTabs?: (node: Gtk.TextView) => void;
        onNotifyTopMargin?: (node: Gtk.TextView) => void;
        onNotifyWrapMode?: (node: Gtk.TextView) => void;
        onNotifyName?: (node: Gtk.TextView) => void;
        onNotifyAccessibleRole?: (node: Gtk.TextView) => void;
        onNotifyHadjustment?: (node: Gtk.TextView) => void;
        onNotifyHscrollPolicy?: (node: Gtk.TextView) => void;
        onNotifyVadjustment?: (node: Gtk.TextView) => void;
        onNotifyVscrollPolicy?: (node: Gtk.TextView) => void;
    }, "ref"> & React$1.RefAttributes<Gtk.TextView>>;
    Overlay: ({ children, x, y, }: OverlayProps) => React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
    Anchor: ({ children, anchor }: AnchorProps) => React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>>;
};

interface ContainerProps {
    children: React$1.ReactNode;
    autoexpand?: boolean;
}
interface ListProps {
    children: React$1.ReactNode;
}
interface ItemProps<T> {
    children?: React$1.ReactNode;
    value: T;
}
declare const _default: {
    Container: ({ children, autoexpand, }: ContainerProps) => React$1.JSX.Element;
    Item: <T>({ children, value }: ItemProps<T>) => React$1.JSX.Element | null;
    List: ({ children }: ListProps) => (string | number | Iterable<React$1.ReactNode> | React$1.JSX.Element)[] | null | undefined;
};

declare function render(element: React.ReactNode, application: Gtk.Application): void;

export { _default$v as AboutDialog, _default$u as ActionBar, AppChooserButton, AppChooserDialog, AppChooserWidget, _default$t as ApplicationWindow, AspectFrame, Assistant, Box, Button, _default$s as Calendar, CellView, _default$r as CenterBox, _default$q as CheckButton, ColorButton, ColorChooserDialog, ColorChooserWidget, _default$p as ColorDialogButton, _default$o as ColumnView, ComboBox, ComboBoxText, Dialog, DragIcon, DrawingArea, _default$n as DropDown, EditableLabel, _default$m as EmojiChooser, Entry, _default$l as Expander, FileChooserDialog, FileChooserWidget, Fixed, FlowBox, FlowBoxChild, FontButton, FontChooserDialog, FontChooserWidget, _default$k as FontDialogButton, _default$j as Frame, GLArea, GLib, GObject, Gdk, Gio, GraphicsOffload, _default$i as Grid, GridView, Gtk, _default$h as HeaderBar, IconView, Image, InfoBar, Inscription, Label, _default$g as LevelBar, LinkButton, ListBase, ListBox, ListBoxRow, ListModelProvider, _default$f as ListProvider, _default$e as ListView, LockButton, MediaControls, _default$d as MenuButton, MessageDialog, MultipleFileDialog, _default$c as Notebook, _default$b as Overlay, _default$a as PageSetupUnixDialog, _default$9 as Paned, Pango, PasswordEntry, Picture, _default$8 as Popover, _default$7 as PopoverMenu, _default$6 as PopoverMenuBar, _default$5 as PrintUnixDialog, ProgressBar, REACT_PORTAL_TYPE, Range, Revealer, _default$4 as Scale, ScaleButton, Scrollbar, ScrolledWindow, SearchBar, SearchEntry, Separator, ShortcutLabel, ShortcutsGroup, ShortcutsSection, ShortcutsShortcut, ShortcutsWindow, SingleFileDialog, _default$3 as SpinButton, Spinner, _default$2 as Stack, StackSidebar, StackSwitcher, Statusbar, Switch, Text, _default$1 as TextView, ToggleButton, TreeExpander, _default as TreeProvider, TreeView, Video, Viewport, VolumeButton, Widget, Window, WindowControls, WindowHandle, createPortal, createReconciler, createRootNode, render as default, useActionGroup, useApplication, useInlineStylesheet, useListItemFactory, useListModel, useMenu, useSelection, useStylesheet };